TCdpbnRlcmEgY2F0ZW5hIGRpIGF0dGl2aXTDoCBkaSByZWdpc3RyYXppb25lIHN0YSBlc3Bsb2RlbmRvPyBTYm9yZGFtZW50byBkYSBCUkMyMCBhIFNvbGFuYSBlIFBvbHlnb24=

2023-11-24, 02:30

<p><img src="https://gimg2.gateimg.com/image/article/1690791857hotspot.jpeg" alt=""></p>
<h2 id="h2-Introduzione673622"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>Dato che ORDI ha stabilito una leggenda mille volte più alta e ha raggiunto un livello incredibile a metà di questo mese, c’è stato un leggero calo, ma questo non può completamente smorzare l’entusiasmo dei “Giocatori dell’Iscrizione”. Tra gli investitori al dettaglio, c’è anche una richiesta per tutti di “continuare a tenere e stabilizzare i prezzi”, e sembra che la loro fiducia in loro abbia superato il loro entusiasmo per i profitti a breve termine. Per i minatori, la situazione è migliore, e l’enorme domanda per la fusione dell’iscrizione ha beneficiato molto.</p>
<p>Da $ORDI, $SATS a $RATS e così via, questi “token senza scenari di applicazione pratici” hanno oscurato numerosi nuovi progetti e catene consortili, riversandosi dai BRC-20 ad altre catene pubbliche con commissioni di gas inferiori e lancio più facile, replicando rapidamente il processo dei token BRC-20.<br><img src="https://gimg2.gateimg.com/image/article/170079282415311700792410_.pic.jpg" alt=""><br>Origine: Gate.io</p>
<h2 id="h2-Inizio20Protocolli20ordinali20e20atomici842794"><a name="Inizio: Protocolli ordinali e atomici" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Inizio: Protocolli ordinali e atomici</h2><p>Qui, ricorderemo brevemente il processo di diffusione di BRC-20 a tutti gli aspetti.</p>
<p>Iniziamo parlando dell’aggiornamento chiave del <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> protocollo di base lanciato nel 2017 - Witness di Isolamento, mirato ad affrontare le sfide dell’espansione di <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> e le vulnerabilità specifiche. Promuove principalmente l’inclusione di ulteriori transazioni correggendo i problemi di scalabilità delle transazioni e ampliando le restrizioni sulla dimensione dei blocchi di Bitcoin. Il witness di isolamento introduce il concetto di peso del blocco, sostituendo il limite tradizionale della dimensione del blocco e aumentando il volume delle transazioni che possono essere ospitate.</p>
<p>Alla fine del 2021, con l’aggiornamento Taproot, l’ecosistema di Bitcoin ha iniziato a supportare  e tipi di dati più complessi, portando notevoli progressi alla programmabilità e scalabilità di BTC.</p>
<p>Successivamente, ci siamo familiarizzati con gli Ordinals, che inizialmente venivano utilizzati principalmente per creare NFT. L’8 marzo 2023, lo sviluppatore anonimo Domo ha lanciato il BRC-20 basato sul protocollo Ordinals, che è un protocollo di emissione di Bitcoin Altcoin simile all’ERC-20. Definisce un formato specifico di pacchetti di dati JSON che vengono incisi sulla catena BTC attraverso gli Ordinals.<br><img src="https://gimg2.gateimg.com/image/article/170079286515321700792427_.pic.jpg" alt=""><br>Sorgente: X@ gateio_ Zh</p>
<p>Ma allo stesso tempo, gli svantaggi di BRC20 sono anche molto significativi. BRC20 richiede l’uso di un ordinatore di terze parti per registrare il registro sotto la catena BTC, il che aumenta ulteriormente la complessità e diventa un punto debole del sistema. Il trasferimento di BRC20 non viene eseguito sulla catena principale BTC e deve essere diviso in due passaggi di transazioni BTC (prima raccolta e poi trasferimento), causando un gran numero di transazioni spazzatura.</p>
<p>Successivamente, c’era un elemento di ottimizzazione in cima a questo - il protocollo atomicals, che ha considerato il problema di come emettere token in modo equo. Si basava su UTXO di Bitcoin per coniare e trasmettere, introducendo al contempo la prova del lavoro per generare un ecosistema ARC20. ATOM era il suo primo token ed è stato coniato rapidamente. Nel complesso, ARC20 è più decentralizzato, ampliando ulteriormente le possibilità dell’ecosistema Bitcoin.</p>
<h2 id="h2-RUNES2020Versione20aggiornata20dal20team20degli20Ordinals883682"><a name="RUNES - Versione aggiornata dal team degli Ordinals" class="reference-link"></a><span class="header-link octicon octicon-link"></span>RUNES - Versione aggiornata dal team degli Ordinals</h2><p>Anche se ORDI può sembrare un ‘token emesso dal team fondatore degli ordinali’, non è effettivamente il caso. Casey Rodarmor, fondatore degli ordinali, ha anche espresso insoddisfazione per il fraintendimento di molte persone secondo cui ORDI appartiene al team degli ordinativi.</p>
<p>Egli ritiene che il 99% degli FT sulla corrente catena pubblica di Bitcoin siano truffe. Infatti, secondo la situazione attuale, molti token BRC20 sono beni meme con solo valore emotivo dalla comunità. Il team di Ordinals è da tempo consapevole delle limitazioni nell’applicazione dei protocolli all’ecosistema di Bitcoin, quindi Casey ha proposto un altro protocollo RUNE - un concetto di protocollo di token fungibile basato su UTXO.<br><img src="https://gimg2.gateimg.com/image/article/170079289715331700792441_.pic_hd.jpg" alt=""><br>Origine: unsplash</p>
<p>Il protocollo RUNE può alleviare i problemi causati da garbage UTXO in BRC20, migliorare l’utilizzo della rete e il valore dell’esperienza dell’utente. Secondo Rodarmor, BRC20 richiede che tu coordini i dati off chain con la blockchain, il che comporta esperienze utente scomode. Il metodo basato sull’indirizzo non può essere utilizzato bene in combinazione con il metodo basato su UTXO di Bitcoin, causando difficoltà simili per gli utenti finali. Rodarmor sostiene che Runes è un protocollo di token alternativo semplice, basato su UTXO, con una buona esperienza utente di Bitcoin e può essere compatibile con le reti lightning.</p>
<p>È importante notare che l’attuale focus di sviluppo del team è ancora sul protocollo Ordinals, quindi i concetti legati a RUNES sono ancora nelle prime fasi. Tuttavia, possiamo fidarci delle capacità di Casey e guardare avanti al team di Ordinals, come l’“origine dell’ecosistema delle iscrizioni”, che affronta ulteriori problemi di usabilità e fornisce più scenari applicativi per l’ecosistema di Bitcoin.</p>
<p>L’autore ritiene che una volta che RUNE avrà ulteriori sviluppi, scatenerà un’altra ondata di entusiasmo nel settore delle iscrizioni.</p>
<h2 id="h2-POLS20SOLS20e20persino20ERC2020Da20una20narrazione20vuota20alla20possibilit20di20introdurre20contratti20intelligenti67283"><a name="POLS, SOLS e persino ERC-20 Da una narrazione vuota alla possibilità di introdurre contratti intelligenti" class="reference-link"></a><span class="header-link octicon octicon-link"></span>POLS, SOLS e persino ERC-20 Da una narrazione vuota alla possibilità di introdurre contratti intelligenti</h2><p>Dopo aver sperimentato un aumento impressionante di centinaia o migliaia di volte nei token BRC20 rappresentati da $ORDI e $SATS, il tasso di occupazione e le commissioni di gas della catena pubblica BTC sono aumentati di conseguenza. Nella maggior parte dei nuovi progetti simili, la popolarità del BRC-20 è anche diminuita. Tuttavia, questa “follia delle iscrizioni” ha mostrato a molti utenti una tendenza speculativa di “tutti possono partecipare, tutti possono guadagnare”. Quindi, naturalmente, si è diffusa anche dalla catena pubblica Bitcoin ad altre catene pubbliche con costi inferiori e ecosistemi più solidi.</p>
<p>Il primo a dimostrare il “trasferimento BRC20” è POLYGON, dove è nato PRC-20, modellato su BRC-20. Il primo progetto di iscrizione, $pols, per un totale di 21 milioni di fogli, è chiamato “isomero” di sats, in quanto entrambi hanno la stessa enorme offerta. La sua comparsa ha improvvisamente reso vecchia la catena pubblica <a href="/price/polygon-matic" rel="nofollow noopener noreferrer" target="_blank">Polygon</a> estremamente affollato per alcuni giorni, poiché le basse commissioni di gas e l’operatività relativamente facile hanno attirato molti utenti, e le commissioni di gas si sono moltiplicate.</p>
<p>Sono emerse rapidamente varie comunità con tutorial su come utilizzare l’assistenza di chatGPT per incidere in batch i POLS e il conteggio delle transazioni di <a href="/price/polygon-matic" target="_blank" class="blog_inner_link">Polygon</a> ha superato i 6,1 milioni, raggiungendo il suo picco nell’arco dell’anno. Ora tutti i 21 milioni di POLS sono stati sconfitti, indicando che l’entusiasmo di molti giocatori con le iscrizioni è lontano dal raggiungere il suo apice.</p>
<p>Secondo il mercato @POLS, POLS sarà completamente aperto per il trading il 24 novembre.<br><img src="https://gimg2.gateimg.com/image/article/170079293415341700792457_.pic.jpg" alt=""><br>Fonte: twitter@polsmarket</p>
<p>Il 16 novembre, subito dopo il fervore del minting di POLS, anche SPL-20 è comparso su <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a>, che può essere coniato attraverso il sito ufficiale di libreplex. Il suo metodo di coniazione è più complesso, principalmente diviso nei seguenti passaggi:</p>
<p>Prepara immagini e testo - Copia il codice - Crea un documento - Crea un NFT - Modifica i parametri - Apri LibrePlex e crea l’inizializzazione della descrizione - Modifica i parametri dell’iscrizione - Applica il codice originariamente copiato ai parametri e infine rilascia. Dopo aver verificato le informazioni dell’iscrizione, seleziona Rendi immutabile - questo completa il processo di creazione dell’iscrizione. Una volta che le informazioni sono corrette, l’iscrizione può essere indicizzata dagli utenti sulla catena SOL.</p>
<p>Rispetto a SOLS, il metodo di coniatura è relativamente complicato e potrebbe comportare errori che non possono essere cercati, ma ciò nonostante non può fermare l’entusiasmo per la partecipazione. Attualmente, sono state coniate tutte le 21000 copie. Sembra che sempre più “20” si stiano unendo.</p>
<h2 id="h2-Eths2020Uniscrizione20Ethereum20e20una20nuova20narrazione20L2603959"><a name="Eths - Un’iscrizione Ethereum e una nuova narrazione L2" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Eths - Un’iscrizione <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> e una nuova narrazione L2</h2><p>Inizialmente, poiché BTC non supportava i contratti intelligenti, BRC-20 è stato riconosciuto da molti come un protocollo basato sulle proprietà stesse di Bitcoin, modellato su ERC-20, poiché non poteva stabilire un ecosistema di applicazioni come <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a>. In un certo senso, questo è anche vero - i contratti intelligenti sono il dominio di Ethereum, mentre il BRC-20 è un’innovazione che non può essere considerata innovativa in termini di attributi BTC. Pertanto, quando Ethereum vuole anche stabilire una ‘pista di iscrizione’, sembra guidare all’indietro.</p>
<p>Ethers è un protocollo che sostituisce i contratti intelligenti e L2, consentendo agli utenti di condividere informazioni e effettuare calcoli a basso costo su Ethereum L1. Raggiunge la computazione decentralizzata applicando regole ai dati di chiamata Ethereum per bypassare lo storage e l’esecuzione del contratto intelligente. Nel agosto 2023, Ethers ha introdotto la Virtual Machine (ESC VM) per migliorare la sua funzionalità e renderla un motore di calcolo universale.</p>
<p>Gli ethers consentono di scrivere dati non finanziari e arbitrari sulla blockchain di Ethereum, consentendo agli utenti di bruciare qualsiasi tipo di file purché la dimensione del file non superi i 96 kilobyte.</p>
<p>Molti seguaci descrivono Ether come “un’altra modalità di layer2”, e i membri della comunità di Ether credono che “ETHS possa raggiungere un costo del gas più economico rispetto a L2 senza commutazione di rete rispetto ad altre soluzioni L2 (come ZK e ARB). Oggi, dopo l’aggiornamento di ESIP-5, il gas per trasferimento è stato ridotto a circa 0,05u, e l’interazione con il gas è ancora più economica rispetto a molte soluzioni L2.”</p>
<p>Attualmente, ETHS non ha le fluttuazioni esagerate di altre iscrizioni e molte persone lo trascurano. Tuttavia, con l’assistenza e l’ottimizzazione dei contratti intelligenti, l’implementazione di meccanismi come il lancio equo non è difficile e ha più elementi decentralizzati. Potremmo anche vedere che un giorno la libertà di iscrizioni Ethereum ed Ethers può portare alcune innovazioni inaspettate.<br><img src="https://gimg2.gateimg.com/image/article/170079297515351700792475_.pic.jpg" alt=""><br>Origine: unsplash</p>
<div class="blog-details-info"><br><div>Autore:<strong>Sherry S.</strong>, Ricercatore di Gate.io<br><div>Traduttore: Joy Z.<br><div class="info-tips"><em>Questo articolo rappresenta solo le opinioni del ricercatore e non costituisce alcun suggerimento di investimento.<br></em><div><em></em>Gate.io si riserva tutti i diritti su questo articolo. Sarà consentito il ripostaggio dell'articolo a condizione che venga citato Gate.io. In tutti i casi, saranno intraprese azioni legali a causa di violazioni del copyright.<br></div><p></p><br></div></div></div></div>