TnVvdmUgb3NzZXJ2YXppb25pOiBpc2NyaXppb25pIGVzcGxvc2l2ZSBkaSBudW92YSBlbWVyZ2VuemE=

2024-01-05, 02:37

<p><img src="https://gimg2.gateimg.com/image/article/1690791857hotspot.jpeg" alt=""></p>
<h2 id="h2-TLDR985018"><a name="[TL;DR]:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL;DR]:</h2><p>Dopo il declino dell’entusiasmo per la coniazione di iscrizioni BRC20, quali sono le nuove modalità di gioco nel campo delle iscrizioni, quali sono le innovazioni nelle strutture dei prodotti e come si comportano?</p>
<p>Entrando nel 2024, non solo l’infrastruttura di <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> L’ecosistema delle iscrizioni è in continua espansione e sta diventando sempre più conveniente, ma anche altri ecosistemi di catene pubbliche hanno arricchito il gameplay e il contenuto delle iscrizioni.</p>
<p>Crediamo che l’era dell’Inion 2.0 sia arrivata, e la traccia dell’Inion è ancora lontana dal raggiungere il limite. Il futuro è ancora pieno di infinite possibilità.</p>
<h2 id="h2-Introduzione116366"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>Da quando è stato rilasciato il protocollo <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> Ordinals nel gennaio 2023, le iscrizioni hanno gradualmente guidato l’onda di innovazione in Bitcoin e persino nell’intero mercato cripto. Protocolli come BRC20 e Ordinals hanno ottenuto ampi consensi per la loro tecnologia all’avanguardia e l’innovazione per gli investitori al dettaglio. Il meccanismo di emissione equo di BRC20 garantisce la coniazione indipendente delle iscrizioni, impedendo qualsiasi interferenza da parte di istituzioni o transazioni interne.</p>
<p>La prosperità di BRC20 ha promosso lo sviluppo di progetti emergenti e infrastrutture, aumentando anche i costi del gas sulla blockchain di Bitcoin, raggiungendo un massimo storico. Questa tendenza di mercato ha generato una domanda di iscrizioni più ricche e innovative, nonché di strumenti e piattaforme di coniazione di iscrizioni più efficienti.</p>
<p>L’articolo fornirà un riassunto e la condivisione delle nuove modifiche nell’era dell’Inion 2.0, a beneficio dei lettori.</p>
<h2 id="h2-120TurtSat20Concentrandosi20sul20Lancio20dellEcosistema20BRC2020Launchpad586817"><a name="1. TurtSat, Concentrandosi sul Lancio dell’Ecosistema BRC20 Launchpad" class="reference-link"></a><span class="header-link octicon octicon-link"></span>1. TurtSat, Concentrandosi sul Lancio dell’Ecosistema BRC20 Launchpad</h2><p>TurtSat è una piattaforma di lancio di progetti basata sugli Ordinals, simile al <a href="/price/gitcoin-gtc" rel="nofollow noopener noreferrer" target="_blank">Gitcoin</a> dell’ecosistema degli ordinali.</p>
<p>Supporta gli sviluppatori e le comunità open source a partecipare alla costruzione dell’ecosistema di Ordinals stabilendo un protocollo di donazione di base PSBT, guadagnando così entrate. TurtSat si impegna a creare un ecosistema attivo e guidato dalla comunità di Ordinals e a collaborare con organizzazioni influenti per promuovere lo sviluppo del protocollo di Ordinals e dell’ecosistema Bitcoin.<img src="https://gimg2.gateimg.com/image/article/1704421874img_v3_026q_d5b67ff4-9269-468f-ab5e-1d407e18cdix.jpg" alt=""><br>Origine: turtsat.io</p>
<p>TurtSat utilizza il token BRC20 TURT come base per lanciare un nuovo progetto. Gli utenti che detengono inizialmente un TURT possono qualificarsi per una lista bianca. Il 7 dicembre 2023, Turtsat ha emesso un nuovo asset, EGGS. Gli utenti possono scommettere $TURT per ottenere EGGS, che possono essere scambiati per la lista bianca dei progetti di lancio. In futuro, EGGS sarà applicato anche in scenari come il voto online del progetto e lo scambio di pacchetti regalo di token di cooperazione. Al 5 gennaio 2024, l’importo scommesso di TURT è di 313,4 milioni.</p>
<p>In realtà, la popolarità delle iscrizioni dal Q4 2024 è stata diversa rispetto ai meme precedenti. Molti nuovi progetti hanno utilizzato alcuni token BRC20 come propri token di protocollo per potenziare la loro utilità, espandendo notevolmente i casi d’uso marginali delle iscrizioni.</p>
<p>Questi nuovi progetti includono non solo la piattaforma di lancio TurtSat menzionata sopra, ma anche molti altri protocolli, come BRC20.COM, che mira a costruire l’ecosistema di rete Bitcoin Super App COM viene utilizzato come token per implementare il Rollup cross-chain per BRC201, con ROUP come token di piattaforma e RDEX come token di protocollo per gli ordini della piattaforma di trading BRC20.orders.exchange.</p>
<p>Infine, va notato che Gate.io ha lanciato il trading spot di TURT.</p>
<h2 id="h2-220BTNS20Emissione20di20asset20attraverso20lindice20di20contabilit5259"><a name="2. BTNS Emissione di asset attraverso l’indice di contabilità" class="reference-link"></a><span class="header-link octicon octicon-link"></span>2. BTNS Emissione di asset attraverso l’indice di contabilità</h2><p>BTNS è l’ecosistema della catena principale BTC costruito da @jdegresorg, un detentore e sviluppatore di BTC. L’idea di base è quella di trasmettere segnali di trasmissione aggiuntivi sulla catena BTC per consentire a BTC di rilasciare i suoi asset nativi in ​​catena.<img src="https://gimg2.gateimg.com/image/article/1704421906img_v3_026q_934e4489-50a4-434a-94d8-06a64dbd67ix.jpg" alt=""><br>Origine: brc-20.name</p>
<p>BTNS-420 è uno standard di protocollo token costruito da @jdegresorg basato su BTNS, che integra varie funzionalità dell’ecosistema come la pubblicazione e il trasferimento di asset.</p>
<p>L’emergere del BTNS-420 ha dato a BTNS i seguenti vantaggi, rendendo possibile il suo concetto:</p>
<p>BTNS ha reso possibile rilasciare asset basati sulla catena principale BTC.</p>
<p>BTNS è completamente open source e non ha discussioni significative o controverse.</p>
<p>BTNS può trasformare BTC in un ecosistema di gioco completamente funzionante e ecologicamente sostenibile.</p>
<p>In sintesi, ci sono delle differenze sostanziali tra i token BTNS e le iscrizioni e le rune:</p>
<p>I token BTNS non occupano BTC, mentre le iscrizioni e le rune occuperanno BTC.</p>
<p>La coniazione dei token BTNS è più aperta ed equa, mentre la coniazione delle iscrizioni e delle rune è più centralizzata.</p>
<h2 id="h2-320Spostare20Smart20Inion20MRC2020con20un20Gameplay20Versatile216411"><a name="3. Spostare Smart Inion MRC20 con un Gameplay Versatile" class="reference-link"></a><span class="header-link octicon octicon-link"></span>3. Spostare Smart Inion MRC20 con un Gameplay Versatile</h2><p>Entrando nel 2024, non solo l’infrastruttura dell’ecosistema di iscrizione di Bitcoin si sta espandendo costantemente diventando sempre più conveniente, ma anche altri ecosistemi hanno arricchito il gameplay e il contenuto delle iscrizioni. Il prominente intelligente iscrizione MRC20MOVE nell’ecosistema Move è diventato rapidamente popolare di recente.</p>
<p>La prima iscrizione MOVE di MRC20 è stata ufficialmente lanciata il 1 gennaio 2024 e in soli tre giorni, 10 miliardi di MOVE sono stati completamente utilizzati. Questa misura ha bloccato oltre 100w SUI, rappresentando un quinto del valore totale bloccato (TVL) dell’intera blockchain SUI. Allo stesso tempo, il numero di indirizzi in cui è stata coniata questa iscrizione si è avvicinato a 50000.<img src="https://gimg2.gateimg.com/image/article/1704421977img_v3_026q_8cce2c3b-bf6b-4f09-9202-af1a430144ix.jpg" alt=""><br>Fonte: mrc20.fun</p>
<p>In particolare, il numero totale di MOVE è di 10 miliardi e ogni epoca (1 minuto) può stampare un’iscrizione per indirizzo, quindi sono necessarie un totale di 21600 epoche per completare il processo. Il numero di $MOVEs in ogni iscrizione non è fisso, ed è diviso equamente in base al numero di indirizzi coinvolti in ogni epoca.</p>
<p>I dettagliati gameplay sono i seguenti:</p>
<p>A partire da ogni epoca, tutti gli indirizzi possono partecipare all’iscrizione.</p>
<p>Ogni indirizzo può avere un’unica iscrizione.</p>
<p>Ogni volta che digiti un’iscrizione, devi bloccare 0.1SUI.</p>
<p>Se vengono inviate più richieste di iscrizioni entro un minuto, verrà digitata solo un’iscrizione e i 0,1 SUI extra verranno accatastati e bloccati all’interno dell’iscrizione digitata nell’epoca corrente.</p>
<p>Tutti gli SUI bloccati sono memorizzati nel portafoglio dell’utente e l’utente può distruggere le iscrizioni in qualsiasi momento per recuperare il proprio capitale.</p>
<p>Ci sono anche alcune opzioni di gioco dell’uovo di Pasqua:</p>
<p>Modalità di accelerazione Rampage: se ogni epoca ha 500 indirizzi partecipanti, la modalità di accelerazione verrà attivata e la durata di ogni epoca verrà accorciata.</p>
<p>Modalità di Vittoria: L’indirizzo in cui viene posizionata la prima iscrizione in ogni epoca riceverà un’iscrizione aggiuntiva, senza la necessità di bloccare 0.1 SUI.<br><img src="https://gimg2.gateimg.com/image/article/1704422068img_v3_026q_b1b87bf3-db99-4903-9935-3a53e9d57dix.jpg" alt=""><br>Fonte: @Moveions</p>
<p>La popolarità dell’iscrizione Move può essere attribuita al suo gameplay più interessante e in linea con lo spirito della coniazione equa.</p>
<p><strong>Gioco imprevedibile</strong><br>Questo gameplay porta a un diverso numero di carte MOVE ottenute con ogni colpo di iscrizione. Per gli utenti che partecipano in anticipo, potrebbe essere più vantaggioso in quanto il numero di indirizzi partecipanti aumenta nel tempo. Questo meccanismo può anche essere progettato per allocare in modo casuale importi all’interno di un intervallo numerico, che è più in linea con il gioco d’azzardo umano come grattare biglietti della lotteria.</p>
<p><strong>La modalità di gioco di blocco SUI</strong><br>Questo gameplay consente agli utenti di distruggere le iscrizioni digitate in qualsiasi momento per recuperare la loro capitale. I fondi dell’utente non sono controllati da terze parti o contratti e sono realmente di proprietà del portafoglio dell’utente. Gli utenti possono ritirare le loro azioni in qualsiasi momento, rendendoli più flessibili.</p>
<p><strong>Gioco dell’uovo di Pasqua</strong><br>Il gameplay dell’uovo di Pasqua porta più spazio all’immaginazione per SPOSTARE iscrizioni. Diversi modelli di gioco, iscrizioni di potenziamento, combinati con giochi a catena completa o altri giochi LEGO possono essere derivati.</p>
<h2 id="h2-420Noion20per20Zero20Gas20Lottery20Mining183120"><a name="4. Noion per Zero Gas Lottery Mining" class="reference-link"></a><span class="header-link octicon octicon-link"></span>4. Noion per Zero Gas Lottery Mining</h2><p>Inoltre, è stato ufficialmente aperto il 1° gennaio il primo Noion di Nostr.</p>
<p>Noion è il primo protocollo di iscrizione di Nostr, utilizzando il metodo di mining PoW basato su Nostr NIP13. Questa iscrizione firma messaggi di testo formattati in JSON, consentendo agli utenti di ottenere la proprietà. NIP13 definisce il metodo di prova del carico di lavoro del biglietto Nostr per la dissuasione dello spam.</p>
<p>Il numero totale di NOSS è di 21 milioni, con 10 token per carta. Un nuovo portafoglio vuoto può partecipare all’estrazione, completamente gratuito.</p>
<p>Tuttavia, poiché Nostr non è correlato alla blockchain, Mint firma il testo dell’iscrizione attraverso una chiave pubblica, ma il problema della doppia spesa dell’attivo esiste ancora.</p>
<p>Tuttavia, dopo l’inizio dell’attività Noion, la funzionalità di coniazione era anomala a causa di problemi con il nodo Arbitrum RPC. La dichiarazione ufficiale afferma che il problema del nodo è stato risolto, ma il vero problema è solo appena iniziato.</p>
<p>Dopo che la funzione di conio è normale, ci sono inizialmente tre tipi di giudizi per ogni conio: blu “Found nonce”, verde “Mint Event Pushed!” e rosso “Richiesta non riuscita”. Tuttavia, dopo aver ricevuto un messaggio verde “Mint Event Pushed!”, il saldo dell’utente ha mostrato un errore e non è stato possibile confermare se il conio è andato a buon fine. <img src="https://gimg2.gateimg.com/image/article/1704422129img_v3_026q_e0791b44-f9ed-4b50-bfdf-806995cda8ix.jpg" alt=""><br>Fonte: @Noion</p>
<p>Successivamente, alcuni membri della comunità hanno ricevuto il quarto giudizio “Miner” e hanno sottolineato che questo avviso rappresenta veramente il successo della coniazione.</p>
<p>Successivamente, varie accuse come “difficoltà di mining” e “furto di potenza di calcolo per il mining” si diffusero rapidamente in tutta la comunità, e il sito web ufficiale di Noion spiegò rapidamente questo, anche se sembrava ancora pallido e impotente.</p>
<p>Non c’è bisogno di dispositivi di fascia alta: puoi scavare $nos con il tuo telefono. La difficoltà di coniazione impostata dal protocollo e NIP-13 è bassa e la maggior parte dei dispositivi è sufficiente per far fronte.</p>
<p>Non contribuisce potenza di calcolo al pool di mining di Bitcoin: la difficoltà della sfida NIP-13 non corrisponde a quella del pool di mining di Bitcoin e il front-end non interagisce con il pool di mining.</p>
<p>Considerazioni sulla equità: Per prevenire lo spam, è necessario aggiungere sfide PoW. Pensato per una coniazione e pubblicazione equa, richiede una certa difficoltà.</p>
<p>Attualmente, il token non è stato completamente coniato e al momento della scrittura, il progresso ha raggiunto solo il 7,57%. Tuttavia, diverse accuse e spiegazioni si sono diffuse in tutta la comunità e se il progetto può diventare virale resta da osservare ulteriormente.<img src="https://gimg2.gateimg.com/image/article/1704422168img_v3_026q_4d98a894-2730-4e84-9f2c-d8af0b4873ix.jpg" alt=""><br>Origine: noion.org</p>
<h2 id="h2-Per20riassumere508926"><a name="Per riassumere" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Per riassumere</h2><p>Il recente lancio di una serie di protocolli di iscrizione e infrastrutture ha continuato l’entusiasmo nel mercato delle iscrizioni e ha dato più possibilità di diventare virale.</p>
<p>Crediamo che l’era dell’Inion 2.0 sia arrivata e la traccia dell’Inion sia lontana dal raggiungere il soffitto. Il futuro è ancora pieno di infinite possibilità e continueremo a prestare attenzione a prodotti di iscrizione più innovativi ed efficaci per servire un numero maggiore di utenti.</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, saranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div></div>