V2Vsa2UgVHJlbmRpbmcgRWNvc3lzdGVtLXByb2plY3RlbiB6aWpuIGhldCB3YWFyZCBvbSBvcCB0ZSBmb2N1c3NlbiBuYSBkZSB1aXRnaWZ0ZSB2YW4gemtTeW5jPw==

2024-06-18, 06:59

<p><img src="https://gimg2.gateimg.com/image/article/1718693609rdzz.jpeg" alt=""></p>
<h2 id="h2-TLDR373493"><a name="[TL;DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL;DR]</h2><p>De lancering van zkSync’s ZK-token markeert een nieuwe golf van enthousiasme, en als gevolg daarvan beginnen we ons te richten op ecosysteemprojecten met een groter potentieel rendement.</p>
<p>Gate Wallet ondersteunt al lange tijd populaire netwerken zoals zkSync en kan dienen als een belangrijke interactieve tool.</p>
<p>We hebben ook ecosysteemprojecten zoals iZUMi en Satori gezien die hun bereidheid hebben uitgedrukt om ZK-tokens aan gemeenschapsgebruikers te distribueren, wat de teleurstelling veroorzaakt door de zkSync (ZK) -luchtdruppel naar de gemeenschap kan compenseren.</p>
<h2 id="h2-Introductie758592"><a name="Introductie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introductie</h2><p>Hoewel het ZK-handelsmerkgeschil, de vooringenomen regels voor luchtdruppels en de controverse over rattenhandel zkSync naar voren hebben gebracht, kan niet worden ontkend dat er nog steeds enkele projecten zijn die de moeite waard zijn om op te focussen in de ecosysteemtoepassing van zkSync, vooral op het gebied van infrastructuur. We verwachten dat het ecosysteem een enorme groeipotentie heeft.</p>
<p>Matter Labs heeft in november 2022 succesvol $200 miljoen opgehaald, en hun team voorzag vier jaar geleden al dat ZK-technologie de sleutel zou zijn tot de grootschalige toepassing van cryptocurrencies. Om deze reden lanceerden ze zkSync Lite (voorheen zkSync 1.0) op 20 december 2020. Echter, vanwege het gebrek aan EVM-functionaliteit, heeft deze versie ontwikkelaars gehinderd in het gebruik.</p>
<p>De lancering van de zkSync Era heeft veel aandacht getrokken omdat het team met succes zkEVM (Zero Knowledge <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Virtual Machine), wat de bruikbaarheid van ontwikkelaars aanzienlijk verbetert. Als voorbeeld van ZK Rollup heeft zkSync Era een trustless protocol geïmplementeerd voor schaalbare en goedkope transacties op <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> met behulp van cryptogeldigheidsbewijs. Bovendien integreert zkSync Era ook functies zoals native account abstractie, LLVM-compiler en gegevenscompressie, waardoor de schaalbaarheid verder wordt verbeterd.</p>
<p>Sinds de lancering van de Alpha-versie van zkSync Era’s mainnet is de on-chain totale waarde vergrendeld (TVL) aanzienlijk toegenomen tot $774M, met meer dan 2,5 miljoen adressen en in totaal 16,32 miljoen transacties in de afgelopen 30 dagen.</p>
<p>Wat betreft ecosysteemopbouw, dekt zkSync momenteel meer dan 205 Dapps, waaronder DeFi, Wallet, Cross Chain, NFT en infrastructuur. De totale TVL van DeFi-protocollen overschrijdt $85M, wat duidt op een sterke momentum in ecosysteemontwikkeling.<br><img src="https://gimg2.gateimg.com/image/article/17186937331.jpeg" alt=""><br>Bron: @zkswap_official</p>
<p>Hieronder zullen we enkele ecosysteemtoepassingen delen met mogelijke interactiemogelijkheden hieronder.</p>
<h2 id="h2-Gate20Wallet377540"><a name="Gate Wallet" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Gate Wallet</h2><p>Op dit moment ondersteunen de meeste gangbare portefeuilles het zkSync-netwerk, en Gate Wallet ondersteunt al geruime tijd populaire netwerken zoals zkSync.</p>
<p>Gate Wallet is een gedecentraliseerde wallet ontwikkeld door het Gate.io-team, die gebruikers innovatieve en gediversifieerde cryptodiensten kan bieden, zoals het beheren van verschillende crypto-activa, interactie met gedecentraliseerde applicaties, opslaan van niet-vervangbare tokens (NFT) creatie, on-chain identiteit en samenwerken met gemeenschappen.<br><img src="https://gimg2.gateimg.com/image/article/17186937712.jpeg" alt=""><br>Bron: Gate.io</p>
<p>De Gate <a href="/web3" target="_blank" class="blog_inner_link">Web3</a> Wallet is volledig geüpgraded en gelanceerd, en gebruikers kunnen de nieuwe versie van de walletfunctie downloaden en ervaren. Deelname aan de zkSync ecosysteemprojectinteractie is nu gemakkelijker en eenvoudiger.</p>
<h2 id="h2-Satori975472"><a name="Satori" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Satori</h2><p>Satori is een gedecentraliseerd financieel derivatenplatform. Het orderboekmodel werkt samen met veel marktmakers om een uitgebreide blootstelling aan een breed scala aan activa te bieden, evenals een ontwerp van ‘off-chain aggregatie en on-chain afwikkeling’ dat de veiligheid en transparantie van gedecentraliseerde beurzen combineert met de snelheid en beschikbaarheid van gecentraliseerde beurzen.</p>
<p>Op dit moment ondersteunt het protocol chains zoals zkSync, gate. <a href="/price/polygon-matic" rel="nofollow noopener noreferrer" target="_blank">Polygon</a> zkEVM, Linea, Scroll, Base en X Layer. Het totale handelsvolume van het protocol is $37B, met een positie van $4M en meer dan 0.6M gebruikers.</p>
<p>Het protocol heeft momenteel ongeveer 1,6 miljoen ZK’s ontvangen en heeft besloten om alle tokens toe te wijzen aan gemeenschapsgebruikers.<br><img src="https://gimg2.gateimg.com/image/article/17186937943.jpeg" alt=""><br>Bron: @SatoriFinance</p>
<h2 id="h2-iZUMi20Finance402123"><a name="iZUMi Finance" class="reference-link"></a><span class="header-link octicon octicon-link"></span>iZUMi Finance</h2><p>IZUMi Finance is een gevestigd multi-chain cross-chain DeFi-protocol dat een one-stop liquiditeit als service (LaaS) biedt en momenteel 24 chains ondersteunt, waaronder zkSync.</p>
<p>IZUMi heeft ook besloten om alle ontvangen ZK-tokens opnieuw toe te wijzen aan gebruikers. Bovendien verklaarde iZUMi dat als een fervent voorstander sinds de eerste dag van het ZKsync-tijdperk, iZUMi gelooft dat @TheZKNation het airdropgeschil beter zal oplossen.<br><img src="https://gimg2.gateimg.com/image/article/17186938124.jpeg" alt=""><br>Bron: @izumi_Finance</p>
<h2 id="h2-SyncSwap624407"><a name="SyncSwap" class="reference-link"></a><span class="header-link octicon octicon-link"></span>SyncSwap</h2><p>SyncSwap is een gedecentraliseerde exchange (DEX) die netwerken zoals zkSync, Linea, Scroll, Taiko, enz. ondersteunt. Het erft niet alleen de beveiliging van Ethereum, maar biedt gebruikers ook een gebruiksvriendelijke, snelle en voordelige DeFi-ervaring met zijn gebruiksvriendelijke interface en snelle en betaalbare L2-technologie.</p>
<p>Het ondersteunt functies zoals aangepaste kostenstructuren, geavanceerde routers, vetoken-modellen en governance, terwijl het functies heeft zoals poolmeter, waardoor het een zeer gebruiksvriendelijke AMM is.</p>
<p>Het protocol is een relatief actief DEX-protocol op de zkSync-keten met een TVL van $52M. L staat op een leidende positie op zkSync en heeft nog geen munten uitgegeven.<br><img src="https://gimg2.gateimg.com/image/article/17186938355.jpeg" alt=""><br>Bron: syncswap.xyz</p>
<h2 id="h2-zkMarkets20NFTmarkt33405"><a name="zkMarkets: NFT-markt" class="reference-link"></a><span class="header-link octicon octicon-link"></span>zkMarkets: NFT-markt</h2><p>Als toonaangevende NFT-markt gebaseerd op het zkSync Era zero-knowledge Rollup protocol, is zkMarkets niet alleen een lanceerplatform, maar biedt het gebruikers ook een uitstekende handelservaring via een diverse interne NFT-serie, zoals zkEagles ontworpen voor zkSync en Scribes gelanceerd voor Scroll, naast andere professionele tools.<br><img src="https://gimg2.gateimg.com/image/article/17186938516.jpeg" alt=""><br>Bron: zkmarkets.com</p>
<h2 id="h2-Libra20GateFi20Platform426120"><a name="Libra: GateFi Platform" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Libra: GateFi Platform</h2><p>Libra is een uitgebreid Web3 gaming platform gebouwd op zkSync Era, dat een schat aan gratis en betaalde gamebronnen samenbrengt. Spelers kunnen hier gemakkelijk hun favoriete spellen vinden en genieten van de plezier van competitie.</p>
<p>Ondertussen biedt Libra ook een one-stop service voor gameontwikkelaars en spelers om te voldoen aan hun diverse behoeften op het gebied van game-ontwikkeling, exploitatie en ervaring.<br><img src="https://gimg2.gateimg.com/image/article/17186966691.png" alt=""><br>Bron: kreatorland.com</p>
<h2 id="h2-Karat20ID20Web320Digitale20Identiteit814464"><a name="Karat ID: Web3 Digitale Identiteit" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Karat ID: Web3 Digitale Identiteit</h2><p>KaratDAO is de crypto-native engine van Web3. Het biedt dual-service datamarkten om gebruikers te helpen hun Web2- en Web3-gegevens te beheren terwijl ze beloningen ontvangen. Met zijn gedecentraliseerde gegevensidentiteitsprotocol, Karat Network, kunnen gebruikers hun gegevens bezitten, controleren en beheren terwijl ze genieten van de voordelen van een gelicentieerd en veilig gegevenshandelsplatform.</p>
<p>Het protocol is momenteel open voor het slaan van ID’s en er zijn nog geen munten uitgegeven.<br><img src="https://gimg2.gateimg.com/image/article/17186967392.jpeg" alt=""><br>Bron: karatdao.com</p>
<h2 id="h2-ZkApes20Metaverse912402"><a name="ZkApes: Metaverse" class="reference-link"></a><span class="header-link octicon octicon-link"></span>ZkApes: Metaverse</h2><p>ZkApes is een metaverse project gebaseerd op zkSync. ZkApes ontwikkelt een metaverse genaamd Apavers, waar gebruikers NFT’s (AMM’s) kunnen verhandelen, spelletjes kunnen spelen en geld kunnen verdienen in Apavers.</p>
<p>Het is vermeldenswaard dat dit project de ERC-6551 standaard heeft gepionierd, die een krachtige set API’s, SDK’s en tools biedt die gericht zijn op het volledig veranderen van de manier waarop NFT-accountbinding wordt gecreëerd en uitgebreid.</p>
<p>Kort gezegd verbetert de ERC-6551 standaard de functionaliteit en waarde van NFT’s door ze te voorzien van smart contract functionaliteit, die kan worden gebruikt als smart contract wallets, etc. Dit betekent dat ERC-6551 tokens en andere NFT’s kan vasthouden zoals een normale smart contract wallet.<br><img src="https://gimg2.gateimg.com/image/article/17186967993.jpeg" alt=""><br>Bron: zkape.io</p>
<h2 id="h2-Samenvattend559146"><a name="Samenvattend" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Samenvattend</h2><p>Ondanks de controverse rond de zkSync airdrop hebben ecosysteemprojecten zoals iZUMi en Satori hun bereidheid uitgesproken om ZK-tokens te distribueren aan gemeenschapsgebruikers. Momenteel zijn er veel ecosysteemprojecten die de moeite waard zijn om aan deel te nemen, wat tot op zekere hoogte de teleurstelling kan compenseren die de zkSync (ZK) airdrop aan de gemeenschap heeft gebracht.</p>
<p>Natuurlijk zijn we blij te geloven dat er meer hoogwaardige en oprechte projecten zullen zijn in dit ecosysteem die langzaam de markt zullen betreden en de ware geest van het delen en transparante crypto zullen demonstreren.</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 zal worden 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>