SXNjcml6aW9uZSBPIEwyOiBEZWNpc2lvbmUgZGkgU3ZpbHVwcG8gZGVsbCdFY29zaXN0ZW1hIEJpdGNvaW4=

2023-12-21, 06:58

<p><img src="https://gimg2.gateimg.com/image/article/1692587449analysis.jpeg" alt=""></p>
<h2 id="h2-TLDR70241"><a name="[TL;DR]:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL;DR]:</h2><p><a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> L’iscrizione è un nuovo metodo per scrivere dati arbitrari sulla blockchain di Bitcoin. Le iscrizioni come ORDI e SATS hanno scatenato una serie di infrastrutture correlate e causato effetti di spillover su altre iscrizioni di catene pubbliche.</p>
<p>Le due tracce di Iscrizione e L2 non solo competono in termini di tecnologia e filosofia, ma si basano anche l’una sull’altra per promuovere la scoperta del valore di Bitcoin. In futuro, porteranno più casi d’uso e libereranno ulteriormente il fascino e il valore della rete Bitcoin.</p>
<h2 id="h2-Introduzione576316"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>Con il lancio della funzione <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> Inion, sempre più utenti stanno iniziando a utilizzare Bitcoin per transazioni NFT, archiviazione di metadati e altre applicazioni. Anche vari progetti L2 basati su Bitcoin stanno iniziando a rientrare nel mercato.</p>
<p>Tuttavia, questioni come le alte commissioni di transazione di rete e la lenta velocità di liquidazione di Bitcoin stanno diventando sempre più evidenti. Ciò ha nuovamente suscitato discussioni sul piano di sviluppo dell’ecosistema Bitcoin.</p>
<p>In passato, sono emersi vari piani di emissione ed espansione di asset attorno alle problematiche di performance di Bitcoin, tra cui l’aumento dello spazio di blocco, le sidechain, le reti di lightning, e così via. Tuttavia, queste soluzioni non sono state ampiamente adottate a causa del perseguimento fondamentalista della comunità Bitcoin.</p>
<p>Oggi, con la crescente domanda di scambi di iscrizioni, hanno iniziato a sorgere dibattiti sulla direzione dello sviluppo dell’ecosistema di Bitcoin: se continuare a sviluppare accordi di attività correlati alle iscrizioni o costruire un ecosistema Layer2 espanso.</p>
<p>L’articolo fornirà una discussione dettagliata di queste due direzioni a beneficio dei lettori.</p>
<h2 id="h2-Inscrizione20Bitcoin20Goditi20una20moda20in20questi20giorni29662"><a name="Inscrizione Bitcoin: Goditi una moda in questi giorni" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Inscrizione Bitcoin: Goditi una moda in questi giorni</h2><p>Bitcoin Inion è un nuovo metodo per scrivere dati arbitrari sulla blockchain di Bitcoin. Utilizza il tipo di  P2TR (Pay-to-Taproot) introdotto nell’aggiornamento Bitcoin Taproot. Lo  P2TR consente di archiviare dati arbitrari utilizzando l’output delle transazioni Bitcoin.</p>
<p>Le iscrizioni di Bitcoin possono essere utilizzate per vari scopi, tra cui:</p>
<p>-Creazione di token non fungibili (NFT): Gli NFT sono un’attività digitale unica e rara. Le iscrizioni di Bitcoin possono essere utilizzate per creare NFT per rappresentare opere d’arte, oggetti da collezione, articoli di gioco e altro ancora.</p>
<p>-Metadati di archiviazione: le iscrizioni Bitcoin possono essere utilizzate per archiviare metadati, come titoli delle immagini, autori, informazioni sul copyright, ecc. Ciò può facilitare la tracciabilità e la gestione delle immagini.</p>
<p>-Implementazione di una logica complessa: le iscrizioni Bitcoin possono essere utilizzate per implementare una logica complessa, come gli smart contract. Questo può portare nuove possibilità di applicazione per la blockchain di Bitcoin.</p>
<p>È proprio sulla base dei seguenti vantaggi che l’iscrizione di Bitcoin ha scatenato una frenesia di mercato quest’anno.</p>
<ul>
<li>Decentralizzazione: le iscrizioni di Bitcoin sono memorizzate sulla blockchain di Bitcoin, possedendo quindi la caratteristica di decentralizzazione.</li></ul>
<p>-Sicurezza: la blockchain di Bitcoin ha una sicurezza estremamente elevata, quindi anche le iscrizioni Bitcoin hanno un’elevata sicurezza.</p>
<ul>
<li>Scalabilità: le iscrizioni di Bitcoin non sono limitate dalla dimensione del blocco, quindi hanno una buona scalabilità.<br><img src="https://gimg2.gateimg.com/image/article/1703141737img_v3_026b_074250c9-ccf1-4c19-9431-a3fe34da5eix.jpg" alt=""><br>Sorgente: Gate.io</li></ul>
<p>Abbiamo precedentemente scritto diversi articoli per presentare la situazione di mercato delle iscrizioni rappresentate da ORDI, SATS e RATS. Qui non forniremo spiegazioni dettagliate delle iscrizioni specifiche.</p>
<p>Con la diffusione della popolarità del mercato delle iscrizioni, molti sviluppatori hanno proposto anche molti protocolli di iscrizione basati sulla rete Bitcoin, utilizzando vari mezzi tecnologici per soddisfare i requisiti di iscrizioni ad alta efficienza e a basso costo.</p>
<h2 id="h2-Nostr20Asset175050"><a name="Nostr Asset" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Nostr Asset</h2><p>NostrAssets è un protocollo decentralizzato open-source che mira a integrare in modo integrato gli asset Taprot e Bitcoin nell’ecosistema Nostr.</p>
<p>Consente agli utenti di utilizzare le chiavi pubbliche e private di Nostr per varie attività finanziarie, inviare, ricevere e scambiare asset digitali; È una rete di rilè senza autorizzazione e senza fiducia che combina la funzionalità delle iscrizioni Bitcoin (Taproot) con la gestione di asset digitali.</p>
<p>Attualmente, è iniziata l’attività di lotteria per la seconda fase del casting equo di NOSTR. Come token di prova investiti nel mercato degli asset, Treat e Trick hanno già generato oltre 20 volte il rendimento, e Gate.io continuerà a monitorare i progressi del progetto.</p>
<h2 id="h2-Atomicals409329"><a name="Atomicals" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Atomicals</h2><p>Il protocollo Atomicals è un protocollo semplice e flessibile utilizzato per creare, scambiare e aggiornare oggetti digitali sulla blockchain dei modelli UTXO come Bitcoin.</p>
<p>Il protocollo Atomicals è più completo in funzionalità rispetto al ben noto protocollo Ordinals. Supporta vari tipi di oggetti digitali come token, NFT, domini, contenitori, ecc., offrendo agli sviluppatori e agli utenti scelte più flessibili. Dall’avvio, il protocollo Atomicals ha attirato numerosi sviluppatori e utenti, e ha raggiunto uno sviluppo rapido, con volumi di casting che raggiungono decine di migliaia.</p>
<h2 id="h2-Trac474435"><a name="Trac" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Trac</h2><p>Trac è un importante metaprotocollo decentralizzato nell’ecosistema Bitcoin, che fornisce strumenti necessari per gli sviluppatori che utilizzano gli ordinali. L’emergere di Trac risolve il problema dell’alta centralizzazione nei tracker di metaprotocolli esistenti, il che è coerente con la natura decentralizzata delle criptovalute come Bitcoin. Trac fornisce una rete decentralizzata che consente a chiunque di connettersi, utilizzare e trarre vantaggio da essa.</p>
<p>Trac ha stabilito partnership con diversi progetti, tra cui Bitmap e InscribedHandles. Inoltre, Trac collabora attivamente con singoli sviluppatori interessati all’implementazione della sua tecnologia. Queste partnership contribuiranno a una più ampia applicazione di Trac nell’ecosistema Bitcoin.</p>
<p>Attualmente, Gate.io ha lanciato questo token.</p>
<p>Oltre all’infrastruttura relativa alle iscrizioni sopra menzionate, ci sono molte altre iscrizioni e accordi che esplorano questo mercato, di cui abbiamo già discusso. Non c’è bisogno di dilungarsi qui.</p>
<h2 id="h2-Bitcoin20L220Ottieni20una20nuova20svolta20nella20vita162900"><a name="Bitcoin L2: Ottieni una nuova svolta nella vita" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Bitcoin L2: Ottieni una nuova svolta nella vita</h2><p>Lo schema Bitcoin L2 è una rete di secondo livello costruita al di fuori della catena principale di Bitcoin, che può migliorare la scalabilità di Bitcoin attraverso vari metodi, tra cui Lightning Network, tecnologia sidechain, BitVM, ecc.</p>
<p>Guidato dalla tendenza delle iscrizioni, lo schema L2 è recentemente iniziato ad essere favorito dai fondi di mercato. Ad esempio, progetti veterani di Bitcoin L2 come STX e RIF hanno registrato rispettivamente i loro più alti incrementi del 90% e del 60% nel mese di dicembre.</p>
<p>In generale, ci sono due idee principali per la soluzione di scalabilità di Bitcoin: scalabilità on-chain e scalabilità off-chain.</p>
<p>La scalabilità on-chain si riferisce all’espansione diretta sulla blockchain di Bitcoin, come ad esempio la modifica della dimensione dei blocchi o della struttura dei dati. Tuttavia, questo metodo è tecnicamente difficile e può portare a frammentazione del consenso, quindi oggi non è più predominante.</p>
<p>La scalabilità off-chain si riferisce all’istituzione di una rete di trading di secondo livello al di fuori della catena principale di Bitcoin, come reti di fulmini, sidechain, ecc. Questo metodo può trasferire alcune transazioni fuori dalla catena, migliorando così la capacità di elaborazione della catena principale.</p>
<p>Attualmente, ci sono diversi tipi di soluzioni di espansione off-chain:</p>
<p>I canali di stato, come le reti di fulmini, possono trasferire transazioni ad alta frequenza fuori dalla catena, migliorando la velocità di transazione.</p>
<p>Side chains, come Liquid, <a href="/price/stacks-stx" rel="nofollow noopener noreferrer" target="_blank">Stacks</a>, e Rootstock, possono trasferire gli asset Bitcoin alla side chain, migliorando la scalabilità e la flessibilità.</p>
<p>Altre aree, come la tecnologia Rollup e BitVM per la prova di frode, hanno mostrato un progresso leggermente più lento in questo settore.</p>
<p>Abbiamo anche scritto diversi articoli nel nostro blog presentando Lightning Network, BitVM, ecc. Qui, introdurremo brevemente il progresso di altri progetti.</p>
<h2 id="h2-Stacks682958"><a name="Stacks" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Stacks</h2><p>Stacks è un vecchio protocollo L2 lanciato nel 2018, con la sua tecnologia principale che è il meccanismo di consenso PoW-to-Proof-of-Transfer (PoW-to-PoX). Il meccanismo PoW-to-PoX combina il meccanismo di consenso PoW di Bitcoin con il meccanismo di consenso PoX per ottenere la sicurezza e la decentralizzazione di Bitcoin, migliorando al contempo la scalabilità dei contratti intelligenti.<br><img src="https://gimg2.gateimg.com/image/article/1703141840img_v3_026b_f63536b5-97ba-4619-b1b7-1b0b373200ix.jpg" alt=""><br>Fonte: sito ufficiale di Stacks</p>
<p>Sin dal suo lancio, <a href="/price/stacks-stx" target="_blank" class="blog_inner_link">Stacks</a> è stato criticato dalla comunità Bitcoin per deviare dal valore di Bitcoin, ma con l’arrivo degli aggiornamenti Nakamoto, questa situazione sarà efficacemente alleviata.</p>
<p>L’aggiornamento di Nakamoto consentirà rapidamente ai blocchi di essere scritti su Bitcoin in modo completamente decentralizzato, consentendo agli sviluppatori di costruire contratti intelligenti su Bitcoin in modo completamente decentralizzato. Inoltre, ridurrà significativamente i tempi di esecuzione, rendendo Stacks una piattaforma di contratti intelligenti più competitiva.</p>
<p>Il token di protocollo STX è supportato sia dai prodotti spot che dai contratti perpetui su Gate.io.</p>
<h2 id="h2-Rootstock832640"><a name="Rootstock" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Rootstock</h2><p>Rootstock è la prima sidechain compatibile con EVM sulla rete Bitcoin, sviluppata e lanciata da IOV Labs nel gennaio 2018. La sua tecnologia principale è Rootstock VM (RVM).<img src="https://gimg2.gateimg.com/image/article/1703141865img_v3_026b_98a55b04-8dfe-488a-a34c-d10665fabbix.jpg" alt=""><br>Sorgente: Sito web ufficiale di Rootstock</p>
<p>RVM è una macchina virtuale basata su Bitcoin che può eseguire smart contract scritti in linguaggio Solidity. L’obiettivo di design di RVM è essere compatibile con la sicurezza e la decentralizzazione di Bitcoin, migliorando nel contempo la scalabilità degli smart contract.</p>
<p>Secondo i dati visualizzati sul sito ufficiale di Rootstock, il suo TVL di blocco dell’ecosistema raggiunge attualmente i 300 milioni di dollari, con oltre 100 progetti di implementazione che coprono diverse aree come Swap, ponti cross-chain, prestiti, macchine oracle, canali di pagamento, portafogli, ecc. È uno dei protocolli di alta qualità con un ecosistema Bitcoin L2 relativamente completo.</p>
<h2 id="h2-Per20riassumere293769"><a name="Per riassumere" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Per riassumere</h2><p>L’espansione dell’ecosistema di Bitcoin Inion è inarrestabile e la rete L2 di Bitcoin esperimenterà anche un vigoroso sviluppo in futuro. L’anno scorso indica che nel mercato rialzista di Bitcoin, <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> e le catene EVM potrebbero perdere la loro posizione dominante, mentre ci si aspetta che l’ecosistema Bitcoin diventi il centro della nuova generazione di finanza crittografica.</p>
<p>Con il miglioramento di varie strutture tecnologiche e la partecipazione di sempre più utenti, il progetto Bitcoin Inion e L2 verrà lanciato in grande quantità nel 2024, arricchendo ulteriormente l’ecosistema Bitcoin.</p>
<p>Analogamente al percorso di evoluzione dell’ecosistema del precedente mercato rialzista, la DeFi Summer del 2020 ha avuto origine da <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> e ha creato molti effetti ricchezza attraverso nuovi modelli come il liquidity mining.</p>
<p>Successivamente, il boom delle infrastrutture ha aperto nuove piste come NFT e GameFi. L’iscrizione ha avuto origine da Bitcoin ed è passata attraverso le prime fasi pionieristiche della catena, il lancio di Unisat e l’ingresso in CEX, completando la prima predicazione del mercato e l’accumulo di capitale.</p>
<p>La crescente popolarità delle iscrizioni Bitcoin è dovuta alla diffusione globale del mondo cinese, che ha guidato lo sviluppo delle infrastrutture e persino delle iscrizioni L2 su Bitcoin.</p>
<p>Inoltre, le due tracce di Inion e L2 non competono solo in tecnologia e filosofia, ma si basano anche l’una sull’altra per promuovere la scoperta del valore di Bitcoin. In futuro, ci sarà una tendenza di dominio duale.</p>
<p>Nonostante ci siano ancora molte controversie, l’ecosistema Bitcoin sta decollando inarrestabilmente. Che si tratti di iscrizioni/runi o soluzioni di scalabilità L2, questi progetti affronteranno una feroce concorrenza, e la produzione di un gran numero di progetti porterà senza dubbio più casi d’uso e libererà ulteriormente il fascino e il valore della rete Bitcoin.</p>
<div class="blog-details-info"><br><div>Autore:<strong>Carl Y.</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. Il ripostaggio dell'articolo sarà consentito a condizione che venga fatto riferimento a Gate.io. In ogni caso, saranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div></div>