TFwnYW5hbGlzaSBjb21wbGV0YSBkZWwgY3JvbGxvIGRpIFpLSjogUXVhbCDDqCBsYSB0ZW5kZW56YSBmdXR1cmEgZGkgWktKIGRvcG8gbG8gc2hvY2sgZGVsIG1lcmNhdG8/

2025-06-19, 09:36

<p><img src="https://gimg2.gateimg.com/image/poly202506191733031929313525.png" alt="">
</p><p>Il 15 giugno, il token di governance ZKJ di Polyhedra Network è crollato dell’83% in 9 ore, passando da $1,92 a $0,32, con quasi 500 milioni di dollari di valore di mercato evaporati istantaneamente. Questo evento di cigno nero ha non solo innescato una cascata di liquidazioni superiori a 99 milioni di dollari, ma ha anche esposto la fatale debolezza dei token emergenti nella gestione della liquidità.</p>
<h2 id="h2-Gli20attacchi20di20liquidit20scatenano20un20crollo20del20mercato20analisi20completa20dellincidente498810"><a name="Gli attacchi di liquidità scatenano un crollo del mercato: analisi completa dell’incidente" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Gli attacchi di liquidità scatenano un crollo del mercato: analisi completa dell’incidente</h2><ul>
<li>Prelievi lampo e vendite: secondo il rapporto preliminare di Polyhedra, più indirizzi in <a href="/price/pancakeswap-cake" rel="nofollow noopener noreferrer" target="_blank">PancakeSwap</a> Un attacco coordinato è stato lanciato contro la coppia di trading ZKJ/KOGE: prima, oltre 7,7 milioni di dollari in liquidità sono stati ritirati in modo concentrato, seguito da un’ondata di “transazioni on-chain anomale” per vendere ZKJ. Questa operazione ha portato all’esaurimento della già fragile liquidità della coppia di trading, con la pressione di vendita che si è rapidamente trasmessa al principale pool di trading di ZKJ.</li><li>Le balene hanno alimentato le fiamme: il market maker Wintermute ha trasferito 3,39 milioni di ZKJ a scambi centralizzati entro 90 minuti prima e dopo il crollo del prezzo, riducendo le sue partecipazioni nell’indirizzo on-chain da 3,41 milioni a 22.000, intensificando ulteriormente la pressione di vendita. Durante questo periodo, il prezzo di ZKJ è crollato da 1,93 dollari a 0,29 dollari, con un calo di oltre l’80%.</li><li>Liquidazione della catena del mercato dei derivati: il crollo del prezzo ha innescato un’ondata di liquidazioni forzate su grandi scambi. Una singola posizione long di 7,15 milioni di dollari in ZKJ è stata liquidata sulla piattaforma Bybit, e l’importo totale delle liquidazioni nel mercato ha raggiunto i 99 milioni di dollari entro 4 ore, rappresentando l’81,3% del volume totale delle liquidazioni di criptovalute nello stesso periodo, stabilendo un record per la più alta proporzione di liquidazioni di criptovalute singole quest’anno.</li></ul>
<h2 id="h2-Risposte20del20Mercato20Gioco20di20Responsabilit20e20Ristrutturazione20delle20Regole943535"><a name="Risposte del Mercato: Gioco di Responsabilità e Ristrutturazione delle Regole" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Risposte del Mercato: Gioco di Responsabilità e Ristrutturazione delle Regole</h2><ul>
<li>Controversia sulla Responsabilità: Il co-fondatore di Polyhedra, Tiancheng Xie, ha accusato pubblicamente il team di KOGE di “danneggiare l’ecosistema”, ma il lato KOGE ha rapidamente ribattuto che “non hanno mai promesso di non vendere le partecipazioni del tesoro” e ha puntato il dito verso la natura di “progetto aereo” di Polyhedra. Wintermute deve ancora rispondere pubblicamente alla svendita.</li><li>Aggiornamento del Controllo del Rischio degli Scambi: Binance ha urgentemente modificato le regole di calcolo dei Punti Alpha dopo l’incidente, annunciando che a partire dal 17 giugno, il volume di scambi delle coppie di token Alpha (come ZKJ/KOGE) non sarebbe più conteggiato ai fini dei premi in punti per ridurre i rischi sistemici portati dalla concentrazione di liquidità.</li><li>Azioni di Auto-Salvataggio da Parte dei Team di Progetto: Il team di Polyhedra ha iniettato l’equivalente di 30 milioni di USD in USDT, USDC, e <a href="/price/bnb-bnb" rel="nofollow noopener noreferrer" target="_blank">BNB</a> in <a href="/price/pancakeswap-cake" rel="nofollow noopener noreferrer" target="_blank">PancakeSwap</a> per stabilizzare la liquidità, ma a causa di un rapido calo dei prezzi, tutti gli asset correlati sono stati scambiati per ZKJ, lasciandoli con una grande quantità di token svalutati.</li></ul>
<h2 id="h2-Le20discrepanze20nelle20previsioni20dei20prezzi20si20ampliano20pressione20a20breve20termine20e20gioco20a20lungo20termine298269"><a name="Le discrepanze nelle previsioni dei prezzi si ampliano: pressione a breve termine e gioco a lungo termine" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Le discrepanze nelle previsioni dei prezzi si ampliano: pressione a breve termine e gioco a lungo termine</h2><h3 id="h3-Il20sentimento20ribassista20a20breve20termine20domina183257"><a name="Il sentimento ribassista a breve termine domina" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Il sentimento ribassista a breve termine domina</h3><p>A partire dal 18 giugno, ZKJ è attualmente valutato a $0.3908, con indicatori tecnici che mostrano un chiaro schema ribassista. Dei 31 indicatori tecnici, il 93,94% segnala una tendenza ribassista, e le medie mobili a 50 giorni e 200 giorni sono scese rispettivamente a $0.931 e $1.79, formando forti livelli di resistenza. Sebbene l’Indice di Forza Relativa (RSI) abbia raggiunto un minimo di 14.77, entrando nella zona di ipervenduto, il MACD indica ancora che il momento ribassista persiste.</p>
<h3 id="h3-Previsione20a20lungo20termine20della20polarizzazione990876"><a name="Previsione a lungo termine della polarizzazione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Previsione a lungo termine della polarizzazione</h3><ul>
<li>Modello conservativo (basato sul sentiment degli utenti e sulla volatilità storica): MEXC prevede un prezzo medio di $0.3908 nel 2025, che sale leggermente a $0.4103 nel 2026, con la speranza di superare $1.32 entro il 2050.</li><li>Analisi Tecnica Ottimistica: Alcune istituzioni forniscono valutazioni aggressive basate sulle prospettive applicative della tecnologia delle prove a conoscenza zero—potenzialmente raggiungendo $4.94 nel 2025 (+1165%) e puntando a $22.9 nel 2029. La logica di supporto include il valore tecnologico sottostante di Polyhedra nell’interoperabilità cross-chain.</li><li>Previsione di compromesso: Coindataflow, considerando i rischi di liquidità del mercato, stima che ZKJ fluttuerà nella fascia di $0.305 – $0.700 nel 2025, con la possibilità di salire a $1.42 nel 2029, ma ciò dipende dalla ricostruzione della fiducia da parte del team del progetto.</li></ul>
<h2 id="h2-Raccomandazioni20per20la20Strategia20degli20Investitori20Regole20di20Sopravvivenza20in20un20Mercato20ad20Alta20Volatilit131856"><a name="Raccomandazioni per la Strategia degli Investitori: Regole di Sopravvivenza in un Mercato ad Alta Volatilità" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Raccomandazioni per la Strategia degli Investitori: Regole di Sopravvivenza in un Mercato ad Alta Volatilità</h2><p>L’incidente recente di ZKJ ha rivelato tre principali punti di rischio per i token emergenti: la vulnerabilità delle pool di liquidità, l’imprevedibilità del comportamento delle balene e gli effetti a catena con leva dei derivati. Per i detentori di token e gli investitori cauti:</p>
<ul>
<li>Breve termine: Fai attenzione al livello di supporto critico a $0.40, e se viene infranto con volume, rimani allerta per ulteriori cali; un rimbalzo deve stabilizzarsi sopra $0.70 per confermare un segnale di riparazione.</li><li>Medio-lungo termine: Segui attentamente i progressi dell’implementazione tecnica e i piani di sblocco dei token (se presenti) del team Polyhedra. Se i loro prodotti principali come zkBridge ottengono adozione mainstream, potrebbe spingere a una rivalutazione del valore.</li><li>Livello industriale: Questo incidente ha accelerato le revisioni del controllo del rischio da parte degli scambi sul “trading con leva dei token a piccola capitalizzazione.”</li></ul>
<h2 id="h2-Prospettive20future988496"><a name="Prospettive future" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Prospettive future</h2><p>Il <a href="/price" rel="nofollow noopener noreferrer" target="_blank">mercato delle criptovalute</a> non manca mai di cigni neri, ma ogni crisi spinge l’industria a costruire un gene finanziario più robusto. Il crollo di ZKJ dovrebbe essere visto non come un fallimento del suo progetto tecnico, ma piuttosto come un necessario test di stress nell’evoluzione dei meccanismi di mercato.</p>
<p>Attualmente, ZKJ si trova in una fase critica di “ricostruzione della fiducia”. La sua inversione di prezzo dipende non solo dall’avanzamento della roadmap tecnica, ma anche dalla capacità del team di stabilire un meccanismo trasparente per la collaborazione con i market maker e una rete di sicurezza per la liquidità. Per gli investitori con alta tolleranza al rischio, il controllo rigoroso dei rapporti di posizione e la disciplina di stop-loss rimangono il principio fondamentale per affrontare la tempesta.</p>
<div class="blog-details-info"><br><div>Autore: <strong>Team del Blog</strong><br><div class="info-tips"><em>Il contenuto qui non costituisce alcuna offerta, sollecitazione o raccomandazione. Dovresti sempre cercare un consiglio professionale indipendente prima di prendere qualsiasi decisione di investimento.<br><div></div>Si prega di notare che Gate potrebbe limitare o vietare l'uso di tutti o parte dei Servizi da Località Riservate. Per ulteriori informazioni, si prega di leggere il Contratto Utente tramite <a href="https://www.gate.com/legal/user-agreement" data-index="5">https://www.gate.com/legal/user-agreement</a>.<br><p></p><br></em></div></div></div>