TmEgZWVuIHZvb3IgZWVuIHRlIHppam4gb3BnZWphYWdkLCBpcyBIeXBlcmxpcXVpZCAoSFlQRSkgbm9nIHN0ZWVkcyBkZSBtb2VpdGUgd2FhcmQgb20gaW4gdGUgaW52ZXN0ZXJlbj8=

2025-04-03, 10:33

<p><img src="https://gimg2.gateimg.com/image/article/1743676174Cryptoinsights.png" alt=""></p>
<h2 id="h2-TLDR975552"><a name="[TL;DR]:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL;DR]:</h2><p>Het recente incident van een reusachtige walvis die JELLYJELLY eruit trekt om Hyperliquid (HYPE) te omcirkelen, heeft ertoe geleid dat de TVL van het platform daalde van $240 miljoen naar $200 miljoen en de prijs van de HYPE-token daalde van $16 naar $12.5.</p>
<p>Eerder maakte een walvis met 50x hefboomwerking gebruik van het overnamelek van Hyperliquid om een winst van $1,8 miljoen te maken, waardoor HLP $4 miljoen verloor en een vertrouwenscrisis veroorzaakte.</p>
<p>Op korte termijn staat Hyperliquid (HYPE) voor uitdagingen als gevolg van recente aanvallen en de investeringswaarde kan laag zijn, maar op lange termijn tonen de technische basis van Hyperliquid en de steun van de gemeenschap een potentieel voor langdurig herstel en zijn geschikt voor beleggers met een hoog risicoprofiel.</p>
<h2 id="h2-Kennismaking146455"><a name="Kennismaking" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Kennismaking</h2><p>Sinds het begin van dit jaar is Hyperliquid snel opgekomen met zijn hoge prestaties en innovatie, en is het een zeldzaam innovatie-ijkpunt geworden in het Perp DEX-veld in deze ronde van stierenmarkt. Het vlaggenschipproduct, Hyperliquid DEX, ondersteunt on-chain orderboektransacties, beweert in staat te zijn om 100.000 orders per seconde te verwerken, maakt gebruik van een aangepast HyperBFT-consensusalgoritme, en met de stimulatie van massale airdrops is de HYPE-token continu gehypet. Echter, diverse plotselinge aanvallen eind maart wierpen een schaduw op deze rijzende ster, en het staat voor een situatie van dalende TVL en een groot aantal gebruikers die binnenkort vertrekken.</p>
<p>Gate.io heeft onlangs verschillende blogposts gepubliceerd, zoals “ <a href="https://www.gate.io/blog/6539/what-is-hyperliquid-where-can-I-buy-hype-token" target="_blank">Wat is Hyperliquid? Waar kan ik HYPE-tokens kopen?</a>”, die al een gedetailleerde introductie heeft gegeven van Hyperliquid. Lezers die niet bekend zijn met de basisachtergrond kunnen hier klikken om het te bekijken. Ik zal hier niet verder op ingaan. Dit artikel richt zich op het analyseren van twee grote jachtincidenten die Hyperliquid onlangs heeft meegemaakt, waarbij hun impact op de TVL van het platform, zakelijke gegevens en de prijs van de governance token HYPE worden onderzocht, en vooruit wordt gekeken naar de investeringswaarde ervan.</p>
<h2 id="h2-JELLYJELLY20Hunting20Een20zorgvuldig20geplande20Liquiditeit20Val652913"><a name="JELLYJELLY Hunting: Een zorgvuldig geplande “Liquiditeit Val”" class="reference-link"></a><span class="header-link octicon octicon-link"></span>JELLYJELLY Hunting: Een zorgvuldig geplande “Liquiditeit Val”</h2><p>Afgelopen woensdag, 26 maart, was Hyperliquid het onderwerp van een georkestreerde marktmanipulatie rond de JELLYJELLY-token.</p>
<p>Eerst opende de aanvaller een JELLY-shortorder ter waarde van $4,08 miljoen op Hyperliquid met een marge van 3,5 miljoen USDC. Deze unilaterale positie vertegenwoordigde 9% van de liquiditeit van het hele netwerk. Vervolgens werkte de aanvaller samen met de spotmarkt om te verkopen om de illusie van dalende prijzen te creëren, waarbij het Hyperliquid Protocol Treasury (HLP) werd aangezet om de positie over te nemen. De walvis duwde vervolgens de prijs omhoog door on-chain aankopen, waardoor zijn eigen positie geliquideerd moest worden.<img src="https://gimg2.gateimg.com/image/article/17436762381.jpeg" alt=""><br>Bron: Hyperliquid</p>
<p>Later, toen twee bekende beurzen de lancering van JELLY-perpetuele contracten aankondigden, werd de on-chain liquiditeit van Hyperliquid direct weggezogen. De prijs van JELLY schoot in een half uur tijd van $0.034 naar $0.051 omhoog, terwijl de liquidatieprijs van de shortposities in handen van de HLP-vault zo hoog was als $0.141. Deze cross-platform samenwerking doet me denken aan de confrontatie tussen WSB-retailbeleggers en instellingen in het GameStop-incident in 2021, behalve dat het strijdtoneel deze keer naar de keten is verplaatst.</p>
<p>Hyperliquid’s noodrespons kan worden omschreven als een ‘gecentraliseerde draadtrek’ zelfredding. Nadat de validators hadden gestemd om het JELLY-contract te verwijderen, dwong het platform de liquidatie af van 392 miljoen short orders tegen de openingsprijs van $0,0095, waarbij niet alleen alle verliezen werden terugverdiend, maar er ook een winst van $703.000 werd gemaakt. Dit gedecentraliseerde protocol vertrouwt echter op gecentraliseerde operaties om een zwarte humor te spelen.<img src="https://gimg2.gateimg.com/image/article/17436762542.jpeg" alt=""><br>Bron: @HyperliquidX</p>
<p>Het incident had een aanzienlijke impact op de prijs van HYPE-tokens. Volgens Gate.io-gegevens daalde HYPE van $16 naar $13 op dat moment, en later herstelde het naar $14 nadat Hyperliquid JELLY had verwijderd. Op de datum van schrijven is de prijs van de munt $12.5.<img src="https://gimg2.gateimg.com/image/article/17436762733.jpeg" alt=""><br>Bron: Gate.io</p>
<h2 id="h2-50x20Hefboom20Walvis20Kwetsbaarheidsaanval942773"><a name="50x Hefboom Walvis Kwetsbaarheidsaanval" class="reference-link"></a><span class="header-link octicon octicon-link"></span>50x Hefboom Walvis Kwetsbaarheidsaanval</h2><p>Lang voor het JELLY-incident had het liquidatiemechanisme van Hyperliquid fatale gebreken blootgelegd. Op 12 maart onttrok een walvis zwevende winsten en creëerde kunstmatig een liquidatierisico, waardoor HLP in één dag meer dan $4 miljoen verloor.</p>
<p>De handelaar, bekend als ‘Insider’ bij de gemeenschap, opende eerst een longpositie van 113.000 ETH met 50x hefboomwerking, een initiële marge van $4,3 miljoen en een totale waarde van ongeveer $340 miljoen, en trok vervolgens de USDC over de marge terug terwijl de positie open stond. Terwijl de prijs van ETH steeg, trok ‘Insider’ ongerealiseerde winsten terug, verminderde de marge, activeerde liquidatie en maakte uiteindelijk een winst van ongeveer $1,8 miljoen, terwijl de HLP-kluis $4 miljoen verloor.<br><img src="https://gimg2.gateimg.com/image/article/17436762964.jpeg" alt=""><br>Bron: @Penny</p>
<p>De reden waarom deze operatie werkt, is dat Hyperliquid het opnemen van drijvende winsten mogelijk maakt. In tegenstelling tot CEX, dat het opnemen van drijvende winsten verbiedt, lijkt het model van HLP’s ‘automatische liquidatie + inname van de kluis’ op naakt lopen bij het tegenkomen van grote posities. Na de ‘insider’ in twee batches $8 miljoen en $9 miljoen opnam, steeg de liquidatieprijs van zijn ETH-lange orders van $1.877 naar $1.915, en HLP werd gedwongen om de verkoopdruk van 140.000 ETH tegen de marktprijs over te nemen.</p>
<p>Wat nog schokkender is, is dat de walvis op 18 maart de naam van de DeBank-account heeft gewijzigd in MELANIA en een positie heeft geopend in het overeenkomstige token. Hoewel on-chain data-analist Yu Jin en on-chain detective ZachXBT hem beschuldigden van het gebruiken van gestolen geld voor handel, blijft de waarheid een mysterie.<img src="https://gimg2.gateimg.com/image/article/17436763145.jpeg" alt=""><br>Bron: @zachxbt</p>
<p>Om soortgelijke incidenten te voorkomen, heeft Hyperliquid vervolgens de hefboomlimiet aangepast, waarbij BTC van 50x naar 40x werd verlaagd, ETH van 50x naar 25x, en het margesysteem werd geüpgraded, waarbij geïsoleerde posities een marge van 20% moeten handhaven na overdracht om te voorkomen dat liquidatie wordt geactiveerd door opnamen. Deze patchmethode compenseerde echter alleen tot op zekere hoogte voor de unilaterale opname van drijvende winsten uit zware posities, maar had niet gerekend op de bilaterale arbitragegedraging van JELLY door het openen van shortposities en het trekken van longposities.</p>
<h2 id="h2-Na20een20zware20klap20te20hebben20gencasseerd20kan20HYPE20herstellen20van20het20instorten20van20vertrouwen33762"><a name="Na een zware klap te hebben geïncasseerd, kan HYPE herstellen van het instorten van vertrouwen?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Na een zware klap te hebben geïncasseerd, kan HYPE herstellen van het instorten van vertrouwen?</h2><p>Na een reeks aanvallen te hebben ondergaan, is de bedrijfsgegevens van Hyperliquid aanzienlijk afgenomen. Per 3 april 2025 is de TVL gedaald tot $200 miljoen, ongeveer 71% lager dan de piek van $690 miljoen in januari van dit jaar, en ook de jaarlijkse omzet is gedaald tot $436 miljoen, wat de marktzorgen weerspiegelt over platformbestuur en transparantie.<img src="https://gimg2.gateimg.com/image/article/17436763366.jpeg" alt=""><br>Bron: Dune</p>
<p>Het resultaat van deze kapitaalvlucht lijkt onvermijdelijk te zijn, omdat de aanvaller een maas in de wet gebruikte om grootschalige arbitrage uit te voeren. Zonder menselijke tussenkomst zal Hyperliquid’s HLP ongetwijfeld worden geleegd, zal het protocol onhoudbaar worden en zullen gebruikers natuurlijk vertrekken. Wanneer de validator in staat is om het token te verwijderen via een noodstemming, is de belofte van ‘decentralisatie’ alleen in naam dood, en gebruikers die teleurgesteld zijn over dit governancefalen zullen natuurlijk ervoor kiezen om hun fondsen op te nemen en te vertrekken.</p>
<p>Wat betreft de prijs van HYPE-tokens, is de prijs van HYPE gedaald van de piek van $16 in maart naar $12,5, en is FDV met ongeveer $6 miljard verdampt. Technisch gezien, als het onder de belangrijke ondersteuning van $11-12 zakt, kan het de uitgifteprijs van $8 testen. De auteur is echter van mening dat de huidige PS (koers-winstverhouding) van 27 keer is teruggekeerd naar het traditionele waarderingsgebied van de industrie, en dat de ruimte voor daling relatief beperkt is.<img src="https://gimg2.gateimg.com/image/article/17436763567.jpeg" alt=""><br>Bron: @HyperliquidX</p>
<p>Op de lange termijn kan de economische modelupgrade van Hyperliquid L1 de sleutel worden om de impasse te doorbreken. De nieuw geïntroduceerde WHYPE cross-chain staking-oplossing op zijn HyperEVM-mainnet stelt gebruikers in staat om inheemse HYPE om te zetten in verpakte activa om deel te nemen aan andere DeFi-protocollen. Dit creëert in feite een tweede prijscurve met de kracht van de <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> ecosysteem. Als de route soepel verloopt, zal de waardeopname van HYPE overgaan van een eenvoudige liquidatie winstdeling naar een ‘cross-chain liquiditeitsgateway’. Naar mijn mening is deze ongeïnde vooruitbetaling de onderliggende logica voor sommige investeerders om hun posities tegen de trend in te vergroten.</p>
<p>Als toeschouwer die de ontwikkeling van DeFi observeert, geloof ik dat de uitdagingen van Hyperliquid niet geïsoleerd zijn, maar een noodzakelijk stadium zijn in de groei van DeFi. Op de lange termijn, als Hyperliquid deze kans kan grijpen om zijn governance mechanisme te optimaliseren en de transparantie te verbeteren, zal zijn leidende positie op het gebied van eeuwigdurende contracthandel nog steeds een kans hebben om te worden geconsolideerd. Vooral voor investeerders met een hoog risicoprofiel en optimistisch over de langetermijnontwikkeling van DeFi, kan HYPE een optie zijn die het waard is om voortdurend in de gaten te houden.</p>
<div class="blog-details-info"><br><div>Auteur:<strong>Charle 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. Alle beleggingen brengen inherente risico's met zich mee; verstandige besluitvorming is essentieel.<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 wegens schending van het auteursrecht.<br></div><p></p><br></div></div></div></div>