TCdhc2Nlc2EgZGkgQ3Jvbm9zIChDUk8pOiBjb250cm92ZXJzYSBlbWlzc2lvbmUgZGkgdG9rZW4gZSBsJ2VmZmV0dG8gVHJ1bXAgY2hlIHNwaW5nZSBsYSBwb21wYQ==

<p><img src="https://gimg2.gateimg.com/image/article/1743058551RDZZ.png" alt=""></p>
<h2 id="h2-Introduzione589076"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p><a href="/price/cronos-cro" rel="nofollow noopener noreferrer" target="_blank">CRO</a>(CRO) ha segnato una svolta importante nel 2025. Come cuore dell’ecosistema Crypto.com, l’emissione di token CRO ha suscitato intense discussioni su <a href="/price/cronos-cro" rel="nofollow noopener noreferrer" target="_blank">Cronos</a> governance. Nel frattempo, il miglioramento della scalabilità della blockchain ha guidato lo sviluppo prosperoso di DeFi e GameFi su <a href="/price/cronos-cro" rel="nofollow noopener noreferrer" target="_blank">Cronos</a> Questo articolo approfondisce le ultime dinamiche di CRO, rivelando la sua posizione unica nell’evoluzione rapida <a href="/price" rel="nofollow noopener noreferrer" target="_blank">mercato delle criptovalute</a></p>
<h2 id="h2-Controversia20sullemissione20di20token20CRO20Il20destino20di207020miliardi20di20token417446"><a name="Controversia sull’emissione di token CRO: Il destino di 70 miliardi di token" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Controversia sull’emissione di token CRO: Il destino di 70 miliardi di token</h2><p>Nel marzo 2025, l’ecosistema di <a href="/price/cronos-cro" target="_blank" class="blog_inner_link">Cronos</a> (CEO) ha vissuto una grande controversia sulla governance a causa dell’emissione improvvisa di 70 miliardi di token, che temporaneamente lo ha reso un token caldo. <a href="/price/cronos-cro" target="_blank" class="blog_inner_link">Cronos</a> ha proposto di annullare l’evento di bruciatura dei token nel febbraio 2021 e di rilasciare di nuovo questi token al portafoglio di custodia delle riserve strategiche di Cronos, al fine di premiare i partecipanti all’ecosistema. Tuttavia, questa mossa ha causato una divisione nella comunità, poiché alcuni utenti ritengono che si tratti di una strategia di ‘pump and dump’ che danneggia gli interessi dei detentori di token.</p>
<p><img src="https://gimg2.gateimg.com/image/article/17430586621.png" alt=""></p>
<p>Il processo specifico di questo evento di emissione è il seguente:</p>
<p>Proposta: Aumentare la circolazione di 70 miliardi di CRO, corrispondenti al 7% dell’offerta totale, per incentivare sviluppatori, fornitori di liquidità e contributori della community.</p>
<p>Risultato del voto: A causa del controllo effettivo del 70-80% dei diritti di voto da parte di Crypto.com e Cronos, la proposta finale è stata approvata ‘per un pelo’ con la partecipazione delle forze ufficiali.</p>
<p>Reazione di mercato: dopo l’emissione, <a href="/price/cronos-cro" rel="nofollow noopener noreferrer" target="_blank">prezzo CRO</a> Un calo del 15% nel breve termine, con alcuni scambi che sospendono il trading di CRO, ha danneggiato la fiducia di mercato. Per placare la comunità, Cronos ha successivamente proposto di bruciare 1 miliardo di CRO all’anno, ma questa mossa è stata derisa dalla comunità come se fossero necessari 700 anni per ripristinare l’attuale offerta.</p>
<p>Questo incidente è stato definito “la farsa di governance più assurda della storia” nel settore, poiché la scala dell’emissione aggiuntiva è troppo grande e manca piena trasparenza e consenso della comunità, il che ha sollevato domande e critiche sul meccanismo di governance di Cronos.</p>
<h2 id="h2-Lecosistema20Cronos20sta20sviluppando20costantemente20collaborando20con20oltre2050020sviluppatori120254"><a name="L’ecosistema Cronos sta sviluppando costantemente, collaborando con oltre 500 sviluppatori" class="reference-link"></a><span class="header-link octicon octicon-link"></span>L’ecosistema Cronos sta sviluppando costantemente, collaborando con oltre 500 sviluppatori</h2><p>In realtà, molto tempo prima che venissero emessi i 70 miliardi di CRO, CRO è diventato un token caldo a causa di molteplici grandi pompe, grazie al suo lungo e costante sviluppo dell’ecosistema. Si dice che Cronos (cronos.org) sia un ecosistema blockchain leader che ha collaborato con oltre 500 sviluppatori di app e contributori, rappresentando una base utenti globale di oltre 100 milioni di utenti potenziali. La sua missione è aprire il futuro della finanza per tutti, con un focus sulla finanza decentralizzata (DeFi) e sul gioco, fornendo transazioni veloci, a basso costo e neutre dal punto di vista ambientale.</p>
<p>Secondo il whitepaper, le caratteristiche di Cronos includono: Scalabilità: fornire transazioni veloci a basso costo, neutralità del carbonio e salvaguardare in modo sicuro miliardi di dollari in asset degli utenti.</p>
<p>Interoperabilità: Combinazione <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> e tecnologie open source di Cosmos per supportare applicazioni cross-chain.</p>
<p>Community-driven: copre utenti, contributori e partner, supportando una comunità globale di oltre 100 milioni di persone.</p>
<h2 id="h2-Collaborare20con20il20Gruppo20Trump20Media20La20storia20dietro20il20grande20pump20del203020di20CRO60316"><a name="Collaborare con il Gruppo Trump Media: La storia dietro il grande pump del 30% di CRO" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Collaborare con il Gruppo Trump Media: La storia dietro il grande pump del 30% di CRO</h2><p>Le performance di mercato di CRO sono state recentemente volatili. Oltre all’evento di emissione menzionato, ha registrato un breve aumento del 30% a causa dell’effetto Trump. Il Trump Media and Technology Group (TMTG) ha annunciato un’intenzione di cooperazione preliminare con le parti correlate di Cronos, pianificando di lanciare ETF e prodotti correlati attraverso Truth.Fi, previsti per essere ufficialmente lanciati nel 2025, ma richiedono ancora la firma di accordi finali e l’approvazione regolamentare.</p>
<p><img src="https://gimg2.gateimg.com/image/article/17430587072.png" alt=""></p>
<p>Influenzato da questa notizia, CRO è salito di più del 30% nel breve termine, con il volume degli scambi che è schizzato a 300 milioni di dollari statunitensi entro 24 ore, mostrando l’alta sensibilità del mercato alle connessioni politiche. Tuttavia, la crescita non è stata sostenuta e il prezzo è successivamente sceso a circa $0.12, riflettendo le preoccupazioni degli investitori sull’incertezza normativa.</p>
<h2 id="h2-Conclusione451814"><a name="Conclusione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusione</h2><p>Nel 2025, Cronos ha mostrato un forte slancio di sviluppo, fornendo una piattaforma ideale per le applicazioni DeFi e GameFi con la sua compatibilità EVM e scalabilità. Tuttavia, le dispute di governance e le fluttuazioni di mercato di Cronos riflettono le sfide che i progetti decentralizzati affrontano nel bilanciare gli interessi della comunità e gli obiettivi aziendali. L’ascesa a breve termine della collaborazione con Trump indica che l’influenza dei legami politici su <a href="/price" rel="nofollow noopener noreferrer" target="_blank">prezzi delle criptovalute</a> non può essere ignorato. In futuro, Cronos deve rafforzare la comunicazione con la comunità e la conformità normativa per ripristinare la fiducia degli investitori.</p>
<p>Avviso di rischio: Il mercato è altamente volatile, i cambiamenti nella politica regolamentare possono influenzare lo sviluppo dell’ecosistema Cronos, gli investimenti devono essere prudenti.</p>
<div class="blog-details-info"><br><div>Autore: Charle A., Ricercatore presso Gate.io<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, il copyright appartiene a Gate.io, se è necessario riportare, si prega di indicare l'autore e la fonte, altrimenti sarà perseguibile la responsabilità legale.<br></div><p></p><br></div></div></div>