TGUgY29tbWlzc2lvbmkgZGkgdHJhbnNhemlvbmUgZGkgQml0Y29pbiBzdXBlcmFubyBFdGhlcmV1bSBwcmltYSBkZWxsJ2hhbHZpbmc6IHVuYSBudW92YSBlcmEgcGVyIGkgbWluYXRvcmk=

2024-05-08, 07:20

<p><img src="https://gimg2.gateimg.com/image/article/1715152529rdzz.jpeg" alt=""></p>
<h2 id="h2-TL20DR775914"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p>Tra il 15 e il 17 aprile il quotidiano <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> le commissioni erano superiori alle commissioni Ethereum.</p>
<p>Il protocollo Runes consente agli sviluppatori di creare token fungibili sulla blockchain di bitcoin.</p>
<p>L’evento di dimezzamento del 2024 ha ridotto la ricompensa mineraria da 6,25 a 3,125 BTC per blocco.</p>
<h2 id="h2-Introduzione450881"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>L’evento di recente dimezzamento di <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">bitcoin</a> che ha ridotto le ricompense di mining da 6.25 BTC a 3.125 BTC per blocco significa che il reddito dei minatori diminuirebbe a seconda del prezzo di BTC e delle commissioni di transazione. Tuttavia, ci sono nuove dinamiche di reddito sulla blockchain di bitcoin a seguito dell’introduzione di iscrizioni ordinarie nel gennaio 2023 e rune. <a href="https://www.gate.io/learn/articles/the-2024-halving-could-usher-in-a-new-era-for-bitcoin/2651" target="_blank">prima dell’ultimo dimezzamento del bitcoin</a>.</p>
<p>L’obiettivo di questo articolo è confrontare le commissioni di transazione tra le reti bitcoin ed <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> nella terza settimana di aprile. Discuteremo anche l’impatto dell’evento di riduzione a metà sulle ricompense dei minatori. Infine, confronteremo il protocollo Runes e il protocollo ordinals e il loro effetto collettivo sulle commissioni di transazione della rete bitcoin.</p>
<h2 id="h2-Le20commissioni20di20Bitcoin20superano20quelle20di20Ethereum20per20tre20giorni708478"><a name="Le commissioni di Bitcoin superano quelle di Ethereum per tre giorni" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Le commissioni di Bitcoin superano quelle di Ethereum per tre giorni</h2><p>Il settore delle criptovalute ha registrato un cambiamento significativo poiché le commissioni giornaliere di transazione di Bitcoin hanno superato quelle di Ethereum per tre giorni consecutivi prima. <a href="https://www.gate.io/blog_detail/1800/bitcoin-halving-in-2024-will-btc-have-another-bull-run" target="_blank">Evento di dimezzamento del 20 aprile</a>. L’aumento dell’attività sulla blockchain di bitcoin a causa dell’avvicinarsi dell’evento di dimezzamento e del lancio di Runes, un nuovo standard di token sulla rete, ha portato all’aumento delle commissioni di transazione di bitcoin.</p>
<p>Nello specifico, tra il 15 e il 17 aprile i minatori di Bitcoin hanno raccolto più commissioni di transazione rispetto ai loro omologhi di Ethereum, il che è diventato un evento unico per le blockchain concorrenti. Ad esempio, solo il 17 aprile i minatori di Bitcoin hanno guadagnato $7,47 milioni in commissioni di rete, mentre gli stakers di Ethereum hanno incassato $7,31 milioni.</p>
<p>Il 15 e 16 aprile, le commissioni di bitcoin erano superiori alle commissioni di Ethereum di $3,5 milioni e $1,1 milioni rispettivamente. Mitrade ha catturato l’aumento delle commissioni di bitcoin nel periodo citato come mostra il grafico seguente.<br><img src="https://gimg2.gateimg.com/image/article/17151526011.jpeg" alt=""><br>L’impennata delle commissioni di Bitcoin tre giorni prima dell’evento dell’Halving: <a href="https://pbs.twimg.com/media/GLqLGYBWgAAYehF?format=jpg&amp;name=4096x4096" rel="nofollow noopener noreferrer" target="_blank">Mitrade</a></p>
<p>Come indica il grafico sopra, c’è stato un forte aumento delle commissioni di bitcoin nella terza settimana di aprile. Un’altra fonte, <a href="https://twitter.com/esatoshiclub/status/1782363972261326983?" rel="nofollow noopener noreferrer" target="_blank">eSatoshiClub</a> indica anche che il 20 aprile, data del dimezzamento del bitcoin, le commissioni di transazione sono aumentate.<br><img src="https://gimg2.gateimg.com/image/article/17151526462.jpeg" alt=""><br>Sorgente: <a href="https://twitter.com/esatoshiclub/status/1782363972261326983?" rel="nofollow noopener noreferrer" target="_blank">x.com</a></p>
<p>In generale, tuttavia, le cifre medie delle commissioni di transazione sono state a favore di Ethereum. Ad esempio, le commissioni di transazione medie per Ethereum e Bitcoin per il periodo di sette giorni che è terminato il 17 aprile erano rispettivamente di $8,55 milioni e $7,57 milioni. Per quanto riguarda le commissioni di transazione, Ethereum rimane il leader rispetto alla sfida Ethereum vs. Bitcoin. <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> rivalità. La seguente tabella mostra le commissioni medie giornaliere per le transazioni su diverse blockchain, inclusi Ethereum, Bitcoin, <a href="/price/aave-aave" rel="nofollow noopener noreferrer" target="_blank">Aave</a> e <a href="/price/uniswap-uni" rel="nofollow noopener noreferrer" target="_blank">Uniswap</a>.<br><img src="https://gimg2.gateimg.com/image/article/17151526853.jpeg" alt=""><br>Commissioni medie giornaliere delle transazioni blockchain - <a href="https://s3.cointelegraph.com/uploads/2024-04/52b6bb62-0c3b-463b-a953-5100d909f645.png" rel="nofollow noopener noreferrer" target="_blank">Cointelegraph</a></p>
<p>Come osservato nella tabella sopra, Ethereum ha le più alte “Tariffe medie giornaliere”, seguito da bitcoin e Uniswap. Naturalmente, le commissioni di transazione di <a href="/price/aave-aave" target="_blank" class="blog_inner_link">Aave</a> e Kyberswap sono anche relativamente alte.</p>
<p>È importante capire che le commissioni del Bitcoin dipendono dalla domanda attuale per lo spazio del blocco e dalle dimensioni delle transazioni. In confronto, le recenti commissioni del Bitcoin sono state in generale inferiori rispetto ai mesi precedenti a causa del calo dei valori di <a href="https://www.gate.io/learn/articles/what-are-cbrc-20-tokens/1569" target="_blank">Token BRC-20</a>, inclusi Sats (SATS) e Ordinals (ORDI). Nel frattempo, lo spostamento del focus dei trader da ORDI a Runes potrebbe determinare futuri cambiamenti nelle commissioni di transazione di Bitcoin e il conseguente ricavo dei minatori.</p>
<h2 id="h2-Evento20di20Halving20di20Bitcoin20e20il20suo20impatto20sulle20ricompense20dei20minatori247688"><a name="Evento di Halving di Bitcoin e il suo impatto sulle ricompense dei minatori" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Evento di Halving di Bitcoin e il suo impatto sulle ricompense dei minatori</h2><p>L’aumento delle commissioni di transazione di Bitcoin è stata una buona notizia per i minatori di bitcoin il cui flusso di entrate è stato influenzato dalla diminuzione delle ricompense per blocco a seguito dell’evento di dimezzamento. Prima dell’evento di dimezzamento del bitcoin, venivano estratti circa 900 BTC del valore di circa 57,2 milioni di dollari al giorno. Ora, solo 450 BTC al giorno vengono estratti nel periodo post-dimezzamento.</p>
<p>Ciò implica che la sostenibilità della rete Bitcoin dipenderà principalmente dalle commissioni di transazione Bitcoin. L’introduzione di Runes su Bitcoin, SATS e Ordinals probabilmente stabilizzerà le commissioni di transazione sulla rete e sosterrà i minatori.</p>
<h2 id="h2-Scenario20competitivo20con20Rune20e20Ordinali958211"><a name="Scenario competitivo con Rune e Ordinali" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Scenario competitivo con Rune e Ordinali</h2><p>Come accennato in precedenza, le innovazioni che si verificano sulla blockchain di Bitcoin probabilmente porteranno a una sostenibilità intrinseca della blockchain di Bitcoin. Gli asset digitali recentemente introdotti sulla blockchain, tra cui iscrizioni ordinali e rune, probabilmente aumenteranno l’attività sulla rete, il che potrebbe comportare commissioni di transazione più elevate e un aumento dei ricavi dei minatori.</p>
<p>In primo luogo, non c’è dubbio che l’introduzione di “Ordinali” simili agli NFT all’inizio del 2023 abbia contribuito ad aumentare le commissioni di Bitcoin. Ora, il lancio di Runes, un nuovo standard di token Bitcoin, aumenterà ulteriormente la generazione di entrate per i minatori. I Runes consentiranno lo sviluppo di token fungibili come le memecoin su Bitcoin, il che potrebbe attirare molti progetti crypto della community sulla blockchain.</p>
<p>Già, l’innovatore delle Rune e degli Ordinali, Casey Rodarmor, ha parlato molto bene dei nuovi token standard di bitcoin. Ad esempio, ha detto che le Rune sono <a href="https://www.gate.io/learn/articles/what-is-utxo/190" target="_blank">basato interamente su UTXO</a>, il che significa che non porteranno a spam di rete e congestione che sono stati associati agli ordinali.</p>
<p>Essenzialmente, le Rune aiuteranno a diversificare le applicazioni di finanza decentralizzata sulla blockchain di bitcoin. Tali protocolli DeFi contribuiranno a stabilizzare le commissioni di rete e aumentare la sua attività. D’altra parte, se c’è una sostenuta <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Prezzo Bitcoin</a> l’aumento dei guadagni dei minatori aumenterà notevolmente.</p>
<h2 id="h2-Confronto20tra20Runes20e20Ordinals20confronto931665"><a name="Confronto tra Runes e Ordinals confronto" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Confronto tra Runes e Ordinals confronto</h2><p>Ora che abbiamo discusso dell’impatto di Runes e Ordinals sulle commissioni e sull’attività di bitcoin, confrontiamoli brevemente. Il protocollo Runes è più <a href="https://www.gate.io/learn/articles/a-brief-analysis-of-bitcoin-ordinals-protocol/1166" target="_blank">più efficiente del protocollo degli Ordinals</a> quando si creano token sulla rete Bitcoin. È un token standard di Bitcoin molto adatto per memecoin e asset digitali simili. Nel suo post su X, Rodarmor ha reso questo punto chiaro, come mostra l’immagine seguente.<br><img src="https://gimg2.gateimg.com/image/article/17151527914.jpeg" alt=""><br>Source: <a href="https://twitter.com/rodarmor/status/1774613900119699701?ref_src=twsrc%5Etfw%7Ctwcamp%5Etweetembed%7Ctwterm%5E1774613900119699701%7Ctwgr%5Edd15e5921fcd5be8baa4c20acbe91747175867cc%7Ctwcon%5Es1_c10&amp;ref_url=https%3A%2F%2Fwww.ccn.com%2Fnews%2Fcrypto%2Fbitcoin-miners-profit-million-runes-minting%2F" rel="nofollow noopener noreferrer" target="_blank">x.com</a></p>
<p>In parole semplici, Runes è un protocollo che consente ai creatori di emettere token fungibili direttamente sulla blockchain di Bitcoin. Dopo aver creato token fungibili, gli sviluppatori possono venderli o scambiarli come preferiscono.</p>
<p>In sostanza, è più facile creare token fungibili utilizzando Runes rispetto al protocollo Ordinals. Runes utilizza semplicemente un sistema di output di transazione non spesi (UTXO). D’altra parte, il protocollo Ordinals richiede tre transazioni per creare e trasferire un token.<br>Inoltre, Runes riduce l’ingombro della blockchain promuovendo una produzione di token coscienziosa. La tabella seguente riassume le differenze tra il protocollo Runes e il BRC-20.<br><img src="https://gimg2.gateimg.com/image/article/17151528255.jpeg" alt=""><br>Source – <a href="https://www.ccn.com/education/crypto/bitcoin-runes-brc-20-token-alternative-explained/" rel="nofollow noopener noreferrer" target="_blank">CCNEducation</a><br>A causa della semplicità del processo di produzione del suo token, alcuni analisti ritengono che diversi progetti di Ordinals potrebbero passare al protocollo di Runes per lanciare i loro airdrop. In generale, ciò potrebbe aumentare le commissioni di bitcoin e introdurre un nuovo livello di funzionalità sulla blockchain.</p>
<h2 id="h2-Come20le20Rune20influenzeranno20lEcosistema20Bitcoin110328"><a name="Come le Rune influenzeranno l’Ecosistema Bitcoin" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Come le Rune influenzeranno l’Ecosistema Bitcoin</h2><p>Il protocollo Runes consente la creazione di memecoin sulla blockchain di bitcoin. Questo probabilmente aumenterà l’attività di rete e la generazione di entrate di bitcoin. Già sappiamo che alcune memecoin come BONK, PEPE e DOGE attirano molta attenzione su <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> e le blockchain Ethereum. Alcune di queste memecoins sono diventate anche le colonne vertebrali di tali reti.</p>
<p>Il protocollo Runes rende possibile avere un DeFi prospero sulla blockchain di bitcoin. La fungibilità dei RUNES significa che possono essere divisi e in seguito riuniti. È importante notare che i Runes possono essere integrati con piattaforme di prestiti e prestiti che costituiscono la base dell’economia DeFi. Ancora più importante, i Runes sono compatibili sia con la rete Lightning sia con il Bitcoin mainnet. Ciò significa che le persone possono collegare i Runes alla rete lightning e viceversa.</p>
<h2 id="h2-Conclusion97078"><a name="Conclusion" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusion</h2><p>In un periodo che è andato dal 15 al 17 aprile, le commissioni di bitcoin hanno superato quelle di Ethereum, dando speranza che Runes e Ordinals aiuteranno a sostenere la blockchain. Tuttavia, Ethereum ha mantenuto il suo vantaggio in termini di commissioni medie giornaliere. Il protocollo Runes, compatibile sia con la rete Lightning che con il mainnet di Bitcoin, consente ai creatori di monete di sviluppare token fungibili.</p>
<div class="blog-details-info"><br><div>Autore: <strong>Mashell C.</strong>, Ricercatore di Gate.io<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>