UHXDsiBCUkMtNDIwIEJsdWUgQm94IGRpdmVudGFyZSBsYSAic2NhdG9sYSBkaSBQYW5kb3JhIiBjaGUgYXByZSBsJ2Vjb3Npc3RlbWEgZGVsIEJpdGNvaW4/

2024-01-25, 07:22

<p><img src="https://gimg2.gateimg.com/image/article/1690791857hotspot.jpeg" alt=""></p>
<h2 id="h2-TLDR719404"><a name="TL;DR" class="reference-link"></a><span class="header-link octicon octicon-link"></span>TL;DR</h2><p>Protocollo BRC-420 - il primo progetto di scrittura basato sull’universo Bitcoin;</p>
<p>La scatola blu è simile alla scatola madre dell’ecosistema $Raca;</p>
<p>Blue Box is actively promoting the development of the full-chain game eco of Bitcoin;</p>
<p>Il successo del protocollo BRC-420 e del progetto Blue Box segna l’inizio di una nuova ondata di entusiasmo nell’ecosistema BTC.</p>
<h2 id="h2-Introduzione434496"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>Recentemente, con lo sviluppo del percorso delle incisioni, l’immaginazione dell’ecosistema <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> Metaverse ha scatenato un fenomeno di FOMO sul mercato.</p>
<p>Il protocollo BRC-420, come primo progetto di incisione basato sull’universo Bitcoin, ha visto il prezzo del pavimento NFT della scatola blu aumentare da 0,15 a 17000 dollari in un breve lasso di tempo, raggiungendo un massimo di 25000 dollari, con un aumento di oltre 160.000 volte, portando così a un’ampia attenzione di mercato per la corsa all’universo Bitcoin.</p>
<h2 id="h2-Cos20il20protocollo20BRC420120228"><a name="Cos’è il protocollo BRC-420" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Cos’è il protocollo BRC-420</h2><p>In breve, BRC-420 è un protocollo di gestione degli asset basato sull’ordinale e sulle bitmap su BTC.</p>
<p>Bitmap è un progetto metaverso nell’ecosistema Bitcoin, basato sulla teoria degli ordini e sulla teoria dei bitmap, correlato al numero di blocco e definito come il terreno di BTC.</p>
<p>RCSV è il team di BRC-420 e attualmente sta sviluppando un universo virtuale BTC basato su bitmap. La Blue Box è il primo asset BRC-420 emesso dal team di BRC-420 RCSV.<br><a href="/price/icon-icx" rel="nofollow noopener noreferrer" target="_blank">criptovaluta ICON</a></p>
<p>La scatola blu BRC420 è simile alla scatola madre dell’ecosistema $Raca. Come protocollo di gestione degli asset su BTC, è guidato da RCSV. Si dice che coloro che possiedono la scatola blu riceveranno una quota degli introiti dell’ecosistema e avranno l’opportunità di ricevere airdrop di progetti collaborativi dell’ecosistema e qualificarsi per la whitelist dei progetti collaborativi di Bitcoin.</p>
<p>Anche se Blue Box è un NFT sulla superficie, si dice che verrà presto tokenizzato. Ogni Blue Box può essere scambiato con 2100 token per garantire la liquidità e facilitare l’allocazione dei grandi capitali e le operazioni degli operatori di mercato.</p>
<h2 id="h2-Continua20a20rompere20il20prezzo20del20pavimento651874"><a name="Continua a rompere il prezzo del pavimento" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Continua a rompere il prezzo del pavimento</h2><p>Poiché la narrazione della Blue Box segue la storia del metaverso di Big Pie, oltre al fatto che il bitmap stesso è già aumentato molto bene, quindi è stato un’ascesa costante. Al momento, bitmap è il progetto con la più alta capitalizzazione di mercato tra gli NFT delle incisioni di ordinals.</p>
<p>Attualmente, il prezzo di Blue Box è di 0.4269 BTC (dati aggiornati al 19 gennaio 2024), con un totale di 10.000 pezzi e una capitalizzazione di mercato di circa 200 milioni. Sulla base dei dati di CoinmarketCap, considerando le dimensioni potenziali dell’ecosistema Bitcoin e l’esperienza dell’ultimo ciclo di mercato rialzista, la previsione è che la capitalizzazione di mercato possa raggiungere 200.000-500.000 dollari.</p>
<p>I partecipanti a Blue Box diventeranno beneficiari dell’ecosistema di Bitcoin, sia i detentori che gli autori dell’ecosistema otterranno ricompense sostanziali in questo mercato rialzista dominato dall’ecosistema di Bitcoin. Pertanto, BRC420 può essere considerato come un albero del denaro e il miglior modo per entrare nell’ecosistema di Bitcoin e partecipare nei settori NFT e GameFi.<br><img src="https://gimg2.gateimg.com/image/article/1706167240img_v3_027e_c925775e-f5a6-466e-8f56-cc2b3a4143ix.jpg" alt=""></p>
<p>Il protocollo BRC-420 consente di combinare più testi in un asset complesso, creando asset di varie dimensioni, dai piccoli personaggi e animali domestici ai completi  di gioco e macchine virtuali. Grazie alla sua natura open source on-chain, qualsiasi client può eseguire o verificare, incarnando appieno lo spirito di ‘Client Agnostic’ del gioco completo, aprendo improvvisamente spazi di immaginazione e aspettative di prezzo.</p>
<p>Nonostante il browser Bitmap di RCSV abbia dominato il mercato, altre squadre hanno l’opportunità di sviluppare client per eseguire gli asset BRC-420. Oggi, il numero di indirizzi dei detentori di Bitmap ha superato quelli di Sandbox, diventando l’asset del metaverso con il maggior numero di detentori in tutta la blockchain. Questo risultato è stato ottenuto grazie al suo meccanismo di lancio equo e agli sforzi collettivi di oltre 200 squadre di sviluppo che ruotano attorno a Bitmap.</p>
<p>Con il lancio del browser Bitmap e del protocollo stesso, il valore di mercato di BRC-420 sta aumentando costantemente.</p>
<p>In qualità di proponente del progetto BRC-420, RCSV sta attivamente promuovendo il piano di gioco completo dell’ecosistema Bitcoin. Il piano sottolinea gli asset, le modalità di gioco, la logica e i dati sull’intera catena, con l’obiettivo di creare un vero e proprio ecosistema di giochi decentralizzati basato su Bitcoin. Ad esempio, gli sviluppatori possono utilizzare il ‘modulo di combattimento’ su BRC-420 per sviluppare e rilasciare rapidamente nuovi giochi, pagando solo i diritti d’autore tramite il protocollo.</p>
<p>Come prodotto del protocollo BRC-420, il Blue Box come incantesimo riflette non solo l’alto livello di attesa del mercato per il progetto, ma anche il riconoscimento degli investitori del potenziale di sviluppo futuro del metaverso. Il concetto di prezzo del pavimento si riferisce al prezzo più basso accettabile sul mercato, e l’impennata del prezzo del pavimento del Blue Box senza dubbio indica la sua rarità e il suo valore unico.<br><img src="https://gimg2.gateimg.com/image/article/1706167269img_v3_027e_75303757-6391-42ed-8856-8b192ca2f0ix.jpg" alt=""></p>
<h2 id="h2-Perch2020cos20popolare20sul20mercato218169"><a name="Perché è così popolare sul mercato" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Perché è così popolare sul mercato</h2><p>Il motivo per cui la scatola blu dell’incisione ha attirato così tanta attenzione sul mercato è principalmente dovuto ai seguenti fattori:</p>
<ol>
<li>Strumenti ecologici: attualmente le attività di trading BRC20 sono concentrate principalmente su OKX e Unisat. Con l’emergere di altri protocolli, sono anche emersi mercati di trading diversi per ogni protocollo. La creazione di un protocollo leader alla fine porterà alla nascita di un mercato di trading unico e la concorrenza nel mercato di trading è ancora lontana dall’essere finita.</li></ol>
<p>Con l’ingresso continuo di fondi nel mercato delle iscrizioni, gli utenti stanno iniziando a rivolgere la loro attenzione alle applicazioni basate sulle iscrizioni. BRC420 è un esempio tipico. Unisat porta innovazione a BRC20, consentendo agli utenti di scambiare facilmente i token BRC20 come AMM DEX tramite BRC20-Swap. Questo potrebbe rilasciare il potenziale dell’ecosistema Bitcoin DeFi e potrebbe portare a funzionalità aggiuntive come prestiti e strumenti derivati.</p>
<ol>
<li>Concetto di metaverso: con la tendenza di Bitcoin Layer2, la costruzione dell’ecosistema del metaverso su Bitcoin sta diventando gradualmente il nuovo punto caldo ricercato dal mercato, e l’iscrizione-Blue Box è nata su questa base.</li></ol>
<p>A marzo 2023, Galaxy Research and Mining prevede che entro il 2025, la capitalizzazione di mercato di Ordinals raggiungerà 500 milioni di dollari. A quel tempo, il numero di incisioni era solo di 260.000, ma ora è aumentato a 33 milioni, un aumento del 126 volte. Nel frattempo, la capitalizzazione di mercato di Dragon One ORDI ha raggiunto i 400 milioni di dollari, mentre quella di Dragon Two SATS ha raggiunto i 300 milioni di dollari. Questo dimostra che le previsioni del mercato dell’ecosistema di Bitcoin sono state notevolmente sottostimate.</p>
<ol>
<li>Prospettive di investimento: molti investitori sono ottimisti sulle prospettive di sviluppo a lungo termine dell’universo meta, ritenendo che gli investimenti precoci possano portare a enormi rendimenti. Oggi ci sono diversi protocolli emergenti nel settore delle criptovalute, e i minatori ne traggono il massimo beneficio, creando un circolo virtuoso. Secondo i dati di monitoraggio della catena di Tokenview, le commissioni di transazione giornaliere della rete Bitcoin hanno raggiunto i 11,6 milioni di dollari, superando <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> per la prima volta dal 2020.</li></ol>
<p>Con l’avvicinarsi dell’imminente dimezzamento di Bitcoin, i minatori hanno urgente bisogno di trovare entrate supplementari. La prosperità della pista delle iscrizioni porta benefici ai minatori, ma allo stesso tempo contribuisce in modo indiretto a mantenere la sicurezza della rete Bitcoin. La riduzione degli incentivi per i blocchi renderà i minatori più dipendenti dalle entrate delle commissioni di transazione per coprire i costi operativi. In futuro, Bitcoin sicuramente sarà oggetto di una competizione tra varie soluzioni di scalabilità. L’esplosione e le elevate commissioni di transazione della pista delle iscrizioni saranno il catalizzatore dello sviluppo futuro.</p>
<ol>
<li>Innovazione tecnologica: Brc420 è un’innovazione significativa nell’assetizzazione dei contenuti dopo Brc20, che in precedenza includeva solo NFT e token. Ora, attraverso una combinazione di asset, viene completata in modo ricorsivo, e ha anche una nuova liquidità rilasciata, attirando davvero l’attenzione di tutto il mercato.</li></ol>
<h2 id="h2-conclusione136264"><a name="conclusione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>conclusione</h2><p>Il protocollo BRC-420 e il progetto correlato Bitmap stanno stimolando l’innovazione e la vitalità nell’ecosistema di Bitcoin. Creando asset digitali complessi e modulari, BRC-420 offre nuove opportunità economiche e esperienze interattive per creatori, sviluppatori e utenti. Con gli sforzi continui del team RCSV, il concetto di giochi blockchain a catena completa e metaverso sta diventando gradualmente realtà, mostrando le ampie prospettive della tecnologia e delle applicazioni di Bitcoin.</p>
<p>Con il progresso tecnologico e una maggiore consapevolezza di mercato, abbiamo motivo di credere che questo settore continuerà a generare ulteriori innovazioni e opportunità. Per gli investitori, mantenere un’attenzione costante sulle dinamiche del metaverso e condurre un’analisi razionale saranno la chiave per cogliere le opportunità future.</p>
<div class="blog-details-info"><br>  <div>Autore:<strong>Byron B.</strong>Ricercatore di Gate.io<div class="info-tips"><em> Questo articolo rappresenta solo le opinioni dell'autore e non costituisce alcun consiglio di trading.<br></em><div><em></em>Il contenuto di questo articolo è originale e la proprietà di Gate.io. Se vuoi riprodurlo, per favore indica l'autore e la fonte, altrimenti saranno perseguite responsabilità legali.<br></div><p></p><br></div></div></div>