TGEgdmlzaW9uZSBkaSBWaXRhbGlrIEJ1dGVyaW4gcGVyIEV0aGVyZXVtOiBSYWdnaXVuZ2VyZSAxMDAuMDAwIHRyYW5zYXppb25pIGFsIHNlY29uZG8gY29uIFJvbGx1cHM=

2024-10-31, 03:17

<p><img src="https://gimg2.gateimg.com/image/article/17303442551692587449analysis.jpeg" alt=""></p>
<h2 id="h2-TL20DR262928"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p><a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Gli sviluppatori mirano a lanciare l’aggiornamento Surge che porterà a 100.000 TPS.</p>
<p>I componenti chiave della roadmap incentrata sul rollup includono soluzioni di scalabilità di layer-2, campionamento di disponibilità dei dati e tecniche di compressione dei dati.</p>
<p>Alcuni vantaggi del <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> L’incremento include transazioni più economiche e più veloci.</p>
<h2 id="h2-Introduzione852423"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>Il <a href="https://www.gate.io/learn/articles/what-is-ethereum/2882" target="_blank">blockchain Ethereum</a> ospita molte applicazioni decentralizzate e alimenta vari progetti crypto. A causa della crescita costante della rete, spesso si trova di fronte a sfide di scalabilità e altre sfide di prestazioni. Ad esempio, la blockchain di solito sperimenta congestione e commissioni di gas elevate. Tali problemi spingono molti investitori dalla rete. Al fine di affrontare alcune di queste sfide <a href="https://www.gate.io/blog/827/who-is-ethereum-founder-vitalik" target="_blank">Vitalik Buterin, il cofondatore di Ethereum</a>, ha annunciato un piano di miglioramento rivoluzionario, il Surge, che potrebbe scalare la rete fino a 100.000 transazioni al secondo (TPS). Se la rete raggiunge questo obiettivo, diventerà una forza dominante nel settore delle criptovalute.</p>
<h2 id="h2-Vitalik20Buterin20mira20a2010000020transazioni20al20secondo20TPS20Come20raggiungerlo706454"><a name="Vitalik Buterin mira a 100.000 transazioni al secondo (TPS): Come raggiungerlo?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Vitalik Buterin mira a 100.000 transazioni al secondo (TPS): Come raggiungerlo?</h2><p>In un recente <a href="https://vitalik.eth.limo/general/2024/10/17/futures2.html" rel="nofollow noopener noreferrer" target="_blank">Nel post del blog, Buterin ha annunciato una roadmap per Ethereum</a> raggiungere un obiettivo di 100.000 TPS nei prossimi due anni. Il team mira a raggiungere tale obiettivo attraverso le sue soluzioni di scalabilità di secondo livello. Tuttavia, Buterin ha promesso di mantenere decentralizzazione e alta sicurezza. L’aspetto centrale della roadmap è la fusione di shard e rollup. Inoltre, il team sta lavorando per garantire che <a href="https://www.gate.io/learn/articles/top-12-layer-2-solutions-on-ethereum/3759" target="_blank">Le blockchain di livello 2 ereditano i principi fondamentali di Ethereum</a> di decentralizzazione, scalabilità e sicurezza. L’aggiornamento di <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> mira a migliorare la compressione, migliorare il campionamento della disponibilità dei dati e rendere le reti L2 veramente senza fiducia. L’implementazione dell’incremento, il prossimo upgrade, probabilmente raggiungerà questi obiettivi.</p>
<p>Leggi anche: <a href="https://www.gate.io/learn/articles/10-layer-2-crypto-projects-to-watch-in-2024/3637" target="_blank">I 10 migliori progetti crittografici Layer 2 da tenere d’occhio in questo momento</a></p>
<h2 id="h2-The20Surge20come20la20prossima20fase20nella20serie20di20aggiornamenti20di20Ethereum20Dencun131744"><a name="‘The Surge’ come la prossima fase nella serie di aggiornamenti di Ethereum Dencun" class="reference-link"></a><span class="header-link octicon octicon-link"></span>‘The Surge’ come la prossima fase nella serie di aggiornamenti di Ethereum Dencun</h2><p>The Surge è di Ethereum <a href="https://www.gate.io/learn/articles/possible-futures-of-ethereum-part-2-the-surge/4471" target="_blank">il prossimo aggiornamento mira a migliorare la scalabilità della rete</a> attraverso soluzioni di livello 2 e rollups senza sacrificare decentralizzazione, sicurezza e interoperabilità. Come detto, uno degli obiettivi principali della crescita è quello di raggiungere 100.000 TPS tra reti di livello 1 e livello 2. Al momento, Ethereum elabora da 5 a 30 TPS sul suo livello base. Tuttavia, questo spesso causa congestione e un picco nelle commissioni gas durante i momenti di punta. Secondo la roadmap incentrata sui rollup, la Crescita mira a rimuovere tali ostacoli e migliorare ulteriormente la capacità della blockchain di alimentare varie applicazioni su scala globale.</p>
<p>Dopo la crescita, Ethereum probabilmente raggiungerà la sua massima prestazione di rete e servirà meglio la comunità globale rispetto ad ora. Uno degli elementi fondamentali di questo aggiornamento della rete è lo sharding, una tecnologia decentralizzata che dividerà la blockchain in unità più piccole e gestibili chiamate shard. Secondo il co-fondatore di Ethereum, la crescita sarà un processo a più fasi che integra tecnologie innovative come il calcolo multi-parti (MPC) e i rollup di Layer 2. Sono proprio queste tecnologie che miglioreranno la sicurezza, la scalabilità e l’usabilità delle reti per soddisfare la crescente domanda dei suoi prodotti e servizi.</p>
<p>Leggi anche: <a href="https://www.gate.io/learn/articles/possible-futures-of-the-ethereum-protocol-part-3-the-scourge/4551" target="_blank">Possibili futuri del protocollo Ethereum</a></p>
<h2 id="h2-La20roadmap20centrata20su20Ethereum20Surge20Rollup20e20i20suoi20componenti903588"><a name="La roadmap centrata su Ethereum Surge Rollup e i suoi componenti" class="reference-link"></a><span class="header-link octicon octicon-link"></span>La roadmap centrata su Ethereum Surge Rollup e i suoi componenti</h2><p>Come accennato in precedenza, il Surge mira ad aumentare la scalabilità di Ethereum attraverso l’integrazione del layer-2 e altre tecnologie come lo sharding e i roll-ups. Si concentra anche sulle tecniche di compressione dei dati e il campionamento della disponibilità dei dati su cui ci concentreremo in questa sezione</p>
<ul>
<li><p>Soluzioni di scaling di Layer-2: i roll-up di Layer-2 renderanno la blockchain Ethereum più economica e più veloce di quanto lo sia attualmente. Fondamentalmente, i roll-up di Layer-2 raggruppano le transazioni e le elaborano fuori dalla catena prima di inviare il rapporto finale alla base decentralizzata. Spostando gran parte dei dati transazionali dalla blockchain Ethereum e elaborandoli fuori dalla catena, la rete sarà in grado di raggiungere l’obiettivo di 100.000 TPS. Allo stesso modo, la tecnologia roll-up divide i compiti tra le reti di Layer-2 e la catena principale. Pertanto, l’ecosistema multi-chain riduce il carico dalla catena principale, consentendo transazioni più efficienti e più veloci rispetto a prima.</p>
</li><li><p>Campionamento della disponibilità dei dati: Anche Ethereum Surge mira a risolvere il problema della disponibilità dei dati. Il team <a href="https://www.gate.io/learn/articles/data-availability-sampling-why-is-das-needed/1282 &quot;will adopt Data Availability Sampling (DAS" rel="nofollow noopener noreferrer" target="_blank">adotterà il campionamento della disponibilità dei dati (DAS)</a>”) che consentirà ai nodi di verificare i dati in modo efficiente. In particolare, DAS consente ai nodi di verificare i dati senza scaricare tutto. In una rete decentralizzata come Ethereum, tutti i nodi devono verificare i dati disponibili. Tuttavia, diventa difficile se ci si aspetta che i nodi scarichino e memorizzino tutti i dati disponibili. Ecco dove entra in gioco DAS, consentendo ai nodi di verificare i dati senza memorizzarli completamente. Per raggiungere questo obiettivo, il team aumenterà il numero di blob collegati a un blocco. Gli sviluppatori propongono di aumentare il numero di blob da 3 a 64, o anche di più. DAS migliorerà l’efficienza delle soluzioni di layer-2, aumentandone i volumi di transazione.</p>
</li></ul>
<p>-Tecniche di compressione dei dati: La tecnica di compressione dei dati mira a ridurre la dimensione dell’impronta delle transazioni. Ciò può essere ottenuto in diversi modi, tra cui l’adozione della compressione a byte zero, l’utilizzo delle firme BLS e la sostituzione degli indirizzi delle transazioni con puntatori a dati storici. Le firme BLS facilitano l’aggregazione di multiple firme in una sola. Ciò consente di risparmiare spazio sulla rete e rende le transazioni più veloci ed efficienti.</p>
<h2 id="h2-Ethereum20Surge20Superare20le20sfide20nellaumento20del20limite20di20Gas700008"><a name="Ethereum Surge: Superare le sfide nell’aumento del limite di Gas" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Ethereum Surge: Superare le sfide nell’aumento del limite di Gas</h2><p>Buterin ha spiegato una delle importanza dell’aggiornamento Ethereum Surge. Aumenterà la scalabilità del layer di base in modo da bilanciare le prestazioni con quelle delle soluzioni di layer-2. Ciò comporterà standard uniformi cross-L2 che porteranno a efficienza operativa. Da notare che se le blockchain di layer-2 aumentano significativamente mentre il layer-1 non riesce a far fronte al livello di transazioni, ciò potrebbe rappresentare un rischio per la rete. La soluzione principale per affrontare il rischio sarebbe aumentare le commissioni del gas. Tuttavia, ciò potrebbe portare a una centralizzazione del limite del gas. Se il limite del gas è troppo alto, ad esempio, ciò comporterà costi elevati di esecuzione dei nodi che potrebbero costringere i validatori più piccoli a uscire dal sistema. In cambio, solo pochi validatori centralizzati gestiranno il carico elevato.</p>
<p>Per superare questa sfida, Buterin suggerisce che la rete dovrebbe utilizzare un approccio adeguato. Ad esempio, uno dei modi più sicuri per superare questa sfida è migliorare il <a href="https://www.gate.io/learn/articles/what-is-evm/68 &quot;Ethereum Virtual Machine (EVM" rel="nofollow noopener noreferrer" target="_blank">Macchina Virtuale Ethereum (EVM)</a>”), il componente della blockchain in cui vengono eseguiti i contratti intelligenti. L’introduzione del formato di oggetto Ethereum (EOF), un nuovo formato di bytecode, renderà efficienti e veloci le esecuzioni dei contratti intelligenti. Inoltre, ciò contribuirà a ridurre il costo del gas. Un altro modo per ridurre i costi è adottare un sistema di pricing del gas multidimensionale che ridurrà le commissioni del gas di altre operazioni. Ad esempio, ciò potrebbe ridurre le commissioni del gas per specifici opcode e precompilazioni. Inoltre, possono esserci diversi livelli di commissioni per dati, calcoli e archiviazione. Pertanto, il sistema di pricing del gas multidimensionale contribuirà ad alleviare la differenza nei livelli di scalabilità tra la main chain e le soluzioni layer-2.</p>
<h2 id="h2-Portare20Ethereum20a20un20altro20livello20La20necessit20di20interoperabilit20blockchain208177"><a name="Portare Ethereum a un altro livello: La necessità di interoperabilità blockchain" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Portare Ethereum a un altro livello: La necessità di interoperabilità blockchain</h2><p>Nel suo blog, Buterin ha anche parlato della necessità di rendere la blockchain di Ethereum un sistema unificato in cui i blockchain di Layer-2 dovrebbero comunicare efficacemente tra loro e con il layer di base decentralizzato. Al momento, l’ecosistema di Ethereum è frammentato poiché i vari blockchain di Layer-2 hanno capacità e funzionalità uniche diverse. Ciò porta spesso a confusione e disunione tra gli utenti di Ethereum. Pertanto, Buterin immagina un futuro in cui i blockchain L2 comunicano senza soluzione di continuità tra loro.</p>
<h2 id="h2-Conclusione997575"><a name="Conclusione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusione</h2><p>Il co-fondatore di Ethereum, Vitalik Buterin, ha delineato come la blockchain possa raggiungere 100.000 TPS nei prossimi due anni. Secondo lui, i roll-up, il campionamento della disponibilità dei dati e la compressione dei dati consentiranno alla catena principale di scalare. Gli sviluppatori lanceranno l’aggiornamento Surge nel 2025 che aumenterà la scalabilità della blockchain e ridurrà le commissioni gas.</p>
<div class="blog-details-info"><br><div>Autore: Mashell C., Ricercatore Gate.io<br><div class="info-tips"><em>Questo articolo rappresenta solo il punto di vista del ricercatore e non costituisce alcun suggerimento di investimento.<br></em><div><em></em> Gate.io si riserva tutti i diritti su questo articolo. La ripubblicazione dell'articolo sarà consentita 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>