WktKIFRva2VuIGdyb3RlIGR1bXA6IE9vcnphYWsgYW5hbHlzZSBlbiBpbnZlc3RlcmluZ3NpbnppY2h0

2025-06-16, 01:35

<p><img src="https://gimg2.gateimg.com/image/1202506160932035335142736.jpg" alt="">
</p><p>Onlangs heeft de prijs van ZKJ Token ernstige schommelingen ondergaan, wat brede aandacht heeft getrokken van de cryptocurrency-markt. Als de governance Token van Polyhedra Network was ZKJ ooit zeer gewild op het Binance Alpha-platform vanwege de hoge-rendement liquiditeitspools. Echter, de flash crash in het midden van juni 2025 zorgde ervoor dat veel investeerders verliezen leden. Dit artikel zal ingaan op de redenen achter de grote dump van ZKJ Token, de marktmechanismen erachter verkennen en investeerders voorzien van toekomstige strategieën om beter geïnformeerde beslissingen te nemen op de cryptocurrency-markt.</p>
<h2 id="h2-120Achtergrond20van20de20grote20dump20van20ZKJ20Token836006"><a name="1. Achtergrond van de grote dump van ZKJ Token" class="reference-link"></a><span class="header-link octicon octicon-link"></span>1. Achtergrond van de grote dump van ZKJ Token</h2><p>ZKJ is de native Token van het Polyhedra Network, dat een blockchain-infrastructuurproject is dat zich richt op Web3-interoperabiliteit en zero-knowledge proof (ZKP) technologie. De ZKJ Token wordt voornamelijk gebruikt voor gedecentraliseerd bestuur, cross-chain brugoperaties en het stimuleren van netwerkdeelnemers. In 2024 werden ZKJ en KOGE Token populaire keuzes voor liquiditeitsverschaffers (LP) vanwege het hoge jaarlijkse percentage rendement (APY) van Binance Alpha. Echter, de marktfluctuaties van 14 tot 15 juni 2025 leidden tot een prijsdaling van ZKJ van meer dan 80% binnen 24 uur, met een scherpe daling in handelsvolume en een verschuiving in de marktsentiment naar paniek.<br>Volgens on-chain gegevens en gemeenschapsanalyse betrof het ZKJ flash crash evenement meerdere factoren, waaronder liquiditeitscrisis, grote verkoop van houders en onjuiste operaties door het projectteam. Het volgende zal dit evenement vanuit meerdere perspectieven analyseren.
</p><hr>
<h2 id="h2-220Analyse20van20de20redenen20voor20de20grote20dump20van20ZKJ20Token702175"><a name="2. Analyse van de redenen voor de grote dump van ZKJ Token" class="reference-link"></a><span class="header-link octicon octicon-link"></span>2. Analyse van de redenen voor de grote dump van ZKJ Token</h2><h3 id="h3-120Trigger20van20de20liquiditeitscrisis933575"><a name="1. Trigger van de liquiditeitscrisis" class="reference-link"></a><span class="header-link octicon octicon-link"></span>1. Trigger van de liquiditeitscrisis</h3><p>De hoogrenderende liquiditeitspools van ZKJ en KOGE hebben een grote instroom van kapitaal aangetrokken, maar hun ontwerp van handelsparen heeft structurele gebreken. Het liquiditeitspoolbereik voor het ZKJ/KOGE-handels paar is extreem smal, waardoor het moeilijk is om grote verkoopdruk te weerstaan. Zodra de markt geconcentreerde verkoopdruk ervaart, kan de liquiditeitspool de verkooporders niet absorberen, wat leidt tot een snelle prijsdaling.</p>
<p>Volgens on-chain analisten hebben drie belangrijke adressen de crisis verergerd door “grote liquiditeitsopnames + continue verkoop.” Bijvoorbeeld, een bepaald adres heeft tussen 20:28 en 20:33 op 15 juni ongeveer $3,76 miljoen aan KOGE en $532.000 aan ZKJ-liquiditeit opgenomen, en vervolgens KOGE omgewisseld voor ZKJ en geconcentreerd verkocht, wat de prijs van ZKJ verder deed crashen.</p>
<p>Bovendien dwingt de onvoldoende diepte van de KOGE/USDT-pool LP’s om alleen via ZKJ te verlaten, wat een kettingreactie van liquidatie creëert. Dit “openlijke schema” van liquiditeitsoogst onthult de verborgen risico’s achter hoogrenderende pools.</p>
<h3 id="h3-220De20operaties20van20de20projectpartij20hebben20een20vertrouwenscrisis20veroorzaakt841617"><a name="2. De operaties van de projectpartij hebben een vertrouwenscrisis veroorzaakt." class="reference-link"></a><span class="header-link octicon octicon-link"></span>2. De operaties van de projectpartij hebben een vertrouwenscrisis veroorzaakt.</h3><p>Gemeenschapsgebruikers wezen erop dat het KOGE-projectteam de illusie van prijssteun creëert door voortdurend unilaterale liquiditeit toe te voegen, maar in werkelijkheid de realiseerbare ruimte comprimeert. Wat betreft ZKJ, vragen sommige investeerders zich af of het Polyhedra-team mogelijk tokens verkoopt via meerdere portefeuilles. Volgens de markttrends werd ZKJ binnen 24 uur 8 keer gedumpt, wat leidde tot een daling van 84% in 8 uur. Het team probeerde hun manipulatie-sporen te verbergen, maar on-chain gegevens onthulden het verkoopgedrag van het hoofdadres.</p>
<p>Bovendien staat ZKJ op 18 juni voor een grote tokenontgrendeling die 1,55% van de circulatie vertegenwoordigt, wat de verwachtingen van verkoopdruk op de markt verder vergroot.</p>
<h3 id="h3-320Het20liquidatieeffect20van20highleverage20contracten274046"><a name="3. Het liquidatie-effect van high-leverage contracten" class="reference-link"></a><span class="header-link octicon octicon-link"></span>3. Het liquidatie-effect van high-leverage contracten</h3><p>ZKJ heeft een grote positie op de futuresmarkt, waarbij enkele grote houders shortposities op CEX innemen ter voorbereiding op een prijsdump en hedging. Wanneer de spotprijs snel daalt, worden de longposities in ZKJ-futures op grote schaal geliquideerd, wat de neerwaartse beweging versterkt en een vicieuze cirkel creëert.</p>
<hr>
<h2 id="h2-320De20impact20van20de20grote20dump20van20de20ZKJtoken20op20de20markt553038"><a name="3. De impact van de grote dump van de ZKJ-token op de markt" class="reference-link"></a><span class="header-link octicon octicon-link"></span>3. De impact van de grote dump van de ZKJ-token op de markt</h2><h3 id="h3-120Het20vertrouwen20van20investeerders20wordt20ondermijnd828967"><a name="1. Het vertrouwen van investeerders wordt ondermijnd" class="reference-link"></a><span class="header-link octicon octicon-link"></span>1. Het vertrouwen van investeerders wordt ondermijnd</h3><p>De flash crash van ZKJ en KOGE heeft ervoor gezorgd dat veel investeerders die deelnemen aan Alpha verliezen hebben geleden, vooral degenen die hoge APY achtervolgen, bekend als “毛党”. De stemming in de gemeenschap is verschoven van optimisme naar paniek, waarbij sommige gebruikers ZKJ zelfs grappend een “varkensslachtplaat” noemen.</p>
<h3 id="h3-220Verhoogde20waakzaamheid20ten20opzichte20van20hoogrenderende20projecten880177"><a name="2. Verhoogde waakzaamheid ten opzichte van hoogrenderende projecten" class="reference-link"></a><span class="header-link octicon octicon-link"></span>2. Verhoogde waakzaamheid ten opzichte van hoogrenderende projecten</h3><p>Dit voorval heeft de potentiële risico’s van hoogrenderende liquiditeitspools blootgelegd, waardoor investeerders de fundamenten en liquiditeitsmechanismen van de projecten opnieuw moeten beoordelen. Tokens zonder daadwerkelijke waardesteun hebben moeite om marktschommelingen te doorstaan.</p>
<hr>
<h2 id="h2-IV20Strategien20voor20Investeerders722816"><a name="IV. Strategieën voor Investeerders" class="reference-link"></a><span class="header-link octicon octicon-link"></span>IV. Strategieën voor Investeerders</h2><p>In het licht van de lessen die zijn geleerd van de grote dump van de ZKJ-token, zouden investeerders de volgende strategieën moeten aannemen om soortgelijke risico’s te vermijden:</p>
<ol>
<li><p>Diepgaand onderzoek naar de fundamenten van het project<br>Voordat je deelneemt aan hoogrenderende projecten, analyseer je zorgvuldig de werkelijke gebruikstoepassingen van de Token, de achtergrond van het team en de on-chain gegevens. Hoewel ZKJ afhankelijk is van de zero-knowledge proof technologie van Polyhedra Network, is de waarde van de Token meer afhankelijk van speculatie dan van daadwerkelijke vraag.
</p></li><li><p>Pas op voor hoge APY liquiditeitspools<br>Hoge jaarlijkse procentuele opbrengsten gaan vaak gepaard met hoge risico’s. Investeerders moeten letten op de diepte van de liquiditeitspool, de verdeling van het handelsvolume en het uittredingspad van de LP om te voorkomen dat ze in liquiditeitsvallen terechtkomen.
</p></li><li><p>Stel Stop Loss in en Diversifieer Investeringen<br>In de cryptocurrency-markt kan het instellen van redelijke stop-losspunten en het diversifiëren van je portefeuille de impact van een grote daling van een enkele activa effectief verminderen. Tijdens de ZKJ-flitscrash leden veel investeerders zware verliezen door te sterk geconcentreerde posities.
</p></li><li><p>Let op on-chain gegevens en gemeenschapsdynamiek<br>Gebruik tools zoals Dune Analytics en Etherscan om grote overboekingen en liquiditeitsveranderingen te volgen, terwijl je ook de gemeenschapsdiscussies op platform X in de gaten houdt om markttrends tijdig vast te leggen.
</p></li><li><p>Wees voorzichtig met tokenontgrendeling<br>Grote ontgrendelingen gaan vaak gepaard met verkoopdrukrisico’s. ZKJ zal op 18 juni 1,55% van zijn tokens ontgrendelen, en investeerders moeten vooraf risicobeheer voorbereiden.
</p></li></ol>
<hr>
<h2 id="h2-V20Toekomstperspectief20Kan20ZKJ20het20tij20keren789912"><a name="V. Toekomstperspectief: Kan ZKJ het tij keren?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>V. Toekomstperspectief: Kan ZKJ het tij keren?</h2><p>Hoewel de prijs van de ZKJ Token een zware klap heeft gekregen, heeft Polyhedra Network nog steeds bepaalde technische potentie als een Web3-interoperabiliteitsinfrastructuur. De zkBridge die is geïmplementeerd via het deVirgo-protocol biedt een efficiënte oplossing voor interoperabiliteit van cross-chain gegevens.</p>
<p>Echter, de korte termijn vooruitzichten voor ZKJ zijn niet optimistisch. De ontgrendeling van tokens, een crisis van het vertrouwen in de gemeenschap en een daling van de marktactiviteit leggen allemaal druk op de prijs. Op de lange termijn moet Polyhedra het markvertrouwen opnieuw vormgeven door de volgende manieren:</p>
<ul>
<li>Transparantie verbeteren: openbaar maken van teambezit en token distributieplannen om de zorgen van de gemeenschap over “pig butchering” schema’s weg te nemen.</li><li>Optimaliseer het token-economische model: verminder speculatieve drang en vergroot praktische gebruikscases van ZKJ in het ecosysteem.</li><li>Versterk de ecologische bouw: trek meer DApp-ontwikkelaars aan en breid de toepassingsscenario’s van het Polyhedra-netwerk uit.</li></ul>
<p>Voor investeerders is het momenteel niet raadzaam om blindelings de dip op ZKJ te kopen. Het wordt aanbevolen om instapmogelijkheden te evalueren nadat de markt is gestabiliseerd en het projectteam positieve signalen afgeeft.</p>
<h2 id="h2-620Conclusie7727"><a name="6. Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>6. Conclusie</h2><p>De grote dump van de ZKJ Token is een microkosmos van de cryptocurrency-markt in 2025, die de systeemrisico’s weerspiegelt die verborgen liggen achter hoge rendementen. Door de oorzaken en gevolgen van deze gebeurtenis te analyseren, kunnen investeerders lessen trekken om herhaling van fouten te vermijden. Bij toekomstige investeringen zullen rationaliteit behouden, focussen op fundamentele analyse en flexibel reageren op marktveranderingen de sleutel tot succes zijn.</p>
<div class="blog-details-info"><br>  <div>Auteur:<strong>Blogteam</strong><br>  <div class="info-tips"><em>Deze inhoud vormt geen aanbod, sollicitatie of aanbeveling. U dient altijd onafhankelijk professioneel advies in te winnen voordat u investeringsbeslissingen neemt.<br>  <div></div>Houd er rekening mee dat Gate alle of een deel van de diensten uit beperkte gebieden kan beperken of verbieden. Lees de gebruikersovereenkomst voor meer informatie, link:<a href="https://www.gate.com/zh/legal/user-agreement。" data-index="1"></a><a href="https://www.gate.com/en/legal/user-agreement" data-index="2">https://www.gate.com/nl/legal/user-agreement</a>.<br><p></p><br></em></div></div></div>