RG9wbyBlc3NlcmUgc3RhdGkgaW5zZWd1aXRpIHVubyBkb3BvIGwnYWx0cm8sIEh5cGVybGlxdWlkIChIWVBFKSBtZXJpdGEgYW5jb3JhIGRpIGVzc2VyZSBpbnZlc3RpdG8/

2025-04-03, 10:33

<p><img src="https://gimg2.gateimg.com/image/article/1743676174Cryptoinsights.png" alt=""></p>
<h2 id="h2-TLDR836826"><a name="[TL;DR]:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL;DR]:</h2><p>L’ultimo incidente di una gigantesca balena che ha ritirato JELLYJELLY per circondare Hyperliquid (HYPE) ha causato una diminuzione del TVL della piattaforma da $240 milioni a $200 milioni e il prezzo del token HYPE è sceso da $16 a $12,5.</p>
<p>In precedenza, una balena con un leverage 50x ha sfruttato la falla di acquisizione di Hyperliquid per guadagnare $1.8 milioni, causando a HLP una perdita di $4 milioni e scatenando una crisi di fiducia.</p>
<p>Nel breve termine, Hyperliquid (HYPE) affronta sfide a causa di recenti attacchi e il suo valore di investimento potrebbe essere basso, ma nel lungo periodo, la base tecnica di Hyperliquid e il supporto della comunità mostrano un potenziale di ripresa a lungo termine e sono adatti agli investitori con un elevato appetito per il rischio.</p>
<h2 id="h2-Introduzione503905"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>Dal principio di quest’anno, Hyperliquid è rapidamente salito con le sue alte prestazioni e innovazioni, diventando un raro punto di riferimento dell’innovazione nel campo del Perp DEX in questa fase di mercato rialzista. Il suo prodotto principale, Hyperliquid DEX, supporta transazioni su registro ordini on-chain, afferma di poter processare 100.000 ordini al secondo, utilizza un algoritmo di consenso personalizzato HyperBFT e, con la stimolazione di massicci airdrop, il token HYPE è stato continuamente enfatizzato. Tuttavia, diversi attacchi improvvisi alla fine di marzo hanno gettato un’ombra su questa stella nascente, che si trova di fronte a una situazione di calo del TVL e a un gran numero di utenti che si allontanano nel prossimo futuro.</p>
<p>Gate.io ha recentemente pubblicato diversi post sul blog, come “ <a href="https://www.gate.io/blog/6539/what-is-hyperliquid-where-can-I-buy-hype-token" target="_blank">Cos’è Hyperliquid? Dove posso comprare i token HYPE?</a>“, che ha già dato una dettagliata introduzione a Hyperliquid. I lettori non familiari con lo sfondo di base possono fare clic qui per visualizzarlo. Non entrerò nei dettagli qui. Questo articolo si concentra sull’analisi di due importanti incidenti di caccia che Hyperliquid ha incontrato di recente, esplorando il loro impatto sul TVL della piattaforma, sui dati aziendali e sul prezzo del token di governance HYPE, e guardando avanti al suo valore di investimento.</p>
<h2 id="h2-JELLYJELLY20Hunting20Una20trappola20di20liquidit20attentamente20pianificata341421"><a name="JELLYJELLY Hunting: Una “trappola di liquidità” attentamente pianificata" class="reference-link"></a><span class="header-link octicon octicon-link"></span>JELLYJELLY Hunting: Una “trappola di liquidità” attentamente pianificata</h2><p>Mercoledì scorso, 26 marzo, Hyperliquid è stato oggetto di una manipolazione di mercato orchestrata riguardante il token JELLYJELLY.</p>
<p>In primo luogo, l’attaccante ha aperto un’ordine short JELLY del valore di $4.08 milioni su Hyperliquid con un margine di 3.5 milioni di USDC. Questa posizione unilaterale rappresentava il 9% della liquidità dell’intera rete. Successivamente, l’attaccante ha coordinato con il mercato spot per vendere e creare l’illusione di prezzi in calo, inducendo il Tesoro del Protocollo Hyperliquid (HLP) a prendere il controllo della posizione. La balena ha poi spinto verso l’alto il prezzo tramite acquisti on-chain, costringendo la propria posizione a essere liquidata.<img src="https://gimg2.gateimg.com/image/article/17436762381.jpeg" alt=""><br>Origine: Hyperliquid</p>
<p>In seguito, quando due scambi ben noti annunciarono il lancio di contratti perpetui JELLY, la liquidità on-chain di Hyperliquid fu istantaneamente sifonata. Il prezzo di JELLY è schizzato da $0.034 a $0.051 in mezz’ora, mentre il prezzo di liquidazione delle posizioni corte detenute dal vault HLP era alto fino a $0.141. Questa operazione collaborativa tra piattaforme diverse mi ricorda la confrontazione tra gli investitori al dettaglio di WSB e le istituzioni nell’incidente di GameStop nel 2021, tranne che questa volta il campo di battaglia si è spostato sulla catena.</p>
<p>La risposta alle emergenze di Hyperliquid può essere descritta come un autosoccorso “centralizzato che tira i fili”. Dopo che i validatori hanno votato per rimuovere il contratto JELLY, la piattaforma ha forzato la liquidazione di 392 milioni di ordini short al prezzo di apertura di $ 0,0095, non solo recuperando tutte le perdite, ma anche realizzando un profitto di $ 703.000. Tuttavia, questo protocollo decentralizzato si basa su operazioni centralizzate per giocare un ruolo di umorismo nero. <img src="https://gimg2.gateimg.com/image/article/17436762542.jpeg" alt=""><br>Origine: @HyperliquidX</p>
<p>L’incidente ha avuto un impatto significativo sul prezzo dei token HYPE. Secondo i dati di Gate.io, HYPE è sceso da $16 a $13 al momento, per poi rimbalzare a $14 dopo che Hyperliquid ha rimosso JELLY. Alla data della stesura, il prezzo della moneta è di $12.5.<br><img src="https://gimg2.gateimg.com/image/article/17436762733.jpeg" alt=""><br>Source: Gate.io</p>
<h2 id="h2-Attacco20alla20vulnerabilit20delle20balene20con20leva2050x959746"><a name="Attacco alla vulnerabilità delle balene con leva 50x" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Attacco alla vulnerabilità delle balene con leva 50x</h2><p>Molto tempo prima dell’incidente JELLY, il meccanismo di liquidazione di Hyperliquid aveva esposto gravi difetti. Il 12 marzo, una balena ha estratto profitti fluttuanti e creato artificialmente un rischio di liquidazione, causando a HLP di perdere più di 4 milioni di dollari in un solo giorno.</p>
<p>Il trader, conosciuto come “Insider” dalla comunità, ha aperto inizialmente una posizione long di 113.000 ETH con leva 50x, un margine iniziale di $4,3 milioni e un valore totale di circa $340 milioni, per poi prelevare gli USDC sopra il margine mentre la posizione era aperta. Con l’aumento del prezzo di ETH, “Insider” ha ritirato profitti non realizzati, ridotto il margine, innescato la liquidazione e alla fine ha realizzato un profitto di circa $1,8 milioni, mentre la cassaforte HLP ha perso $4 milioni.<br><img src="https://gimg2.gateimg.com/image/article/17436762964.jpeg" alt=""><br>Origine: @Penny</p>
<p>Il motivo per cui questa operazione funziona è che Hyperliquid permette il prelievo dei profitti fluttuanti. A differenza del CEX, che vieta il prelievo di profitti fluttuanti, il modello di “liquidazione automatica + acquisizione del caveau” di HLP è come correre nudi quando si incontrano grandi posizioni. Dopo che l’”insider” ha ritirato 8 milioni di dollari e 9 milioni di dollari in due lotti, il prezzo di liquidazione dei suoi ordini long su ETH è salito da 1.877$ a 1.915$ e HLP è stata costretta ad affrontare la pressione di vendita di 140.000 ETH al prezzo di mercato.</p>
<p>Ciò che è ancora più sorprendente è che la balena ha cambiato il nome dell’account DeBank in MELANIA il 18 marzo e ha aperto una posizione nel token corrispondente. Anche se l’analista dei dati on-chain Yu Jin e il detective on-chain ZachXBT lo hanno accusato di utilizzare denaro rubato per il trading, la verità rimane un mistero.<img src="https://gimg2.gateimg.com/image/article/17436763145.jpeg" alt=""><br>Fonte: @zachxbt</p>
<p>Per evitare incidenti simili, Hyperliquid ha successivamente regolato il limite di leva, riducendo BTC da 50x a 40x, ETH da 50x a 25x, e ha aggiornato il sistema di margine, richiedendo alle posizioni isolate di mantenere un tasso di margine del 20% dopo il trasferimento per evitare che la liquidazione venga attivata dalle operazioni di prelievo. Tuttavia, questo metodo di correzione ha solo compensato in parte il prelievo unilaterale dei profitti fluttuanti dalle posizioni pesanti, senza prevedere il comportamento di arbitraggio bilaterale di JELLY di aprire posizioni corte e trarre profitto dalle posizioni lunghe.</p>
<h2 id="h2-Dopo20aver20subito20un20duro20colpo20pu20HYPE20riprendersi20dal20crollo20della20fiducia716644"><a name="Dopo aver subito un duro colpo, può HYPE riprendersi dal crollo della fiducia?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Dopo aver subito un duro colpo, può HYPE riprendersi dal crollo della fiducia?</h2><p>Dopo aver subito una serie di attacchi, i dati aziendali di Hyperliquid si sono ridotti significativamente. Al 3 aprile 2025, il TVL è sceso a 200 milioni di dollari, circa il 71% in meno rispetto al picco di 690 milioni di dollari di gennaio di quest’anno, e il reddito annualizzato è sceso a 436 milioni di dollari, riflettendo le preoccupazioni del mercato riguardo alla governance e alla trasparenza della piattaforma.<img src="https://gimg2.gateimg.com/image/article/17436763366.jpeg" alt=""><br>Source: Dune</p>
<p>Il risultato di questa fuga di capitali sembra essere inevitabile, perché l’attaccante ha utilizzato una falla nelle regole per condurre arbitrati su larga scala. Senza intervento umano, l’HLP di Hyperliquid verrà inevitabilmente svuotato, il protocollo diventerà insostenibile e gli utenti lasceranno naturalmente. Quando il validatore sarà in grado di rimuovere il token tramite un voto di emergenza, la promessa di “decentralizzazione” sarà morta solo di nome e gli utenti delusi da questo fallimento della governance sceglieranno naturalmente di ritirare i propri fondi e andarsene.</p>
<p>Per quanto riguarda il prezzo dei token HYPE, il prezzo di HYPE è sceso dall’alta di $16 a marzo a $12.5, e il FDV è evaporato di circa $6 miliardi. Tecnicamente, se scende al di sotto del supporto chiave di $11-12, potrebbe testare il prezzo di emissione di $8. Tuttavia, l’autore ritiene che il attuale rapporto prezzo/guadagni (P/E) di 27 volte sia tornato all’area di valutazione dell’industria tradizionale, e lo spazio per il declino è relativamente limitato.<img src="https://gimg2.gateimg.com/image/article/17436763567.jpeg" alt=""><br>Fonte: @HyperliquidX</p>
<p>A lungo termine, l’aggiornamento del modello economico di Hyperliquid L1 potrebbe diventare la chiave per rompere l’impasse. La nuova soluzione di staking cross-chain WHYPE introdotta sulla sua mainnet HyperEVM consente agli utenti di convertire HYPE nativo in asset confezionati per partecipare ad altri protocolli DeFi. Questo crea essenzialmente una seconda curva dei prezzi con il potere del <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> ecosistema. Se il percorso procede senza intoppi, il valore di HYPE passerà da una semplice condivisione del profitto da liquidazione a un ‘gateway di liquidità cross-chain’. A mio parere, questo assegno anticipato non incassato rappresenta la logica sottostante per alcuni investitori per aumentare le loro posizioni contro la tendenza.</p>
<p>Come osservatore che guarda lo sviluppo di DeFi, credo che le sfide di Hyperliquid non siano isolate, ma rappresentino una fase necessaria nella crescita di DeFi. Nel lungo periodo, se Hyperliquid può cogliere questa opportunità per ottimizzare il suo meccanismo di governance e migliorare la trasparenza, la sua posizione di primo piano nel campo del trading di contratti perpetui avrà comunque la possibilità di consolidarsi. Specialmente per gli investitori con un alto appetito per il rischio e ottimisti sullo sviluppo a lungo termine di DeFi, HYPE potrebbe essere un’opzione degna di ulteriore attenzione.</p>
<div class="blog-details-info"><br><div>Autore:<strong>Charle Y.</strong>, Ricercatore di Gate.io<br><div>Traduttore: Joy Z.<br><div class="info-tips"><em>Questo articolo rappresenta solo le opinioni del ricercatore e non costituisce alcun suggerimento di investimento. Tutti gli investimenti comportano rischi intrinseci; è essenziale prendere decisioni oculate.<br></em><div><em></em>Gate.io si riserva tutti i diritti su questo articolo. Il ri-pubblicare dell'articolo sarà consentito a condizione che venga citato Gate.io. In tutti i casi, saranno adottate azioni legali a causa della violazione del copyright.<br></div><p></p><br></div></div></div></div>