QWxsZXMgd2F0IGplIG1vZXQgd2V0ZW4gb3ZlciBoZXQgWksgUm9sbHVwLWVjb3N5c3RlZW0=

2023-07-03, 09:24

<p><img src="https://gimg2.gateimg.com/blog/167999845218246089620230328-181352.jpeg" alt=""></p>
<h2 id="h2-TR20DR603021"><a name="【TR; DR】" class="reference-link"></a><span class="header-link octicon octicon-link"></span>【TR; DR】</h2><p>ZK Rollups bieden een schaalbare en veilige oplossing voor blockchainnetwerken door meerdere transacties te bundelen tot één bewijs, waardoor congestie en transactiekosten worden verminderd. Ze hebben verschillende toepassingen, waaronder gedecentraliseerde beurzen, gaming en betalingen. Vooraanstaande projecten zoals <a href="/price/mina-protocol-mina" rel="nofollow noopener noreferrer" target="_blank">Mina Protocol</a>, Dusk Network, Immutable X, <a href="/price/loopring-lrc" rel="nofollow noopener noreferrer" target="_blank">Loopring</a>, en <a href="/price/polygon-matic" rel="nofollow noopener noreferrer" target="_blank">Veelhoek</a> gebruiken ZK Rollups om de functionaliteit en efficiëntie van hun platforms te verbeteren.</p>
<h2 id="h2-Kennismaking750"><a name="Kennismaking" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Kennismaking</h2><p>Blockchain technologie heeft aanzienlijke vooruitgang geboekt, maar schaalbaarheid blijft een uitdaging voor breed gebruik. Netwerkcongestie en hoge transactiekosten hebben de naadloze werking van gedecentraliseerde applicaties (DApps) en slimme contracten belemmerd. ZK Rollups zijn echter naar voren gekomen als een mogelijke oplossing, die verbeterde schaalbaarheid en beveiliging biedt voor blockchain-netwerken.</p>
<h2 id="h2-Wat20is20een20ZK20Rollup83834"><a name="Wat is een ZK Rollup?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wat is een ZK Rollup?</h2><p>ZK Rollup, afkorting voor Zero-Knowledge Rollup, is een Layer 2 schaaloplossing die is ontworpen om de doorvoer van blockchain te verbeteren. Dit wordt bereikt door meerdere transacties te bundelen en deze als één bewijs naar de hoofdketen te sturen, waardoor congestie wordt verminderd en transactiekosten worden verlaagd. Het aspect ‘zero-knowledge’ verwijst naar de cryptografische techniek die wordt gebruikt om de geldigheid van de gebundelde transacties te bewijzen zonder hun specifieke details prijs te geven, waardoor privacy wordt gewaarborgd.</p>
<p>In een ZK Rollup behoudt de hoofdchain zijn rol als de uiteindelijke arbiter en handhaver van de consensusregels van de blockchain. Validators valideren de gebundelde transacties off-chain en genereren beknopte bewijzen van hun juistheid. Deze bewijzen worden vervolgens ingediend bij de hoofdchain voor verificatie en opname in de blockchain. Dit proces vermindert aanzienlijk de rekenkundige last op de hoofdchain, terwijl de beveiligingsgaranties die worden geboden door het onderliggende consensusmechanisme behouden blijven.</p>
<h2 id="h2-De20oorsprong20van20ZK20Rollups975213"><a name="De oorsprong van ZK Rollups" class="reference-link"></a><span class="header-link octicon octicon-link"></span>De oorsprong van ZK Rollups</h2><p>Om ZK Rollups op een meer gedetailleerd niveau te begrijpen, is het essentieel om in te gaan op de principes en ontwikkelingen in de industrie die deze revolutionaire schaaloplossing hebben gevormd. Zoals beschreven in het inzichtelijke artikel van HashKey, gaat de reis van ZK Rollups terug naar het baanbrekende werk aan zero-knowledge-bewijzen en hun toepassing in het blockchain-domein.</p>
<p>Zero-kennisbewijzen, een cryptografisch concept, werden voor het eerst geïntroduceerd door Shafi Goldwasser, Silvio Micali en Charles Rackoff in de late jaren 1980. Deze bewijzen stellen een bewijs in staat om kennis van een verklaring aan te tonen zonder de onderliggende informatie zelf te onthullen. Dit baanbrekende concept legde de basis voor privacybehoudende transacties en veilige berekeningen binnen het blockchain-ecosysteem.</p>
<p>In de afgelopen jaren heeft het gebruik van zero-knowledge bewijzen in het kader van schaalbaarheid aanzienlijke aandacht gekregen. De ontwikkeling van ZK Rollups als een Layer 2 schaaloplossing is een direct gevolg van het benutten van deze principes. Door meerdere transacties te bundelen in één bewijs, pakken ZK Rollups de doorvoerbeperkingen van blockchainnetwerken aan, waardoor de schaalbaarheid wordt verbeterd zonder de veiligheid in gevaar te brengen.</p>
<p>Naarmate de industrie het potentieel van ZK Rollups erkende, begonnen verschillende projecten en onderzoekers hun toepassing te verkennen. <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a>, een van de toonaangevende blockchain-platforms, introduceerde zijn onderzoek naar ZK Rollups in 2019. De Ethereum-gemeenschap werkte actief aan de implementatie van ZK Rollups als een schaaloplossing, met als doel de beperkingen van de netwerkcapaciteit en stijgende transactiekosten te overwinnen.</p>
<p>Sindsdien heeft de acceptatie van ZK Rollups in de industrie aan momentum gewonnen. Bedrijven en onderzoeksteams hebben middelen geïnvesteerd in het ontwikkelen en verfijnen van deze technologie, waardoor de grenzen van schaalbaarheid en beveiliging worden verlegd. Met succesvolle implementaties en praktijkvoorbeelden zijn ZK Rollups een belangrijk aandachtspunt geworden voor blockchain-ontwikkelaars en enthousiastelingen.</p>
<p>Bovendien hebben samenwerkingen en partnerschappen een cruciale rol gespeeld bij het stimuleren van de adoptie van ZK Rollups. Industrieleiders, waaronder Ethereum, zkSync, en <a href="/price/optimism-op" rel="nofollow noopener noreferrer" target="_blank">Optimisme</a>, hebben actief bijgedragen aan de ontwikkeling en standaardisatie van ZK Rollup-protocollen. Deze samenwerkingen hebben innovatie gestimuleerd, waarbij interoperabiliteit en compatibiliteit over verschillende blockchain-netwerken zijn gewaarborgd.</p>
<h2 id="h2-Wat20zijn20de20gebruiksmogelijkheden20van20ZK20Rollups371303"><a name="Wat zijn de gebruiksmogelijkheden van ZK Rollups?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wat zijn de gebruiksmogelijkheden van ZK Rollups?</h2><p>ZK Rollups hebben tractie gekregen vanwege hun potentieel om de schaalbaarheidsbeperkingen van blockchain-netwerken aan te pakken. Door meerdere transacties in één bewijs te bundelen, kunnen ZK Rollups het aantal transacties dat per seconde wordt verwerkt aanzienlijk verhogen, waardoor ze ideaal zijn voor applicaties met een hoog doorvoervermogen. Laten we enkele prominente use-cases verkennen:</p>
<h3 id="h3-Decentrale20beurzen20DEXs411779"><a name="Decentrale beurzen (DEXs)" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Decentrale beurzen (DEXs)</h3><p>ZK Rollups hebben het potentieel om de prestaties van DEXs te revolutioneren door snellere en kosteneffectievere transacties mogelijk te maken. Gebruikers kunnen activa verhandelen op gedecentraliseerde platforms met minimale latentie en verminderde kosten, wat zorgt voor een naadloze handelservaring.</p>
<h3 id="h3-Gaming20en20Nietvervangbare20Tokens20NFTs870273"><a name="Gaming en Niet-vervangbare Tokens (NFT’s)" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Gaming en Niet-vervangbare Tokens (NFT’s)</h3><p>De bloeiende NFT-markt vraagt om schaalbare oplossingen om de toenemende hoeveelheid transacties te verwerken. ZK Rollups bieden een efficiënte manier om grote aantallen NFT-transacties en gamegerelateerde transacties te verwerken, zodat een soepele gameplay en verbeterde gebruikerservaringen gegarandeerd zijn.</p>
<h3 id="h3-Betalingen20en20Micropayments151836"><a name="Betalingen en Micropayments" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Betalingen en Micropayments</h3><p>ZK Rollups kunnen directe en goedkope transacties mogelijk maken, waardoor ze geschikt zijn voor micropayments en dagelijkse transacties. Met lagere kosten en snellere bevestigingstijden kunnen ZK Rollups de mainstream adoptie van cryptocurrencies vergemakkelijken voor dagelijkse aankopen.</p>
<h2 id="h2-Wat20zijn20enkele20van20de20beste20huidige20ZK20Rollupprojecten241709"><a name="Wat zijn enkele van de beste huidige ZK Rollup-projecten?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wat zijn enkele van de beste huidige ZK Rollup-projecten?</h2><p>Verschillende projecten maken actief gebruik van ZK Rollups om de schaalbaarheid en efficiëntie van hun blockchainplatforms te verbeteren. Laten we eens nader bekijken welke opvallende projecten er zijn:</p>
<h3 id="h3-Mina20Protocol288661"><a name="Mina Protocol" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Mina Protocol</h3><p>Mina Protocol heeft als doel een lichtgewicht blockchain te creëren die wordt aangedreven door zk-SNARKs, een vorm van zero-knowledge proof. Door gebruik te maken van ZK Rollups bereikt <a href="/price/mina-protocol-mina" target="_blank" class="blog_inner_link">Mina Protocol</a> schaalbare en privacybehoudende transacties, terwijl het een kleine blockchain footprint behoudt. Het maakt snelle en veilige transfers mogelijk, waardoor het geschikt is voor verschillende toepassingen.</p>
<h3 id="h3-Dusk20Network423122"><a name="Dusk Network" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Dusk Network</h3><p>Dusk Network richt zich op het creëren van een privacygerichte blockchain-infrastructuur voor financiële toepassingen. Door het opnemen van ZK Rollups, verbetert Dusk Network zijn schaalbaarheid, waardoor veilige en snelle transacties mogelijk zijn met behoud van privacy. Het biedt een ideaal kader voor toepassingen die privacy en naleving vereisen.</p>
<h3 id="h3-Immutable20X91539"><a name="Immutable X" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Immutable X</h3><p>Immutable X is een Layer 2 schaaloplossing gebouwd op Ethereum, waarbij gebruik wordt gemaakt van ZK Rollups om een hoge doorvoer en gas-efficiëntie te bieden. Het is specifiek ontworpen voor NFT-toepassingen en maakt een veilige en schaalbare handel in digitale activa mogelijk. Immutable X zorgt voor een naadloze gebruikerservaring zonder concessies te doen aan de beveiliging.</p>
<h3 id="h3-Loopring657588"><a name="Loopring" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Loopring</h3><p>Loopring is een Layer 2-protocol voor gedecentraliseerde beurzen. Door ZK Rollups te implementeren, verbetert <a href="/price/loopring-lrc" target="_blank" class="blog_inner_link">Loopring</a> aanzienlijk de transactiedoorvoer, verlaagt kosten en verbetert de algehele handelservaring op zijn platform. Het biedt gebruikers de voordelen van snel en veilig handelen, terwijl het de niet-custodial aard van gedecentraliseerde beurzen behoudt.</p>
<h3 id="h3-Polygon427294"><a name="Polygon" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Polygon</h3><p>Voorheen bekend als Matic Network, is <a href="/price/polygon-matic" target="_blank" class="blog_inner_link">Polygon</a> een Layer 2 schaaloplossing voor Ethereum. Door gebruik te maken van ZK Rollups en andere Layer 2 technologieën, biedt Polygon snellere en betaalbare transacties, waardoor het een aantrekkelijke keuze is voor zowel ontwikkelaars als gebruikers. Het biedt schaalbaarheidsoplossingen die het Ethereum-ecosysteem aanvullen.</p>
<h2 id="h2-Conclusie665142"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>ZK Rollups vertegenwoordigen een veelbelovende vooruitgang in schaalbaarheid en beveiliging van blockchain. Door meerdere transacties te bundelen in één bewijs, verbeteren ZK Rollups de doorvoer van blockchain-netwerken en verminderen ze congestie en transactiekosten. Deze technologie heeft toepassingen gevonden in verschillende sectoren, waaronder gedecentraliseerde beurzen, gaming en betalingen.</p>
<p>Projecten zoals Mina Protocol, Dusk Network, Immutable X, Loopring en Polygon integreren actief ZK Rollups om hun platforms te optimaliseren en gebruikers te voorzien van verbeterde ervaringen. Naarmate de vraag naar schaalbaarheid en efficiëntie in blockchainnetwerken blijft groeien, zullen ZK Rollups waarschijnlijk een cruciale rol spelen in het vormgeven van de toekomst van gedecentraliseerde toepassingen en slimme contracten.</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 op dit artikel. Het opnieuw plaatsen van het artikel is toegestaan op voorwaarde dat Gate.io wordt vermeld. In alle glen zal er juridische actie worden ondernomen vanwege schending van het auteursrecht.<br></div><p></p><br></div></div></div>