Z2F0ZUxpdmUgQU1BIFJlY2FwLUFsZXhMYWI=

<p><img src="https://gimg2.gateimg.com/image/article/1684130940BlogA.jpg" alt=""></p>
<h2 id="h2-BRC2020il20token20standard20sulla20blockchain20di20Bitcoin20BTC20ha20superato20i20620miliardi20di20dollari20di20capitalizzazione20di20mercato20in20pochi20mesi20dal20lancio20Cosa2020esattamente20BRC2020Quali20sono20i20token20pi20popolari890831"><a name="BRC-20, il token standard sulla blockchain di Bitcoin (BTC), ha superato i 6 miliardi di dollari di capitalizzazione di mercato in pochi mesi dal lancio. Cosa è esattamente BRC-20? Quali sono i token più popolari?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>BRC-20, il token standard sulla blockchain di <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> (BTC), ha superato i 6 miliardi di dollari di capitalizzazione di mercato in pochi mesi dal lancio. Cosa è esattamente BRC-20? Quali sono i token più popolari?</h2><p><strong>Dr. Chiente Hsu(CEO e CoFondatore di Alex):</strong><br>La cosa più importante è che con BRC20, <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> ora ha uno standard di token fungibile che consente a chiunque di distribuire un ticker unico che avvierà una coniazione gratuita.</p>
<p>1)gregory maxwell, andrew poelstra and pieter wuille back in 2018 proposed an upgrade of <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Alessio</a> il protocollo chiamato ‘taproot’ che fondamentalmente ha migliorato due cose. Uno è MultiSig e l’altro è rilassare i limiti dello  e dell’input su <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> transazioni, ossia ottimizzare l’utilizzo dello spazio dei blocchi. Ed è stato attivato nel novembre 2021.</p>
<p>2)Casey Rodarmor sfrutta i limiti di  rilassati e i vincoli rilassati sulle dimensioni di input per costruire un protocollo semplice che incorpora pezzi di dati arbitrari in <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Quando Casey Rodarmor ha lanciato il protocollo Ordinals nel gennaio 2023, ha trovato un modo per indicizzare ogni Satoshi e tenerlo tracciato per l’intero <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> rete. Un Satoshi o sat, è l’unità più piccola di <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Alessio</a> Il protocollo degli ordinali ti consente di incapsulare qualsiasi tipo di file sulla catena di blocchi su gate. <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Alessio</a>. Quell’iscrizione indica un sat che traccia la sua proprietà, quindi ciò che otterrai è un completamente on-chain <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> NFT.</p>
<p>3) domodata inventa lo standard brc-20, un formato json per coniare token tramite iscrizioni ordinali<br>L’8 marzo 2023 Domodata ha twittato un thread teorizzando un modo per creare uno standard di token fungibili sopra il protocollo Ordinals chiamato BRC-20.</p>
<p>Si afferma che chiunque possa iscrivere file Java Object Notation o JSON su <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> tramite il protocollo Ordinals per “Deployare” un BRC-20, utilizzando il token $ORDI come esempio è stato deployato con il nome “Ordi”, un massimo di 21 milioni e un limite di 1000.</p>
<p>Allora chiunque può coniarlo gratuitamente. Tutti i token BRC-20 sono coni gratuiti senza pre-coniazione. Una volta che $ORDI è stato implementato, chiunque può iscrivere un JSON conio che funziona fino a quando vengono coniati 21.000.000 di token.</p>
<p>Una volta che il token si genera, puoi iniziare a trasferire i tuoi token iscrivendo un JSON di trasferimento con il numero di token che desideri inviare.</p>
<p>Sono stati emessi oltre 14.000 token BRC-20, con ORDI, PIZA, MEME e MOON che sono i più popolari.</p>
<p>L’ultima cosa da capire su entrambi gli ordinali e BRC-20 è che gli indicizzatori assegnano ad ogni iscrizione o token BRC-20 un numero unico in base all’ordine della sua creazione. Quindi il primo token BRC-20 è 1, il secondo è 2, ecc. Il mercato sembra attribuire molta importanza a questo ordine.</p>
<p>Con gli NFT e tutte queste memecoin BRC20 sembra proprio che il <a href="/web3" target="_blank" class="blog_inner_link">Web3</a> sia arrivato <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a>. Se questo è davvero il caso, allora abbiamo molto da recuperare.</p>
<h2 id="h2-Recenti20attivit20hanno20contribuito20allaumento20recente20delle20commissioni20di20transazione20per20i20minatori20insieme20al20limite20di20mercato20Quali20impatti20avr20questo20sugli20minatori689491"><a name="Recenti attività hanno contribuito all’aumento recente delle commissioni di transazione per i minatori insieme al limite di mercato. Quali impatti avrà questo sugli minatori?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Recenti attività hanno contribuito all’aumento recente delle commissioni di transazione per i minatori insieme al limite di mercato. Quali impatti avrà questo sugli minatori?</h2><p><strong>Dr. Chiente Hsu (CEO e co-fondatore di Alex):</strong><br>Dal lancio del Protocollo Ordinals ci sono state oltre 5 milioni di iscrizioni con oltre $27M di commissioni Ordinals pagate ai minatori. Ordinals ha risolto <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> problema di tariffa.</p>
<p>Per mettere in contesto la media attuale <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> La commissione di transazione è di circa $ 31 mentre a gennaio era di circa $ 1.</p>
<p>La crescita delle transazioni è stata del 99% circa per le iscrizioni di testo BRC-20 per la coniazione e il commercio. L’attività di trading relativa a questi token ha contribuito alle transazioni giornaliere su gate.io. <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> La rete, raggiungendo un nuovo record di 534.000, secondo i dati di The Block.</p>
<p>E questo è un passo molto importante per il futuro di <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> come blockchain: aumentando le commissioni di transazione, Ordinals incentiva i minatori a continuare a proteggere la rete e attira gli sviluppatori nell’ecosistema, portando più utenti, più adozione, più crescita.</p>
<h2 id="h2-Questi20token20hanno20congestionato20la20rete20Bitcoin20e20lhanno20portata20ai20suoi20limiti20operativi20Quali20saranno20gli20effetti20sullecosistema20Bitcoin395441"><a name="Questi token hanno congestionato la rete Bitcoin e l’hanno portata ai suoi limiti operativi. Quali saranno gli effetti sull’ecosistema Bitcoin?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Questi token hanno congestionato la rete Bitcoin e l’hanno portata ai suoi limiti operativi. Quali saranno gli effetti sull’ecosistema Bitcoin?</h2><p><strong>Dr. Chiente Hsu (CEO e CoFounder di Alex):</strong><br>La congestione di rete è il motore dei costi di transazione più elevati. La congestione è un vantaggio netto, significa <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> è richiesta dagli utenti, significa che i minatori sono incentivati a continuare a garantire la sicurezza della rete, significa <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> attirerà più sviluppatori, il che stimolerà nuove innovazioni e nuovi casi, maggiore attenzione e un’adozione più ampia.</p>
<p>Per mettere le cose in prospettiva, anche se ci sono oltre 400.000 transazioni in sospeso nel gate <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> mempool, <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> è ancora più costoso da usare. <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> le commissioni gas sono la ragione per cui c’è stata così tanta attività degli sviluppatori attorno a L2 come <a href="/price/polygon-matic" rel="nofollow noopener noreferrer" target="_blank">Polygon</a> e Arbitrum e inevitabilmente <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> la congestione porta a soluzioni L2.</p>
<p>È inevitabile che vedremo lo stesso accadere con <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> L2s. I livelli di scalabilità sono essenziali per l’accesso a 1 miliardo di persone su Gate.io <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a>.</p>
<p>Tutte le strade portano a <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a>, e tutte le strade su <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> portare a <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> L2s. Questo è il momento più emozionante per il <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> community in recent memory. For example, the Lightning Network uses channels between participants, so that multiple transactions can be handled without waiting for the slower main net to confirm single exchanges. Another is Stack which is like gate. <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> su <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> che consente di eseguire smart contract su <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a>.</p>
<p>Certo, ci sono alcuni Bitcoiners che sono arrabbiati, ma io lo paragonerei ad avere un ristorante preferito che improvvisamente diventa estremamente popolare. Sì, tu come cliente abituale potresti essere arrabbiato perché ora devi aspettare di più e i prezzi sono aumentati, ma significa anche che è improbabile che il ristorante chiuda. In realtà stanno costruendo un secondo e un terzo piano per ospitare più ospiti!</p>
<p>Guardando indietro, vedremo questo come il momento in cui il <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> ecosys-tem è venuto alla vita.</p>
<h2 id="h2-ALEX20ha20annunciato20su20Twitter20di20stai20costruendo20il20pi20veloce20BRC2020DEX20Raccontaci20di20pi999879"><a name="ALEX ha annunciato su Twitter di stai costruendo il più veloce BRC-20 DEX. Raccontaci di più!" class="reference-link"></a><span class="header-link octicon octicon-link"></span>ALEX ha annunciato su Twitter di stai costruendo il più veloce BRC-20 DEX. Raccontaci di più!</h2><p><strong>Dr. Chiente Hsu (CEO e cofondatore di Alex):</strong><br>ALEX sta costruendo B20 che è il primo orderbook per i token BRC20. È come <a href="/price/dydx-dydx" rel="nofollow noopener noreferrer" target="_blank">dYdX</a> per token BRC-20 e altri <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Alessio</a> (L1) beni nativi. La cosa interessante di questo è che combinando l’indicizzazione L1 e l’ottimizzazione L2, B20 di ALEX offre il meglio di entrambi i livelli.</p>
<p>Al momento, se vuoi fare qualcosa su gate.io, <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> ora, è necessario pagare una tariffa molto alta. L2 come <a href="/price/stacks-stx" rel="nofollow noopener noreferrer" target="_blank">Stacks</a> funziona bene e ogni transazione su <a href="/price/stacks-stx" rel="nofollow noopener noreferrer" target="_blank">Stacks</a> funziona bene, perché vengono aggregati e liquidati in un’unica operazione (e quindi possiamo permetterci una commissione gas più alta come gruppo). Bellezza del L2.</p>
<p>Inoltre, <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> non ha la capacità dei contratti intelligenti. qualsiasi cosa un po ‘più sofisticata, come ad esempio DeFi correlati, come DEX, prestito/prestito, non sarà in grado di gestirlo. Quindi dobbiamo costruire queste funzionalità su un L2, come il nostro libro degli ordini. Inoltre, per accelerare ancora di più, utilizziamo ottimizzazione off-chain ma liquidiamo tutto on-chain. Così gli utenti ottengono un’esperienza di trading simile a CeFi. Abbiamo abbinato acquirenti e venditori in base ai loro ordini limitati e di mercato. Puoi inserire ordini limitati per acquistare o vendere a un prezzo specifico, e questi ordini vengono aggiunti al libro degli ordini. Gli ordini di mercato vengono eseguiti al miglior prezzo disponibile nel libro degli ordini.</p>
<p>Ha funzionalità di trading più avanzate come gli ordini di stop loss e i servizi di prestito/prestito.<br>La scoperta del prezzo è più efficiente nelle DEX basate sul book degli ordini, in quanto si basa sulle offerte e le richieste dei partecipanti al mercato anziché sulle… <a href="/price/uniswap-uni" rel="nofollow noopener noreferrer" target="_blank">Uniswap</a> tipo AMM basato su formula matematica.</p>
<h2 id="h2-Quali20sfide20principali20vedi20che20BRC2020affronta20che20ALEX20sta20risolvendo20Come20inizier20la20quotazione20del20token20su20B2020e20quanto20tempo20ci20vorr20prima20che20venga20lanciato33690"><a name="Quali sfide principali vedi che BRC-20 affronta che ALEX sta risolvendo? Come inizierà la quotazione del token su B20 e quanto tempo ci vorrà prima che venga lanciato?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Quali sfide principali vedi che BRC-20 affronta che ALEX sta risolvendo? Come inizierà la quotazione del token su B20 e quanto tempo ci vorrà prima che venga lanciato?</h2><p><strong>Dr. Chiente Hsu (CEO e cofondatore di Alex):</strong><br>Quindi, B20 di ALEX risolve due punti critici:<br>1) I mercati attuali per BRC20 vengono scambiati come NFT, con liquidità frammentata. Il B20 di ALEX risolve questo offrendo un’esperienza simile a CEX con asset di coda lunga.<br>2) La velocità delle transazioni del mercato attuale di BRC20 dipende da <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Blocca il tempo di conferma, impiegando 20-40 minuti con un throughput limitato. B20 di ALEX utilizza la tecnologia rollup per migliorare notevolmente il tempo di finalizzazione e il throughput, consentendo un volume di transazioni maggiore con la velocità della luce</p>
<p>La quotazione dei progetti BRC20 è già iniziata. E il nostro orderbook verrà probabilmente lanciato il prossimo mercoledì. Per iniziare a usarlo, sarà necessario scaricare portafogli come Hiro e xVerse. I portafogli Xverse / Hiro supportano già <a href="/price/stacks-stx" rel="nofollow noopener noreferrer" target="_blank">Stacks</a> <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a>/BRC20, quindi l’interazione tra L1 e L2 dal punto di vista del portafoglio è pronta</p>
<p>Pubblicheremo molto presto un articolo su Medium. Se hai domande sull’uso del libro degli ordini, unisciti alla nostra community sul nostro sito ufficiale, il nostro leader della community ti aiuterà.</p>
<div class="blog-details-info"><br><div>Autore:<strong> GateLive</strong>, Team 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. Sarà consentito il riposting dell'articolo 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>