QW5hbGlzaSBkZWwgQ3Jhc2ggZGkgWktKOiBVbiBDYW1wYW5lbGxvIGRcJ0FsbGVydGEgc3VpIFJpc2NoaSBkaSBMaXF1aWRpdMOgIG5lbCBNZXJjYXRvIENyeXB0bw==

2025-06-20, 07:37

<p><img src="https://gimg2.gateimg.com/image/zkj202506201534572439059509.png" alt="">
</p><p>Il 15 giugno 2025, alle 20:30, il token nativo ZKJ della Polyhedra Network ha vissuto una scena scioccante. Il prezzo è crollato da $1.946 in un grande dump, raggiungendo un minimo di $0.3767 in due ore, con una caduta fino all’80,64%. Allo stesso tempo, un altro token popolare KOGE sulla piattaforma Binance Alpha è crollato, scendendo da $61 a $8.46.</p>
<p>Il flash crash ha rapidamente innescato una reazione a catena. Secondo i dati di Coinglass, l’importo totale delle liquidazioni in tutta la rete quella notte ha raggiunto 102 milioni di USD, di cui la criptovaluta ZKJ ha contribuito da sola con 94,36 milioni di USD in liquidazioni, formando un tipico bull trap.</p>
<h2 id="h2-Prelievo20di20liquidit20il20fuse20del20crollo67427"><a name="Prelievo di liquidità, il fuse del crollo" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Prelievo di liquidità, il fuse del crollo</h2><p>I dati on-chain rivelano le operazioni meticolose dietro il grande ribasso. Secondo la società di analisi blockchain Lookonchain, sei portafogli di balene hanno venduto 5,23 milioni di ZKJ poco prima del crollo, per un valore di circa 9,66 milioni di dollari.</p>
<p>Il processo operativo presenta passi strategici chiari:</p>
<ul>
<li>L’indirizzo chiave (che inizia con 0x1A2) ha ritirato liquidità per un valore di 3,76 milioni di USD in KOGE e 532.000 USD in ZKJ in 5 minuti.</li><li>Scambia 45.470 KOGE per ZKJ e poi vendi 1,573 milioni di ZKJ a lotti.</li><li>Con un obiettivo chiaro, scegli di attaccare prima la liquidità di KOGE, e poi spostati su ZKJ per un doppio raccolto.</li></ul>
<p>L’interconnessione dei pool di liquidità accelera la spirale della morte. Quando l’USDT nel pool KOGE/USDT si esaurisce, i fornitori di liquidità sono costretti a scambiare KOGE per ZKJ e vendere, intensificando ulteriormente la pressione di vendita su ZKJ. Questo difetto di design rende i due token una comunità di destino.</p>
<p>“KOGE è stato completamente rilasciato sin dal primo giorno, senza blocco. 48Club non ha mai promesso di non vendere posizioni di tesoreria,” ha dichiarato il team di KOGE quando il prezzo ha mostrato per la prima volta volatilità, che è stata successivamente interpretata come un avvertimento di un crollo.</p>
<h2 id="h2-Sblocco20dei20Token20e20Regolamenti20Aggiungere20Insulto20al20Danno189478"><a name="Sblocco dei Token e Regolamenti, Aggiungere Insulto al Danno" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Sblocco dei Token e Regolamenti, Aggiungere Insulto al Danno</h2><p>Il piano di rilascio dei token è diventato un’altra goccia che ha fatto traboccare il mercato. Il 15 giugno, Polyhedra Network ha rilasciato 15,53 milioni di token ZKJ, che rappresentano l’1,55% dell’offerta totale. Ancora più grave, token del valore di circa 32 milioni di dollari, pari al 5,3%, sono programmati per essere sbloccati il 19 giugno. In un ambiente di esaurimento della liquidità, i token appena aggiunti si traducono direttamente in pressione di vendita.</p>
<p>Il cambiamento improvviso nell’ambiente normativo ha accelerato l’insorgenza della crisi. Il giorno del grande crollo, Binance ha annunciato un adeguamento delle regole di calcolo dei Punti Alpha:</p>
<ul>
<li>A partire dal 17 giugno, 0:00 UTC, il trading tra i token Alpha non contribuirà più ai punti.</li><li>Le nuove normative sono rivolte direttamente a coppie di trading come ZKJ/KOGE che sono coinvolte nel wash trading.</li><li>Stimolare alcuni fondi di arbitraggio a ritirarsi anticipatamente è diventato l’ultima goccia che ha spezzato la liquidità.</li></ul>
<p>“Per mantenere l’equità e la stabilità del mercato, e per ridurre i rischi sistemici concentrati,” Binance ha spiegato la motivazione dietro le modifiche politiche nell’annuncio. Tuttavia, questa dichiarazione è inaspettatamente diventata un catalizzatore per il grande crollo.</p>
<h2 id="h2-Meccanismo20Alpha20di20Binance20una20bomba20a20orologeria20sotto20lillusione20della20prosperit516945"><a name="Meccanismo Alpha di Binance, una bomba a orologeria sotto l’illusione della prosperità" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Meccanismo Alpha di Binance, una bomba a orologeria sotto l’illusione della prosperità</h2><p>L’ascesa di ZKJ e KOGE è strettamente legata all’ecosistema Binance Alpha. Essendo i due token con il volume di scambi più alto sulla catena BSC di Binance Alpha, il loro volume di scambi rappresentava una volta l’85,10% del volume totale degli scambi.</p>
<p>L’alta liquidità è guidata dal meccanismo di ricompensa Alpha Points.</p>
<ul>
<li>Gli utenti guadagnano punti attraverso il trading da scambiare per premi airdrop.</li><li>La coppia di trading ZKJ/KOGE è diventata la prima scelta per la valutazione grazie al suo basso tasso di usura.</li><li>Il TVL delle pool di liquidità di entrambi ha superato i 30 milioni di dollari.</li></ul>
<p>L’economia dei punti nasconde la fragilità del valore reale. Con un aumento dei partecipanti, i rendimenti sono crollati bruscamente:</p>
<ul>
<li>All’inizio di giugno, erano necessari 45 punti per ricevere gli airdrop, e il 13 giugno, la soglia del nuovo progetto ROAM è aumentata a 247 punti.</li><li>Il reddito del numero d’ordine dell’utente è sceso da 70-100 dollari a soli 15 dollari.</li><li>Ha causato direttamente un dimezzamento del volume degli scambi, passando dal picco di 2 miliardi di dollari dell’8 giugno a meno di 1 miliardo di dollari.</li></ul>
<p>Quando il reddito derivante dai punti non può coprire i rischi, i grandi investitori astuti scelgono di ritirare i loro fondi, lasciando gli investitori al dettaglio a sopportare le conseguenze del crollo.</p>
<h2 id="h2-Le20conseguenze20del20mercato20crisi20di20fiducia20e20allerta20regolatoria739591"><a name="Le conseguenze del mercato: crisi di fiducia e allerta regolatoria" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Le conseguenze del mercato: crisi di fiducia e allerta regolatoria</h2><p>L’evaporazione della ricchezza causata dal flash crash è scioccante. Prendendo come esempio un investimento di 1000 dollari, gli utenti che hanno venduto in preda al panico hanno perso in media circa 800 dollari, molto più dei guadagni derivanti da 10 airdrop di Binance Alpha. Alcuni utenti con un capitale di 5000 dollari sono rimasti con meno di 500 dollari dopo il flash crash. Ancora più brutale, sei trader sono stati liquidati per oltre 1 milione di dollari ciascuno.</p>
<p>La gestione della crisi di Polyhedra Network non è riuscita a placare la rabbia pubblica. Il team ha dichiarato sulla piattaforma X che “la tecnologia e i fondamenti della comunità rimangono solidi”, attribuendo il grande crollo a “transazioni on-chain anomale”. Tuttavia, la comunità non ci sta e l’etichetta “ruggito da entrambi i lati” si è rapidamente diffusa sui social media.</p>
<p>Gli indicatori tecnici di mercato suggeriscono una difficile ripresa. Al 16 giugno:</p>
<ul>
<li>Il prezzo di trading di ZKJ oscilla tra $0,33 e $0,40.</li><li>Il volume di scambi giornaliero è diminuito del 61% a 1,23 miliardi di dollari.</li><li>rispetto al massimo storico di $9,56 di marzo 2024, è ancora sceso del 96%.</li></ul>
<p>Gli analisti avvertono di un potenziale “rimbalzo del gatto morto” prima di continuare a scendere. La strada verso il recupero per ZKJ è costellata di spine. Le scosse di assestamento di questo crollo istantaneo si stanno ancora diffondendo. Il 19 giugno, giorno di sblocco dei token ZKJ, il prezzo di ZKJ è ancora fermo a un minimo di $0,40, giù del 96% dal suo massimo storico.<br>Il <a href="/price" rel="nofollow noopener noreferrer" target="_blank">mercato delle criptovalute</a> non è mai privo della brillantezza dell’innovazione tecnologica, ma quando la Liquidità diventa un’arma manipolabile, gli investitori ordinari sono sempre in prima linea nella tempesta.</p>
<div class="blog-details-info"><br><div>Autore: <strong>Team del Blog</strong><br><div class="info-tips"><em>Il contenuto qui presente 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 totale o parziale 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="2">https://www.gate.com/legal/user-agreement</a>.<br><p></p><br></em></div></div></div>