TGF5b3V0IEFSQy0yMDogaWwgZmFzY2lubyBkZWxsYSBudW92YSBjcmlwdG92YWx1dGEgJFNPUEhPTg==

2024-01-25, 07:42

<p><img src="https://gimg2.gateimg.com/image/article/1690791857hotspot.jpeg" alt=""></p>
<h2 id="h2-TDLR498443"><a name="TD;LR" class="reference-link"></a><span class="header-link octicon octicon-link"></span>TD;LR</h2><p>Con l’attiva partecipazione della comunità, la peculiarità tecnica degli asset ARC-20 sta attirando sempre più l’attenzione dei giocatori di incisioni. Dopo il successo del token ARC-20 $QUARK, che si è misurato con SATS, il nuovo $SOPHON sembra portare una nuova ondata di tendenza alla comunità di ARC-20.</p>
<p>Quali sono le caratteristiche speciali di $QUARK e $SOPHON, che non sono solo simili a SATS ma hanno anche un certo attributo meme e hanno guadagnato popolarità? Quali sono le parti dell’ecosistema ARC-20 degne di nota di recente?</p>
<h2 id="h2-Breve20descrizione20del20protocollo20Atomicals506"><a name="Breve descrizione del protocollo Atomicals" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Breve descrizione del protocollo Atomicals</h2><p>Il protocollo Atomicals è posizionato come un protocollo più conciso e flessibile. Si basa sul modello UTxO della blockchain e realizza la creazione, il trasferimento e l’aggiornamento di oggetti digitali.</p>
<p>La tecnologia principale utilizzata dal protocollo Atomicals è quella delle monete colorate (Colored Coins) e segue il principio che ogni token ARC-20 è ancorato all’unità minima di Bitcoin, ossia 1 satoshi.</p>
<p>Dal punto di vista, il valore di ARC-20 non sarà azzerato, perché i token ARC-20 sono colorati per ogni satoshi e il <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">bitcoin</a> è ancora presente quando viene creato il colore. Un Atomical può essere considerato come un meccanismo che incapsula la creazione, la trasmissione e l’aggiornamento degli oggetti digitali.</p>
<p>Poiché ARC-20 è stato creato e trasmesso utilizzando gli UTXO di BTC, è associato a ogni satoshi, consentendo la suddivisione e l’unione (UTXO) come avviene con BTC e consentendo i trasferimenti diretti tramite la rete Bitcoin.</p>
<p>Inoltre, il protocollo Atomicals propone un nuovo concetto emergente - Realm - che mira a sovvertire i domini tradizionali. Può collegare comunità, organizzazioni o gruppi e può essere applicato a vari settori come giochi, social, terreni e medaglie, diventando così una porta per l’espansione dell’intero ecosistema.</p>
<h2 id="h2-Cos20SOPHON225221"><a name="Cos’è $SOPHON" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Cos’è $SOPHON</h2><p>Il concetto di Sophon proviene dal famoso romanzo di fantascienza “I tre corpi”, dove i sophoni sono computer microscopici formati da particelle elementari (come i protoni) piegati tramite la tecnologia della piegatura multidimensionale, dotati di un’intelligenza e capacità di calcolo estremamente elevate. I sophoni possono espandersi o restringersi a qualsiasi dimensione, permettendo loro di leggere a velocità ultrarapida qualsiasi dato umano, libro e archivio informatico.</p>
<p>Nel romanzo originale, svolge un ruolo importante e, grazie alla sua unica fonte concettuale e alle caratteristiche di conio, SOPHON potrebbe anche suscitare un’inaspettata attrazione per ARC-20 e la pista delle iscrizioni.</p>
<p>$SOPHON ha un numero di conio di 420.000, con 100.000 token (incluso il valore in moneta) per ogni singola moneta. Mantiene la stessa difficoltà di mining di $QUARK, con una difficoltà di 6 cifre. La sua caratteristica distintiva è che richiede un quantitativo maggiore di Bitcoin bloccato per lo stoccaggio.</p>
<p>Per estrarre un token Zhi, è necessario bloccare 100.000 satoshi di BTC. Supponendo che il prezzo attuale del BTC sia di 40.000 dollari per token, è necessario bloccare un valore equivalente a 40 dollari di BTC e pagare un costo aggiuntivo per il gas. Considerando che il totale dei token Zhi è di 420.000, secondo le regole di estrazione, una volta che tutti i token Zhi sono stati estratti, corrisponderà a bloccare 420 BTC.<br><img src="https://gimg2.gateimg.com/image/article/1706168431img_v3_027e_074a4c4d-0f8e-47d3-84b4-8097fb54bcix.jpg" alt=""><br>Fonte dell’immagine: Pixabay</p>
<p>In generale, il costo di produzione di SOPHON includerà sicuramente il prezzo di 10.000 satoshi di BTC immagazzinati al suo interno, il quale si basa sulla variazione in tempo reale del mercato, ma non scenderà mai a zero; inoltre, sia la produzione che la transazione richiedono una tassa di gas, quindi è importante fare transazioni quando la tassa di gas è bassa.</p>
<p>Andando alle origini, Zhi Zi deriva da un evento molto interessante. Nel ottobre scorso, Rijndael, uno sviluppatore di Bitcoin e ex capo ingegnere di AWS, ha creato un robot di cecchino di token chiamato Zhi Zi. Il funzionamento di questo robot consiste nel monitorare la memoria pool della blockchain e, una volta rilevata la nuova implementazione dell’iscrizione di un token BRC-20, verrà effettuata l’implementazione di un token con lo stesso nome, ma con un’offerta di 1, e pagando una commissione gas più alta, sarà implementato prima degli altri.</p>
<p>Poiché il protocollo BRC-20 non consente nomi di token duplicati, ciò significa che il nuovo token che era stato pianificato per essere rilasciato non può essere implementato con successo ed è stato bloccato dal robot Zhi. Dopo la prima esecuzione, il robot Zhi ha ridotto efficacemente il numero di nuove iscrizioni del 72% rispetto al giorno precedente.</p>
<p>Ciò ha attirato l’attenzione degli sviluppatori del protocollo Ordinals, che hanno anche pubblicato un tweet definendo il ‘Bosco Oscuro’ come <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> La stagione 2 sembra essere d’accordo con questo tipo di ‘intercettazione’ e ritiene che anche l’ecosistema Bitcoin abbia bisogno di questo meccanismo per proteggere Bitcoin dall’eccesso di informazioni.<br><img src="https://gimg2.gateimg.com/image/article/1706168468img_v3_027e_fe111ba9-257a-4568-ba47-94ddd47129ix.jpg" alt=""><br>Immagine per gentile concessione di Pixabay</p>
<p>In questo momento, @raphjaph rispose: ‘Abbiamo bisogno del ritorno di Zhi Zi’, e di recente SOPHON è apparso sul mercato di Atomicals, attirando naturalmente molta attenzione.</p>
<p>IN BASE AI GIORNI DI CONIO DI SOPHON, IL COSTO DEL GAS SI AGGIRA TRA I 5 E I 7 DOLLARI, AD ECCEZIONE DEI 100.000 BTC SATOSHI CHE DEVONO ESSERE BLOCCATI PER CHISON. Pertanto, anche se Zhizi torna a zero, l’ontologia vale comunque 0,001 BTC. QUESTO È SIMILE A QUARK, MA SOPHON È PIÙ “GENEROSO” E HA UNA QUANTITÀ MAGGIORE DI BTC BLOCCATI.</p>
<p>Il casting o l’acquisto di SOPHON equivale a memorizzare BTC in un’altra forma. Nel caso in cui il mercato si preveda in crescita a lungo termine, non è senza motivo che si guardi al potenziale di $SOPHON.</p>
<h2 id="h2-Come20partecipare20allecosistema20ARC2020recente752771"><a name="Come partecipare all’ecosistema ARC-20 recente?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Come partecipare all’ecosistema ARC-20 recente?</h2><p>Il primo token ARC-20 è stato $ATOM, attualmente il token ARC-20 con la capitalizzazione di mercato più alta, il cui prezzo è il più elevato, con un’offerta limitata e una piccola detenzione, con una capitalizzazione di mercato superiore a 150 milioni di dollari.</p>
<p>Il più recente leader è $QUARK, il cui significato è l’unità di base che costituisce la materia - il quark, simile alle SATS, l’unità più piccola che compone Bitcoin. La quantità totale è di 500.000 token, con 20.000 monete per token. Ha il maggior numero di indirizzi di possesso, perché la sua proprietà di meme è considerata la più probabile ad avere successo. Dai risultati sembra che non deluda le aspettative, diventando attualmente l’ARC-20 con il maggior numero di indirizzi di possesso.</p>
<p>Il mining di Quark è di difficoltà 6, relativamente più semplice rispetto a Electron e Neutron. Durante l’intero processo di conio, il costo medio di ogni Quark è di circa 20-30 dollari, rendendo più facile per i giocatori partecipare alla coniazione del mercato primario.</p>
<p>Nel mercato secondario di Atomicals, il prezzo di Quark ha raggiunto un massimo di 17 sats, pari a circa 0,00348 BTC, con un aumento del 400% rispetto al costo di produzione. Al momento della stesura, il prezzo si mantiene a 8,17 sats.<br><img src="https://gimg2.gateimg.com/image/article/1706168501img_v3_027e_cfdb1f6a-ab49-4d5f-b929-2a44876954ix.jpg" alt=""></p>
<p>Attualmente, l’ecosistema ARC-20 è abbastanza popolare nel settore delle incisioni. Vale la pena prestare attenzione a progetti come $ATOMI e $PHOTON, che sono ancora in fase di sviluppo. Atomicals ha anche una piattaforma piuttosto completa - Atomicals Market, che integra funzioni di scambio e incisione. I portafogli supportati includono Atomical Martket Wallet, Unisat Wallt e Wizz Wallet.</p>
<p>Il portafoglio Gate <a href="/web3" target="_blank" class="blog_inner_link">Web3</a> ha recentemente lanciato la funzione di mercato dell’iscrizione, che include: iscrizione, trading di token BRC-20 e BTC NFT, acquisto multipiattaforma di BTC NFT, BTC NFT confronto sull’intera piattaforma di rete, hot list di mercato, ecc., e supporterà anche ERC-20, DRC-20, LRC-20, ARC-20 e altri protocolli in futuro. Allo stesso tempo, verrà lanciata anche la funzione “Inion Launchpad”, che consentirà agli utenti di partecipare all’ecosistema delle iscrizioni con soglia zero e correttezza.</p>
<p>Prova subito: <a href="https://www.gate.io/web3/inion/brc-20" target="_blank">https://www.gate.io/web3/iscrizione/brc-20</a></p>
<h2 id="h2-riassunto14625"><a name="riassunto" class="reference-link"></a><span class="header-link octicon octicon-link"></span>riassunto</h2><p>Recentemente, il mercato criptato ha registrato un calo generale, soprattutto il prezzo del bitcoin ha raggiunto il minimo. Rispetto ai momenti più pazzi dei due mesi precedenti, anche l’asset di Mingwen ha ricevuto una certa freddezza. Tuttavia, i punti salienti tecnologici del protocollo Atomicals e la narrazione unica come un nuovo asset hanno portato un’ottimismo piuttosto evidente a $SOPHON.</p>
<p>Tuttavia, è necessario menzionare che l’avanzamento della fusione di SOPHON è ora al 100%. Se si desidera fare trading sul mercato secondario, è ancora necessario fare attenzione alle aspettative.</p>
<div class="blog-details-info"><br>  <div>Autore:<strong>Sherry S.</strong>Ricercatore di Gate.io<div class="info-tips"><em>Questo articolo rappresenta solo il punto di vista dell'autore e non costituisce alcun consiglio di trading.<br>  </em><div><em></em> Il contenuto di questo articolo è originale e il copyright è di proprietà di Gate.io, se desideri ripubblicarlo, ti preghiamo di citare l'autore e la fonte, in caso contrario saranno perseguite eventuali responsabilità legali.<br></div><p></p><br></div></div></div>