SHlwZXJsaXF1aWQgZW4gSkVMTFkgVG9rZW46IEVlbiBEaWVwZ2FhbmRlIEFuYWx5c2UgdmFuIE1hcmt0dmVyc3RvcmluZw==

2025-03-27, 02:31

<p><img src="https://gimg2.gateimg.com/image/article/1743042174HOTSPOT.png" alt=""><br>Met de snelle ontwikkeling van gedecentraliseerde financiën (DeFi), <a href="https://www.gate.io/zh/futures/USDT/HYPE_USDT" target="_blank">Hyperliquid</a> Als een nieuwe gedecentraliseerde eeuwigdurende contracthandelsplatform, met zijn innovatieve liquiditeitspoolontwerp en hoge hefboomhandelsfunctie, trok het snel de aandacht van een groot aantal cryptogebruikers. Echter, een geschil dat betrekking heeft op het einde van maart 2025 <a href="https://www.gate.io/zh/futures/USDT/JELLYJELLY_USDT" target="_blank">JELLY</a> De marktmanipulatie van tokens heeft Hyperliquid in de schijnwerpers gezet. Dit legt niet alleen mogelijke zwaktes bloot in het risicobeheer van het platform, maar triggert ook een diepgaande reflectie binnen en buiten de industrie over het governance mechanisme van gedecentraliseerde beurzen (DEX).</p>
<h2 id="h2-De20opkomst20van20Hyperliquid20en20de20anomalie20van20de20JELLY20Token174948"><a name="De opkomst van Hyperliquid en de anomalie van de JELLY Token" class="reference-link"></a><span class="header-link octicon octicon-link"></span>De opkomst van Hyperliquid en de anomalie van de JELLY Token</h2><p><a href="https://www.gate.io/zh/futures/USDT/HYPE_USDT" target="_blank">Hyperliquid</a> Is een op blockchain gebaseerd platform voor eeuwigdurende contracthandel, waarvan de kernfunctie ligt in het interne liquiditeitspool (HLP), die gebruikersfondsen bundelt om diepteliquiditeit te bieden voor de handel. Het platform ondersteunt een verscheidenheid aan tokenhandelsparen, waarvan <a href="https://www.gate.io/zh/futures/USDT/JELLYJELLY_USDT" target="_blank">JELLY</a> Tokens, als een project met een relatief kleine marktwaarde, hebben lange tijd niet veel aandacht getrokken.</p>
<p>Echter, op 26 maart vestigde een mysterieuze handelaar (naar verluidt met een portefeuilleadres dat begint met 0xde95) een shortpositie ter waarde van miljoenen dollars op JELLY-tokens op Hyperliquid, en kocht vervolgens een grote hoeveelheid JELLY on-chain en op andere beurzen, waardoor de prijs in korte tijd met meer dan 230% steeg, waarbij de marktwaarde toenam van $10-20 miljoen tot ongeveer $50 miljoen.</p>
<p>Deze operatie resulteerde in Hyperliquid’s HLP die passief een enorme shortpositie overnam, met ongerealiseerde verliezen die op een gegeven moment zelfs opliepen tot $13,5 miljoen. Wat nog zorgwekkender is, is dat als de JELLY-prijs blijft stijgen naar $0,17 (op dat moment was het al bijna $0,16), het schatkist van het platform (ongeveer $240 miljoen) zelfs liquidatierisico kan lopen.</p>
<p>In het licht van deze crisis heeft het Hyperliquid validatorscomité snel gehandeld door op 27 maart te stemmen voor het schrappen van het JELLY-perpetual contract en alle posities gedwongen af te wikkelen tegen een prijs van $0.0095, om grotere potentiële verliezen te voorkomen.</p>
<h2 id="h2-Technische20en20bestuurlijke20geschillen20achter20het20evenement255783"><a name="Technische en bestuurlijke geschillen achter het evenement" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Technische en bestuurlijke geschillen achter het evenement</h2><p>Deze storm is niet zomaar een eenvoudige</p>
<p><strong>Marktmanipulatie</strong>, het legt verder de dubbele uitdagingen van Hyperliquid bloot op het gebied van technologie en governance. Vanuit technisch oogpunt maakt de aard van high leverage trading Hyperliquid uiterst gevoelig voor prijsschommelingen, terwijl de JELLY-token, als een activum met lage marktwaarde, gemakkelijk gemanipuleerd kan worden door operators die de ‘pump and dump’-strategie gebruiken. In deze situatie, hoewel het ontwerp van HLP liquiditeit kan bieden, is het moeilijk om om te gaan met extreem marktgedrag, wat ertoe leidt dat het platform rechtstreeks ingrijpt op de markt.</p>
<p>Vanuit een governance perspectief is ook de decentralisatie van Hyperliquid in twijfel getrokken. Met een beperkt aantal validators en een zeer gecentraliseerd besluitvormingsproces is de beslissing om het JELLY-perpetuele contract noodgedwongen te schrappen, hoewel verliezen worden beperkt, bekritiseerd door de gemeenschap als ‘ondoorzichtig’ en zelfs ‘in strijd met de geest van decentralisatie’. Daarentegen hebben gecentraliseerde beurzen snel het JELLY-perpetuele contract genoteerd tijdens het incident, wat niet alleen de marktactiviteit stimuleerde, maar ook gezien werd als een ‘competitieve reactie’ op Hyperliquid, waarbij de verschillen tussen gedecentraliseerde en gecentraliseerde platforms in crisismanagement verder werden benadrukt.</p>
<h2 id="h2-De20ecologische20impact20van20Hyperliquid20en20JELLYtokens650525"><a name="De ecologische impact van Hyperliquid en JELLY-tokens" class="reference-link"></a><span class="header-link octicon octicon-link"></span>De ecologische impact van Hyperliquid en JELLY-tokens</h2><p>De directe impact van het incident op Hyperliquid is de scherpe daling van de prijs van zijn eigen token HYPE. HYPE daalde in één dag met meer dan 16%-20%, met een cumulatieve daling van meer dan 60% vanaf het hoogste niveau ooit, wat wijst op een schok in het marktvertrouwen in het platform. Gracy Chen, CEO van Bitget, waarschuwde zelfs openlijk dat de responsmaatregelen van Hyperliquid het in ‘FTX 2.0’ kunnen veranderen, waarbij ze twijfelde aan haar vermogen in risicobeheer en gebruikersfondsenbeveiliging. Hoewel controversieel, verergert deze verklaring ongetwijfeld de paniek in de gemeenschap.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1743042498EHasgNwo.png" alt=""></p>
<p>Voor de JELLY Token, ondanks de scherpe stijging van de prijs als gevolg van manipulatie aan het begin van het evenement, koelde de markthitte van JELLY snel af toen Hyperliquid zijn handelsparen schrapte. Op korte termijn trokken de prijsschommelingen speculanten’ aandacht, maar met een gebrek aan fundamentele ondersteuning blijft de langetermijnwaarde van de JELLY Token onzeker. Dit evenement heeft ook meer aandacht getrokken voor de potentiële risico’s van tokens met een lage marktwaarde bij hoogfrequente handel.</p>
<h2 id="h2-Industrieinzichten20en20toekomstperspectieven485665"><a name="Industrie-inzichten en toekomstperspectieven" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Industrie-inzichten en toekomstperspectieven</h2><p>Het conflict tussen Hyperliquid en JELLY-tokens</p>
<p><strong>De hele DeFi-industrie heeft het alarm doen afgaan</strong> Ten eerste moeten gedecentraliseerde uitwisselingsplatforms op technisch niveau de liquiditeitspools en risicobeheersmechanismen optimaliseren om soortgelijke marktmanipulatiegedragingen te voorkomen. Door bijvoorbeeld prijsorakels te introduceren of de hefboomverhoudingen dynamisch aan te passen, kan de waarschijnlijkheid van extreme schommelingen effectief worden verminderd. Ten tweede is de verbetering van governance-modellen cruciaal. Als Hyperliquid de validatorengemeenschap kan uitbreiden en de besluitvormingstransparantie kan verbeteren, kan het mogelijk het vertrouwen van gebruikers herwinnen.</p>
<p>Voor beleggers herinnert dit evenement mensen eraan om platforms en tokens zorgvuldig te kiezen bij deelname aan eeuwigdurende contracthandel, vooral om waakzaam te blijven voor activa met kleinere marktkapitalisatie.</p>
<p><strong>De korte piek van JELLY-tokens is opvallend</strong> Maar de risico’s erachter mogen niet worden genegeerd. Voor Hyperliquid is dit zowel een crisis als een kans. Als het platform kan leren van dit incident, zijn technologie en governance kan optimaliseren, kan het mogelijk standhouden in de concurrerende DeFi-markt.</p>
<h2 id="h2-Conclusie963420"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p><a href="https://www.gate.io/zh/futures/USDT/JELLYJELLY_USDT" target="_blank">JELLY</a> Of het nu gaat om de noodrespons van Hyperliquid of de dramatische schommelingen van de JELLY Token, ze hebben waardevolle lessen geboden voor de industrie. Tegen de achtergrond van de voortdurende evolutie van blockchaintechnologie blijft het in balans brengen van innovatie en veiligheid een gemeenschappelijke uitdaging voor alle DeFi-projecten. Voor investeerders en gebruikers die aandacht besteden aan Hyperliquid en JELLY Token is geïnformeerd blijven en rationele oordelen vellen de beste strategie om met toekomstige onzekerheden om te gaan.</p>
<div class="blog-details-info"><br><div>Auteur: Rooick Z., Gate.io onderzoeker<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen het standpunt van de auteur en vormt geen handelsadvies. Beleggen brengt risico's met zich mee en beslissingen dienen voorzichtig te worden genomen.<br></em><div><em></em>Deze inhoud is origineel en auteursrechtelijk beschermd door Gate.io. Als u deze wilt herdrukken, geef dan de auteur en bron aan, anders zullen er juridische verantwoordelijkheden worden nagestreefd.<br></div><p></p><br></div></div></div>