SG9lIGdyaWpwIGplIGRlIGJlc3RlIG1pam5ib3V3a2Fuc2VuIG5hIGRlIGxhbmNlcmluZyB2YW4gemtTeW5jIEFpcmRyb3AgQ2hlY2tpbmcgRmVhdHVyZT8=

2024-06-17, 09:44

<p><img src="https://gimg2.gateimg.com/image/article/1718617222sdfx.jpeg" alt=""></p>
<h2 id="h2-TLDR226550"><a name="[TL;DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL;DR]</h2><p>ZkSync is een <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Layer 2 schaalbaarheidsoplossing gelanceerd door Matter Labs in 2019. De ZK-Rollup technologieoplossing kan aanzienlijk de verwerkingscapaciteiten van handel verbeteren en transactionele privacy en veiligheid waarborgen.</p>
<p>Volgens de laatste gegevens zijn er 203 Dapps op de zkSync keten, en de TVL voor Era en Lite versies is momenteel respectievelijk $760 miljoen en $87 miljoen.</p>
<p>Gebruikers kunnen snel zoeken naar ZK-token luchtdruppelgeschiktheid met behulp van de Gate <a href="/web3" target="_blank" class="blog_inner_link">Web3</a> Wallet en deelnemen aan andere ecosysteeminteractieprojecten om mogelijke winsten te behalen.</p>
<h2 id="h2-Introductie350229"><a name="Introductie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introductie</h2><p>Met de explosieve groei van toepassingen zoals DeFi, NFT en Game zijn de schaalbaarheidsproblemen waarmee <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> wordt geconfronteerd steeds prominenter geworden. Om dit probleem op te lossen, heeft zkSync als schaalbaarheidsoplossing voor Ethereum Layer 2 veel aandacht gekregen vanwege zijn unieke technologie en innovatieve concepten.</p>
<p>Met de officiële opening van airdrop-controle door zkSync deze week en de officiële start van airdrops volgende week, is zkSync opnieuw een veelbesproken onderwerp in de branche als het laatste muntuitgifteproject voor de vier belangrijkste Ethereum Layer 2 Kings. Dit artikel zal kort de introductie, het team, de technische hoogtepunten, de ontwikkeling van het ecosysteem, het model van de token-economie, enz. van zkSync schetsen, en zich richten op het gebruik van Gate Wallet voor ZK-token airdrop-queries, om lezers een uitgebreid en diepgaand begrip te bieden.</p>
<h2 id="h2-I20Inleiding20tot20zkSync401034"><a name="I. Inleiding tot zkSync" class="reference-link"></a><span class="header-link octicon octicon-link"></span>I. Inleiding tot zkSync</h2><p>ZkSync is een schaalbaarheidsoplossing van Ethereum Layer 2 gelanceerd door Matter Labs in 2019. De missie is om een hogere transactieverwerking en lagere transactiekosten naar Ethereum te brengen door het toepassen van zero proof of knowledge (ZK-SNARKs) technologie, terwijl de veiligheid en anti-censuur van fondsen behouden blijft.</p>
<p>Het kernconcept van zkSync is om de Ethereum-hoofdketen uit te breiden via off-chain computing en on-chain validatie, waardoor gebruikers een snellere, goedkopere en veiligere handelservaring krijgen.</p>
<h2 id="h2-II20ZkSync20Team511631"><a name="II. ZkSync Team" class="reference-link"></a><span class="header-link octicon octicon-link"></span>II. ZkSync Team</h2><p>Als moederbedrijf van zkSync heeft Matter Labs tot nu toe $258 miljoen aan financiering opgehaald. Het werd opgericht door CEO Alex G. in 2018 en heeft zijn hoofdkantoor in Duitsland. Het team heeft momenteel meer dan 50 experts op het gebied van blockchaintechnologie en senior ontwikkelaars wereldwijd.</p>
<p>Ondertussen heeft zkSync ook samenwerkingsverbanden met meerdere bekende instellingen en bedrijven opgezet om gezamenlijk de ontwikkeling en toepassing van blockchaintechnologie te bevorderen.</p>
<h2 id="h2-III20Technische20hoogtepunten34347"><a name="III. Technische hoogtepunten" class="reference-link"></a><span class="header-link octicon octicon-link"></span>III. Technische hoogtepunten</h2><p>ZkSync staat bekend als het einde van Ethereum Layer 2 omdat het gebruikmaakt van geavanceerde ZK Rollup-technologie. Deze technische oplossing kan de verwerkingscapaciteit van transacties aanzienlijk verbeteren en zorgen voor privacy en beveiliging van transacties. Bovendien ondersteunt zkSync ook soepele interoperabiliteit met Ethereum slimme contracten en maakt de modulaire ontwerp het gemakkelijk te upgraden en uit te breiden.</p>
<h3 id="h3-Zero20Knowledge20Proof20ZK20SNARKs20Technologie142729"><a name="Zero Knowledge Proof (ZK SNARKs) Technologie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Zero Knowledge Proof (ZK SNARKs) Technologie</h3><p>Een van de kerntechnologieën van zkSync is zero-knowledge proof (ZK-SNARKs) technologie. Deze technologie stelt validators in staat om de geldigheid van transacties te valideren zonder de specifieke handelsinhoud te kennen, waardoor privacy en schaalbaarheid van transacties worden bereikt.</p>
<p>Daarnaast zijn er momenteel twee mainstream Rollup-oplossingen. Optimistic Rollup-technologie kan transacties versnellen en kosten verminderen, maar de snelle en betaalbare functies gaan ten koste van enige beveiliging en decentralisatie, wat voornamelijk tot uiting komt in grote projecten zoals gate. <a href="/price/optimism-op" rel="nofollow noopener noreferrer" target="_blank">Optimisme</a>, Arbitrum en Metis. Daarentegen biedt ZK Rollup handelsprivacybescherming, uitstekende schaalbaarheid en relatief lage kosten. Deze technologie brengt echter ook uitdagingen met zich mee wat betreft de complexiteit van implementatie, met belangrijke projectvertegenwoordigers zoals Starknet en zkSync.</p>
<h3 id="h3-Offchain20Computing20en20Onchain20Validatie797920"><a name="Off-chain Computing en On-chain Validatie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Off-chain Computing en On-chain Validatie</h3><p>ZkSync maakt gebruik van off-chain computing en on-chain validatiemethoden, waarbij het grootste deel van het rekenwerk buiten de keten wordt geplaatst om de belasting op de Ethereum-hoofdketen te verminderen. Tegelijkertijd wordt door middel van on-chain validatie de effectiviteit en veiligheid van transacties gewaarborgd. Deze aanpak verbetert niet alleen de handelssnelheid, maar verlaagt ook de handelskosten.</p>
<h3 id="h3-Compatibiliteit20met20de20Ethereum20Main20Chain787002"><a name="Compatibiliteit met de Ethereum Main Chain" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Compatibiliteit met de Ethereum Main Chain</h3><p>ZkSync is zeer compatibel met het Ethereum-hoofdnet, waardoor gebruikers transacties kunnen uitvoeren op zkSync zonder portefeuilles of adressen te wijzigen. Het ondersteunt ook de overdracht en handel van ERC-20-tokens, waardoor gebruikers meer handige diensten worden geboden.</p>
<h3 id="h3-Slimme20Contract20Interoperabiliteit20Ondersteuning269847"><a name="Slimme Contract Interoperabiliteit Ondersteuning" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Slimme Contract Interoperabiliteit Ondersteuning</h3><p>ZkSync 2.0 (ook bekend als zkSync Era) voegt ondersteuning toe voor Solidity (via zkEVM) en Zinc (de interne programmeertaal van Rollup), waardoor ontwikkelaars bestaande Ethereum smart contracts eenvoudig kunnen implementeren op zkSync. Deze functie verbetert aanzienlijk de schaalbaarheid en interoperabiliteit van zkSync.</p>
<h2 id="h2-IV20Ecosysteemconstructie421799"><a name="IV. Ecosysteemconstructie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>IV. Ecosysteemconstructie</h2><p>Momenteel heeft zkSync een relatief compleet ecosysteem gevormd, dat meerdere gebieden bestrijkt zoals portefeuilles, beurzen, DeFi, GameFi, Social en DAO-toepassingen.<br><img src="https://gimg2.gateimg.com/image/article/17186172831.jpeg" alt=""><br>Bron: Layer 2BEAT</p>
<p>Volgens gegevens van DappRadar en Layer 2BEAT zijn er 203 Dapps op het zkSync-netwerk. Op dit moment bedraagt de TVL voor de Era- en Lite-versies respectievelijk $760 miljoen en $87 miljoen, terwijl het dagelijkse aantal TPS 6,12 is. De kosten van Gas bedragen $0,01, met 7 miljoen on-chain adressen en meer dan 3 miljoen wekelijks actieve adressen.</p>
<h2 id="h2-V20Token20Economy20Model42454"><a name="V. Token Economy Model" class="reference-link"></a><span class="header-link octicon octicon-link"></span>V. Token Economy Model</h2><p>De inheemse token van zkSync is ZK, met een totale voorraad van 21 miljard. De uitgifte en distributie van ZK-tokens volgen de principes van eerlijkheid, onpartijdigheid en openheid, met als doel gebruikers aan te moedigen om deel te nemen aan de ecosysteemconstructie en -ontwikkeling van zkSync.</p>
<p>De toewijzing van ZK-tokens omvat voornamelijk de volgende aspecten: teamreservering, gemeenschapsstimulansen, ecosysteemsamenwerking, luchtdalingsbeloningen, enz. Onder hen zijn gemeenschapsstimulansen een belangrijk onderdeel van de distributie van ZK-tokens, gericht op het stimuleren van gebruikers om deel te nemen aan de gemeenschapsopbouw en -werking van zkSync.<br><img src="https://gimg2.gateimg.com/image/article/17186173412.jpeg" alt=""><br>Bron: zkSync</p>
<p>Volgens de laatste officiële aankondiging zal zkSync volgende week 3,675 miljard ZK-tokens airdroppen aan vroege gebruikers en bijdragers, wat overeenkomt met 17,5% van de totale voorraad van 21 miljard ZK-tokens. De deadline is 3 januari 2025. De in aanmerking komen voor airdrop is gebaseerd op een momentopname die is genomen op 24 maart 2024, en in aanmerking komende adressen worden toegewezen op basis van het bedrag dat naar zkSync Era is gestuurd en de tijd dat crypto-activa in de portemonnee blijven. In totaal zijn er 695.232 portefeuilles geselecteerd en elk adres heeft minimaal één punt nodig om in aanmerking te komen. Het projectteam past meerdere methoden toe om robots te filteren terwijl ze de toewijzing aanpassen op basis van menselijk gedrag en bijdragen aan zkSync.</p>
<p>Hoewel dit project gepaard gaat met het geschil van het moederbedrijf van zkSync over de aanvraag van het zk-handelsmerk, evenals het huidige geschil over de hoge heksnelheid, is de gemeenschap nog steeds zeer enthousiast over dit project. De volgende tekst zal introduceren hoe u snel Gate Wallet kunt gebruiken voor het controleren van luchtafvoerkwalificatie.</p>
<p>Stap 1: Gebruikers die de Gate Web3 Wallet voor de eerste keer gebruiken, kunnen naar gate gaan <a href="https://www.gate.io/web3" target="_blank">de pagina</a> om de portemonnee te downloaden en te installeren, die momenteel beschikbaar is in twee types: App-versie en Chrome-extensieversie.<br><img src="https://gimg2.gateimg.com/image/article/17186173743.jpeg" alt=""><br>Bron: Gate.io</p>
<p>De Gate Web3 Wallet is een niet-custodial openbare crypto wallet die onafhankelijk is ontwikkeld door Gate.io, en voldoet aan de behoeften van Web3-gebruikers om op elk moment en overal cryptocurrencies te verhandelen. Het kan gebruikers voorzien van innovatieve en gevarieerde cryptodiensten zoals het beheren van crypto-activa, communiceren met gedecentraliseerde applicaties, het opslaan van niet-vervangbare tokens (NFT) creatie, on-chain identiteit, en samenwerken met gemeenschappen.</p>
<p>Stap 2: Neem de browserextensie als voorbeeld, zoals te zien is in de afbeelding, klik op ‘Toevoegen aan Chrome’, maak vervolgens of importeer mnemonische zinnen / privésleutels volgens de instructies om de portemonnee te openen en over te schakelen naar de zkSync Era-keten.<br><img src="https://gimg2.gateimg.com/image/article/17186173984.jpeg" alt=""><br>Bron: Chrome</p>
<p><img src="https://gimg2.gateimg.com/image/article/17186174105.jpeg" alt=""><br>Bron: Gate.io</p>
<p>Stap 3: Ga naar <a href="https://claim.zknation.io/" rel="nofollow noopener noreferrer" target="_blank">de airdrop-controlepagina van zkSync</a>, en klik op “Verbind wallet” in de rechterbovenhoek om <a href="/price/link-ln" rel="nofollow noopener noreferrer" target="_blank">LINK</a> naar je browser wallet.<br><img src="https://gimg2.gateimg.com/image/article/17186174246.jpeg" alt=""><img src="https://gimg2.gateimg.com/image/article/17186174347.jpeg" alt=""><br>Bron: zknation.io</p>
<p>Stap 4: Na succesvolle koppeling van de portemonnee kunt u controleren of u in aanmerking komt om de token te ontvangen, en gebruikers kunnen zich richten op de officiële updates van zkSync met betrekking tot de specifieke inzameltijd.<br><img src="https://gimg2.gateimg.com/image/article/17186174568.jpeg" alt=""><br>Bron: zknation.io</p>
<p>Als schaalbaarheidsoplossing voor Ethereum Layer 2 zal zkSync een belangrijke speler worden in de Layer 2-competitie vanwege zijn efficiënte transactiesnelheid, lage transactiekosten, goede privacybeschermingsmogelijkheden en rijke toepassingsscenario’s. We zullen de laatste ontwikkelingen van dergelijke innovatieve projecten blijven volgen.</p>
<div class="blog-details-info"><br><div>Auteur:<strong>Carl Y.</strong>, Gate.io-onderzoeker<br><div>Vertaler: Joy Z.<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de standpunten van de onderzoeker en vormt geen enkele beleggingsaanbeveling.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het opnieuw plaatsen van het artikel is toegestaan mits Gate.io wordt vermeld. In alle glen zullen juridische stappen worden ondernomen vanwege inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div></div>