Q29zdHJ1aXJlIGlsIGZ1dHVybyBkaSBXZWIzIGNvbiB6a0VWTQ==

2023-06-02, 03:13

<p><img src="https://gimg2.gateimg.com/blog/1679447253155655279redian.jpeg" alt=""></p>
<h2 id="h2-TR20DR114252"><a name="【TR; DR】" class="reference-link"></a><span class="header-link octicon octicon-link"></span>【TR; DR】</h2><p>Nel paesaggio in rapida evoluzione di Web3, stanno emergendo soluzioni innovative per affrontare sfide di scalabilità ed efficienza che coincidono con lo sviluppo rapido delle tecnologie emergenti associate (prendi ad esempio le criptovalute). Una di queste soluzioni è zkEVM (Zero-Knowledge <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Virtual Machine), una tecnologia che combina la potenza delle prove a conoscenza zero con la <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> Virtual Machine (EVM).</p>
<p>zkEVM ha il potenziale per rivoluzionare <a href="/web3" target="_blank" class="blog_inner_link">Web3</a> migliorando la scalabilità, la privacy e la sicurezza pur mantenendo la compatibilità con l’ecosistema Ethereum. In questo articolo, ci addentriamo nel mondo di zkEVM, esplorando la sua definizione, il suo ruolo in Web3, gli impatti potenziali nel panorama tecnologico più ampio e l’emozionante futuro che si prospetta.</p>
<h2 id="h2-Cosa20sono20gli20zkEVM510232"><a name="Cosa sono gli zkEVM?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Cosa sono gli zkEVM?</h2><p>zkEVMs, o Zero-Knowledge Ethereum Virtual Machines, sono una sviluppo innovativo nel campo di Web3. Questa tecnologia combina i principi delle prove a conoscenza zero con la Ethereum Virtual Machine (EVM) per migliorare la scalabilità e la privacy delle applicazioni decentralizzate (dApp) costruite su Ethereum.</p>
<p>Al suo interno, zkEVM è un framework che sfrutta le prove a conoscenza zero per fornire una verifica di calcolo efficiente e privata sulla blockchain di Ethereum. Le prove a conoscenza zero consentono a una parte (il dimostratore) di dimostrare la validità di un’affermazione a un’altra parte (il verificatore) senza rivelare ulteriori informazioni oltre alla veridicità dell’affermazione.</p>
<p>Nel contesto di zkEVM, le prove a conoscenza zero consentono la verifica di calcoli e smart contract sulla rete Ethereum senza divulgare i dati o i calcoli sottostanti. Ciò significa che le dApps possono beneficiare di una maggiore privacy e riservatezza mantenendo al contempo la trasparenza e la sicurezza offerte dalla tecnologia blockchain.</p>
<p>zkEVM introduce un nuovo approccio per elaborare transazioni e verificare calcoli e smart contract sfruttando le prove a conoscenza zero mantenendo i principi della Ethereum Virtual Machine. Il processo può essere suddiviso in tre fasi principali: inizializzazione dello stato, elaborazione delle transazioni e generazione di uno stato aggiornato insieme a una prova a conoscenza zero.</p>
<p><strong><em>Inizializzazione dello stato</em></strong><br>All’inizio, zkEVM prende uno stato iniziale, che rappresenta lo stato della rete Ethereum in un momento specifico. Lo stato iniziale include tipicamente informazioni come saldi degli account, codice contrattuale e valori di archiviazione.</p>
<p><strong><em>Elaborazione delle transazioni</em></strong><br>Una volta stabilito lo stato iniziale, zkEVM elabora le transazioni in arrivo. Queste transazioni possono coinvolgere trasferimenti di valore, interazioni contrattuali o qualsiasi operazione supportata dall’EVM. Tuttavia, in zkEVM, gli input delle transazioni sono crittografati e rimangono privati, garantendo la riservatezza.</p>
<p>Durante la fase di elaborazione delle transazioni, entrano in gioco gli zk-SNARK (Zero-Knowledge Succinct Non-Interactive Argument of Knowledge). Gli zk-SNARK consentono la creazione di prove succinte che convalidano la correttezza dei calcoli eseguiti sugli input criptati, senza rivelare alcuna informazione sensibile.</p>
<p>zkEVM utilizza zk-SNARK per costruire prove compatte che dimostrano la validità dei calcoli delle transazioni preservando al contempo la privacy degli input. Queste prove fungono da prova che la transazione è stata eseguita correttamente e si attiene alle regole e alla logica predefinite del contratto intelligente.</p>
<p><strong><em>Generazione di uno stato aggiornato e prova a conoscenza zero</em></strong><br>Una volta che le transazioni sono state elaborate e la validità dei calcoli è stata dimostrata, zkEVM genera uno stato aggiornato. Lo stato aggiornato riflette le modifiche derivanti dall’esecuzione delle transazioni, compresi i nuovi saldi dei conti, gli stati dei contratti modificati e i valori di archiviazione aggiornati.</p>
<p>Insieme allo stato aggiornato, zkEVM genera una prova a conoscenza zero. Questa prova attesta il fatto che i calcoli delle transazioni sono stati eseguiti correttamente, senza rivelare i dettagli specifici degli input o dei passaggi intermedi del calcolo. La prova a conoscenza zero fornisce una garanzia crittografica che le transazioni sono state eseguite secondo le regole e vincoli del contratto intelligente, senza compromettere la privacy dei partecipanti.</p>
<p>La prova a conoscenza zero può essere verificata da qualsiasi partecipante nella rete senza la necessità che essi possiedano conoscenza degli input della transazione o dei passaggi di calcolo intermedi. Questo processo di verifica consente trasparenza e fiducia nell’esecuzione delle transazioni mantenendo al contempo la privacy per le parti coinvolte.</p>
<p><img src="https://gimg2.gateimg.com/image/article/16856755383031685675248_.pic.jpg" alt=""><br>Ciclo di vita di zkEVM, illustrazione a cura di ChainLink.</p>
<h2 id="h2-Il20ruolo20degli20zkEVM20in20Web3129358"><a name="Il ruolo degli zkEVM in Web3" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Il ruolo degli zkEVM in Web3</h2><p>Gli zkEVM svolgono un ruolo vitale nel affrontare le sfide di scalabilità e privacy affrontate dalle applicazioni decentralizzate in Web3. Con la crescita esplosiva delle dApps e la crescente domanda di soluzioni blockchain efficienti e sicure, gli zkEVM offrono un’alternativa promettente.</p>
<p>Uno dei principali vantaggi degli zkEVM è la loro capacità di migliorare significativamente la scalabilità delle applicazioni basate su Ethereum. Utilizzando zk-SNARK per raggruppare più transazioni in una singola prova, gli zkEVM consentono verifiche batch, riducendo il carico computazionale e aumentando la velocità della rete. Questo miglioramento della scalabilità può aprire la strada all’adozione di massa delle applicazioni decentralizzate, riducendo le commissioni di transazione e la congestione di rete.</p>
<p>Inoltre, gli zkEVM offrono un ulteriore livello di privacy alle dApp. Consentendo la verifica delle transazioni senza rivelarne i dettagli, gli zkEVM proteggono le informazioni sensibili degli utenti e mantengono la riservatezza. Questo miglioramento della privacy beneficia non solo gli utenti individuali ma apre anche nuove opportunità per le aziende per sfruttare la tecnologia blockchain nel rispetto delle normative sulla protezione dei dati.</p>
<p>Inoltre, l’integrazione delle zkEVM nello sviluppo del Web3 sblocca la possibilità di trasformare il futuro del panorama e di creare collegamenti intrinseci e sicuri con la tecnologia concorrente. Gli zkEVM possono favorire una maggiore interoperabilità tra diverse reti blockchain. Consentendo il trasferimento efficiente e privato di risorse e dati tra piattaforme diverse, gli zkEVM creano una base per un’integrazione e una collaborazione senza soluzione di continuità in tutto l’ecosistema Web3. Questa interoperabilità può sbloccare nuove possibilità per le applicazioni cross-chain e le soluzioni di finanza decentralizzata (DeFi).</p>
<p>In secondo luogo, gli zkEVM possono rafforzare la sicurezza delle applicazioni decentralizzate. Fornendo un ulteriore livello di privacy e proteggendo i dati sensibili degli utenti, gli zkEVM riducono al minimo il rischio di violazioni dei dati e accessi non autorizzati. Questa sicurezza più elevata può favorire la fiducia tra gli utenti e attirare più partecipanti nello spazio Web3.</p>
<p>Esplora lo spazio fantastico di Web3: <a href="https://www.gate.io/web3" target="_blank">https://www.gate.io/web3</a></p>
<h2 id="h2-Come20possono20gli20zkEVM20influenzare20la20tecnologia20pi20ampia285364"><a name="Come possono gli zkEVM influenzare la tecnologia più ampia?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Come possono gli zkEVM influenzare la tecnologia più ampia?</h2><p>L’influenza degli zkEVM ha il potenziale di estendersi oltre il concetto singolare di ‘Web3’, possedendo il potere e l’utilità di rivoluzionare le tecnologie esistenti e integrarle in Web3. Questo include meccaniche di gioco e sviluppo software fino a finanza tradizionale e decentralizzata.</p>
<p>L’integrazione degli zkEVM nei giochi apre opportunità per meccaniche di gioco uniche, proprietà di asset in-game e transazioni peer-to-peer sicure. Questa innovazione può rivoluzionare l’industria dei giochi fornendo una vera proprietà e scarsità di asset digitali, consentendo ai giocatori di scambiare e monetizzare i loro oggetti in-game con maggiore trasparenza e sicurezza, democratizzando ulteriormente i rispettivi spazi di gioco e asset digitali.</p>
<p>Inoltre, gli zkEVM hanno il potenziale per alimentare la prossima rivoluzione industriale consentendo una gestione sicura ed efficiente della catena di approvvigionamento. La capacità della tecnologia di verificare e tracciare l’integrità delle transazioni e dei dati senza rivelare informazioni sensibili può migliorare la trasparenza e la fiducia nei processi di gestione della catena di approvvigionamento. Ciò può portare a un aumento dell’efficienza, una riduzione delle frodi e un miglioramento della tracciabilità nei settori della logistica, della farmaceutica e della sicurezza alimentare.</p>
<p>Inoltre, gli zkEVM possono avere un profondo impatto sui sistemi finanziari e sulle applicazioni DeFi. Migliorando la scalabilità e la privacy, gli zkEVM possono consentire transazioni più veloci e sicure, migliorando l’esperienza dell’utente e riducendo i costi delle transazioni. Ciò può favorire una maggiore adozione delle piattaforme finanziarie decentralizzate e consentire alle persone di avere un maggiore controllo sui propri asset finanziari riducendo al minimo i rischi associati agli intermediari finanziari tradizionali.</p>
<h2 id="h2-Cosa20si20cela20nel20futuro662811"><a name="Cosa si cela nel futuro?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Cosa si cela nel futuro?</h2><p>I zkEVM sono pronti a costruire il futuro di Web3 affrontando le limitazioni di scalabilità e privacy delle applicazioni decentralizzate. Con la loro capacità di migliorare l’efficienza, la privacy e la sicurezza, gli zkEVM aprono la strada a una più ampia adozione della tecnologia blockchain in tutti i settori. Dalla rivoluzione delle esperienze di gioco alla trasformazione della gestione delle catene di approvvigionamento e alla rivoluzione dei sistemi finanziari, gli zkEVM offrono uno sguardo su un ecosistema Web3 più scalabile, sicuro e interconnesso.</p>
<p>La ricerca in corso continuerà ad ampliare il potenziale degli zkEVM e ottimizzare la tecnologia esistente - oltre a gettare le basi per il futuro. Man mano che ciò avviene, possiamo aspettarci un aumento dell’adozione e dell’integrazione degli zkEVM in varie soluzioni di livello 2 e tecnologie di scalabilità simili, come gli zk-rollup, che hanno il potenziale di migliorare drasticamente la scalabilità e la velocità di transazione su diverse blockchain e di fare un passo avanti nella risoluzione del trilemma delle blockchain. Ciò potrebbe portare alla creazione di un’esperienza Web3 più accessibile e senza interruzioni, pronta ad accogliere una base utenti più ampia e più applicazioni.</p>
<p>Man mano che gli zkEVM continuano a maturare, possiamo aspettarci un aumento dell’adozione e dell’integrazione in varie industrie, tra cui finanza, giochi, gestione della catena di approvvigionamento e altro ancora. La capacità della tecnologia di affrontare le sfide della scalabilità e della privacy delle applicazioni decentralizzate posiziona gli zkEVM come componente vitale nello sviluppo futuro del Web3.</p>
<div class="blog-details-info"><br><div>Autore:<strong>Matthew Webster-Dowsing</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 venga citato Gate.io. In tutti i casi, verranno intraprese azioni legali a causa di violazioni del copyright.<br></div><p></p><br></div></div></div>