SWwgUGFyYWxsZWwgRVZNIGRpdmVudGVyw6AgdW4gY2F0YWxpenphdG9yZSBwZXIgdW4gbWVyY2F0byByaWFsemlzdGEgZGF0byBjaGUgbGEgc3VhIHBvcG9sYXJpdMOgIHN0YSBhdW1lbnRhbmRvIGdyYWR1YWxtZW50ZT8=

2024-04-25, 09:50

<p><img src="https://gimg2.gateimg.com/image/article/1714038408sdfx.jpeg" alt=""></p>
<h2 id="h2-TLDR319475"><a name="[TL;DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL;DR]</h2><p>Di recente, la catena pubblica L1 Monad ha ricevuto un enorme finanziamento di 225 milioni di dollari guidato da Paradigm, attirando l’attenzione del mercato sulla tecnologia EVM parallela adottata da Monad.</p>
<p>Attualmente, l’EVM parallelo può essere classificato in quattro categorie, ma ciò che è veramente impegnato a consolidare l’ecosistema EVM e a cambiare le capacità parallele dal basso è l’enhanced EVM layer1 chain. Questo potrebbe anche essere il motivo per cui Monad, che ha recentemente adottato questa soluzione, ha ricevuto elevati investimenti nel mercato del venture capital.</p>
<p>Parallel EVM diventerà la terza soluzione di ottimizzazione delle prestazioni dopo universal Rollup L2+Dapp, modular stack+Dapp Rollup (RollAPP) e darà vita a molte innovazioni tecnologiche e applicazioni su larga scala.</p>
<h2 id="h2-Introduzione680489"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>Recentemente, la catena pubblica L1 Monad ha ricevuto un finanziamento enorme di $225 milioni guidato da Paradigm, attirando l’attenzione forte del mercato sulla tecnologia EVM parallela adottata nel progetto.</p>
<p>Parallel EVM mira a migliorare le prestazioni di EVM attraverso l’elaborazione parallela per affrontare le sfide delle catene di Layer1 ad alte prestazioni e garantire lo sviluppo sostenibile del <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Ecosistema EVM.</p>
<p>Esplorare l’espansione delle prestazioni della catena è sempre stato un punto focale di attenzione nel mercato della crittografia, e questo articolo effettuerà un’esplorazione preliminare di questo.</p>
<h2 id="h2-Parallel20EVM20La20soluzione20definitiva20per20le20prestazioni20di20scalabilit20della20catena735433"><a name="Parallel EVM: La soluzione definitiva per le prestazioni di scalabilità della catena?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Parallel EVM: La soluzione definitiva per le prestazioni di scalabilità della catena?</h2><p>Già nel 2021, era emerso il concetto di Parallel EVM, con la sua idea di base di supportare l’elaborazione simultanea di più transazioni, ottimizzando e migliorando così le prestazioni e l’efficienza dell’EVM tradizionale.</p>
<p>In quel momento, c’erano già alcune pratiche rappresentative nel settore, come <a href="/price/polygon-matic" rel="nofollow noopener noreferrer" target="_blank">Polygon</a> parallel EVM basato sulla tecnologia Block STM e il parallel EVM sviluppato in collaborazione con BSC e NodeReal.</p>
<p>Entro la fine del 2023 e nei mesi successivi, una ondata di iscrizioni ha travolto il <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> ecosistema, con deflussi di capitale e sentimento FOMO che spingono le iscrizioni a diffondersi rapidamente su altre catene. Ma questo ha anche causato una serie di problemi. A causa del aumento del numero e dei tipi di iscrizioni, molte reti blockchain stanno affrontando gravi sfide di prestazioni, figuriamoci le applicazioni su larga scala combinate con il mondo reale in futuro.</p>
<p>È in questo contesto che sta emergendo gradualmente una nuova narrazione strettamente legata all’ottimizzazione delle prestazioni di EVM - EVM parallela.</p>
<p>Georgios Konstantopoulos, CTO di Paradigm, e Haseeb Qureshi, Dragonfly, hanno menzionato l’EVM parallelo come chiave per risolvere i colli di bottiglia delle prestazioni guardando avanti alla tendenza del 2024.<br><img src="https://gimg2.gateimg.com/image/article/17140385121.jpeg" alt=""><br>Fonte: @jdkanani</p>
<p>Sono state adottate varie soluzioni di ottimizzazione per EVM, come sidechains, L2 e modulari <a href="/price/stacks-stx" rel="nofollow noopener noreferrer" target="_blank">Stacks</a>. Tuttavia, l’EVM parallela consente di condurre contemporaneamente diverse transazioni o contratti intelligenti indipendenti, il che può migliorare significativamente la velocità di elaborazione e la capacità di sistema dell’EVM. Pertanto, anche gli sviluppatori lo preferiscono e ha un elevato potenziale di crescita.</p>
<p>Prendendo come esempio il valore di mercato di ogni catena per confronto, il valore di mercato circolante totale di L1 e L2 ha raggiunto i 752,123 miliardi di dollari, che è piuttosto considerevole. Tuttavia, rispetto a questo, il valore di mercato circolante del blockchain parallelo è solo di 52,539 miliardi di dollari, rappresentando solo circa il 7% del valore di mercato complessivo, indicando la sua dimensione relativamente piccola nell’intero campo del blockchain.</p>
<p>Vale la pena sottolineare che i progetti legati alle narrazioni parallele di EVM hanno un valore di mercato circolante di 2,339 miliardi di dollari. Sebbene questo numero non sia piccolo, rappresenta solo il 4% del valore di mercato circolante della blockchain parallela, indicando che la sua quota di mercato è relativamente piccola in questo campo specifico.<br><img src="https://gimg2.gateimg.com/image/article/17140385342.jpeg" alt=""><br>Origine: Accademia Gryphsis</p>
<p>Nel complesso, anche se stanno sviluppando progetti correlati alla blockchain parallela e all’EVM, c’è ancora margine di miglioramento nelle dimensioni complessive del mercato.</p>
<h2 id="h2-Quattro20percorsi20tecnici20per20EVM20parallelo814817"><a name="Quattro percorsi tecnici per EVM parallelo" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Quattro percorsi tecnici per EVM parallelo</h2><p>Attualmente, non c’è un consenso nell’industria sul piano di implementazione dell’EVM parallelo, ma può essere suddiviso in quattro categorie in termini di tipi di adattamento tecnologico. Naturalmente, questa classificazione semplifica solo la nostra comprensione del sistema e nuove prospettive emergeranno con l’aggiornamento e l’iterazione della tecnologia.</p>
<p>In primo luogo, le catene di livello 1 EVM potenziate come Monad, Artela e SEI si impegnano a migliorare significativamente il TPS pur essendo altamente compatibili con l’EVM e dotando le transazioni di capacità di elaborazione parallela in ambienti EVM simulati.<br><img src="https://gimg2.gateimg.com/image/article/17140385563.jpeg" alt=""><br>Sorgente: MONAD</p>
<p>Queste catene layer1 EVM parallele indipendenti hanno meccanismi di consenso e caratteristiche tecniche uniche, ma il loro obiettivo principale rimane essere compatibili ed espandere l’ecosistema EVM. Questo approccio può essere visto come la ristrutturazione completamente nuova della catena EVM mentre si serve dell’ecosistema EVM.</p>
<p>In secondo luogo, le catene compatibili con EVM su layer2 scalabili, come Eclipse e MegaETH, utilizzano il consenso indipendente e le capacità di pre-elaborazione delle transazioni delle catene layer2 per filtrare e elaborare lo stato delle transazioni prima che venga elaborato a lotti e inviato alla rete principale.</p>
<p>Questo tipo di soluzione consente anche la selezione simultanea di livelli di esecuzione da qualsiasi altra catena per determinare in ultima analisi lo stato della transazione, ottenendo l’astrazione e la modularità di esecuzione collegabile dell’EVM. Questa flessibilità consente loro di selezionare il “livello di esecuzione” ottimale in base alle proprie esigenze, ottenendo così capacità di elaborazione parallela.</p>
<p>Tuttavia, anche se questo tipo di soluzione serve l’EVM, va oltre il campo dei tradizionali framework EVM.</p>
<p>Il terzo tipo è la catena Alt-layer1 equivalente, rappresentata da <a href="/price/polygon-matic" target="_blank" class="blog_inner_link">Polygon</a> e BSC. Queste catene hanno, in qualche misura, raggiunto la capacità di elaborazione parallela di EVM, ma principalmente attraverso ottimizzazioni a livello di algoritmo, senza approfondire l’ottimizzazione a livello di consenso e archiviazione.</p>
<p>Infine, le catene parallele differenziali non EVM includono <a href="/price/aptos-apt" rel="nofollow noopener noreferrer" target="_blank">Aptos</a>, Sui e Fuel, che, sebbene non implementino direttamente catene EVM, sono compatibili con gli ambienti EVM tramite middleware o analisi del codice grazie alle loro elevate capacità di esecuzione di concorrenza. Come layer 2 di Ethereum, Starknet ha capacità parallele, ma la compatibilità con EVM richiede comunque meccanismi speciali. Questo tipo di catena generalmente si trova di fronte a sfide di compatibilità durante l’integrazione con EVM.</p>
<p>Queste quattro soluzioni principali hanno ognuna il loro punto di forza, alcune enfatizzano la flessibilità del layer2, altre mettono in evidenza la personalizzazione delle funzionalità e altre mirano ad attirare liquidità. Ma coloro che sono davvero impegnati nel consolidamento dell’ecosistema EVM e nel cambiamento delle capacità parallele dalla base sono le catene layer1 EVM migliorate. Questo potrebbe anche essere il motivo per cui Monad, che ha recentemente adottato questa soluzione, ha ricevuto alti investimenti nel mercato del venture capital.</p>
<h2 id="h2-Pu20il20Parallel20EVM20diventare20una20nuova20narrazione20che20guida20il20mercato20rialzista751008"><a name="Può il Parallel EVM diventare una nuova narrazione che guida il mercato rialzista?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Può il Parallel EVM diventare una nuova narrazione che guida il mercato rialzista?</h2><p>Naturalmente, dobbiamo vedere la concorrenza e le sfide che il campo parallelo EVM affronta. Dal punto di vista della comunicazione, il parallelo EVM è un argomento spesso menzionato. Tuttavia, la maggior parte dei team di progetto modifica e imita principalmente il modello di esecuzione OP rappresentato dal meccanismo Block STM di <a href="/price/aptos-apt" target="_blank" class="blog_inner_link">Aptos</a> senza sostanziali progressi per lungo tempo, il che rende difficile sostenere la popolarità.</p>
<p>Inoltre, Layer 2 e le blockchain di seconda generazione come Aptos e Sui sono forti concorrenti. Hanno stabilito comunità ed ecosistemi maturi, esercitando una pressione significativa sui progetti emergenti. Tuttavia, ciò offre anche un’opportunità per i progetti paralleli di EVM di imparare e trarre insegnamento, e per migliorare la propria competitività attraverso un’innovazione e un’ottimizzazione continue.</p>
<p>Nel campo dell’EVM parallela, sebbene vi siano alcune comunanze tecniche, come il modello di parallelizzazione OP che rappresenta il consenso della catena pubblica L1, diversi progetti hanno dimostrato anche realizzazioni tecniche uniche. Essi adottano diversi pattern di design architettonico, modelli di dati o meccanismi di pre-elaborazione per guidare l’avanzamento continuo della tecnologia parallela.</p>
<p>Guardando avanti, l’onda della tecnologia blockchain spingerà più progetti L1 e L2 a competere in parallelo EVM. Su questa traccia, l’EVM parallelo diventerà la terza soluzione di ottimizzazione delle prestazioni dopo il Rollup universale L2+Dapp e lo stack modulare+Dapp Rollup (RollAPP), e darà origine a molte innovazioni tecnologiche e applicazioni popolari.<br><img src="https://gimg2.gateimg.com/image/article/17140385864.jpeg" alt=""><br>Origine: Eclipse</p>
<p>In questo contesto, possiamo prevedere che Monad si distinguerà in base ai suoi vantaggi nei database specializzati, alla facilità di utilizzo per gli sviluppatori, al consenso sull’esecuzione ritardata e alla tecnologia della pipeline superscalare. In futuro, emergeranno progetti simili e più accattivanti, e si distingueranno nella competizione dell’EVM parallelo con i loro vantaggi tecnologici unici e le strategie di mercato. Questi progetti ci porteranno casi di applicazione più innovativi e promuoveranno l’attuazione della tecnologia blockchain in vari settori.</p>
<p>L’esplorazione della tecnologia è senza fine, e l’EVM parallela, come parte importante dell’attuale innovazione tecnologica, giocherà un ruolo sempre più importante. Non vediamo l’ora di vedere emergere più progetti eccezionali in questo settore e creare insieme un futuro migliore per la tecnologia blockchain.</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">*Questo articolo rappresenta solo le opinioni del ricercatore e non costituisce alcun suggerimento di investimento.<br><div>*Gate.io si riserva tutti i diritti su questo articolo. Sarà consentito il ripostaggio dell'articolo a condizione che venga menzionato Gate.io. In tutti i casi, verranno intraprese azioni legali a causa della violazione del copyright.<br></div>

<p></p><p></p></div><p></p><br></div></div></div><p></p>