T1JESSByYWdnaXVuZ2UgdW4gbnVvdm8gcmVjb3JkLCBhbmFsaXp6YSBsZSB0ZW5kZW56ZSBlIGxvIHN2aWx1cHBvIGRlbGxlIGlzY3JpemlvbmkgQml0Y29pbg==

2023-12-06, 07:59

<p><img src="https://gimg2.gateimg.com/image/article/1690791857hotspot.jpeg" alt=""></p>
<h2 id="h2-TLDR29923"><a name="[TL；DR]:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL；DR]:</h2><p>Secondo i dati di Gate.io, il valore di mercato attuale di ORDI supera 1.3 miliardi di dollari, con un volume di trading delle ultime 24 ore che si avvicina ai 30 milioni di dollari, classificandosi al terzo posto nella lista delle ricerche più calde.</p>
<p>Oltre a ORDI, ci sono anche token incisi popolari come SATS, RATS, OXBT, MEME, ecc.</p>
<p>L’ecosistema creato da Ordinals è sufficiente per fungere da nuova narrazione per l’emissione di asset su <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> La catena. Questo fenomeno emergente fluttua nella crescita del consenso e nelle critiche pubbliche, realizzando infine la scoperta del valore.</p>
<h2 id="h2-Introduzione946779"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>Il mercato del <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> è sempre pieno di argomenti caldi, e l’iscrizione al mercato caldo è senza dubbio la più accattivante di quest’anno. Le iscrizioni rappresentate da ORDI non solo hanno un impatto significativo sul valore del Bitcoin, ma ci forniscono anche una nuova prospettiva per capire il mercato delle criptovalute.</p>
<p>Quindi, come queste iscrizioni sono diventate popolari e quali altre iscrizioni popolari vale la pena conoscere? Esploriamo insieme queste questioni.</p>
<h2 id="h2-ORDI20ha20corso20fino20alla20LUNA244574"><a name="ORDI ha corso fino alla LUNA" class="reference-link"></a><span class="header-link octicon octicon-link"></span>ORDI ha corso fino alla LUNA</h2><p>Alla data di scrittura, nonostante alcuni aggiustamenti minori, ORDI è ancora salito del 27,87% nelle ultime 24 ore e ha registrato un ritorno del 250% negli ultimi 7 giorni.</p>
<p>Secondo i dati di Gate.io, la capitalizzazione di mercato attuale di ORDI è di 1,3 miliardi di dollari, con un volume di trading delle ultime 24 ore che si avvicina ai 30 milioni di dollari, posizionandosi al terzo posto nella lista delle ricerche più calde.<img src="https://gimg2.gateimg.com/image/article/170184940815971701849201_.pic.jpg" alt=""><br>Origine: Gate.io</p>
<p>In realtà, il protocollo Ordinals è stato lanciato già all’inizio di quest’anno, in quanto consente in modo creativo agli utenti di “scrivere” media come immagini e testo nella blockchain di Bitcoin. Questa mossa innovativa è diventata popolare senza intaccare i requisiti originali della comunità Bitcoin.</p>
<p>Entro marzo di quest’anno, gli utenti sono stati in grado di creare token alternativi attraverso lo standard BRC-20. Essendo il primo token di questo tipo deployato dall’anonimo creatore Domo, ORDI naturalmente si conforma alla legge dell’effetto del primo rilascio nell’industria, diventando il primo punto di riferimento nella corsa all’iscrizione.</p>
<p>Dopo il silenzio delle iscrizioni Bitcoin per mezzo anno, l’entusiasmo degli investitori pubblici è tornato in questo settore. Come leader, ORDI è stato ampiamente adottato, con il supporto degli scambi come Gate e il lancio di nuove funzionalità da parte degli Ordinals, con un significativo aumento dei prezzi delle monete. Nella scorsa settimana, ORDI ha registrato il suo più grande aumento fino ad oggi.</p>
<p>Secondo i dati di CoinMarketCap, ORDI è sempre stato il token più grande nel mercato BRC20, classificandosi al 66° posto per valore di mercato, seguito da vicino da SATS, TRAC e RATS.<br><img src="https://gimg2.gateimg.com/image/article/170184944115981701849212_.pic.jpg" alt=""><br>Fonte: CoinMarketcap</p>
<h2 id="h2-Quei20distintivi20iscrizioni20che20sono20emersi20dallo20spazio20cripto606294"><a name="Quei distintivi iscrizioni che sono emersi dallo spazio cripto" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Quei distintivi iscrizioni che sono emersi dallo spazio cripto</h2><p>Abbiamo scritto diversi articoli che introducono l’origine di ORDI, quindi non entreremo troppo nei dettagli qui. I lettori possono fare clic su <a href="https://www.gate.io/blog_detail/3438/new-narrative-of-the-bull-market-bitcoin-eco-development-landscape" target="_blank">Nuova narrazione del mercato toro - Paesaggio dello sviluppo dell’ecosistema Bitcoin</a> per navigare e visualizzare. Questo articolo si concentra sull’introduzione di altri token BRC20 molto popolari.</p>
<p><strong>SATS</strong><br>SATS è il nono token iscritto basato sul protocollo Brc-20, e il suo nome completo è satoshi. Satoshi è l’unità più piccola in Bitcoin, comunemente chiamata satoshi o Bit satoshi.</p>
<p>Nel sistema Bitcoin, un BTC (Bitcoin) equivale a 100 milioni di satoshi. La circolazione totale è di 2100 trilioni di yuan, equivalente a 21 milioni di BTC.</p>
<p>L’attenzione di mercato di SATS, il valore di mercato totale e persino superato ORDI a novembre, diventando il token popolare culturalmente più significativo. Con il supporto di Unisat per Sats come commissione di gas su L2 e altri fattori positivi, Sats è ora diventato il token di alto valore di mercato secondo solo a ORDI.</p>
<p><strong>RATS</strong><br>Rats è un tipo di asset di iscrizione della serie BRC20, fondato nel marzo di quest’anno, con un limite massimo di conio singolo di 1 milione di pezzi.</p>
<p>Come token di inbreeding dei Sats, il successo dei RATS è attribuito anche alla coesione dei membri della comunità a livello di consenso. Essa prende in prestito la creatività delle monete Meme animali e incorpora fattori di appartenenza culturale sia dell’Est che dell’Ovest. La comunità dei Rats una volta ha catturato la piattaforma di promozione di Twitter.</p>
<p>La relazione corrispondente tra “rat” e “mint” è utilizzata in modo intelligente nel marketing della community e giochi di testo come questo sono pieni di umorismo e immagini, facendo sì che le persone ricordino immediatamente le caratteristiche dei token RATS.</p>
<p><strong>OXBT</strong><br>OXBT è un token BRC20 emesso dal progetto Redacted NFT, con un totale di 2 miliardi di token. Quest’estate, il volume di trading on-chain di OXBT ha raggiunto 10 volte quello di Ordi.</p>
<p><strong>MEME</strong><br>MEME è il secondo token BRC20 con un’offerta di soli 99.999 token e ogni inserimento può generare al massimo 1 MEME.</p>
<p>Dopo un’attenta considerazione del meccanismo di allocazione dei token, c’erano già oltre 2000 detentori di $meme dopo che la moneta è stata coniata, e questo numero è ora aumentato a 5071.</p>
<p><strong>MOON</strong><br>Il token MOON, derivato dalla parola gergale TO DA MOON nella comunità cripto, ha anche un grande seguito, con un limite di fornitura di soli 100 milioni di monete e 6685 detentori, che lo posiziona al 10° posto per valore di mercato in questo settore.</p>
<h2 id="h2-Lo20spazio20potenziale20delliscrizione20BRC20874511"><a name="Lo spazio potenziale dell’iscrizione BRC20" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Lo spazio potenziale dell’iscrizione BRC20</h2><p>In realtà, BRC-20 è un punto di riferimento per il classico <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Il protocollo ERC-20 e il suo campo operativo e l’ecosistema derivato si baseranno anche su ERC-20. Ma rispetto al protocollo ERC-20, questo protocollo è innestato sulla comunità di Bitcoin con il consenso più elevato e ha uno spazio operativo più ampio e una piattaforma di diffusione.</p>
<p>Di conseguenza, con metodi di coniazione della comunità più equi e l’aggiornamento continuo del protocollo BRC-20, il valore di questo tracciato sta gradualmente venendo rilasciato, e sempre più istituzioni e scambi (come Gate.io) stanno iniziando a collegarsi, espandersi e applicare il suo valore.</p>
<p>In generale, questo standard sperimentale per la coniazione di monete on-chain, che utilizza il protocollo Ordinals per coniare iscrizioni su ogni satoshi (il satoshi è l’unità più piccola di Bitcoin, 1 satoshi è 0.0000001btc), ha le caratteristiche di una distribuzione equa e di elevata sicurezza, facendo sì che un gruppo di iscrizioni abbia naturalmente attributi MEME auto-propaganti.</p>
<p>Alla fine, l’attuale aumento dei token BRC20 è guidato sia dal sentimento speculativo che dal valore degli investimenti, con diverse ragioni specifiche:</p>
<p>L’emissione dei token BRC20 è relativamente equa e tutti gli utenti di coniazione sono trattati allo stesso modo. Il progetto non può riservare o emettere ulteriori token BRC20. Anche se l’emittente desidera ottenere i token BRC20 emessi, deve partecipare alla coniazione. Ciò rende il token BRC20 naturalmente scarso, attirando così l’attenzione degli investitori.</p>
<p>Il token BRC20 ha un’elevata sicurezza e adotta il meccanismo di sicurezza della catena Bitcoin, che ha un’elevata resistenza agli attacchi. Ciò rende il token BRC20 più affidabile per gli investitori.</p>
<p>L’ecosistema del token BRC20 è in costante sviluppo, e un gruppo di progetti di token BRC20 di alta qualità è emerso. Questi progetti coprono diversi settori come il pagamento, DeFi, NFT e GameFi, e hanno un grande potenziale.</p>
<p>Tuttavia, quando si tratta di questo, dobbiamo comunque prestare attenzione al fatto che questo consenso è ancora fragile rispetto a Bitcoin, e i rapidi cambiamenti di sentimento nel breve termine si rifletteranno sincronamente sul prezzo della moneta, e potrebbero addirittura influenzare le strategie di molti investitori istituzionali a deviare.</p>
<p>Il 5 dicembre 2023, Gate.io ha rilasciato uno snapshot al 100% delle riserve dei migliori progetti dell’ecosistema BRC20 sulla piattaforma, in risposta alle recenti fluttuazioni di mercato.<img src="https://gimg2.gateimg.com/image/article/170184951815991701849230_.pic.jpg" alt=""><br>Sorgente: Gate.io</p>
<p>In realtà, l’importante aumento del volume di trading nella serata del 4 dicembre 2023 è stato principalmente causato da significative fluttuazioni di mercato quella notte, che hanno portato a problemi con le strategie di trading di alcuni utenti istituzionali quantitativi. Non è raro che le strategie degli utenti istituzionali si discostino durante le fluttuazioni di mercato, ma gli utenti devono comunque bilanciare e controllare i rendimenti e i rischi.</p>
<p>In sintesi, l’ecosistema creato dagli Ordinals è sufficiente come nuova narrazione per l’emissione di asset sulla catena di Bitcoin. Questo fenomeno emergente fluttua nella crescita del consenso e nelle critiche pubbliche, realizzando infine la scoperta del valore. Siamo disposti ad abbracciare questa innovazione ed esplorare nuovi valori.</p>
<p>Infine, va menzionato che il valore delle cose nuove è in costante evoluzione e Roma non è stata costruita in un giorno. Pertanto, gli investitori devono rimanere cauti di fronte ai suddetti progetti caldi.</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 il ripostaggio dell'articolo a condizione che si faccia riferimento a Gate.io. In tutti i casi, verranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div></div>