WktzeW5jIGhlZWZ0ICQ1IG1pbGpvZW4gYWFuIGdlc3RvbGVuIHRva2VucyBsYXRlbiB2YWxsZW4sIHZlcnRyb3V3ZW5zcHJvZWYga29tdCBvcG5pZXV3

2025-04-16, 02:25

<p><img src="https://gimg2.gateimg.com/image/article/1744769991zk.png" alt=""></p>
<p>In de drukte van de cryptowereld verlichtte ZKsync als een rijzende ster ooit de toekomst van <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> Layer 2 met de technologie van zero-knowledge proofs (ZK). Echter, op 15 april 2025 wierp een plotselinge aanval een schaduw over deze ster - de privésleutel van het airdrop-contract lekte uit en er werden 111 miljoen ZK-tokens illegaal gemunt. De $5 miljoen uitverkoop zorgde ervoor dat de tokenprijs op één dag met bijna 20% kelderde. Deze onrust schudde niet alleen de markt op, maar zorgde er ook voor dat talloze supporters dit project met de droom van decentralisatie opnieuw gingen bekijken.</p>
<p>Eén, Scheuren in Vertrouwen: De Ins en Outs van Airdrop Aanvallen</p>
<p>Het verhaal begint met een zorgvuldig geplande airdrop. In 2024 lanceerde ZKsync een grootschalige ZK-token airdrop om de gemeenschap te stimuleren, wat talloze gebruikers en ontwikkelaars aantrok om deel te nemen. Er waren echter enkele niet-geclaimde tokens in het airdrop-contract, die stil op de keten lagen te wachten om ‘ontwaakt’ te worden. Niemand had verwacht dat deze onopvallende hoek de doorbraak van de aanvaller zou worden.</p>
<p>Op 15 april heeft ZKsync officieel een noodverklaring uitgegeven: de privésleutel van het beheerdersaccount van het airdropcontract is gelekt. Door misbruik te maken van deze kwetsbaarheid, heeft de aanvaller de sweepUnclaimed() -functie in het contract aangeroepen, waardoor er uit het niets 1,11 miljard ZK-tokens zijn gecreëerd. Deze tokens stroomden snel de markt op, wat een verkoopgolf veroorzaakte die de ZK-prijs met wel 20% deed kelderen. Op sociale media barstte de gemeenschap los, waarbij sommigen boos de veiligheidsmaatregelen van het project in twijfel trokken, anderen zich zorgen maakten over de toekomst van het ecosysteem, en weer anderen koud toekeken terwijl dit gebruikelijke ‘zwarte zwaan’-evenement zich ontvouwde in de cryptowereld.</p>
<p>De aanval zelf is niet ingewikkeld, maar de blootgelegde kwesties zijn prikkelend. Waarom is het beheer van privésleutels zo kwetsbaar? Waarom behouden niet-geclaimde tokens zoveel autoriteit? Belangrijker nog, waarom zou een project als ZKsync, dat draait om technische innovatie, falen op het gebied van basisveiligheid? Binnen de stemmen van de gemeenschap is er een mix van teleurstelling en anticipatie: ze hopen dat ZKsync een overtuigend antwoord kan geven.</p>
<p>Het officiële antwoord was snel en beslissend. Het ZKsync-beveiligingsteam bevroor het aanvalsvector, eiste dat de aanvaller de fondsen terug zou geven via officiële kanalen en beloofde binnen 24 uur een gedetailleerd rapport vrij te geven. In de verklaring benadrukte het team dat het protocol zelf, tokencontracten en gebruikersfondsen niet waren getroffen, in een poging om marktpaniek te verzachten. Echter, de scherpe prijsdaling en gemeenschapsdoubts geven aan dat het herstellen van vertrouwen veel complexer is dan het oplossen van de code.</p>
<h2 id="h2-De20Ambitie20van20Zero20Knowledge20De20Oorsprong20en20Missie20van20ZKsync882263"><a name="De Ambitie van Zero Knowledge: De Oorsprong en Missie van ZKsync" class="reference-link"></a><span class="header-link octicon octicon-link"></span>De Ambitie van Zero Knowledge: De Oorsprong en Missie van ZKsync</h2><p>Om de betekenis van deze onrust te begrijpen, moeten we teruggaan naar de oorsprong van ZKsync. In 2019 begonnen Alex Gluchowski, de oprichter van Matter Labs, en zijn team aan een gedurfd experiment: het gebruik van nul-kennisbewijs technologie om de pijnpunten van <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> aan te pakken. Ethereum, als de ‘wereldcomputer’ van blockchain, host talloze gedecentraliseerde applicaties, maar wordt bekritiseerd vanwege hoge gasvergoedingen en een overbelast netwerk. De missie van ZKsync is om Ethereum-transacties sneller en goedkoper te maken zonder in te leveren op veiligheid en decentralisatie.</p>
<p>ZKsync’s kerntechnologie is ZK-Rollup, een Layer 2-oplossing gebaseerd op zero-knowledge proofs. In eenvoudige bewoordingen comprimeert het duizenden transacties tot een beknopt bewijs, ingediend bij het Ethereum-mainnet, waardoor de kosten worden verlaagd terwijl de mainnet-beveiliging wordt gehandhaafd. In 2020 werd ZKsync 1.0 mainnet gelanceerd, met ondersteuning van eenvoudige overdrachtsfuncties; in 2022 werd ZKsync Era (voorheen ZKsync 2.0) geïntroduceerd, met ondersteuning van algemene slimme contracten, wat de overgang van het project naar een volwaardig Layer 2-netwerk markeert.</p>
<p>De charme van ZKsync ligt niet alleen in de technologie, maar ook in het streven naar gebruikerservaring. Vergeleken met de gasvergoedingen van tientallen dollars op het Ethereum-mainnet, is de transactiekost van ZKsync zo laag als een paar cent, terwijl de snelheid vergelijkbaar is met gecentraliseerde platforms.</p>
<p>Dit trok al snel ontwikkelaars aan in de DeFi, NFT en betalingsvelden, met bekende protocollen zoals <a href="/price/uniswap-uni" target="_blank" class="blog_inner_link">Uniswap</a> en <a href="/price/aave-aave" target="_blank" class="blog_inner_link">Aave</a> die binnenstromen. Zelfs traditionele financiële instellingen zoals UBS zijn begonnen met experimenteren met blockchain-toepassingen op ZKsync. Een tijdje lang is ZKsync een van de meest oogverblindende spelers geworden in de Layer 2-race, op gelijke voet met Arbitrum en <a href="/price/optimism-op" target="_blank" class="blog_inner_link">Optimism</a>.</p>
<p>De ZK-token luchtdropp van 2024 heeft de enthousiasme van de gemeenschap verder aangewakkerd. Van de totale voorraad van 21 miljard tokens wordt een deel via luchtdropp verspreid naar vroege gebruikers, ontwikkelaars en andere bijdragers. De token wordt niet alleen gebruikt voor het betalen van transactiekosten, maar draagt ook de hoop van gemeenschapsbestuur. De visie van ZKsync is om een door de gemeenschap gedreven gedecentraliseerd ecosysteem te creëren waar elke deelnemer kan delen in de dividenden die worden gebracht door blockchaintechnologie.</p>
<h2 id="h2-Drie20Huidige20Situatie20en20Uitdagingen20ZKsync20in20de20Storm278946"><a name="Drie, Huidige Situatie en Uitdagingen: ZKsync in de Storm" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Drie, Huidige Situatie en Uitdagingen: ZKsync in de Storm</h2><p>Echter, de reis van de sterren is nooit gladjes verlopen. In het begin van 2025 zorgde de algehele neergang van de cryptomarkt voor rillingen bij ZKsync. In maart kondigde het project de beëindiging van het Ignite liquiditeitsbeloningsprogramma aan, waarbij verwezen werd naar verslechterende marktomstandigheden en financiële druk. Deze beslissing leidde tot een 50% daling in het Totale Waarde Vergrendeld (TVV) van $270 miljoen, terwijl de prijs van ZK-tokens in dezelfde periode met 35% daalde. Binnen de gemeenschap werden discussies over de ‘airdrop gelijk aan verkooppiek’ verhit, waarbij velen begonnen te twijfelen aan de langetermijnwaarde van ZKsync.</p>
<p>De aanval in april was ongetwijfeld de druppel die de emmer deed overlopen. Het illegaal slaan van 111 miljoen tokens, hoewel slechts 0,45% van het totale aanbod, heeft het marktvertrouwen een flinke klap toegebracht, ver voorbij de cijfers zelf. Wat nog zorgwekkender is, is dat het incident de zwaktes van ZKsync op het gebied van beveiliging en governance blootlegde. Waarom is het ontwerp van het airdrop-contract zo kwetsbaar? Waarom zijn niet-geclaimde tokens niet vernietigd of overgebracht naar een meer beveiligd mechanisme? Deze vragen wijzen niet alleen op technische details, maar ook op de operationele en crisisresponscapaciteiten van het project.</p>
<p>Vanuit een concurrerend perspectief wordt het Layer 2-traject steeds drukker. Arbitrum heeft zijn marktpositie versterkt door middel van gedecentraliseerd bestuur en ecosysteemstimulansen; de OP Stack van <a href="/price/optimism-op" target="_blank" class="blog_inner_link">Optimism</a> heeft een groot aantal nieuwe ketenadopties aangetrokken; het opkomende StarkNet maakt ook inspanningen op het gebied van ZK-technologie. Hoewel ZKsync technisch gezien voorop loopt, staat het voor uitdagingen op het gebied van ecosysteemuitbreiding en gemeenschapsvertrouwen. Dit aanvalsevenement kan ertoe leiden dat sommige ontwikkelaars aarzelen om verder te bouwen op ZKsync, en investeerders kunnen zich ook richten op andere meer stabiele Layer 2-projecten.</p>
<h2 id="h2-Vier20The20Future20Starlight20Kan20ZKsync20vertrouwen20hervormen138730"><a name="Vier, The Future Starlight: Kan ZKsync vertrouwen hervormen?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Vier, The Future Starlight: Kan ZKsync vertrouwen hervormen?</h2><p>Ondanks de voortdurende onrust is het verhaal van ZKsync nog lang niet voorbij. Hoewel het aanvalincident problemen aan het licht bracht, bood het ook een kans voor zelfiteratie van het project. Technisch gezien kan ZKsync mechanismen introduceren zoals multi-handtekening, tijdsvergrendeling, optimalisatie van contractontwerp en privésleutelbeheer; qua governance moet de projectzijde transparanter communiceren met de gemeenschap om het vertrouwen te herstellen; op het gebied van ecologie moet ZKsync nog steeds de incentives verhogen om meer hoogwaardige projecten aan te trekken om zich te vestigen.</p>
<p>Vanuit een breder perspectief ligt de waarde van ZKsync niet alleen in het zijn van een Layer 2-netwerk, maar ook in het vertegenwoordigen van de belofte van blockchaintechnologie voor de toekomst. Zero-knowledge proof is niet alleen een technisch hulpmiddel, maar ook een filosofie - het opbouwen van een vertrouwde gedecentraliseerde wereld terwijl privacy wordt beschermd. Elke val van ZKsync is met het doel om verder te gaan.</p>
<p>Voor de gemeenschap en investeerders is deze storm een test. De cryptowereld heeft nooit een tekort aan crises, maar ook nooit een tekort aan wonderbaarlijke herstelacties. Kan ZKsync leren van deze aanval en de ster van zero knowledge opnieuw doen ontbranden?</p>
<div class="blog-details-info"><br><div>Auteur: Rooick Z., Gate.io onderzoeker<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de standpunten van de auteur en vormt geen enkel handelsadvies. Beleggen brengt risico's met zich mee, dus beslissingen moeten voorzichtig worden genomen.<br></em><div><em></em>Dit artikel is origineel en het auteursrecht behoort toe aan Gate.io. Geef de auteur en bron aan als u wilt herdrukken, anders zullen er juridische verantwoordelijkheden worden nagestreefd.<br></div><p></p><br></div></div></div>