U3ZlbGFuZG8gaWwgcG90ZW56aWFsZSBkZWkgdG9rZW4gQlJDLTIwIGRpIEJpdGNvaW4=

2023-05-12, 01:14

<p><img src="https://gimg2.gateimg.com/blog/1679447253722320711jiami.jpeg" alt=""><br>L’avvento della tecnologia blockchain ha aperto un’era di innovazione, creando un intero ecosistema di asset digitali, con <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> al timone. Essendo la prima e più rinomata criptovaluta, <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> ha stabilito il passo per questa rivoluzione tecnologica. Ora, in un nuovo ed emozionante sviluppo, <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> ha una nuova funzionalità: i token BRC-20. Il token BRC-20 è uno standard tecnico utilizzato per i contratti intelligenti sulla piattaforma. <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> blockchain. Come concetto simile a <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> I token ERC-20 di Gate.io, così come i token BRC-20, rappresentano un significativo passo in avanti. <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> evoluzione di ‘s, diversificando i suoi casi d’uso e aumentando la sua funzionalità.</p>
<h2 id="h2-Standard20dei20token20BRC202020Lorigine52139"><a name="Standard dei token BRC-20 - L’origine" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Standard dei token BRC-20 - L’origine</h2><p>Un programmatore pseudonimo noto come Domo ha creato gli standard del token BRC-20 nel marzo 2023. Questa creazione è stata ampiamente spinta dal lancio del <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Protocollo Ordinals nel gennaio 2023, che ha permesso per la prima volta di creare token non fungibili (NFT) sulla <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> blockchain. La visione di Domo era quella di estendere questa capacità dai token non fungibili a quelli fungibili. È stato così ideato lo standard del token BRC-20, che consente di creare e coniare token fungibili direttamente sul <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> rete.</p>
<p>Il <a href="https://www.gate.io/trade/ORDI_USDT" target="_blank">il primo token BRC-20 ad essere implementato è stato “ORDI”,</a> preparando il terreno per altri token da seguire. Nei mesi successivi, sono stati lanciati molti token BRC-20, compresi diversi token meme, ognuno contribuendo alla crescita esponenziale di questo ecosistema nascente. Al momento della stesura, alcuni token BRC-20 hanno registrato un significativo aumento del loro prezzo, ottenendo capitalizzazioni di mercato significative.</p>
<h2 id="h2-Come20funzionano20i20token20BRC20875455"><a name="Come funzionano i token BRC-20?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Come funzionano i token BRC-20?</h2><p>I token BRC-20 operano utilizzando il <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Il protocollo degli ordinali, un sistema unico che consente la numerazione dei singoli satoshi e l’aggiunta di dati aggiuntivi ad essi attraverso un processo chiamato “iscrizione”.</p>
<p>Per creare, coniare e trasferire token BRC-20, gli sviluppatori scrivono i dati JSON (Java Object Notation) sul <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> La blockchain. Lo standard dei token BRC-20 include funzioni specifiche per queste operazioni: la funzione ‘deploy’ per creare un nuovo token BRC-20, la funzione ‘mint’ per generare una quantità specificata del nuovo token creato e la funzione ‘transfer’ per spostare questi token tra gli indirizzi.</p>
<p>Nonostante questa tecnologia abbia un enorme potenziale, è importante notare che è ancora agli inizi. Il processo di implementazione, coniazione e trasferimento dei token BRC-20 non è ancora user-friendly e l’infrastruttura di supporto è limitata. Tuttavia, man mano che l’ecosistema BRC-20 continua a evolversi, ci si aspetta che questi processi diventino più efficienti e accessibili.</p>
<h2 id="h2-Vantaggi20dei20token20BRC20509708"><a name="Vantaggi dei token BRC-20" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Vantaggi dei token BRC-20</h2><p><strong>Sicurezza</strong>: Uno dei principali vantaggi dei token BRC-20 è la loro sicurezza intrinseca. Poiché questi token esistono sulla <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> blockchain, beneficiano della robusta sicurezza che offre <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Alessio</a> fornisce il protocollo. <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Il meccanismo di consenso Proof of Work (PoW) di e l’ampia rete di miner lo rendono una delle blockchain più sicure.</p>
<p><strong>Compatibilità</strong>: I token BRC-20 sono compatibili nativamente con <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Alessio</a> blockchain, agevolando l’integrazione senza soluzione di continuità nel <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> questa compatibilità consente l’utilizzo dell’ecosistema esistente. <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> sviluppatori per costruire e incorporare facilmente token BRC-20 nei loro progetti.</p>
<p><strong>Fungibilità</strong>: I token BRC-20 sono fungibili, il che significa che ciascun token è interscambiabile con qualsiasi altro token identico. Questa caratteristica li rende facilmente negoziabili su varie piattaforme, offrendo un’alternativa semplice e accessibile per i nuovi arrivati a <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> trading.</p>
<h2 id="h2-Svantaggi20dei20token20BRC20312199"><a name="Svantaggi dei token BRC-20" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Svantaggi dei token BRC-20</h2><p>Sebbene i token BRC-20 offrano molti vantaggi, è anche essenziale considerare alcune potenziali sfide.</p>
<p><strong>Ecosistema Limitato</strong>: Lo standard di token BRC-20 è relativamente nuovo, il che significa che il suo ecosistema è più piccolo rispetto allo standard ERC-20 ben consolidato su <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a>. Ciò porta a meno risorse, sviluppatori e strumenti disponibili per la creazione e la gestione dei token BRC-20.</p>
<p><strong>Potenziali commissioni di transazione elevate</strong> La rapida crescita dell’attività dei token BRC-20 ha portato ad un aumento delle commissioni di transazione sul <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> network. Con il coinvolgimento di un numero maggiore di utenti con i token BRC-20, ciò potrebbe potenzialmente portare a costi di transazione più elevati, influenzando l’accessibilità e l’accessibilità economica dell’uso di questi token.</p>
<h2 id="h2-Le20implicazioni20dei20token20BRC20764751"><a name="Le implicazioni dei token BRC-20" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Le implicazioni dei token BRC-20</h2><p>L’introduzione dei token BRC-20 ha ampie implicazioni per <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> e l’industria delle criptovalute in generale. <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> ha a lungo detenuto la posizione di criptovaluta leader, ma la mancanza di un livello di smart contract è stato un fattore limitante nella sua competizione con <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> e altre piattaforme smart contract. L’introduzione dei token BRC-20 potrebbe aiutare a livellare il campo da gioco, permettendo <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> competere direttamente in settori che sono stati prentemente <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> dominio.</p>
<p>Ad esempio, la finanza decentralizzata, o DeFi, è stata una delle tendenze più evidenti nello spazio blockchain negli ultimi anni. Tuttavia, fino ad ora, la maggior parte delle attività DeFi si è svolta sul <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> blockchain grazie alle sue capacità di smart contract. Con l’introduzione dei token BRC-20, i progetti DeFi possono ora essere costruiti anche sulla <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> blockchain. Questo sviluppo ha il potenziale per incidere significativamente sul panorama DeFi. <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> La robusta sicurezza di e la sua più ampia accettazione potrebbero attirare più utenti e sviluppatori ai suoi progetti DeFi. Inoltre, potrebbe contribuire ad alleviare la congestione e le elevate commissioni di gas sperimentate sul <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> network.<br><img src="https://gimg2.gateimg.com/image/article/16838539441.jpeg" alt=""><br>L’introduzione dei token BRC-20 svolge anche un ruolo in <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> sforzi di scalabilità. Come il <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> La rete lotta con problemi di scalabilità, sono emerse soluzioni alternative come il Lightning Network. L’introduzione dei token BRC-20 aggiunge un’altra dimensione a questi sforzi, creando più opportunità affinché le transazioni avvengano al di fuori della rete principale. <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> blockchain, alleviando la congestione di rete. Pertanto, può avere un impatto significativo <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> posizione di mercato, aumentando potenzialmente il suo valore e la sua base utenti.</p>
<h2 id="h2-Risposta20del20mercato20ai20token20BRC20867348"><a name="Risposta del mercato ai token BRC-20" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Risposta del mercato ai token BRC-20</h2><p>Recentemente, la capitalizzazione di mercato totale dei token BRC-20 ha superato 1 miliardo di dollari, e nelle ultime 24 ore, questi token hanno avuto un volume di scambi totale di 206,2 milioni di dollari. Alcuni dei token BRC-20 più noti includono ORDI, VMPX, MEME, BANKBRC, PEPEBRC e NALS, che attualmente sono attivi su popolari borse di criptovalute come <a href="https://www.gate.io/" target="_blank">Gate.io</a>. In effetti, Gate.io è la prima piattaforma di trading BRC-20 sul web ad elencare sei token BRC-20. E c’è una varianza di prezzo tra +197% e -56% nelle ultime 24 ore.<br><img src="https://gimg2.gateimg.com/image/article/16838539692.png" alt=""><br>Inoltre, i fornitori di portafogli si stanno preparando per l’integrazione, garantendo che gli utenti possano archiviare e effettuare transazioni con i token BRC-20 senza problemi. Ad esempio, BitKeep ha dichiarato che supporterà sia i protocolli Ordinals che BRC-20 sulle sue piattaforme mobili e di estensione del plugin. Ciò include l’introduzione di una nuova <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> La sezione NFT nel mercato BitKeep NFT, che consentirà la visualizzazione, la creazione, il trasferimento e la negoziazione di BTC NFT basati sul protocollo Ordinals.</p>
<p>Mentre <a href="/price/trust-wallet-twt" rel="nofollow noopener noreferrer" target="_blank">Trust Wallet</a> non ha ancora integrato il supporto per <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Alessio</a> Gli ordinali, altri importanti fornitori di portafogli, hanno compiuto passi in questa direzione. MetaMask, un’applicazione popolare <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Il portafoglio, ha aggiunto una funzione a febbraio per memorizzare gli ordinali, e Ledger, un rinomato fornitore di portafogli hardware, supporta anche il protocollo degli ordinali.</p>
<h2 id="h2-Conclusione156538"><a name="Conclusione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusione</h2><p>L’introduzione dei token BRC-20 è un momento di svolta per <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> e al mercato più ampio delle criptovalute. Portando la funzionalità dei contratti intelligenti al <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Alessio</a> In rete, i token BRC-20 hanno il potenziale per rivoluzionare lo spazio delle criptovalute, aprendo un nuovo mondo di possibilità per sviluppatori e utenti. Sebbene siano ancora i primi giorni per i token BRC-20, la risposta iniziale del mercato è stata schiacciante positiva e il futuro sembra promettente.</p>
<p>Poiché l’ecosistema continua a svilupparsi, possiamo aspettarci di vedere una serie di innovative applicazioni e progetti che sfruttano questa eccitante nuova tecnologia. Il cambiamento è l’unico elemento costante nel mondo delle criptovalute e l’emergere dei token BRC-20 ne è una testimonianza. Mentre continuiamo ad esplorare il potenziale della tecnologia blockchain, l’introduzione dei token BRC-20 rappresenta un importante passo avanti, avvicinandoci a un futuro in cui gli asset digitali svolgono un ruolo ancora più centrale nella nostra vita.</p>
<div class="blog-details-info"><br><div>Autore: <strong>Andrei Dr.</strong>, Ricercatore di Gate.io<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 citato Gate.io. In tutti i casi, saranno intraprese azioni legali a causa della violazione del copyright.<br></div><p></p><br></div></div></div>