SHlwZXJsaXF1aWQgZSBKRUxMWSBUb2tlbjogVW4nYW5hbGlzaSBhcHByb2ZvbmRpdGEgZGVsbGUgdHVyYm9sZW56ZSBkaSBtZXJjYXRv

<p><img src="https://gimg2.gateimg.com/image/article/1743042174HOTSPOT.png" alt=""><br>Con lo sviluppo rapido della finanza decentralizzata (DeFi), <a href="https://www.gate.io/zh/futures/USDT/HYPE_USDT" target="_blank">Hyperliquid</a> Come nuova piattaforma di trading di contratti perpetui decentralizzata, con il suo innovativo design di pool di liquidità e la funzione di trading ad alta leva, ha rapidamente attirato l’attenzione di un gran numero di utenti di criptovalute. Tuttavia, una controversia coinvolge la fine di marzo 2025 <a href="https://www.gate.io/zh/futures/USDT/JELLYJELLY_USDT" target="_blank">JELLY</a> La manipolazione di mercato dei token ha messo Hyperliquid sotto i riflettori. Questo non solo espone potenziali debolezze nella gestione del rischio della piattaforma, ma scatena anche una profonda riflessione all’interno e all’esterno del settore sul meccanismo di governance degli exchange decentralizzati (DEX).</p>
<h2 id="h2-Lascesa20di20Hyperliquid20e20lanomalia20del20Token20JELLY968214"><a name="L’ascesa di Hyperliquid e l’anomalia del Token JELLY" class="reference-link"></a><span class="header-link octicon octicon-link"></span>L’ascesa di Hyperliquid e l’anomalia del Token JELLY</h2><p><a href="https://www.gate.io/zh/futures/USDT/HYPE_USDT" target="_blank">Hyperliquid</a> È una piattaforma di trading di contratti perpetui basata su blockchain, la cui caratteristica principale risiede nel pool di liquidità interno (HLP), che aggrega i fondi degli utenti per fornire liquidità di profondità per il trading. La piattaforma supporta una varietà di coppie di trading di token, tra cui <a href="https://www.gate.io/zh/futures/USDT/JELLYJELLY_USDT" target="_blank">JELLY</a> I token, come progetto con un valore di mercato relativamente basso, non hanno attirato molta attenzione per molto tempo.</p>
<p>Tuttavia, il 26 marzo, un misterioso trader (presumibilmente con un indirizzo del portafoglio che inizia con 0xde95) ha aperto una posizione corta del valore di milioni di dollari sui token JELLY su Hyperliquid, per poi comprare una grande quantità di JELLY on-chain e su altre borse, facendo schizzare il prezzo del 230% in un breve periodo di tempo, aumentando il suo valore di mercato da 10-20 milioni di dollari a circa 50 milioni di dollari.</p>
<p>Questa operazione ha comportato che l’HLP di Hyperliquid assumesse passivamente una posizione corta enorme, con perdite non realizzate che hanno raggiunto un massimo di $13.5 milioni in un momento. Ciò che è ancora più preoccupante è che se il prezzo di JELLY continuerà a salire fino a $0.17 (al momento era già vicino a $0.16), il tesoro della piattaforma (circa $240 milioni) potrebbe persino essere a rischio di liquidazione.</p>
<p>Di fronte a questa crisi, il comitato dei validatori di Hyperliquid ha agito prontamente, votando per cancellare il contratto perpetuo JELLY il 27 marzo e liquidare forzatamente tutte le posizioni a un prezzo di $0.0095, evitando maggiori perdite potenziali.</p>
<h2 id="h2-Dispute20tecniche20e20di20governance20dietro20levento872734"><a name="Dispute tecniche e di governance dietro l’evento" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Dispute tecniche e di governance dietro l’evento</h2><p>Questa tempesta non è solo una cosa semplice</p>
<p><strong>Manipolazione del mercato</strong>, espone ulteriormente le sfide duali di Gate in termini di tecnologia e governance. Da un punto di vista tecnico, la natura del trading ad alto leverage rende Gate estremamente sensibile alle fluttuazioni dei prezzi, mentre il token JELLY, come un asset a basso valore di mercato, è facilmente manipolato dagli operatori che utilizzano la strategia di ‘pump and dump’. In questa situazione, anche se il design di HLP può fornire liquidità, è difficile far fronte a comportamenti di mercato estremi, portando la piattaforma a intervenire direttamente sul mercato.</p>
<p>Da un punto di vista della governance, anche la decentralizzazione di Hyperliquid è stata messa in discussione. Con un numero limitato di validatori e un processo decisionale altamente centralizzato, la decisione di rimuovere in modo emergenziale il contratto perpetuo JELLY, pur mitigando le perdite, è stata criticata dalla comunità come ‘opaca’ e persino ‘contraria allo spirito della decentralizzazione’. Al contrario, le borse centralizzate hanno rapidamente inserito il contratto perpetuo JELLY durante l’incidente, non solo aumentando l’attività di mercato ma anche considerato una ‘risposta competitiva’ ad Hyperliquid, evidenziando ulteriormente le differenze tra piattaforme decentralizzate e centralizzate nella gestione delle crisi.</p>
<h2 id="h2-Limpatto20ecologico20dei20token20Hyperliquid20e20JELLY973799"><a name="L’impatto ecologico dei token Hyperliquid e JELLY" class="reference-link"></a><span class="header-link octicon octicon-link"></span>L’impatto ecologico dei token Hyperliquid e JELLY</h2><p>L’impatto diretto dell’incidente su Hyperliquid è stato il brusco calo del prezzo del suo token nativo HYPE. HYPE è sceso di oltre il 16%-20% in un giorno, con un calo cumulativo di oltre il 60% dal suo massimo storico, riflettendo una scossa nella fiducia del mercato nella piattaforma. Gracy Chen, CEO di Bitget, ha addirittura avvertito pubblicamente che le misure di risposta di Hyperliquid potrebbero trasformarlo in ‘FTX 2.0’, mettendo in dubbio la sua capacità di gestione del rischio e la sicurezza dei fondi degli utenti. Sebbene controversa, questa affermazione senza dubbio esacerba il panico della comunità.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1743042498EHasgNwo.png" alt=""></p>
<p>Per il Token JELLY, nonostante l’accentuato aumento del prezzo dovuto alla manipolazione all’inizio dell’evento, il calore di mercato di JELLY si è rapidamente raffreddato quando Hyperliquid ha rimosso le sue coppie di trading. Nel breve termine, le fluttuazioni di prezzo hanno attirato l’attenzione degli speculatori, ma con la mancanza di supporto fondamentale, il valore a lungo termine del Token JELLY rimane incerto. Questo evento ha anche attirato maggiori attenzioni sui potenziali rischi dei token a basso valore di mercato nel trading ad alto leverage.</p>
<h2 id="h2-Insights20del20settore20e20prospettive20future289665"><a name="Insights del settore e prospettive future" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Insights del settore e prospettive future</h2><p>La controversia tra Hyperliquid e token JELLY</p>
<p><strong>L’intera industria DeFi ha lanciato l’allarme</strong> In primo luogo, le piattaforme di scambio decentralizzate devono ottimizzare i pool di liquidità e i meccanismi di controllo del rischio a livello tecnico per prevenire comportamenti simili di manipolazione di mercato. Ad esempio, introducendo oracoli di prezzo o regolando dinamicamente i rapporti di leva, è possibile ridurre efficacemente la probabilità di fluttuazioni estreme. In secondo luogo, il miglioramento dei modelli di governance è cruciale. Se Hyperliquid può espandere la comunità dei validatori e aumentare la trasparenza decisionale, potrebbe riacquistare la fiducia degli utenti.</p>
<p>Per gli investitori, questo evento ricorda alle persone di scegliere piattaforme e token con attenzione quando partecipano al trading di contratti perpetui, specialmente di rimanere vigili per gli asset con una capitalizzazione di mercato più piccola.</p>
<p><strong>La breve impennata dei token JELLY è accattivante</strong> Ma i rischi che si celano dietro non possono essere ignorati. Per Hyperliquid, questa è sia una crisi sia un’opportunità. Se la piattaforma può imparare da questo incidente, ottimizzare la sua tecnologia e governance, potrebbe essere in grado di resistere saldamente nel competitivo mercato DeFi.</p>
<h2 id="h2-Conclusion44820"><a name="Conclusion" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusion</h2><p><a href="https://www.gate.io/zh/futures/USDT/JELLYJELLY_USDT" target="_blank">JELLY</a> Che si tratti della risposta di emergenza di Hyperliquid o delle fluttuazioni drammatiche del Token JELLY, hanno fornito preziose lezioni per l’industria. Sullo sfondo dell’evoluzione continua della tecnologia blockchain, bilanciare innovazione e sicurezza rimane una sfida comune per tutti i progetti DeFi. Per gli investitori e gli utenti che prestano attenzione a Hyperliquid e al Token JELLY, rimanere informati e prendere giudizi razionali è la migliore strategia per affrontare le incertezze future.</p>
<div class="blog-details-info"><br><div>Autore: Rooick Z., Ricercatore di Gate.io<br><div class="info-tips"><em>Questo articolo rappresenta solo il punto di vista dell'autore e non costituisce alcun consiglio di trading. Gli investimenti comportano rischi e le decisioni dovrebbero essere prese con cautela.<br></em><div><em></em>Questo contenuto è originale e protetto da copyright da Gate.io. Se è necessario riutilizzarlo, si prega di indicare l'autore e la fonte, altrimenti saranno perseguite responsabilità legali.<br></div><p></p><br></div></div></div>