R2xpIGFzc2V0IGRpIFRhcHJvb3Qgc2FyYW5ubyBpbCBwcm9zc2ltbyBsaXZlbGxvIDIgZGkgQlRDPw==

2023-10-26, 03:24

<p><img src="https://gimg2.gateimg.com/image/article/1692587449analysis.jpeg" alt=""></p>
<h2 id="h2-TLDR356127"><a name="[TL;DR]:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL;DR]:</h2><p>Il protocollo Taproot Assets è un livello di asset nativo costruito su <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a>, fornendo funzionalità di base per sviluppatori per emettere, inviare, ricevere e scoprire asset sulla blockchain di <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> senza causare l’espansione della rete Bitcoin.</p>
<p>Gli asset di Taproot non utilizzano Bitcoin come un livello di disponibilità dati completo, e gli utenti devono indicizzare o configurare la memorizzazione dei dati al di fuori della catena.</p>
<p>Attualmente, gli asset di Taproot sono più adatti per scenari di trading ad alta frequenza, come i token fungibili (stablecoin, ecc).</p>
<h2 id="h2-Introduzione281954"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>La società di infrastrutture Layer2 di Bitcoin, Lightning Labs, ha recentemente rilasciato la versione alpha della rete principale degli asset di Taproot, affermando ufficialmente che il protocollo fornirà un’esperienza di sviluppo completamente funzionale per l’emissione, gestione ed esplorazione di stablecoin o altri asset sulla blockchain di Bitcoin.</p>
<p>In realtà, ci sono già molti progetti volti a espandere le prestazioni delle reti Bitcoin, come il BRC20 di cui abbiamo parlato sul nostro blog e il recente BitVM. Tuttavia, la rete lightning sviluppata da Lighting Labs mantiene ancora il principale vantaggio in termini di completezza del sistema e gamma di servizi applicativi. Quali sono i punti salienti dei loro attuali Taproot Assets, se possono diventare un progetto leader in BTC L2 e come influenzeranno la situazione di mercato, l’articolo verrà pubblicato insieme.</p>
<h2 id="h2-Concezione20tecnica20degli20asset20di20Taprot940860"><a name="Concezione tecnica degli asset di Taprot" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Concezione tecnica degli asset di Taprot</h2><p>Secondo il protocollo BIP di Taproot Assets, il protocollo Taproot Assets è uno strato di asset nativi di Taproot costruito su Bitcoin.</p>
<p>Questo protocollo fornisce funzionalità di base per gli sviluppatori per emettere, inviare, ricevere e scoprire asset sulla blockchain di Bitcoin cercando di raggiungere una maggiore privacy e scalabilità, senza causare l’espansione della rete Bitcoin. <img src="https://gimg2.gateimg.com/image/article/169829046012011698290368_.pic.jpg" alt=""><br>Figura 1: Esempio di ricevuta e pagamento per gli asset di Taproot</p>
<p>Sappiamo che Bitcoin può ottenere una programmazione limitata scrivendo “codice semplice” in uno  all’indirizzo Taproot e quindi eseguendolo come istruzione per la condizione di spesa UTXO.</p>
<p>Nello scenario di emissione di asset di Taproot Assets, il sistema può specificare questo semplice codice operativo come le regole di base dell’importo totale di emissione, del tempo di emissione, dell’oggetto di emissione, ecc. del token. Collegandosi a un insieme di indirizzi firmati multipli, il codice operativo può essere attivato congiuntamente, realizzando così una funzione di trading batch punto a punto.</p>
<p>Un aspetto interessante del processo di implementazione tecnica del protocollo è che i nodi di rilancio della rete Lightning svolgono funzioni di gestione contabile per la gestione e la distribuzione degli asset, consentendo interazioni di distribuzione a basso costo, ad alta frequenza ed efficienti.</p>
<p>In questo processo, la nuova struttura ad albero originale di Taproot supporta gli sviluppatori nell’incorporare metadati di asset arbitrari, mentre i partecipanti al trasferimento di Taproot Assets sopportano i costi di verifica e archiviazione. Di conseguenza, un sistema di contabilità decentralizzato per l’emissione, gestione e distribuzione di più asset ha iniziato a prendere forma.</p>
<p>In sintesi, gli asset Taproot hanno le seguenti caratteristiche tecniche:</p>
<p>Bassa occupazione UTXO (simile a Runes/IPE), poiché gli utenti possono creare o trasferire più token in una singola transazione;</p>
<p>Gli utenti possono archiviare la maggior parte dei loro dati di transazione al di fuori della catena stessa o nell’universo, il che significa che l’occupazione in catena delle grandi transazioni è molto piccola;</p>
<p>È completamente basato su UTXO, quindi può essere ben integrato con Lightning di Bitcoin, DLC, RGB, ecc;</p>
<p>È direttamente integrato con Lightning, quindi dopo il trasferimento su Lightning (tutti i token+BTC in una singola transazione), gli utenti possono effettuare transazioni veloci e economiche.</p>
<h2 id="h2-Le20prospettive20applicative20degli20asset20Taproot55393"><a name="Le prospettive applicative degli asset Taproot" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Le prospettive applicative degli asset Taproot</h2><p>Rispetto al basso livello, semplice e leggermente grezzo del BRC20 di quest’estate, il design del protocollo multi-asset di Taproot Assets è più completo e rigoroso e può integrare soluzioni tecnologiche native come RGB, DLC e Lightning Network. Attualmente, è più adatto per scenari di trading ad alta frequenza, come token fungibili (stablecoin, ecc).<img src="https://gimg2.gateimg.com/image/article/169829050912021698290384_.pic.jpg" alt=""><br>Figura 2: Spiegazione di Lightning Labs su Taproot Assets</p>
<p>Poiché gli Asset Taproot non utilizzano Bitcoin come completo strato di disponibilità dei dati, gli utenti devono indicizzare o configurare lo storage dei dati al di fuori della catena, quindi gli scenari di applicazione del protocollo saranno limitati. Di seguito sono riportati alcuni potenziali scenari di adattamento:</p>
<p>-Introduzione di stablecoin sugli asset di Taproot (il focus principale del laboratorio di lighting)</p>
<p>-Emissione e trasferimento di altri token su asset Taproot</p>
<ul>
<li>Funzione di ricezione asincrona e trasmissione e trasferimento di token one-to-many in una singola transazione</li></ul>
<p>-Implementazione di Taproot Assets+Lightning Network per alcuni casi d’uso di Bitcoin DeFi</p>
<p>-Combinazione con BRC20, mining proof-of-work Atomicals e altre forme di mining, ecc</p>
<p>-Creazione e trasferimento di asset ERC-721 e ERC-1155</p>
<p>Secondo fonti ufficiali, dal lancio del mainnet di Taproot Assets il 18 ottobre, l’accordo ha emesso oltre 15.000 asset diversi.</p>
<p>Nel complesso, Taproot Assets ha i suoi compromessi in termini di direzione rispetto ai protocolli di token intercambiabili esistenti di Bitcoin. Non è la soluzione definitiva per Bitcoin L2, ma propone una direzione di sviluppo multi asset pratica e fattibile che può svolgere un buon ruolo in scenari consolidati.</p>
<h2 id="h2-Limpatto20degli20asset20Taproot20sulle20condizioni20di20mercato713234"><a name="L’impatto degli asset Taproot sulle condizioni di mercato" class="reference-link"></a><span class="header-link octicon octicon-link"></span>L’impatto degli asset Taproot sulle condizioni di mercato</h2><p>Il protocollo Taproot Asset lanciato da Lightning Labs si impegna a realizzare funzioni di emissione e gestione di più asset sulla rete Bitcoin. Nonostante ci siano ancora molte barriere tecniche e bug, la prosperità dell’ecosistema Bitcoin è giunta al termine.</p>
<p>In futuro, poiché il protocollo supporta le reti Lightning e completa le funzioni dei canali di pagamento, emergeranno progetti di supporto come portafogli decentralizzati e canali di pagamento per il consumo offline. Allo stesso tempo, gli utenti saranno in grado di ricevere, inviare e gestire in modo efficiente e conveniente token personalizzati attraverso le reti Lightning, il che contribuirà a migliorare ulteriormente il tasso di adozione effettivo di Bitcoin.</p>
<p>Si può prevedere che con il lancio e lo sviluppo di Bitcoin meta protocolli come Taproot Asset, BRC20, Runes e BitVM, l’ecosistema di Bitcoin diventerà sempre più prospero, compensando in qualche modo le carenze di <a href="/how-to-buy/moonbeam-glmr" rel="nofollow noopener noreferrer" target="_blank">dove acquistare glmr</a> diventare l’ecosistema dominante e persino diventare una nuova narrazione per il prossimo mercato rialzista di Bitcoin.<img src="https://gimg2.gateimg.com/image/article/169829063112031698290408_.pic.jpg" alt=""><br>Figura 3: Coppie di trading ORDI/USDT su Gate.io</p>
<p>Infine, va notato che come piattaforma leader nel trading di asset crittografici nell’industria, Gate.io ha sempre seguito i professionisti che contribuiscono al progresso tecnologico e all’innovazione dei prodotti nell’industria crittografica. Ad esempio, nell’Ordinals Summer di quest’anno, siamo stati i primi a lanciare il token principale $ORDI, guidando la follia ‘popolare’ per le iscrizioni Bitcoin. In futuro, continueremo a prestare attenzione a sviluppi più innovativi nell’ecosistema Bitcoin, fornendo agli investitori osservazioni di valore e prodotti di investimento migliori.</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. Sarà consentito ripubblicare l'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>