TGUgUnVuZSBzb25vIGRpdmVudGF0ZSB2aXJhbGksIHBvc3Nvbm8gZGl2ZW50YXJlIHVuYSBudW92YSBuYXJyYXppb25lIGRpIGh5cGUgZG9wbyBsJ2hhbHZpbmc/

2024-04-23, 08:25

<p><img src="https://gimg2.gateimg.com/image/article/1713860094rdzz.jpeg" alt=""><br>[TL;DR]:<br>Come <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Raggiunge con successo il suo quarto dimezzamento, la popolarità delle rune di Runes nell’ecosistema <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> continua a riscaldarsi.</p>
<p>Che si tratti dell’emergere di iscrizioni e rune con effetti di ricchezza a breve termine o del lancio di protocolli basati su Bitcoin come L2 e DeFi, ciò indica un rinnovato entusiasmo tra investitori e sviluppatori per l’espansione di Bitcoin come rete di ecosistema.</p>
<p>Bitcoin si è evoluto nel corso di quattro anni, con ogni dimezzamento rappresentando una pietra miliare importante nella sua evoluzione. Sebbene il prezzo di Bitcoin possa fluttuare dopo il dimezzamento, il suo trend di crescita stabile a lungo termine sembra non rimanere immutato.</p>
<h2 id="h2-Introduzione992573"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>Con il completamento del quarto halving di Bitcoin, il tema caldo nel mercato è se l’effetto dell’halving sia stato pienamente riflettuto nei prezzi. Allo stesso tempo, le persone attendono con impazienza nuovi driver di prosperità di mercato, tra cui i numeri ordinali e le rune sono diventati importanti tendenze che non possiamo ignorare.</p>
<h2 id="h2-Runes20Runes20Online20Attivo20Mercato20Trading293427"><a name="Runes Runes Online, Attivo Mercato Trading" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Runes Runes Online, Attivo Mercato Trading</h2><p>Con il quarto halving di Bitcoin, la popolarità dei numeri ordinali e delle rune nell’ecosistema Bitcoin continua a crescere.</p>
<p>Il concetto innovativo dei numeri ordinali, introdotto per la prima volta da @rodarmor nel gennaio 2023, promuove notevolmente lo sviluppo della tecnologia di iscrizione aumentando la quantità di dati memorizzati sulla blockchain. L’emergere di questa tecnologia ha dato origine a numerose applicazioni innovative, come BRC-20 e rune.</p>
<p>Oggi, con il lancio del protocollo Runes durante il quarto halving di Bitcoin, il volume di scambi di rune ha mostrato una crescita sorprendente, vagamente reminiscente della popolarità delle iscrizioni dell’anno scorso.</p>
<p>Sebbene BRC20 abbia una volta dominato il trading nell’ecosistema Bitcoin dopo il rilascio di Ordinals, @rodarmor ha sempre avuto riserve al riguardo.</p>
<p>A settembre 2023, @rodarmor ha ufficialmente proposto il concetto di Runes attraverso un articolo sul blog e ha analizzato i vari problemi esistenti nei protocolli esistenti come BRC20, RGB e Taproot Assets. In particolare, lo standard del token BRC20, a causa della generazione di dati ‘spazzatura’ che porta alla congestione della rete Bitcoin, ha ricevuto severe critiche dagli sviluppatori principali di Bitcoin l’anno scorso. Abbiamo anche scritto un articolo intitolato “ <a href="https://www.gate.io/blog_detail/3691" target="_blank">Ripensando dietro la Follia: 8 Idee Sbagliate dei Dibattiti In_scrittura</a>“ per approfondire questa questione.<br><img src="https://gimg2.gateimg.com/image/article/17138605501.jpeg" alt=""><br>Fonte: @rodarmor</p>
<p>Oggi, la mania delle rune è in aumento, e le Rune di @rodarmor hanno molti vantaggi rispetto a BRC20:</p>
<p>Convenienza operativa: Runes semplifica ed esegue in modo efficiente, emette e trasferisce, riduce i tempi di transazione e supporta trasferimenti multi-destinatario e multi-token.</p>
<p>Facilità d’uso per gli sviluppatori: Runes ha un metodo di archiviazione dei dati e di indicizzazione più user-friendly, utilizzando il modello UTXO per una facile conferma del saldo. Inoltre, Runes fornisce implementazioni di riferimento, tra cui funzioni come l’indicizzazione, il browser e il portafoglio, riducendo la complessità dello sviluppo.</p>
<p>Compatibilità e scalabilità: Runes è compatibile con il protocollo UTXO Layer 2, utilizza la funzionalità dei contratti intelligenti e supporta il portafoglio leggero e gli aggiornamenti soft fork, garantendo una maggiore scalabilità.</p>
<p>Flessibilità nell’emissione di token: i Runes offrono maggiore flessibilità e scelte riguardo alla lunghezza del nome del token, la chiarezza del nome, i metodi di emissione, ecc., adottando il meccanismo Commit-Reveal per risolvere il problema della corsa al nome.</p>
<p>Sicurezza: le Rune possono efficacemente resistere agli attacchi di avvelenamento e di trading, migliorando complessivamente la sicurezza.<img src="https://gimg2.gateimg.com/image/article/17138605942.jpeg" alt=""><br>Origine: Informazioni pubbliche</p>
<p>In realtà, poche ore dopo il lancio del protocollo Runes il 20 aprile, le persone hanno speso oltre 3.200 BTC (circa 205 milioni di dollari) per le rune, e la commissione di trading di blocco Bitcoin ha raggiunto 20 BTC ad un certo punto, con i minatori che guadagnavano il doppio rispetto a prima dell’halving. UniSat aveva un conteggio utenti attivi settimanali di 500.000 a gennaio, e nel giro di una settimana dal lancio di Runes, questo indicatore è rapidamente salito a 1 milione.</p>
<p>Fino ad ora, Gate.io ha lanciato anche alcuni token Runes, come $WANKO•MANKO•RUNES, $SATOSHI•NAKAMOTO, $MEME•ECONOMICS, ecc.</p>
<h2 id="h2-Sviluppo20dellecosistema20Bitcoin20e20Riduzione20a20Met707493"><a name="Sviluppo dell’ecosistema Bitcoin e Riduzione a Metà" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Sviluppo dell’ecosistema Bitcoin e Riduzione a Metà</h2><p>Sebbene le Rune abbiano molti vantaggi, ci sono anche alcuni significativi svantaggi.</p>
<p>In primo luogo, le sue complesse regole di gestione dell’emissione e i requisiti specifici di denominazione non solo aumentano la difficoltà delle operazioni degli utenti ma possono anche aumentare il rischio di phishing per gli utenti.</p>
<p>In secondo luogo, Casey ha scelto di andare in diretta durante il periodo di dimezzamento di BTC e ha mancato il testnet, con conseguente accesso limitato alle istituzioni all’inizio e la necessità di maturità dell’ecosistema.</p>
<p>Inoltre, Rune ha ancora problemi di compatibilità, principalmente limitati al livello di distribuzione e non completamente integrati in un ecosistema più ampio.</p>
<p>Il mercato è anche scettico su se Runes possa fornire un’esperienza di trading più amichevole, con alcuni che ritengono che non abbia superato significativamente il BRC20 e che incontri ancora problemi simili.<img src="https://gimg2.gateimg.com/image/article/17138606343.jpeg" alt=""><br>Origine: mempool.space/</p>
<p>Indipendentemente dalla situazione, il lancio esplosivo delle Rune dimostra la positiva volontà del mercato di partecipare all’ecosistema Bitcoin. Tuttavia, nell’attuale ambiente macroeconomico e minerario che non è favorevole all’impennata di Bitcoin, il mercato ha urgentemente bisogno di una nuova narrazione dopo la speculazione sull’halving e l’arresto temporaneo.</p>
<p>Fidarsi solo dell’entusiasmo per le rune nel protocollo Runes non è sufficiente a sostenere i minatori dalla crisi dell’halving per molto tempo.</p>
<p>Prima di tutto, rivediamo l’esperienza storica del dimezzamento del bestiame nelle precedenti fasi. Durante i primi due episodi di dimezzamento di Bitcoin, avvenuti nel 2012 da 50BTC a 25BTC e nel 2016 da 25BTC a 12.5BTC, gli appassionati di tecnologia nella comunità si sono concentrati principalmente sul potenziale di Bitcoin come denaro elettronico.</p>
<p>Tuttavia, nel 2020, quando si è verificato il terzo dimezzamento, da 12,5 BTC a 6,25 BTC, l’attenzione delle persone si è gradualmente spostata sul ruolo di Bitcoin come metodo di pagamento, suscitando molte discussioni.</p>
<p>Ora, siamo nel quarto ciclo di dimezzamento, riducendo da 6,25 BTC a 3,125 BTC. Bitcoin e l’intera industria hanno mostrato alcuni nuovi cambiamenti senza precedenti. Con l’applicazione di successo dell’ETF di Bitcoin, Bitcoin è gradualmente stato considerato un asset di investimento alternativo e la disposizione delle istituzioni tradizionali e del capitale è diventata un nuovo punto focale.</p>
<p>Nel frattempo, che si tratti dell’emergere di iscrizioni e rune con effetti di ricchezza a breve termine, o del lancio di protocolli come L2 e DeFi basati su Bitcoin, tutto indica che gli investitori e gli sviluppatori hanno ravvivato il loro entusiasmo per espandere Bitcoin come rete ecosistemica, portando un potenziale di sviluppo illimitato e nuove opportunità per Bitcoin stesso.</p>
<h2 id="h2-Prospettive20future20di20Bitcoin729898"><a name="Prospettive future di Bitcoin" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Prospettive future di Bitcoin</h2><p>Ripensando all’halving precedente, dopo l’evento, il prezzo del BTC era aumentato significativamente e aveva raggiunto più volte nuovi massimi storici. Questo modello fa sì che attualmente anche il mercato delle criptovalute spera che il BTC possa creare un’altra brillante futuro.</p>
<p>Tuttavia, va sottolineato che i prezzi del BTC esperimenteranno gradi variabili di ritracciamento dopo ciascuna riduzione della metà, fino a un massimo del 40%. Pertanto, anche se il mercato è generalmente ottimista sull’aumento dimezzato, gli investitori devono essere cauti.<img src="https://gimg2.gateimg.com/image/article/17138606734.jpeg" alt=""><br>Fonte: @ChartsBtc</p>
<p>Riguardo a questo halving, non c’è ancora un consenso su una prospettiva di mercato rialzista. Tuttavia, nel complesso, la maggioranza vede comunque una crescita stabile a lungo termine del Bitcoin. L’halving delle ricompense per blocco è passato da 6,25 bitcoin a 3,125 bitcoin, con l’impatto più diretto che è una diminuzione dei profitti dei minatori. Ciò spinge anche i minatori a rivalutare la tecnologia sottostante e le dinamiche di rete delle criptovalute, potenziando la solidità della rete Bitcoin e aumentando la fiducia degli utenti e delle imprese.</p>
<p>Nel frattempo, l’esistenza degli ETF Bitcoin spot ha fornito un momentum sostenuto per la crescita del Bitcoin. Gli emittenti di ETF negli Stati Uniti stanno lavorando duramente per ottenere il riconoscimento da parte delle istituzioni e di un maggior numero di investitori al dettaglio rispetto al Bitcoin. Quando più investitori si renderanno conto che aumentare l’allocazione di asset del 5% per le criptovalute è vantaggioso per aumentare i rendimenti di rischio, si scatenerà una frenesia di investimenti più ampia.</p>
<p>Nel mercato di Hong Kong, Bitcoin e <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Gli spot ETF stanno per essere elencati e consentono la sottoscrizione delle quote degli ETF tramite rimborso fisico, il che offrirà migliori opportunità di scoperta del prezzo per le istituzioni tradizionali e migliorerà la liquidità complessiva di Bitcoin.</p>
<p>Inoltre, molti ecosistemi costruiti su Bitcoin sono costantemente in crescita e sviluppo. Se le iscrizioni dell’anno scorso hanno aperto la porta alla costruzione dell’ecosistema Bitcoin, rispetto alle Rune, che hanno mostrato evidenti vantaggi in termini di funzionamento, sviluppo, compatibilità, emissione e sicurezza, Runes fornisce una soluzione più completa ed efficiente per lo sviluppo dell’ecosistema. Il lancio di altri protocolli L2 e DeFi rilascerà anche notevolmente il valore degli asset di Bitcoin.</p>
<p>Complessivamente, Bitcoin si è evoluto nel corso di quattro anni, con ogni dimezzamento che rappresenta una pietra miliare importante nel suo sviluppo. Sebbene il prezzo di Bitcoin possa oscillare dopo il dimezzamento, la sua tendenza di crescita stabile a lungo termine rimane invariata. Allo stesso tempo, gli investitori dovrebbero monitorare attentamente la liquidità macro e le dinamiche di sviluppo dell’ecosistema di Bitcoin dopo il dimezzamento e cogliere più opportunità di mercato.</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 di violazioni del copyright.<br></div><p></p><br></div></div></div></div>