Q29tcHJlbmRlcmUgbG8gc3RhdG8gYXR0dWFsZSBlIGxlIGZ1dHVyZSB0ZW5kZW56ZSBkZWxsbyBzdmlsdXBwbyBkaSBFdGhlcmV1bSBpbiB1biBhcnRpY29sbw==

2025-04-24, 06:23

<p><img src="https://gimg2.gateimg.com/image/article/17454757963.png" alt=""></p>
<h2 id="h2-Introduzione931885"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>Come la seconda criptovaluta più grande nel campo della crittografia, <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> è in una fase cruciale. Dal suo lancio nel 2015, <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> ha stabilito la sua posizione di leadership con i suoi smart contract e l’ecosistema delle applicazioni decentralizzate (dApps). Tuttavia, lo sviluppo futuro sta affrontando test severi a causa delle attuali prestazioni di mercato, delle sfide tecniche e dell’ambiente normativo. Questo rapporto analizza lo stato attuale, le tendenze potenziali e le prospettive future di <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> da molteplici dimensioni, con l’obiettivo di fornire agli investitori e sviluppatori una visione completa.</p>
<p>Trade ETH ora:<br><a href="https://www.gate.io/trade/ETH_USDT" target="_blank">https://www.gate.io/trade/ETH_USDT</a><a href="https://www.gate.io/trade/ETH_USDT" target="_blank">https://www.gate.io/trade/ETH_USDT</a></p>
<h2 id="h2-Debolezza20dei20prezzi20deflusso20di20capitale20Ethereum2020passato20di20moda295377"><a name="Debolezza dei prezzi, deflusso di capitale, Ethereum è passato di moda?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Debolezza dei prezzi, deflusso di capitale, Ethereum è passato di moda?</h2><p>Al 23 aprile 2025, <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Prezzo Ethereum</a> Oscillando intorno a $1500-1800, il più grande calo dell’ultimo anno ha raggiunto il 65%, lontano dall’alto storico di $4800.</p>
<p>Secondo i dati di Gate.io, il valore di mercato totale attuale di Ethereum è di 216 miliardi di dollari statunitensi, con un’offerta circolante di 121 milioni di ETH e la quota di mercato è scesa al 7,4%, molto al di sotto <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> la quota di mercato di ’, riflettendo un calo della posizione di Ethereum nel <a href="/price" rel="nofollow noopener noreferrer" target="_blank">mercato delle criptovalute</a>.</p>
<p>Osservando il <a href="/price/flow-flow" rel="nofollow noopener noreferrer" target="_blank">flusso</a> dei fondi è la più intuitiva. Gli asset sotto gestione (AUM) dell’Ethereum spot ETF sono scesi a $45,7 miliardi, raggiungendo un minimo storico. I dati di CoinShares mostrano che ci sono stati continui deflussi netti di $772 milioni nelle ultime otto settimane, indicando una mancanza di fiducia tra gli investitori istituzionali. Inoltre, istituzioni come Galaxy Digital e Polychain Capital hanno depositato una grande quantità di ETH negli scambi, mentre le balene (grandi detentori) hanno venduto 140.000 ETH nella scorsa settimana. Anche alcuni indirizzi inattivi da 3-10 anni sono diventati attivi di nuovo, vendendo ETH.</p>
<p><img src="https://gimg2.gateimg.com/image/article/17454756081.png" alt=""></p>
<p>Nel frattempo, c’è stato un significativo calo dell’attività di rete su Ethereum. Dal 10 aprile, il numero di nuovi indirizzi e indirizzi attivi è diminuito drasticamente, con commissioni medie per transazione che sono scese da $0.86 a $0.63. Ciò indica una domanda indebolita per la rete Ethereum, con un sentiment di mercato basso e la fiducia degli investitori scossa. Inoltre, il rapporto ETH/BTC ha raggiunto un minimo di 0.02193 questa settimana, riflettendo ulteriormente la debolezza delle prestazioni di Ethereum rispetto a <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a>.</p>
<h2 id="h2-Critiche20della20comunit20Politicizzazione20della20comunit20soluzioni20L220portano20alla20frammentazione20del20valore20del20traffico138598"><a name="Critiche della comunità: Politicizzazione della comunità, soluzioni L2 portano alla frammentazione del valore del traffico" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Critiche della comunità: Politicizzazione della comunità, soluzioni L2 portano alla frammentazione del valore del traffico</h2><p>Le critiche a Ethereum nella comunità si concentrano principalmente sulla politicizzazione della comunità, che porta a una serie di stagnazione e erosione del valore.</p>
<p>Ad esempio, @0xJigglypuff ha sottolineato che l’EIP-1559 (introdotto nel 2021, mirato a raggiungere la ‘deflazione ETH’ attraverso un meccanismo di bruciatura) ha causato una divisione nella comunità. Anche se ha migliorato il modello economico della rete, ha anche portato a insoddisfazione tra i detentori a lungo termine. Gli aggiornamenti post-Merge (nel 2022) come Shanghai e Dencun sono considerati inefficaci da alcuni, con soltanto 3⁄117dei membri della comunità che credono che questi aggiornamenti abbiano portato progressi.</p>
<p>Ma i core developers non si sarebbero mai aspettati che Ethereum fosse così poco utilizzato oggi… Tutte le metriche, il volume delle transazioni e le commissioni Gwei hanno toccato nuovi minimi negli ultimi anni, e i guadagni derivanti dagli ‘asset deflazionistici’ sono quasi completamente evaporati.</p>
<p>Inoltre, soluzioni di secondo livello (L2) come Arbitrum, <a href="/price/optimism-op" rel="nofollow noopener noreferrer" target="_blank">Ottimismo</a>, e zkSync sono progettati per migliorare la scalabilità attraverso l’elaborazione off-chain, ma affrontano critiche. Alcuni ritengono che le soluzioni L2 siano troppo affrettate, portando a centralizzazione e frammentazione dell’ecosistema, danneggiando la composabilità e l’esperienza dell’utente. Attualmente lo strato base di Ethereum utilizza solo il 2% del suo limite di scalabilità, il che significa che le prestazioni possono essere significativamente migliorate ottimizzando lo strato base senza fare eccessivo affidamento su L2.</p>
<p>Un altro punto è che le prestazioni dell’EVM sono limitate dall’efficienza del database. L’attuale utilizzo di LevelDB e PebbleDB non è stato ottimizzato per la struttura dati a indirizzo numero casuale dell’EVM. Al contrario, SonicDB, come database a file piatto progettato specificamente per la blockchain, ha dimostrato di aumentare il throughput di 8 volte e ridurre i requisiti di archiviazione del 98%. Tuttavia, la cultura di Ethereum, che evita i rischi, ha portato ad esitazione nell’adozione di tali miglioramenti a basso rischio.</p>
<h2 id="h2-Laggiornamento20di20Pectra2020imminente20Ethereum20pu20tornare20al20suo20picco11796"><a name="L’aggiornamento di Pectra è imminente, Ethereum può tornare al suo picco?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>L’aggiornamento di Pectra è imminente, Ethereum può tornare al suo picco?</h2><p>Attualmente, Ethereum ha una quota di mercato del 7,4%, ma è ancora in testa nel campo DeFi, con un valore totale bloccato (TVL) di $650 miliardi (anche se in calo dai $100 miliardi alla fine dell’anno scorso). Competitor come <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> e <a href="/price/bnb-bnb" rel="nofollow noopener noreferrer" target="_blank">BNB</a> Chain hanno TVL di $9 miliardi e $7.3 miliardi rispettivamente, indicando che Ethereum detiene ancora una posizione dominante nel campo DeFi, ma il suo vantaggio sta venendo eroso.</p>
<p><img src="https://gimg2.gateimg.com/image/article/17454756262.png" alt=""></p>
<p>E di recente, Ethereum accoglierà i seguenti aggiornamenti tecnici:</p>
<p>Aggiornamento di Pectra: inizialmente programmato per il 7 maggio 2024, ma potrebbe essere ritardato, mira a migliorare la scalabilità attraverso varie ottimizzazioni.</p>
<p>Aggiornamento PCRAs: Si prevede che introdurrà funzioni di associazione operativa nativa e astrazione dell’account, che potrebbero eliminare la necessità di portafogli e commissioni di Gas, migliorando significativamente l’esperienza utente. L’implementazione di successo di questi aggiornamenti sarà cruciale per la futura competitività di Ethereum.</p>
<p>Tuttavia, secondo l’opinione dell’autore, i benefici portati da questi aggiornamenti potrebbero essere ancora temporanei. La chiave è che Ethereum ha bisogno di un modello di governance più inclusivo per ricostruire la fiducia e unificare la comunità. Il ruolo di leadership e il processo decisionale della fondazione avranno un ruolo cruciale nei prossimi anni, specialmente nella formazione degli aggiornamenti tecnici e del consenso della comunità.</p>
<h2 id="h2-Conclusione683934"><a name="Conclusione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusione</h2><p>Ethereum è attualmente in una fase sfidante ma potenzialmente illimitata. Nonostante affronti divisioni nel consenso della comunità, problemi di scalabilità, intensa concorrenza e incertezze regolamentari, gli aggiornamenti tecnici di Ethereum, l’ecosistema robusto e la comunità attiva di sviluppatori forniscono una base solida. Se Ethereum riuscirà a implementare con successo il suo piano tecnico e a navigare le sfide regolamentari, sarà pronto a riguadagnare slancio nei prossimi anni, arrivando anche a superare i massimi storici. Tuttavia, la chiave del successo risiede nell’unità della comunità, nell’innovazione tecnologica e in una pronta risposta alle dinamiche di mercato.</p>
<p>Avvertenza di rischio: La volatilità del mercato e i cambiamenti della politica regolamentare possono influenzare lo sviluppo di Ethereum. Gli investitori devono valutare attentamente i rischi.</p>
<div class="blog-details-info"><br>  <div>Autore: Charle A., Ricercatore presso Gate.io<div class="info-tips"><em>Questo articolo rappresenta solo le opinioni dell'autore e non costituisce alcun consiglio di investimento. Gli investimenti comportano rischi, quindi le decisioni devono essere prese attentamente.<br></em><div><em></em>Questo contenuto è originale e il copyright appartiene a Gate.io. Se è necessario ripubblicare, si prega di indicare l'autore e la fonte, altrimenti saranno perseguite responsabilità legali.<br></div><p></p><br></div></div></div>