Uml2ZWxhbmRvIGwnYWdnaW9ybmFtZW50byBkaSBFdGhlcmV1bSBDYW5jdW4gLSBsYSBwcm9zc2ltYSBvcHBvcnR1bml0w6AgZGEgMTAwIG1pbGlhcmRpIGRpIGRvbGxhcmk/

2024-01-30, 03:02

<p><img src="https://gimg2.gateimg.com/image/article/1690791857hotspot.jpeg" alt=""></p>
<h2 id="h2-TLDR876164"><a name="[TL;DR]:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL;DR]:</h2><p>Dopo un anno di soppressione, <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> ha finalmente iniziato una nuova narrazione. Il testnet Goerli aggiornato è stato completato con successo, con la possibilità di un aggiornamento della mainnet entro la fine di febbraio.</p>
<p>La proposta più discussa è EIP-4844, in cui gli sviluppatori cercano di ridurre i costi delle transazioni della blockchain di Layer 2 introducendo un nuovo tipo di transazione chiamato Blob, che fornisce più spazio per l’espansione della blockchain.</p>
<p>I settori specifici come Ethereum Layer2, la disponibilità dei dati, lo storage decentralizzato e vari DAPP potrebbero beneficiare di questo aggiornamento.</p>
<h2 id="h2-Introduzione339048"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>Dopo l’approvazione dell’ETF <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> spot, l’Ethereum, soppresso per un anno, sta diventando gradualmente un argomento centrale: il lancio dell’ETF Ethereum spot a maggio, l’upgrade di Cancun e il Restaking, e in particolare l’upgrade di Cancun che sarà il primo ad essere implementato. Questo articolo descriverà la pianificazione temporale dell’upgrade di Cancun, i temi principali dell’upgrade e l’impatto sulle future condizioni di mercato.</p>
<h2 id="h2-Calendario20di20aggiornamento20di20Cancun723859"><a name="Calendario di aggiornamento di Cancun" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Calendario di aggiornamento di Cancun</h2><p>In realtà, già alla fine di aprile dell’anno scorso, la Fondazione Ethereum aveva stabilito il prossimo importante cambiamento, ovvero l’aggiornamento di Cancun. In quel momento, durante la 160ª conferenza telefonica degli sviluppatori principali, si è previsto il lancio ufficiale del piano nel novembre dello stesso anno.</p>
<p>Ma successivamente, a causa di problemi tecnici, è stato ritardato fino alla fine del 2023. In realtà, in seguito, a causa del fallimento del lancio della rete di test a settembre e dell’incapacità di rilasciare l’aggiornamento di Cancun ad Holesky a ottobre, è stato nuovamente rimandato al 2024.</p>
<p>Fino al 28 dicembre dell’anno scorso, Vitalik ha pubblicato un articolo intitolato “Make <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> L’articolo ‘Cypherpunk Again’ condivide la sua visione del futuro delle criptovalute.</p>
<p>Ha sottolineato che una delle principali ragioni per cui la tecnologia blockchain è limitata è il continuo aumento dei costi delle transazioni. I costi elevati delle transazioni di rete rendono le persone più propense a diventare speculatori della rete blockchain anziché utilizzatori effettivi. Per realizzare un’applicazione e una diffusione estesa della tecnologia blockchain, i costi delle transazioni devono essere notevolmente ridotti. Sebbene l’introduzione del Layer 2 abbia già ridotto i costi di rete, non è ancora sufficiente rispetto alla mainnet di Ethereum.</p>
<p>Pertanto, Vitalik ritiene che Ethereum debba adottare ulteriori misure per ridurre le commissioni di transazione al fine di promuovere la diffusione e l’uso della tecnologia blockchain. Si potrebbe dire che questo articolo rappresenta il tono di aggiornamento di Cancun da parte di Vitalik.</p>
<p>Recentemente, il programma ha finalmente fissato un programma. La sera del 4 gennaio, la riunione online degli sviluppatori principali di Ethereum (ACDE #178) ha confermato definitivamente il piano di aggiornamento proposto per la rete di test Dencun presentato il 21 dicembre nell’ACDE #177 e ha discusso le priorità per il piano di aggiornamento successivo di Pectra.</p>
<p>In base alla programmazione della riunione, l’aggiornamento di Dencun è stato completato il 17 di questo mese sulla rete di test Goerli ed è stato ripristinato con successo il funzionamento normale. Successivamente, gli sviluppatori completeranno l’aggiornamento delle reti di test Sepolia e Holesky rispettivamente il 30 gennaio e il 7 febbraio.<img src="https://gimg2.gateimg.com/image/article/1706583514img_v3_027j_68f41087-70d7-4609-b494-3fb42ca8d6ix.jpg" alt=""><br>Gli sviluppatori annunciano il successo della rete di test goerli Figura 1 Fonte: @parithosh_j</p>
<p>E una volta che i tre testnet sopra menzionati funzionano correttamente, verrà presto pianificato l’avvio della mainnet.</p>
<p>Tuttavia, la maggior parte degli sviluppatori ritiene che questa pianificazione del tempo sia un po’ stretta, ad esempio, lo sviluppatore potuz1 ha sollevato dubbi in merito, ritenendo che il periodo di aggiornamento tra la rete di test Goerli e la rete di test Sepolia (13 giorni) sia troppo breve e potrebbe non essere sufficiente per osservare eventuali problemi potenziali.</p>
<p>È importante notare che nel resoconto della riunione di lightclient non è stato menzionato il programma di aggiornamento della mainnet. Tuttavia, durante la discussione di ACDE #177, gli sviluppatori hanno menzionato che l’aggiornamento potrebbe essere implementato sulla mainnet già alla fine di febbraio. Poiché ACDE #178 non ha ritardato il programma di aggiornamento della testnet, possiamo ancora mantenere questa previsione temporale.</p>
<h2 id="h2-EIP484420che20si20concentra20sulla20riduzione20dei20costi20e20sullespansione2020un20importante20aggiornamento20del20nucleo755188"><a name="EIP-4844, che si concentra sulla riduzione dei costi e sull’espansione, è un importante aggiornamento del nucleo" class="reference-link"></a><span class="header-link octicon octicon-link"></span>EIP-4844, che si concentra sulla riduzione dei costi e sull’espansione, è un importante aggiornamento del nucleo</h2><p>In realtà, abbiamo scritto un post a settembre dell’anno scorso, “ <a href="https://www.gate.io/blog_detail/3253/%E9%9D%A2%E4%B8%B4%E6%8E%A8%E8%BF%9F%E7%9A%84%E5%9D%8E%E6%98%86%E5%8D%87%E7%BA%A7-%E8%BF%98%E8%83%BD%E5%B8%A6%E6%9D%A5%E5%93%AA%E4%BA%9B%E6%8A%95%E8%B5%84%E6%9C%BA%E4%BC%9A" target="_blank">Quali opportunità di investimento può portare il ritardo dell’aggiornamento di Cancun?</a> Il documento ha fornito una breve introduzione sugli aggiornamenti di Cancun, e questo articolo fornisce una spiegazione più semplice.</p>
<p>Questa attesa upgrade è molto attesa dalla comunità di Ethereum perché avrà un ruolo chiave nell’espansione di Ethereum, tra cui la riduzione dei costi di Layer2 e l’aumento dell’efficienza, il che aumenterà notevolmente la competitività di Ethereum su Layer2.</p>
<p>Tra i cinque miglioramenti proposti per Ethereum (EIP), quelli più interessanti includono il principale EIP-4844, insieme a EIP-1153 ed EIP-4788.</p>
<p>EIP-4844, come proposta principale di questo aggiornamento, è fondamentale per implementare l’espansione di Ethereum. In breve, gli sviluppatori stanno cercando di fornire alla blockchain più spazio per l’espansione introducendo un nuovo tipo di transazione chiamato Blob, al fine di ridurre le commissioni di transazione della blockchain di Layer 2.<img src="https://gimg2.gateimg.com/image/article/1706583576img_v3_027j_3f748c9e-9be2-4355-94c6-7982b2a711ix.jpg" alt=""><br>Grafico comparativo delle commissioni di diversi livelli 2 2 fonte: l2fees.info</p>
<p>Il piano originale di Ethereum era quello di migliorare la velocità di elaborazione delle transazioni attraverso la tecnologia di shard, ma lo sviluppo è stato difficile e l’avanzamento è stato lento. Al contrario, il piano di scalabilità di Rollup si è sviluppato rapidamente e ha soddisfatto parte delle esigenze di espansione, portando Ethereum a concentrarsi sulla suddivisione dei dati per Rollup. L’aggiornamento di Dencun introdurrà Proto-Danksharding, che introdurrà blob nello spazio dei blocchi per ottimizzare il costo di disponibilità dei dati e migliorare la scalabilità di L2.</p>
<p>Il Proto-Danksharding non è solo il contenuto principale dell’aggiornamento di Dencun, ma è anche il primo passo verso una completa espansione di Ethereum. Fornisce le basi per il successivo completamento del Danksharding, l’introduzione di propositori di blocchi e costruttori separati e il campionamento della disponibilità dei dati.<img src="https://gimg2.gateimg.com/image/article/1706583603img_v3_027j_6573ec2c-54ec-47ce-a3d4-3f17e2ca76ix.jpg" alt=""><br>Cambiamenti nell’aggiornamento del blocco Figura 3 Fonte: a16zcrypto.com</p>
<p>Secondo una stima preliminare degli osservatori di mercato, i costi di transazione potrebbero diminuire di 10-100 volte.</p>
<p>Di conseguenza, il titolo del protocollo di miglioramento EIP-4844 è stato modificato da ‘Proto-danksharding’ a ‘Shard Blob Transactions’, ovvero ‘Transazioni di blob di shard’.</p>
<p>Inoltre, altre proposte importanti includono:</p>
<p>EIP-1153 aggiunge l’opcode di memoria transiente per risolvere il problema della comunicazione interna al blocco, con il vantaggio di un costo di Gas inferiore.</p>
<p>EIP-6780 modifica la funzionalità del codice operativo SELFDESTRUCT, preparandosi per l’architettura Verkle Tree delle future applicazioni Ethereum.</p>
<p>L’EIP-4788 apre la radice del blocco della catena di proof-of-stake nella macchina virtuale di Ethereum, contribuendo a sviluppare casi d’uso e migliorare il protocollo.</p>
<p>EIP-5656 introduce l’istruzione MCOPY, utile per copiare aree di memoria e utile per operazioni ad alta intensità computazionale.</p>
<p>L’EIP-7516 introduce il codice operativo BLOBBASEFEE, che restituisce la tassa di base del blob in base al protocollo EIP-4844.</p>
<h2 id="h2-Quali20settori20beneficeranno20dellaggiornamento20di20Cancun868801"><a name="Quali settori beneficeranno dell’aggiornamento di Cancun?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Quali settori beneficeranno dell’aggiornamento di Cancun?</h2><p>Con il miglioramento dell’efficienza di archiviazione dei dati e la riduzione dei costi, anche le tariffe Gas degli utenti Layer2 sono diminuite di conseguenza. Questo cambiamento attirerà maggiore attenzione in settori come Ethereum Layer2, il livello di disponibilità dei dati, lo storage decentralizzato e varie DAPP, e questi settori potrebbero avere maggiori opportunità di sviluppo a causa della riduzione delle tariffe Gas.</p>
<p><strong>Blockchain Pubblica L2</strong><br>Arbitrum rimane il leader del mercato L2 di Ethereum, insieme a <a href="/price/optimism-op" rel="nofollow noopener noreferrer" target="_blank">Ottimismo</a> Hanno vantaggi competitivi diversi. Arbitrum è leader in termini di diversità di protocolli basati su Arbitrum One, mentre <a href="/price/optimism-op" target="_blank" class="blog_inner_link">Optimism</a> è in testa per la diversità ecologica tra le catene basate su OP Stack.<br><img src="https://gimg2.gateimg.com/image/article/1706583655img_v3_027j_2a943960-5d15-4c0e-8bb6-b499294b26ix.jpg" alt=""><br>Tendenza dei prezzi di ARB Figura 4 Fonte: Gate.io</p>
<p>Arbitrum attualmente ha la più ampia varietà di protocolli e il volume delle transazioni è tre volte quello di Optimism. Pertanto, considerando l’alto volume delle transazioni di Arbitrum e l’ottimizzazione del TPS, sarà uno dei principali beneficiari dell’aggiornamento di Dencun. Arbitrum promuove attivamente anche Arbitrum Orbit e il linguaggio Stylus per migliorare la sua rete di effetti.</p>
<p>Optimism si concentra sulla costruzione della rete Optimism SuperChain basata su OP Stack, il cui valore è strettamente correlato al valore di rete di tale rete. L’upgrade premium di Optimism è costituito dalla combinazione di valore di rete portato dal suo ecosistema. Se l’upgrade di Dencun genera la nascita di ulteriori nuovi L2, questi nuovi L2 potrebbero scegliere di costruirsi su OP Stack, spingendo così Optimism verso la sua visione finale di un super-ecosistema.</p>
<p><strong>Archiviazione cloud</strong><br>È prevedibile che l’upgrade di Cancun darà <a href="/price/filecoin-fil" rel="nofollow noopener noreferrer" target="_blank">Filecoin</a>、 <a href="/price/arweave-ar" rel="nofollow noopener noreferrer" target="_blank">Arweave</a> Progetti di archiviazione decentralizzata di vecchia data come Storj portano esigenze di archiviazione decentralizzata più pratiche. In realtà, progetti come Arweave, che si concentrano sul pagamento una tantum e archiviazione permanente, potrebbero essere in grado di acquisire una maggiore crescita nel settore dell’archiviazione dei dati di stato L2, che potrebbe essere parzialmente abbandonato da blob.</p>
<p><strong>Ordinatore</strong><br>Il problema del classificatore centralizzato è sempre stato il fulcro delle critiche di mercato. Durante l’epidemia di Ming nel corso dell’anno scorso, è stato criticato molte volte per il downtime, mentre l’aggiornamento di Dencun a venire potrebbe aumentare i rischi di guasti del singolo punto.</p>
<p>Per risolvere questo problema, Metis adotta l’innovazione e mira a diventare il primo ordinatore PoS decentralizzato di livello 2 per Ethereum. Un nodo che blocca 20.000 token METIS può diventare un operatore di ordinamento e deve firmare in modo collaborativo per caricare i dati su L1. Inoltre, un campione di validatori garantisce che l’ordine delle transazioni sia corretto.</p>
<p><strong>Una serie di DAPP basate su L2</strong><br>Alcune applicazioni DeFi, DAO, Game, RWA e altre su L2 otterranno valore grazie ai bassi costi e all’efficienza della rete, come discusso in ‘Quali opportunità di investimento porterà il ritardo dell’upgrade di Cancun?’.</p>
<h2 id="h2-Riepilogo977176"><a name="Riepilogo" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Riepilogo</h2><p>Dopo aver completato la conversione del consenso di aggiornamento di Parigi e il riscatto di Shanghai, Ethereum si concentrerà sull’espansione durante l’aggiornamento di Cancun. Al momento, l’EIP4844 più atteso ridurrà ulteriormente i costi degli utenti attraverso il temporary storage e il recupero dei dati fuori catena, migliorando ulteriormente la scalabilità ed efficienza di Ethereum.</p>
<p>Tornando al mercato secondario, di recente, una serie di monete concettuali come ARB, OP e METIS hanno già ricevuto una certa ondata di entusiasmo, ma di recente, a causa della pressione ribassista del Bitcoin, hanno esercitato una certa pressione su questo settore.</p>
<p>Nonostante ciò, continuiamo ad avere grandi aspettative per l’aggiornamento di Cancun che sta arrivando. Mentre gli ETF di Bitcoin stanno diventando sempre più accessibili e aumentando l’adozione nel mondo reale, crediamo che l’aggiornamento costante di Ethereum porterà sicuramente una fonte di innovazione per la prosperità del mercato delle criptovalute.</p>
<div class="blog-details-info"><br>  <div>Autore:<strong>Carl Y.</strong>，Ricercatore di Gate.io<br>  <div class="info-tips"><em>Questo articolo rappresenta solo l'opinione dell'autore e non costituisce alcun consiglio di investimento.<br>  </em><div><em></em>Il contenuto di questo articolo è originale, il copyright è di proprietà Gate.io, se hai bisogno di ristampare, indica l'autore e la fonte, altrimenti sarai ritenuto legalmente responsabile.<br></div><p></p><br></div></div></div>