UXVhbnRpIGRlaSBwcmltaSAxMCB0b2tlbiBuZWxsJ2Vjb3Npc3RlbWEgQml0Y29pbiBoYWkgaW52ZXN0aXRvPw==

2023-12-22, 03:39

<p><img src="https://gimg2.gateimg.com/image/article/1690791857hotspot.jpeg" alt=""></p>
<p>Il mercato delle criptovalute di quest’anno è molto emozionante, con <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> rivitalizzante, Layer 2 e blockchain modulare. Tuttavia, quando si parla della stella più brillante di quest’anno, non può essere altro che la <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> ecosistema.</p>
<p>Proprio come <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> usato per stupire l’intero mondo delle blockchain con i contratti intelligenti, il trend delle iscrizioni di 23 anni è anche una nuova narrazione che permette alle persone di vedere “costruire più possibilità sulla blockchain di Bitcoin.”</p>
<p>Qui, introdurremo brevemente le attuali prime 10 token in termini di valore di mercato. La classifica basata sui dati del valore di mercato è fornita da X utente @0xSea.eth.</p>
<h2 id="h2-TOP1STX657450"><a name="TOP1-$STX" class="reference-link"></a><span class="header-link octicon octicon-link"></span>TOP1-$STX</h2><p>STX è il token nativo del <a href="/price/stacks-stx" rel="nofollow noopener noreferrer" target="_blank">Stacks</a> la rete, che è Layer2 sulla catena BTC e mira ad implementare i contratti intelligenti su Bitcoin.<br><img src="https://gimg2.gateimg.com/image/article/1703216113img_v3_026c_79823990-e0fe-4df0-bca8-5608514317ix.jpg" alt=""></p>
<p>Con l’emergere di progetti NFT basati su <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> come Ordinals, la posizione di <a href="/price/stacks-stx" target="_blank" class="blog_inner_link">Stacks</a> è aumentata nettamente nell’ultimo anno. Secondo DefiLlama, i fondi bloccati in Stacks sono aumentati da 7 milioni di dollari a 50 milioni di dollari dall’inizio di quest’anno. Nel frattempo, da quando l’investitore Tim Draper ha espresso un feedback positivo su Stacks, $STX è rapidamente aumentato del 30%.</p>
<p>Stacks può essere definito il leader nelle applicazioni economiche su Bitcoin, mirando a costruire la pietra angolare di Defi, Dapp e altre applicazioni. Stacks introduce il concetto di “sBTC”, che sarà ancorato a BTC, consentendo al livello di Stacks di rilasciare $500 miliardi di capitale in BTC, portando gli asset decentralizzati massimi e più duraturi a più persone e più casi d’uso.</p>
<p>Ora Stacks può anche guadagnare BTC partecipando al consenso, detenere e bloccare temporaneamente STX e sostenere la sicurezza e il consenso di rete. La ricompensa del consenso ha distribuito oltre 2000 Bitcoin, e non sorprende che il suo TVL e valore di mercato siano così sorprendenti.</p>
<h2 id="h2-TOP2sats663833"><a name="TOP2-$sats" class="reference-link"></a><span class="header-link octicon octicon-link"></span>TOP2-$sats</h2><p>$Sats è il primo lotto di token emessi utilizzando il protocollo BRC-20, denominato come l’unità più piccola di Bitcoin, satoshi, con un’offerta massima corrispondente di 21 milioni.</p>
<p>All’inizio, Sats era più simile a una memecoin, ma dopo essere stato utilizzato come commissioni di transazione su UniSats, ha indubbiamente acquisito uno scenario di applicazione più stabile e versatile. Dopo il lancio di CEX, il suo status è stato ulteriormente riconosciuto; Il valore individuale di Sats è relativamente basso e anche le sue detenzioni sono sparse, ma non ha subito una brusca diminuzione dopo una ondata di guadagni; Ora il suo valore di mercato totale ha superato ORDI.<br><img src="https://gimg2.gateimg.com/image/article/1703216156img_v3_026c_66e9edaa-705b-4a75-9712-13c63b874fix.jpg" alt=""></p>
<h2 id="h2-TOP3ordi746616"><a name="TOP3-$ordi" class="reference-link"></a><span class="header-link octicon octicon-link"></span>TOP3-$ordi</h2><p>Forse il token BRC-20 più familiare per tutti, nonché il primo token BRC-20 creato dall’utente della comunità @ Domo; A quel tempo, ORDI attirò molta attenzione perché era costruito direttamente sulla blockchain BTC e il suo nome era anche derivato dal protocollo Ordinals.</p>
<p>I giocatori possono creare i propri token Ordi e piazzare ordini per transazioni tramite creazione, distribuzione e iscrizione sulla catena. L’essenza del protocollo Ordinals è una logica di indicizzazione e riordino del testo, che è diversa dalla funzione dei contratti intelligenti. Non è necessario completarlo tramite piattaforme o applicazioni specifiche e richiede solo basse commissioni Gas per creare i propri asset di iscrizione.</p>
<p>Dal principio del 2023, molti giocatori hanno visto il potenziale di Ordi come un progetto leader nella nuova traccia dell’ecosistema BTC e hanno partecipato ad esso. Il prezzo è saltato da dipendere solo dalle commissioni di trasferimento a pochi centesimi, a quasi 70U nel mercato secondario.</p>
<p>Tuttavia, il token BRC-20 ha anche suscitato molte controversie, come ad esempio l’aumento del carico sui blocchi di Bitcoin. Alcune persone ritengono che ciò comprometta la purezza di Bitcoin come registro decentralizzato. Tuttavia, va detto che coloro che hanno partecipato inizialmente alle iscrizioni Ordi nel mercato primario hanno padroneggiato il codice di ricchezza più sorprendente dell’anno, e alcuni addirittura si riferiscono alle iscrizioni come “stampare denaro”. Almeno dal punto di vista della crescita, ciò non è irragionevole. Tuttavia, il valore a lungo termine degli asset delle iscrizioni deve ancora essere osservato con calma.</p>
<h2 id="h2-TOP4Mubi638961"><a name="TOP4-$Mubi" class="reference-link"></a><span class="header-link octicon octicon-link"></span>TOP4-$Mubi</h2><p>Mubi è il token nativo di MultiBit, che è il primo ponte a doppio senso nella storia progettato per agevolare i trasferimenti tra reti tra token BRC20 e ERC20. In generale, gli utenti trasferiscono i token BRC20 agli indirizzi BRC20 dedicati. Dopo la conferma, questi token possono essere emessi sulla rete EVM. Tuttavia, l’unicità di MultiBit risiede nella sua funzione di ponte a doppio senso, che consente una transizione senza soluzione di continuità dalla rete EVM a Bitcoin.</p>
<p>Promuovendo la liquidità di questi token, MultiBit migliora l’interoperabilità cross chain. La sua visione è di migliorare la liquidità e l’accessibilità dei token BRC e ERC in modo sicuro e user-friendly.</p>
<p>Al 20 dicembre, il valore di mercato di MUBI è di circa 340 milioni di dollari, con un’offerta totale di 1 miliardo.</p>
<h2 id="h2-TOP5Rats39603"><a name="TOP5-$Rats" class="reference-link"></a><span class="header-link octicon octicon-link"></span>TOP5-$Rats</h2><p>RATS è un token BRC-20 creato tramite il protocollo Ordinals, con un valore di mercato attuale di circa 330 milioni di dollari. È una tipica memecoin.</p>
<p>Il punto forte di RATS risiede nel suo attivo supporto della comunità e il suo design dell’immagine è molto riuscito. Anche il significato implicito di “piccoli e numerosi ospiti non invitati nella blockchain” ha colpito la psicologia di molti giocatori. RATS ha completato la piena circolazione a novembre.<br><img src="https://gimg2.gateimg.com/image/article/1703216201img_v3_026c_6b653f8e-2f12-4e3b-a5ac-7427773be5ix.jpg" alt=""></p>
<h2 id="h2-TOP6Atom196728"><a name="TOP6-$Atom" class="reference-link"></a><span class="header-link octicon octicon-link"></span>TOP6-$Atom</h2><p>ATOM è un token basato sullo standard ARC-20 della blockchain di Bitcoin e appartiene al protocollo Atomicals.</p>
<p>Il protocollo Atomic è un protocollo semplice e flessibile utilizzato per coniare, trasferire e aggiornare gli NFT per le blockchain UTXO come Bitcoin. Atomic (o “atomico”) è un modo di organizzare la creazione, il trasferimento e l’aggiornamento di oggetti digitali - è essenzialmente una catena di possesso digitale definita in base a alcune semplici regole.</p>
<p>Dal punto di vista degli sviluppatori, Atomic è il modo più semplice per organizzare asset digitali su blockchain come Bitcoin. Atomicals ha una vasta gamma di applicazioni, come dinamiche di gioco, collezioni d’arte, terreni virtuali, ecc., ma attualmente manca di stabilità.<br><img src="https://gimg2.gateimg.com/image/article/1703216224img_v3_026c_c2873a0c-45af-4bd8-b7a9-cad8b97849ix.jpg" alt=""></p>
<h2 id="h2-TOP7ALEX471996"><a name="TOP7-$ALEX" class="reference-link"></a><span class="header-link octicon octicon-link"></span>TOP7-$ALEX</h2><p>ALEX è la prima piattaforma a fornire servizi DeFi one-stop su Bitcoin attraverso Stacks. Sulla base del prestito Bitcoin, i contratti intelligenti che gestiscono questi prestiti possono essere utilizzati per creare obbligazioni. Utilizzando queste obbligazioni decentralizzate, i prodotti derivati, la leva finanziaria e tutte le altre funzioni finanziarie avanzate possono essere ricreate e sostituite con algoritmi da scambi di liquidità automatizzati o ALEX.</p>
<p>L’attuale offerta circolante di $ALEX è di 600 milioni di pezzi, con un’offerta massima di 1 miliardo.</p>
<h2 id="h2-TOP8Trac786142"><a name="TOP8-$Trac" class="reference-link"></a><span class="header-link octicon octicon-link"></span>TOP8-$Trac</h2><p>$TRAC è un token basato sullo standard BRC-20, simile a ORDI, con una circolazione totale di 21 milioni di token.</p>
<p>Il valore di mercato circolante attuale di TRAC è di $140 milioni.</p>
<h2 id="h2-TOP9RIF176630"><a name="TOP9-$RIF" class="reference-link"></a><span class="header-link octicon octicon-link"></span>TOP9-$RIF</h2><p>$RIF è il token nativo di Rootstock Infrastructure Framework, che applica un protocollo di infrastruttura aperto e decentralizzato per sviluppare applicazioni distribuite (dApps) più velocemente, facilmente e in modo più scalabile in un ambiente unificato. Fornendo strumenti e tecnologie open-source e decentralizzati, è facile costruire prodotti DeFi accessibili.</p>
<p>Il RIF Rollup è supportato dalla tecnologia zkRollup, e i giocatori interessati a <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> potrebbero sapere che zkRollUp è una soluzione Layer2 utilizzata per risolvere i problemi di throughput, un protocollo senza fiducia per pagamenti veloci, scalabili e a basso costo su Rootstock. Le sue attuali funzioni e ambito comprendono il trasferimento a basso costo di token RBTC e ERC20 sulla rete Rootstock.</p>
<p>Nel complesso, RIF ha costruito un ponte tra la complessa tecnologia blockchain e un’esperienza utente senza soluzione di continuità, fornendo strumenti e tecnologie aperti e decentralizzati, con un valore di mercato attuale di circa $130 milioni.</p>
<p>Nell’ecosistema Bitcoin, i token con architetture sottostanti come $RIF, STX, ALEX, STX, ecc. sono diversi da quelli con iscrizioni. Puoi tenere d’occhio le dinamiche del progetto e comprendere il suo modello economico, e puoi anche fare trading sulla piattaforma Gate.</p>
<h2 id="h2-TOP10PIPE666166"><a name="TOP10-$PIPE" class="reference-link"></a><span class="header-link octicon octicon-link"></span>TOP10-$PIPE</h2><p>PIPE è un protocollo di token locali Bitcoin ispirato alle idee di Casey Rodarmor’s RUNES e Ordinal’s BRC-20.</p>
<p>A causa del fatto che RUNES non consente una coniazione equa (un aspetto importante di BRC-20) e potenzialmente rende tutti i suoi token titoli di valore, PIPE cerca di combinare i vantaggi di questi due concetti.</p>
<p>PIPE è composto da tre funzioni: distribuzione, creazione di monete e trasferimento, simile a BRC-20. La funzione di distribuzione indica che è stato distribuito un nuovo token, mentre la funzione di creazione di monete consente di creare monete da quel token in base alle regole di distribuzione (offerta, restrizione). Infine, la funzione di trasferimento viene utilizzata per inviare token al destinatario selezionato.</p>
<p>Attualmente, il valore di mercato circolante di pipeline è di circa 130 milioni, e pipeline non ha un indice o un portafoglio. Con ulteriori mercati specializzati per supportare la coniazione e il trading di pipeline, si ritiene che possa anche innescare un effetto a catena positivo.</p>
<div class="blog-details-info"><br><div>Autore:<strong>Sherry</strong>, Ricercatore 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 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></div>