SGV0IGJvdXdlbiB2YW4gZGUgdG9la29tc3QgdmFuIFdlYjMgbWV0IHprRVZN

2023-06-02, 03:13

<p><img src="https://gimg2.gateimg.com/blog/1679447253155655279redian.jpeg" alt=""></p>
<h2 id="h2-TR20DR105944"><a name="【TR; DR】" class="reference-link"></a><span class="header-link octicon octicon-link"></span>【TR; DR】</h2><p>In het snel veranderende landschap van <a href="/web3" target="_blank" class="blog_inner_link">Web3</a> ontstaan innovatieve oplossingen om schaalbaarheids- en efficiëntie-uitdagingen aan te pakken die samenvallen met de snelle ontwikkeling van bijbehorende opkomende technologieën (neem cryptocurrency als voorbeeld). Een van deze oplossingen is zkEVM (Zero-Knowledge <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Virtual Machine), een technologie die de kracht van zero-knowledge bewijzen combineert met de <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> Virtual Machine (EVM).</p>
<p>zkEVM heeft het potentieel om Web3 te revolutioneren door de schaalbaarheid, privacy en beveiliging te verbeteren, terwijl het compatibel blijft met het Ethereum-ecosysteem. In dit artikel duiken we in de wereld van zkEVM, waarbij we de definitie, rol in Web3, mogelijke impact op het bredere technologische landschap en de spannende toekomst ervan verkennen.</p>
<h2 id="h2-Wat20zijn20zkEVMs262144"><a name="Wat zijn zkEVM’s?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wat zijn zkEVM’s?</h2><p>zkEVM’s, of Zero-Knowledge Ethereum Virtual Machines, zijn een baanbrekende ontwikkeling op het gebied van Web3. Deze technologie combineert de principes van zero-knowledge proofs met de Ethereum Virtual Machine (EVM) om de schaalbaarheid en privacy van gedecentraliseerde applicaties (dApps) gebouwd op Ethereum te verbeteren.</p>
<p>In de kern is zkEVM een raamwerk dat gebruikmaakt van zero-knowledge bewijzen om efficiënte en private verificatie van berekeningen op de Ethereum blockchain te bieden. Zero-knowledge bewijzen stellen één partij (de bewijsvoerder) in staat om de geldigheid van een verklaring aan een andere partij (de verificateur) te tonen zonder extra informatie prijs te geven dan alleen de waarheid van de verklaring.</p>
<p>In de context van zkEVM stellen zero-knowledge bewijzen in staat om berekeningen en slimme contracten op het Ethereum-netwerk te verifiëren zonder de onderliggende gegevens of berekeningen bekend te maken. Dit betekent dat dApps kunnen profiteren van verbeterde privacy en vertrouwelijkheid terwijl ze de transparantie en beveiliging behouden die blockchain-technologie biedt.</p>
<p>zkEVM introduceert een nieuwe benadering voor het verwerken van transacties en verifiëren van berekeningen en slimme contracten door gebruik te maken van zero-knowledge proofs, terwijl de principes van de Ethereum Virtual Machine worden gehandhaafd. Het proces kan worden opgesplitst in drie hoofdfasen: het initialiseren van de staat, het verwerken van transacties en het genereren van een bijgewerkte staat samen met een zero-knowledge proof.</p>
<p><strong><em>De staat initialiseren</em></strong><br>Bij het begin neemt zkEVM een initiële staat aan, die de staat van het Ethereum-netwerk op een specifiek tijdstip vertegenwoordigt. De initiële staat omvat meestal informatie zoals accountbalansen, contractcode en opslagwaarden.</p>
<p><strong><em>Verwerken van transacties</em></strong><br>Zodra de initiële staat is vastgesteld, verwerkt zkEVM binnenkomende transacties. Deze transacties kunnen waardeoverdrachten, contractinteracties of elke operatie ondersteund door de EVM omvatten. In zkEVM zijn de invoeren van transacties echter versleuteld en blijven ze privé, waardoor vertrouwelijkheid wordt gegarandeerd.</p>
<p>Tijdens de transactieverwerkingfase komen zk-SNARKs (Zero-Knowledge Succinct Non-Interactive Arguments of Knowledge) in het spel. zk-SNARKs maken het mogelijk om beknopte bewijzen te creëren die de juistheid van de berekeningen die zijn uitgevoerd op de versleutelde invoergegevens valideren, zonder enige gevoelige informatie te onthullen.</p>
<p>zkEVM maakt gebruik van zk-SNARKs om compacte bewijzen te construeren die de geldigheid van de transactieberekeningen aantonen terwijl de privacy van de invoer behouden blijft. Deze bewijzen dienen als bewijs dat de transactie correct is uitgevoerd en voldoen aan de vooraf gedefinieerde regels en logica van het slimme contract.</p>
<p><strong><em>Genereren van een bijgewerkte staat en zero-knowledge bewijs</em></strong><br>Zodra de transacties zijn verwerkt en de geldigheid van de berekeningen is aangetoond, genereert zkEVM een bijgewerkte staat. De bijgewerkte staat weerspiegelt de veranderingen als gevolg van de uitvoering van de transacties, inclusief nieuwe accountbalansen, gewijzigde contractstaten en bijgewerkte opslagwaarden.</p>
<p>Naast de bijgewerkte staat genereert zkEVM een zero-knowledge bewijs. Dit bewijs bevestigt dat de transactieberekeningen correct zijn uitgevoerd, zonder de specifieke details van de invoer of de tussenstappen van de berekening bekend te maken. Het zero-knowledge bewijs biedt cryptografische zekerheid dat de transacties zijn uitgevoerd volgens de regels en beperkingen van het smart contract, zonder dat de privacy van de deelnemers in het gedrang komt.</p>
<p>De zero-knowledge proof kan worden geverifieerd door elke deelnemer op het netwerk zonder dat ze kennis hoeven te hebben van de transactie-invoer of de tussentijdse berekeningsstappen. Dit verificatieproces maakt transparantie en vertrouwen mogelijk bij de uitvoering van de transacties, terwijl de privacy van de betrokken partijen wordt gewaarborgd.</p>
<p><img src="https://gimg2.gateimg.com/image/article/16856755383031685675248_.pic.jpg" alt=""><br>Levenscyclus van zkEVM, illustratie met dank aan ChainLink.</p>
<h2 id="h2-De20rol20van20zkEVMs20in20Web39770"><a name="De rol van zkEVMs in Web3" class="reference-link"></a><span class="header-link octicon octicon-link"></span>De rol van zkEVMs in Web3</h2><p>zkEVM’s spelen een cruciale rol bij het aanpakken van de schaalbaarheids- en privacy-uitdagingen waarmee gedecentraliseerde applicaties in Web3 worden geconfronteerd. Met de explosieve groei van dApps en de toenemende vraag naar efficiënte en veilige blockchain-oplossingen, bieden zkEVM’s een veelbelovend alternatief.</p>
<p>Eén van de belangrijkste voordelen van zkEVM’s is hun vermogen om de schaalbaarheid van Ethereum-gebaseerde applicaties aanzienlijk te verbeteren. Door gebruik te maken van zk-SNARKs om meerdere transacties te bundelen in één bewijs, stellen zkEVM’s batchverificaties in staat, waardoor de rekenefficiëntie wordt verminderd en de doorvoer van het netwerk wordt verhoogd. Deze schaalbaarheidsverbetering kan de weg vrijmaken voor de massa-adoptie van gedecentraliseerde applicaties door transactiekosten en netwerkcongestie te minimaliseren.</p>
<p>Bovendien bieden zkEVM’s een extra privacylaag voor dApps. Door transacties te verifiëren zonder hun details te onthullen, beschermen zkEVM’s gevoelige gebruikersinformatie en handhaven vertrouwelijkheid. Deze privacyverbetering komt niet alleen individuele gebruikers ten goede, maar opent ook deuren voor ondernemingen om blockchain-technologie te benutten terwijl ze voldoen aan de regelgeving inzake gegevensbescherming.</p>
<p>Daarnaast ontgrendelt de integratie van zkEVMs in de ontwikkeling van Web3 de mogelijkheid om de toekomst van het landschap te transformeren en intrinsieke en veilige koppelingen te creëren naar gelijktijdige technologie. zkEVMs kunnen een grotere interoperabiliteit tussen verschillende blockchainnetwerken bevorderen. Door de efficiënte en private overdracht van activa en gegevens tussen uiteenlopende platforms mogelijk te maken, creëren zkEVMs een basis voor naadloze integratie en samenwerking binnen het Web3-ecosysteem. Deze interoperabiliteit kan nieuwe mogelijkheden ontgrendelen voor cross-chain toepassingen en gedecentraliseerde financiële (DeFi) oplossingen.</p>
<p>Ten tweede kunnen zkEVM’s de beveiliging van gedecentraliseerde applicaties versterken. Door een extra laag privacy te bieden en gevoelige gebruikersgegevens te beschermen, minimaliseren zkEVM’s het risico op datalekken en ongeoorloofde toegang. Deze verhoogde beveiliging kan het vertrouwen onder gebruikers bevorderen en meer deelnemers aantrekken tot de Web3-ruimte.</p>
<p>Verken de fantastische Web3-ruimte: <a href="https://www.gate.io/web3" target="_blank">https://www.gate.io/web3</a></p>
<h2 id="h2-Hoe20kunnen20zkEVMs20bredere20technologie20benvloeden435137"><a name="Hoe kunnen zkEVM’s bredere technologie beïnvloeden?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Hoe kunnen zkEVM’s bredere technologie beïnvloeden?</h2><p>De invloed van zkEVM’s heeft het potentieel om verder te reiken dan het enkele concept van ‘Web3’, en heeft de kracht en het nut om bestaande technologieën te revolutioneren en ze te integreren in Web3. Dit omvat onder andere gamingmechanica en softwareontwikkeling tot traditionele en gedecentraliseerde financiën.</p>
<p>De integratie van zkEVM’s in gaming opent mogelijkheden voor unieke gameplay mechanica, eigendom van in-game activa en veilige peer-to-peer transacties. Deze innovatie kan de gaming-industrie revolutioneren door ware eigendom en schaarste van digitale activa te bieden, waardoor spelers hun in-game items kunnen verhandelen en monetiseren met verhoogde transparantie en beveiliging, en respectievelijk de gaming- en digitale activaruimtes verder te democratiseren.</p>
<p>Bovendien hebben zkEVM’s het potentieel om de volgende industriële revolutie aan te drijven door het mogelijk maken van veilig en efficiënt supply chain management. De mogelijkheid van de technologie om de integriteit van transacties en gegevens te verifiëren en te volgen zonder gevoelige informatie vrij te geven, kan de transparantie en het vertrouwen in supply chain processen verbeteren. Dit kan leiden tot verhoogde efficiëntie, verminderde fraude en verbeterde traceerbaarheid in de logistiek, farmaceutische en voedselveiligheidsindustrieën.</p>
<p>Bovendien kunnen zkEVM’s een diepgaande impact hebben op financiële en en DeFi-toepassingen. Door de schaalbaarheid en privacy te verbeteren, kunnen zkEVM’s snellere en veiligere transacties mogelijk maken, waardoor de gebruikerservaring wordt verbeterd en de transactiekosten worden verlaagd. Dit kan de bredere acceptatie van gedecentraliseerde financiële platforms stimuleren en individuen in staat stellen meer controle te hebben over hun financiële activa, terwijl de risico’s van traditionele financiële tussenpersonen worden geminimaliseerd.</p>
<h2 id="h2-Wat20ligt20er20in20de20toekomst248882"><a name="Wat ligt er in de toekomst?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wat ligt er in de toekomst?</h2><p>zkEVM’s staan op het punt om de toekomst van Web3 op te bouwen door de schaalbaarheid en privacy beperkingen van gedecentraliseerde applicaties aan te pakken. Met hun vermogen om efficiëntie, privacy en beveiliging te verbeteren, banen zkEVM’s de weg voor bredere adoptie van blockchain technologieën in verschillende sectoren. Van het revolutioneren van gaming ervaringen tot het transformeren van supply chain management en het revolutionaire financiële en, zkEVM’s bieden ons een glimp van een meer schaalbare, veilige en onderling verbonden Web3 ecosysteem.</p>
<p>Lopend onderzoek zal doorgaan met het verbreden van het potentieel van zkEVM’s en het optimaliseren van bestaande technologie - evenals het leggen van de fundamenten voor de toekomst. Naarmate dit gebeurt, kunnen we verwachten dat er een toename zal zijn van de adoptie en integratie van zkEVM’s in verschillende laag-2 oplossingen en soortgelijke schaaltechnologieën, zoals zk-rollups, die het potentieel hebben om de schaalbaarheid en doorvoer over verschillende blockchains drastisch te verbeteren en een stap te zetten in het oplossen van het blockchain trilemma. Dit zou kunnen resulteren in de bouw van een meer toegankelijke en naadloze Web3-ervaring die klaar staat om een grotere gebruikersbasis en meer toepassingen te accommoderen.</p>
<p>Naarmate zkEVM’s volwassener worden, kunnen we een grotere acceptatie en integratie verwachten in verschillende sectoren, waaronder financiën, gaming, supply chain management en meer. De mogelijkheid van deze technologie om de schaalbaarheids- en privacy-uitdagingen van gedecentraliseerde applicaties aan te pakken, positioneert zkEVM’s als een essentieel onderdeel in de toekomstige ontwikkeling van Web3.</p>
<div class="blog-details-info"><br><div>Auteur:<strong>Matthew Webster-Dowsing</strong>, Gate.io-onderzoeker<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de standpunten van de onderzoeker en vormt geen enkele beleggingssuggestie.<br></em><div><em></em>Gate.io behoudt alle rechten voor op dit artikel. Het is toegestaan om het artikel opnieuw te plaatsen op voorwaarde dat Gate.io wordt vermeld. In alle glen zal er juridische stappen worden ondernomen wegens auteursrechtinbreuk.<br></div><p></p><br></div></div></div>