SWwgbW9tZW50byBpbiBjdWkgbGUgc3RlbGxlIGRlbGwnaXNjcml6aW9uZSBicmlsbGFubw==

2023-12-19, 08:16

<p><img src="https://gimg2.gateimg.com/image/article/1690791857hotspot.jpeg" alt=""></p>
<h2 id="h2-TLDR911758"><a name="[TL;DR]:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL;DR]:</h2><p>Recentemente, una serie di iscrizioni di animali su BRC20 ha nuovamente scatenato una frenesia, con i gatti che sono diventati le principali iscrizioni nel settore grazie alla diffusione attiva della comunità e alla promozione di molteplici KOL.</p>
<p>L’effetto di overflow di <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> le iscrizioni hanno portato all’aumento della popolarità delle iscrizioni su varie catene pubbliche, come <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> i sol di ’s, il cuoco di Rune Alpha e avav, asct e BEEG di Avalanche.</p>
<p>Nonostante alcune controversie, il nuovo metodo di emissione delle monete equo e trasparente del mercato delle iscrizioni stesso è più in linea con la ricerca di consenso della decentralizzazione, che porta liquidità, attenzione e prosperità dell’ecosistema.</p>
<h2 id="h2-Introduzione183778"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>Guidata dalla recente popolarità delle iscrizioni BRC20 su Bitcoin, la mania per coniare e scambiare iscrizioni sui principali leader delle catene pubbliche si sta diffondendo. Questo articolo presenterà le attuali iscrizioni delle catene pubbliche popolari per intrattenere i lettori.</p>
<h2 id="h2-Zoo20Inion20Tokens20Leading20the20Way20in20Price20BRC2020Inions20Continue20to20Dominate20the20Screen510995"><a name="Zoo Inion Tokens Leading the Way in Price, BRC20 Inions Continue to Dominate the Screen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Zoo Inion Tokens Leading the Way in Price, BRC20 Inions Continue to Dominate the Screen</h2><p>Recentemente, una serie di iscrizioni di animali su BRC20 hanno ancora una volta dato il via a una frenesia, con i gettoni delle iscrizioni dello zoo rappresentati da tassi, gatti, topi, orsi, turt, mmss, ecc. in testa al prezzo. L’aumento giornaliero fino al 100% sta suscitando l’entusiasmo del mercato.</p>
<p>In realtà, già alla fine di ottobre, UniSat Wallet ha lanciato il mainnet BRC20-swap, e molteplici token BRC-20 denominati con il nome di vari animali che sono stati distribuiti a marzo sono stati venduti in modo pazzesco.</p>
<p>Prendendo come esempio il tasso di guida, il tasso è stato stabilito a marzo di quest’anno, con un limite di emissione singola di 1 milione di pezzi. Nei primi giorni, i Rats non sono diventati leader scorrendo lo schermo, ma con la diffusione attiva della comunità e la promozione di molti KOL, i Rats hanno presto superato gli Orsi e hanno rapidamente guadagnato popolarità.</p>
<p>Ad esempio, sull’account Twitter ufficiale della comunità cinese BRC20, Rats ha guadagnato una posizione di primo piano. Inoltre, il progetto criptato di incubazione KOL SoulLand ha anche pubblicato sulla piattaforma Twitter ufficiale della comunità, annunciando la creazione di un edificio virtuale Rats.<br><img src="https://gimg2.gateimg.com/image/article/1702973583img_v3_0269_5bf14bee-fa51-47b8-8573-aafb638985ix.jpg" alt=""><br>Fonte: twitter@soulland_en</p>
<p>Dal mese di novembre, Gate.io ha lanciato successivamente topi, ratti e altri prodotti, rilasciando nuovamente il sentimento di mercato per il mercato dello zoo. Numerosi token dello zoo hanno ruotato e ripristinato i prezzi, e persino attivato un gran numero di progetti <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> L2, come la sidechain Liquid di Bitcoin per i servizi istituzionali e il cross chain BEVM basato su Taprot. Anche Lightning Network ha lanciato NostrAssets, che fornisce applicazioni e servizi per gli asset Taprot e i pagamenti Lightning. Discuteremo in dettaglio questi sviluppi dell’ecosistema nel prossimo articolo.</p>
<p>Si noti che non tutti i token animali hanno guadagnato favore. Secondo quanto riportato dai media, le iscrizioni degli animali come volpi e leoni, che sono state inserite all’inizio di novembre, sono state quasi del tutto ignorate finora.</p>
<h2 id="h2-RUNE20Alpha20ha20lanciato20il20suo20primo20Rune2020Cook762797"><a name="RUNE Alpha ha lanciato il suo primo Rune - Cook" class="reference-link"></a><span class="header-link octicon octicon-link"></span>RUNE Alpha ha lanciato il suo primo Rune - Cook</h2><p>Rune Alpha è un nuovo progetto di rete Bitcoin basato su Ord 0.11.1, con la sua versione situata nel repository Ordinal. Va notato che questo progetto non è direttamente correlato al protocollo Runes proposto da Casey, il fondatore del protocollo degli Ordinali.</p>
<p>Secondo le spiegazioni ufficiali, le rune di Bitcoin si basano sul modello UTXO di Bitcoin, un token nuovo di zecca, unico e sostituibile progettato per rappresentare asset sostituibili con caratteristiche e metadati unici. Secondo Casey Rodarmor, il protocollo Runes che vuole creare è un semplice protocollo FT basato su UTXO in grado di fornire agli utenti di Bitcoin una buona esperienza utente. Può ridurre l’UTXO “spazzatura” non valido e non bloccherà la rete Bitcoin.</p>
<p>Anche se sia Rune Alpha che Casey hanno spiegato che non erano collegati tra loro, il primo rilascio di COOK ha comunque avuto un’interferenza del traffico e il prezzo fuori borsa è brevemente aumentato di circa dieci volte.<img src="https://gimg2.gateimg.com/image/article/1702973622img_v3_0269_2602d0b7-b7e1-4963-af46-9ccbcfe58fix.jpg" alt=""><br>Sorgente: Rune Alpha</p>
<p>Con il lancio ufficiale della funzione Sign da parte di Rune Alpha di recente, il prossimo passo sarà aprire la rete di test per aggiungere casi d’uso per i s. Il ruolo di primo piano dei s come primo concetto di rune ha naturalmente attirato grande attenzione di mercato.</p>
<p>Nel frattempo, la prima token pipe basata sul protocollo di token Bitcoin UTXO Pipe e gli ers basati sul protocollo di token ERC-1155 Etherunes hanno anche suscitato hype di mercato.</p>
<h2 id="h2-Prima20iscrizione20dellecosistema20in20tendenza20di20Solana2020Sols987980"><a name="Prima iscrizione dell’ecosistema in tendenza di Solana - Sols" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Prima iscrizione dell’ecosistema in tendenza di <a href="/price/solana-sol" target="_blank" class="blog_inner_link">Solana</a> - Sols</h2><p>Sols è la prima iscrizione dell’ecosistema Solana basata su SPL-20, simile al protocollo Ordinals BRC20, con un totale di 21.000 pezzi.</p>
<p>A causa dei forti guadagni consecutivi di Solana nei due mesi scorsi e del ritorno del suo ecosistema alla prosperità, il mercato ha generato aspettative più elevate per il progetto di iscrizione di Solana. Di conseguenza, la sera del 16 novembre, Solana ha iniziato a concentrarsi su una vasta gamma di calore di mercato.</p>
<p>A causa del processo di coniazione eccessivamente complesso, molte persone hanno iniziato a chiedersi se Sols sia veramente un progetto di iscrizione.</p>
<p>Ma questo dubbio è rapidamente scomparso nella tendenza alla menta calda, e dal 17 novembre, Sols ha iniziato a mostrare il volume di trading di mercato con un prezzo di transazione di circa $250 per foglio, un aumento fino a 40 volte rispetto al costo medio di conio iniziale.</p>
<p>A differenza di token di connessione convenzionali o soluzioni di cross-chain basate su EVM, Sols si distingue su Solana come primo protocollo di scambio nativo con iscrizioni nell’ecosistema. Ciò consente a Sols di svolgere un ruolo centrale nell’ecosistema di Solana, senza dipendere da soluzioni di Layer 2 o sistemi esterni.<br><img src="https://gimg2.gateimg.com/image/article/1702973662img_v3_0269_b6ef8842-cad1-4dbe-9e6c-200a2c9cddix.jpg" alt=""><br>Origine: Gate.io</p>
<p>Soprattutto dopo essere stato supportato da Gate.io per il suo lancio online completo il 14 dicembre, il prezzo di Sol è salito a un picco di $ 8,33, ma è leggermente diminuito al momento della scrittura. La rapida fluttuazione del prezzo della moneta riflette pienamente l’elevato riconoscimento del mercato del suo potenziale speculativo.</p>
<h2 id="h2-Liscrizione20Avalanche20va20da20Asct20a20Avav20e20poi20a20BEEG567030"><a name="L’iscrizione Avalanche va da Asct a Avav e poi a BEEG" class="reference-link"></a><span class="header-link octicon octicon-link"></span>L’iscrizione <a href="/price/avalanche-avax" target="_blank" class="blog_inner_link">Avalanche</a> va da Asct a Avav e poi a BEEG</h2><p>Già a giugno di quest’anno, la prima iscrizione AVAS su Avalanche era già stata implementata da Ethan, il fondatore del progetto di nomi di dominio <a href="/price/tezos-xtz" rel="nofollow noopener noreferrer" target="_blank">Tezos</a> Domini. Tuttavia, il consenso di mercato della prima figura di spicco è stato messo in discussione sul <a href="/price/avalanche-avax" rel="nofollow noopener noreferrer" target="_blank">Valanga</a> protocollo, e il 19 novembre AVAL è diventata la prima iscrizione a crescere in popolarità.</p>
<p>Ma i bei tempi non sono durati a lungo. Asct è diventata un’iscrizione di successo. Secondo i dati di Dune, Asct ha iniziato il dispiegamento il 7 dicembre e ora ha terminato il conio. Al momento della pubblicazione, il suo valore di mercato ha raggiunto i 13 milioni di dollari. <img src="https://gimg2.gateimg.com/image/article/1702973689img_v3_0269_18e283ea-de08-4f49-bdb2-1e48cd4fc1ix.jpg" alt=""><br>Origine: Dune</p>
<p>Il 16 dicembre, l’iscrizione è stata ottenuta l’etichetta blu ufficiale, e il volume degli scambi è rapidamente salito sopra i 27.000 AVAX, mostrando un forte trend di ritorno alla posizione di leader.</p>
<p>Tuttavia, il 18, la nuova iscrizione BEEG ha fatto un forte ritorno, spingendo ulteriormente la popolarità dell’iscrizione del Protocollo Avalanche al top delle principali classifiche di iscrizione delle catene pubbliche.</p>
<p>Cryptofishx, il co-fondatore di TraderJoe, il più grande exchange decentralizzato su Avalanche, ha annunciato lunedì il rilascio dell’iscrizione BEEG, affermando che BEEG non ha una roadmap, né un potere decisionale, ed è semplicemente un esperimento sociale.</p>
<p>Cryptofishx, il co-fondatore di TraderJoe, la più grande exchange decentralizzata su Avalanche, ha anche annunciato oggi (18) il rilascio dell’iscrizione BEEG, affermando che BEEG non ha alcuna roadmap, nessun potere elettorale ed è solo un esperimento sociale.</p>
<p>Questo movimento memetico si è diffuso rapidamente nella comunità, portando a un aumento delle commissioni gas su Avalanche, con una commissione gas media di 5110,30 nAVAX (circa 4,41 dollari). Secondo i dati di avascan.info, al momento della stesura, le commissioni gas on-chain sono tornate a 0,49 dollari.</p>
<p>Dopo diversi colpi di scena, l’attore attualmente dominante sullo schermo è Avav, che inizialmente non era favorito.</p>
<p>Il costo iniziale di conio di avav era compreso tra $1,2 e $1,7, che non era molto popolare all’inizio, ma dopo più della metà del tempo, poiché tutte le principali iscrizioni erano già state coniate, la comunità in rapida crescita ha spostato la sua attenzione su avav.</p>
<p>Avav ha creato più miracoli, con un costo del gas fino a $16M e un numero cumulativo di iscrizioni di 21M. Più di 50000 persone in tutto il mondo hanno partecipato contemporaneamente, ma dopo il lancio è precipitato ed è stato rapidamente risollevato a $50M dai compratori.<br><img src="https://gimg2.gateimg.com/image/article/1702973731img_v3_0269_cb91981f-d824-4a16-bf68-f2fc6eac85ix.jpg" alt=""><br>Origine: Avaions</p>
<p>Il protocollo Avalanche ha una vasta base di utenti in tutto il mondo, e il suo enorme entusiasmo per il consenso e i giusti vantaggi tecnologici hanno portato all’emergere di molteplici popolari iscrizioni su Avalanche, che è un’altezza che altre catene pubbliche non hanno raggiunto, almeno per ora.</p>
<h2 id="h2-In20sintesi455298"><a name="In sintesi" class="reference-link"></a><span class="header-link octicon octicon-link"></span>In sintesi</h2><p>L’emergere delle iscrizioni Bitcoin e i loro effetti di spillaggio hanno senza dubbio spinto questa nuova fase del mercato rialzista delle criptovalute ad una nuova altezza. Sebbene abbia suscitato alcuni dubbi e discussioni, il nuovo metodo di emissione delle monete delle iscrizioni sul mercato stesso è più in linea con la ricerca di consenso della decentralizzazione. L’aumento della liquidità, dell’attenzione e della prosperità dell’ecosistema che porta non può essere ignorato.</p>
<p>Naturalmente, il mercato delle iscrizioni continua a coesistere con rischi e benefici. Con il passare del tempo, la popolarità delle iscrizioni svanirà gradualmente. I partecipanti dovrebbero condurre ricerche sufficienti e comprendere, identificare i vantaggi e gli svantaggi del progetto e evitare fraintendimenti irrazionali causati dall’ingresso in FOMO.</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 venga citato Gate.io. In tutti i casi, verranno intraprese azioni legali a causa della violazione del copyright.<br></div><p></p><br></div></div></div></div>