WktKIENyYXNoIEFuYWx5c2U6IEVlbiBPcHJvZXAgdG90IFdhYWt6YWFtaGVpZCBvdmVyIExpcXVpZGl0ZWl0c3Jpc2ljb1wncyBpbiBkZSBDcnlwdG9tYXJrdA==

2025-06-20, 07:37

<p><img src="https://gimg2.gateimg.com/image/zkj202506201534572439059509.png" alt="">
</p><p>Op 15 juni 2025, om 20:30, beleefde de native token ZKJ van Polyhedra Network een schokkende scene. De prijs daalde in een grote dump van $1,946 naar een dieptepunt van $0,3767 binnen twee uur, een daling van maar liefst 80,64%. Tegelijkertijd stortte een andere populaire token KOGE op het Binance Alpha-platform ook in, crashend van $61 naar $8,46.</p>
<p>De flash crash veroorzaakte snel een kettingreactie. Volgens gegevens van Coinglass bereikte het totale liquidatiebedrag in het netwerk die nacht 102 miljoen USD, waarbij de ZKJ-cryptocurrency alleen al 94,36 miljoen USD aan liquidaties bijdroeg, wat een typische bull trap vormde.</p>
<h2 id="h2-Liquiditeitsopname20de20ontsteking20van20de20crash991171"><a name="Liquiditeitsopname, de ontsteking van de crash" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Liquiditeitsopname, de ontsteking van de crash</h2><p>On-chain gegevens onthullen de zorgvuldige operaties achter de grote dump. Volgens blockchain-analysebedrijf Lookonchain hebben zes walvisportefeuilles 5,23 miljoen ZKJ verkocht net voor de crash, ter waarde van ongeveer 9,66 miljoen dollar.</p>
<p>Het operationele proces presenteert duidelijke strategische stappen:</p>
<ul>
<li>Het sleuteladres (beginnend met 0x1A2) heeft binnen 5 minuten liquiditeit ter waarde van 3,76 miljoen USD in KOGE en 532.000 USD in ZKJ opgenomen.</li><li>Verwissel 45.470 KOGE voor ZKJ, en verkoop vervolgens 1,573 miljoen ZKJ in batches.</li><li>Met een duidelijk doel, kies ervoor om eerst de liquiditeit van KOGE aan te vallen en verschuif vervolgens naar ZKJ voor dubbele oogst.</li></ul>
<p>De onderlinge verbinding van liquiditeitspools versnelt de doodsspiraal. Wanneer de USDT in de KOGE/USDT-pool is uitgeput, worden liquiditeitsaanbieders gedwongen om KOGE in te wisselen voor ZKJ en te verkopen, wat de verkoopdruk op ZKJ verder versterkt. Dit ontwerpgebrek maakt de twee tokens een gemeenschap van lot.</p>
<p>“KOGE is vanaf dag één volledig vrijgegeven, zonder lock-up. 48Club heeft nooit beloofd geen treasury-posities te verkopen,” verklaarde het KOGE-team toen de prijs voor het eerst volatiliteit vertoonde, wat later werd geïnterpreteerd als een waarschuwing voor een ineenstorting.</p>
<h2 id="h2-Tokenontgrendeling20en20regelgevende20aanpassingen20zout20in20de20wond20toevoegen985593"><a name="Tokenontgrendeling en regelgevende aanpassingen, zout in de wond toevoegen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Tokenontgrendeling en regelgevende aanpassingen, zout in de wond toevoegen</h2><p>Het token vrijgaveplan is een andere druppel die de emmer deed overlopen voor de markt. Op 15 juni heeft Polyhedra Network 15,53 miljoen ZKJ-tokens vrijgegeven, wat 1,55% van de totale voorraad vertegenwoordigt. Nog ernstiger is dat tokens ter waarde van ongeveer 32 miljoen dollar, wat 5,3% vertegenwoordigt, op 19 juni worden vrijgegeven. In een omgeving van liquiditeitsuitputting vertalen nieuw toegevoegde tokens zich direct in verkoopdruk.</p>
<p>De plotselinge verandering in de regelgevende omgeving versnelde de uitbraak van de crisis. Op de dag van de grote dump kondigde Binance een aanpassing aan van de berekeningsregels voor Alpha Points:</p>
<ul>
<li>Vanaf 17 juni, 0:00 UTC, zal de handel in Alpha-tokens niet meer meetellen voor punten.</li><li>De nieuwe regelgeving is gericht op handelsparen zoals ZKJ/KOGE die zich bezighouden met wash trading.</li><li>Het stimuleren van sommige arbitragefondsen om vroegtijdig op te nemen, is de laatste druppel die de liquiditeit deed breken.</li></ul>
<p>“Om de markteerlijkheid en stabiliteit te waarborgen, en om geconcentreerde systeemrisico’s te verminderen,” legde Binance de motivatie achter de beleidsaanpassingen in de aankondiging uit. Deze verklaring werd echter onverwacht een katalysator voor de grote dump.</p>
<h2 id="h2-Binance20Alpha20Mechanisme20een20Tijdbom20Onder20de20Illusie20van20Welvaart851463"><a name="Binance Alpha Mechanisme, een Tijdbom Onder de Illusie van Welvaart" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Binance Alpha Mechanisme, een Tijdbom Onder de Illusie van Welvaart</h2><p>De opkomst van ZKJ en KOGE is nauw verbonden met het Binance Alpha-ecosysteem. Als de twee tokens met het hoogste handelsvolume op de BSC-keten van Binance Alpha, vertegenwoordigde hun handelsvolume ooit 85,10% van het totale handelsvolume.</p>
<p>De hoge liquiditeit wordt aangedreven door het Alpha Points beloningsmechanisme.</p>
<ul>
<li>Gebruikers verdienen punten door te handelen om in te wisselen voor airdrop-beloningen.</li><li>Het ZKJ/KOGE handels paar is de eerste keuze voor scoring geworden vanwege de lage slijtagegraad.</li><li>De TVL van de liquiditeitspools van beide overschreed 30 miljoen dollar.</li></ul>
<p>De punten economie verbergt de kwetsbaarheid van echte waarde. Met een toename van deelnemers zijn de rendementen scherp gedaald:</p>
<ul>
<li>Begin juni waren er 45 punten nodig om airdrops te ontvangen, en op 13 juni steeg de drempel van het nieuwe project ROAM naar 247 punten.</li><li>Het omzet van gebruikersordernummers is gedaald van 70-100 dollar naar slechts 15 dollar.</li><li>Dit heeft er direct toe geleid dat het handelsvolume is gehalveerd van de piek van 2 miljard dollar op 8 juni naar minder dan 1 miljard dollar.</li></ul>
<p>Wanneer de inkomsten uit punten de risico’s niet kunnen dekken, kiezen slimme grote investeerders ervoor om hun fondsen terug te trekken, waardoor particuliere investeerders de gevolgen van de ineenstorting moeten dragen.</p>
<h2 id="h2-Nasleep20van20de20Markt20Crisis20van20Vertrouwen20en20Regelgevende20Alarm588150"><a name="Nasleep van de Markt: Crisis van Vertrouwen en Regelgevende Alarm" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Nasleep van de Markt: Crisis van Vertrouwen en Regelgevende Alarm</h2><p>De vermogensverdamping veroorzaakt door de flash crash is schokkend. Neem een investering van 1000 dollar als voorbeeld; gebruikers die in paniek verkochten, verloren gemiddeld ongeveer 800 dollar, wat ver boven de verdiensten van 10 Binance Alpha airdrops uitkomt. Sommige gebruikers met een hoofdsom van 5000 dollar hielden minder dan 500 dollar over na de flash crash. Nog brutaler, zes handelaren werden elk geliquideerd voor meer dan 1 miljoen dollar.</p>
<p>Het crisisbeheer van Polyhedra Network kon de publieke woede niet bedwingen. Het team verklaarde op platform X dat “de technologie en de fundamenten van de gemeenschap stevig blijven,” en schreef de grote dump toe aan “abnormale on-chain transacties.” De gemeenschap gelooft het echter niet, en het label “van beide kanten gerugged” verspreidde zich snel op sociale media.</p>
<p>Markttechnische indicatoren suggereren een moeilijke herstel. Op 16 juni:</p>
<ul>
<li>De handelsprijs van ZKJ fluctueert tussen $0,33 en $0,40.</li><li>Het dagelijkse handelsvolume daalde met 61% tot 1,23 miljard dollar.</li><li>vergeleken met de historische hoogtepunt van $9,56 in maart 2024, is het nog steeds met 96% gedaald.</li></ul>
<p>Analisten waarschuwen voor een mogelijke “dead cat bounce” voordat de daling doorgaat. De weg naar herstel voor ZKJ is bezaaid met doornen. De naschokken van deze flash crash verspreiden zich nog steeds. Op 19 juni, de ontgrendelingsdag voor ZKJ-tokens, zweeft de prijs van ZKJ nog steeds rond een laagte van $0,40, een daling van 96% ten opzichte van de historische hoogtepunt. <a href="/price" rel="nofollow noopener noreferrer" target="_blank">cryptomarkt</a> is nooit tekort aan de schittering van technologische innovatie, maar wanneer liquiditeit een manipuleerbaar wapen wordt, staan gewone investeerders altijd aan de frontlinie van de storm.</p>
<div class="blog-details-info"><br><div>Auteur: <strong>Blog Team</strong><br><div class="info-tips"><em>De inhoud hierin 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 het gebruik van alle of een deel van de Diensten vanuit Beperkte Locaties kan beperken of verbieden. Voor meer informatie, lees de Gebruikersovereenkomst via <a href="https://www.gate.com/legal/user-agreement" data-index="2">https://www.gate.com/legal/user-agreement</a>.<br><p></p><br></em></div></div></div>