RGEgUXVlcnkgcGVyIENhcGlyZTogQXByaSBsYSBQYXNzd29yZCBkZWxsYSBSaWNjaGV6emEgZGVsbGUgSXNjcml6aW9uaQ==

2023-12-21, 06:40

<p><img src="https://gimg2.gateimg.com/image/article/1690791857hotspot.jpeg" alt=""></p>
<h2 id="h2-TLDR165950"><a name="TL;DR" class="reference-link"></a><span class="header-link octicon octicon-link"></span>TL;DR</h2><p>Numerare i satoshi e usarli come base per lo storage e il trading dei dati, dotando ciascun satoshi di un valore e di una significatività unici;</p>
<p>Il problema principale delle iscrizioni è ancora la scalabilità di <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a>, e l’essenza è ancora la lotta tra blocchi grandi e piccoli;</p>
<p>L’aggiornamento Taproot di BTC ha portato un cambiamento sottile, che ha di nuovo attirato l’attenzione sull’ecosistema BTC;</p>
<p>I progetti relativi alle iscrizioni coprono tracce come portafogli, catene incrociate, mercati commerciali, strumenti di coniazione e analisi dei dati.</p>
<h2 id="h2-Introduzione825501"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>Con lo sviluppo continuo e l’innovazione dell’ecosistema Bitcoin, un nuovo concetto sta attirando l’attenzione diffusa del mercato: gli ordinali.</p>
<p>L’introduzione del protocollo Ordinals ha portato nuove prospettive di applicazione a Bitcoin. Il suo nucleo consiste nel assegnare un valore unico e un significato a ciascun SATS numerandolo e utilizzandolo come base per l’archiviazione e la negoziazione dei dati.</p>
<p>Il principio di funzionamento del protocollo Ordinals può essere riassunto come “numerazione+iscrizione”. Prima assicura la sua unicità e irriproducibilità assegnando un numero seriale univoco a ciascun satoshi. Questo numero seriale è come ogni carta d’identità intelligente, è la prova della sua esistenza nell’ecosistema Bitcoin. Successivamente, il protocollo Ordinals utilizza questo numero seriale per allegare qualsiasi tipo di dati (come testo, immagini, video, ecc.) a un dispositivo specifico, un processo noto come “iscrizione”.</p>
<p>Il processo di incisione è simile alla creazione di un contratto intelligente sulla blockchain, dove i metadati e il numero seriale di Satoshi vengono codificati e archiviati sulla blockchain. Una volta confermata la transazione, i metadati e il numero seriale di Satoshi saranno memorizzati permanentemente sulla blockchain, diventando una parte immutabile.</p>
<p>In questo modo, ogni satoshi non ha solo un numero seriale unico, ma anche informazioni e storie uniche, rendendolo un nuovo tipo di token non fungibile (NFT).<br><img src="https://gimg2.gateimg.com/image/article/1703140545img_v3_026b_18393747-6965-4047-9510-1a0798df20ix.jpg" alt=""></p>
<h2 id="h2-20liscrizione20spazzatura480943"><a name="È l’iscrizione spazzatura?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>È l’iscrizione spazzatura?</h2><p>Già all’inizio del mese (6 dicembre), il post del developer principale di Bitcoin, Luke Dashjr, ha causato un’enorme scossa nel mercato delle iscrizioni. Luke ha dichiarato che l’iscrizione sta sfruttando una vulnerabilità nel client <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> Core per inviare messaggi di spam alla blockchain. Dal 2013, Bitcoin Core ha permesso agli utenti di impostare limiti di dimensione dati aggiuntivi durante l’inoltro o il mining delle transazioni. Omettendo i dati nel codice del programma, l’iscrizione evita questa limitazione.</p>
<p>L’autore fa un’analogia inappropriata, che è equivalente al fatto che le buste rosse di WeChat venivano originariamente trasferite, ma ora ogni volta che ti trasferisco 1 centesimo, entrambi insistiamo a chattare attraverso le note sulla busta rossa. Anche se è difficile dire che questo è uno sfruttamento, è molto probabile che sia abusivo o addirittura senza senso.</p>
<p>Inoltre, il normale Bitcoin non supporta la creazione di NFT, ma ciò è realizzato attraverso questa forma di “trasferimento + nota”. Nel frattempo, utilizzando la tecnologia Taproot, ha bypassato il limite superiore originale delle note e lo ha aumentato da pochi byte a un massimo di 512 byte.<br><img src="https://gimg2.gateimg.com/image/article/1703140585img_v3_026b_818037fa-069e-4f4e-a93f-f9ccbba7b6ix.jpg" alt=""></p>
<p>Ciò scriverà una grande quantità di informazioni ridondanti inutili nel blocco Bitcoin, aumentando l’onere di archiviazione dell’intero nodo. Il problema principale delle iscrizioni è ancora la scalabilità di Bitcoin e l’essenza è ancora la competizione tra blocchi grandi e piccoli. Certamente, le iscrizioni sono guidate dalla domanda di mercato, ma Bitcoin è ancora una piccola tazza. Le iscrizioni stanno giocando un tornado dentro la tazza e schiacciarlo inevitabilmente comporterà un restringimento del trading normale.</p>
<p>Ma in realtà, la blockchain stessa viene realizzata attraverso un gran numero di nodi, utilizzando algoritmi di consenso per completare congiuntamente la contabilità. Alcune persone dicono anche che la blockchain è ridondante. La decentralizzazione derivante da questa ridondanza è ciò che alcune persone sperano. Allo stesso modo, questa ridondanza porta alcune cose più interessanti all’ecosistema di Bitcoin, credendo che incorporare oggetti da collezione in Bitcoin non sia solo interessante ma anche utile.</p>
<p>Anche se Luke Dashjr ha affermato una volta che BRC-20 e il protocollo di iscrizione eludono il limite di dimensione dei blocchi Bitcoin e inseriscono forzatamente una grande quantità di dati spazzatura nei blocchi, questo approccio causerebbe un onere inutile per i nodi poiché aumenterebbe la velocità di rete, la larghezza di banda e le spese di capacità di archiviazione. Se questa situazione continua per molto tempo, ridurrà continuamente il grado di decentralizzazione nelle reti Bitcoin.</p>
<p>Ma ha anche confermato l’opinione che Bitcoin Layer 2 è la nuova destinazione per BRC-20 e ha affermato senza mezzi termini che non è necessario eliminare tutte le iscrizioni per apportare benefici alla rete Bitcoin.</p>
<h2 id="h2-Approfondimento20sul20Valore20delle20Iscrizioni974876"><a name="Approfondimento sul Valore delle Iscrizioni" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Approfondimento sul Valore delle Iscrizioni</h2><p>L’anno scorso, l’aggiornamento di Taproot di BTC ha portato un cambiamento sottile, che ha ancora una volta attirato l’attenzione sull’ecosistema di BTC.</p>
<p>Questo upgrade ha gettato una base importante per lo sviluppo di BTC dalle caratteristiche finanziarie alle caratteristiche di adozione. Con l’emergere di nuovi protocolli come Ordinals, Drivechain, BitVM e Taprot Asset, le proprietà di adozione di Bitcoin si sono ulteriormente sviluppate.<br><img src="https://gimg2.gateimg.com/image/article/1703140624img_v3_026b_0b196d54-8d94-4237-b9d4-6990746212ix.jpg" alt=""></p>
<p>Il valore dell’iscrizione delle azioni BTC presenta somiglianze con il valore dei gioielli in oro, entrambi possono essere esposti e condensati in un consenso estetico parzialmente separato. La somiglianza di questa forma di valore significa che se comprendi questa logica, capirai perché l’iscrizione ha recentemente riacquistato vitalità dopo la sua apparente breve apparizione a marzo di quest’anno.</p>
<p>La particolarità delle iscrizioni non risiede solo nelle varie immagini o caratteri che attualmente portano, ma anche nella possibilità di trasportare ulteriori informazioni in futuro. Queste informazioni possono diventare nuovi ancoraggi di valore, proprio come la ciotola utilizzata dall’Imperatore Qin Shi Huang, che non è solo una ciotola ordinaria, ma trasporta anche valori storici e culturali. Pertanto, il valore delle iscrizioni potrebbe superare di gran lunga quello di BTC stesso, in quanto potrebbero diventare nuovi ancoraggi di valore.</p>
<h2 id="h2-Progetti20di20iscrizione20selezionati561215"><a name="Progetti di iscrizione selezionati" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Progetti di iscrizione selezionati</h2><p>I progetti legati alle iscrizioni coprono vari settori come portafogli, cross chain, mercati di scambio, strumenti di fusione, dati &amp; query, ecc. Abbiamo selezionato 5 progetti che potrebbero diventare la prossima traccia stellare e condividerli con tutti. Le suggerimenti non sono di investimento sono solo a scopo di riferimento, e stiamo cercando infrastrutture legate alle iscrizioni.<br><img src="https://gimg2.gateimg.com/image/article/1703140655img_v3_026b_933bb54d-f921-4634-8f06-ee784b4e22ix.jpg" alt=""></p>
<p><strong>Unisat</strong><br>Unisat è un portafoglio plugin di iscrizione Bitcoin open source non custodiale che supporta Ordinals e BRC20, aiutando gli utenti a memorizzare, coniare e trasmettere token BRC20, compresi l’acquisto e la vendita di BTC, NFT, nomi a dominio e altro. Inoltre, Unisat Marketplace è un mercato Insights sulla catena Bitcoin sotto Unisat che si basa su PSBT e supporta asset BRC-20. A novembre, si è classificato al quarto posto nel mercato NFT con un volume di scambi di $41 milioni.<br><img src="https://gimg2.gateimg.com/image/article/1703140686img_v3_026b_4213d0b3-2f36-464a-bf6f-2d26c53c1cix.jpg" alt=""></p>
<p><strong>BIIS</strong><br>BIIS mira a creare l’ultima pila tecnologica integrata e conveniente per i token BRC20, posizionata come il “BRC Eco Toolbox” per sviluppatori e utenti. Si prefigge di fornire un set completo di strumenti di integrazione per sviluppatori e utenti di progetti, compresa la distribuzione e la raccolta batch di token BRC20, la distribuzione e la raccolta batch di asset NFT come BRC-721 e altri strumenti di integrazione. In futuro, verrà lanciata anche una piattaforma di rilascio di asset completamente automatizzata, supportando modalità di rilascio di asset multi-modali come Free Mint/AirDrop/IDO e fornendo al team del progetto un sistema di voto Dao inciso per realizzare il rilascio automatizzato del progetto e la governance decentralizzata della comunità.<br><img src="https://gimg2.gateimg.com/image/article/1703140710img_v3_026b_d37c17b0-2297-4b45-843e-2a03fa9f2fix.jpg" alt=""></p>
<p><strong>MultiBit</strong><br>MultiBit è un protocollo cross-chain tra BRC20 e ERC20, basato sul design bidirezionale del ponte cross-chain BRC20, mirato a raggiungere la trasmissione cross-chain tra i token BRC20 e ERC20.<br><img src="https://gimg2.gateimg.com/image/article/1703140734img_v3_026b_6b11479d-74d7-4dac-a125-4101e4c723ix.jpg" alt=""></p>
<p><strong>GeniiData</strong><br>GeniiData è una piattaforma di analisi dei dati dell’ecosistema Ordinals che fornisce l’indice di popolarità e i dati di classifica dei token BRC20, supportando gli utenti nella cattura in tempo reale delle iscrizioni più calde e degli NFT.</p>
<p>Nel frattempo, ha lanciato il servizio di indicizzazione ORC-20, che mostra principalmente informazioni sulla distribuzione del token ORC-20, tra cui l’offerta massima, lo stato attuale della coniazione delle monete e se può essere aggiornato, le informazioni sul detentore del token ORC-20, i record delle transazioni e la possibilità di verificare lo stato della transazione.<br><img src="https://gimg2.gateimg.com/image/article/1703140765img_v3_026b_fff3d0f9-247e-42ab-ad0c-e358b8268eix.jpg" alt=""></p>
<p><strong>Magic Eden Bitcoin</strong><br>Magic Eden Bitcoin è un mercato NFT dell’ecosistema Bitcoin lanciato a marzo di quest’anno, che consente agli utenti di elencare, acquistare e vendere Ordinals. Inoltre, Magic Eden ha anche lanciato il Bitcoin Launchpad, con l’obiettivo di aiutare i creatori a lanciare direttamente il protocollo Ordinals e creare NFT di Bitcoin su Magic Eden Launchpad.</p>
<h2 id="h2-Conclusione996870"><a name="Conclusione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusione</h2><p>Nel mondo della blockchain, vengono costantemente proposti nuovi concetti e l’attuale corsa alle iscrizioni è così, come se tutte le catene pubbliche stessero iniziando a “cultura delle iscrizioni”.</p>
<p>Siamo in un campo in cui i codici di ricchezza cambiano rapidamente, ed è difficile per te essere distratto nemmeno per un secondo, perché il secondo successivo qualcuno potrebbe fare profitto su un progetto che conosci ma non sei sicuro. Questo tipo di effetto di profitto o perdita attira capitale in modo continuo <a href="/price/flow-flow" rel="nofollow noopener noreferrer" target="_blank">Flusso</a> nell’ecosistema delle iscrizioni, formando l’effetto Matteo, che fa sì che sempre più persone si affollino ad esso.</p>
<p>In sintesi, anche se l’emergere delle iscrizioni ha accelerato lo sviluppo della blockchain di Bitcoin verso uno stato che è sempre stato quasi pieno, potrebbe portare ad un aumento della congestione nella rete Bitcoin e rendere l’uso di Bitcoin più costoso. Ma dovremmo essere più consapevoli del fatto che l’emergere degli ordinali di Bitcoin ha infranto il concetto tradizionale di NFT, portando nuove prospettive di applicazione all’ecosistema Bitcoin conferendo a ciascun individuo un valore e una significatività unici.</p>
<p>Al momento ci sono ancora alcune sfide, ma dobbiamo credere che con il continuo progresso della tecnologia e l’espansione degli scenari di applicazione, abbiamo motivo di credere che le iscrizioni giocheranno un ruolo ancora più importante in futuro e guideranno l’innovazione e lo sviluppo di tutto l’ecosistema Bitcoin.</p>
<div class="blog-details-info"><br><div>Autore:<strong>Byron B.</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 ripostare l'articolo a condizione che venga citato Gate.io. In tutti i casi, verranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div></div>