UHJlenpvIGF0dHVhbGUgZGkgVGVycmEgTHVuYSBlIHByb3NwZXR0aXZlIGZ1dHVyZQ==

2025-07-07, 10:54

<p><img src="https://gimg2.gateimg.com/image/lunc202507071854134141855562.jpg" alt="">
</p><p>A partire dal 7 luglio 2025, il prezzo di <a href="/price/terra-luna" rel="nofollow noopener noreferrer" target="_blank">Terra</a> Classic (LUNC) è segnalato a $0.0000566, in aumento dell’1,37% nelle ultime 24 ore. Nel frattempo, la nuova versione <a href="/price/terra-luna" rel="nofollow noopener noreferrer" target="_blank">prezzo di LUNA</a> A 0,151 USD, in attesa di un’opportunità di rottura tra le fluttuazioni. Questo progetto blockchain, che una volta ha subito un crollo storicamente poetico, sta cercando un nuovo posizionamento attraverso la divisione e la ricostruzione.</p>
<h2 id="h2-Essenza20del20Progetto20DallEsperimento20di20Stablecoin20Algoritmica20alla20Ricostruzione20Ecologica19"><a name="Essenza del Progetto: Dall’Esperimento di Stablecoin Algoritmica alla Ricostruzione Ecologica" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Essenza del Progetto: Dall’Esperimento di Stablecoin Algoritmica alla Ricostruzione Ecologica</h2><p><a href="/price/terra-luna" rel="nofollow noopener noreferrer" target="_blank">Terra</a> Luna era inizialmente una piattaforma blockchain progettata per fornire soluzioni di pagamento sicure per stablecoin ancorate a valute fiat, con il suo meccanismo centrale che manteneva l’equilibrio di valore attraverso lo scambio reciproco della stablecoin algoritmica UST e del token nativo LUNA.</p>
<p>Questo sistema ha mostrato una crescita straordinaria dalla fine del 2021 all’inizio del 2022, con il prezzo di LUNA che è balzato a $116, rendendola la quinta criptovaluta per capitalizzazione di mercato. Tuttavia, l’incidente di disaccoppiamento dell’UST nel maggio 2022 ha innescato una spirale mortale, causando un crollo del valore di LUNA del 99,9% in pochi giorni, portando alla perdita di quasi 250.000 investitori e a una perdita complessiva di circa $400 miliardi nell’intero mercato delle criptovalute.</p>
<p>Dopo il crollo, la comunità ha diviso il progetto in due catene tramite un fork: <a href="/price/terra-luna" target="_blank" class="blog_inner_link">Terra</a> Classic (LUNC) ha mantenuto la catena originale e i suoi token, mentre Terra 2.0 (LUNA) è emersa come un nuovo token di governance.</p>
<p>Oggi, LUNC esiste più come un relitto storico, mentre la nuova versione di LUNA si sposta verso il voto di governance, lo staking e le funzioni di sicurezza della rete, con i prezzi guidati più dalle attività on-chain e dalle proposte della comunità.</p>
<h2 id="h2-Performance20del20Mercato20Tendenze20di20Prezzo20Divergenti945875"><a name="Performance del Mercato: Tendenze di Prezzo Divergenti" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Performance del Mercato: Tendenze di Prezzo Divergenti</h2><p>Secondo i dati in tempo reale della piattaforma Gate, all’inizio di luglio 2025, i due token di Terra hanno mostrato performance di mercato molto diverse:</p>
<ul>
<li>Terra Classic (LUNC): Il prezzo attuale è $0.0000566, in aumento dell’1.37% nelle ultime 24 ore e un incremento dell’1.27% negli ultimi 7 giorni. La sua capitalizzazione di mercato rimane a $310 milioni, con un volume di trading nelle ultime 24 ore di circa $7.1 milioni, riflettendo una bassa attività di mercato.</li><li>Nuova versione di LUNA: Prezzo segnalato a 0,17524 USD, in calo del 2,27% nelle ultime 24 ore. Il valore di mercato circolante attuale è di circa 103 milioni di USD, con un volume di trading nelle ultime 24 ore vicino a 16,9 milioni di USD, e la liquidità rimane stabile. L’analisi tecnica mostra che il <a href="/price/terra-luna" rel="nofollow noopener noreferrer" target="_blank">prezzo di LUNA</a> sta correndo al di sotto della media mobile a 30 giorni, in un debole schema di oscillazione.</li></ul>
<p>Il mercato è chiaramente differenziato, con LUNC che attira speculazioni a breve termine a causa del suo prezzo molto basso, mentre il valore di LUNA si basa maggiormente su proposte di governance e progressi ecologici.</p>
<h2 id="h2-Previsione20dei20prezzi20Pressione20a20breve20termine20e20potenziale20a20lungo20termine448690"><a name="Previsione dei prezzi: Pressione a breve termine e potenziale a lungo termine" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Previsione dei prezzi: Pressione a breve termine e potenziale a lungo termine</h2><p>Secondo i dati di diverse agenzie di analisi, i futuri percorsi dei due token di Terra mostrano differenze significative:<br>Previsione di Terra Classic (LUNC):
</p><ul>
<li>2025: Si prevede che il prezzo medio fluttui nell’intervallo di $0.00004-0.00008. Alcuni modelli predittivi indicano un potenziale picco di $0.0000808.</li><li>2035: Le previsioni a lungo termine puntano a $0.0001, il che offre un potenziale tasso di ritorno superiore al 100% rispetto al prezzo attuale. Tuttavia, il suo approvvigionamento circolante di oltre 54 trilioni e il meccanismo di approvvigionamento illimitato rimangono ostacoli significativi all’aumento di valore.</li></ul>
<p>Nuovo <a href="/price-prediction/terra-luna" rel="nofollow noopener noreferrer" target="_blank">Previsione LUNA</a> (Luglio-Settembre 2025):</p>
<ul>
<li>Luglio: Se la proposta di governance viene implementata con successo, si prevede che il prezzo rimbalzi nella fascia $0.180–0.185.</li><li>Agosto: Con <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> mantenendo sopra $100.000, potrebbe ulteriormente salire a $0,185–$0,190.</li><li>Settembre: In uno scenario ottimista, potrebbe testare $0.195, ma se sorgono venti contrari normativi, potrebbe tornare al livello di supporto di $0.165.</li></ul>
<h2 id="h2-Prospettive20future20Il20percorso20di20ricostruzione20nelle20sfide942564"><a name="Prospettive future: Il percorso di ricostruzione nelle sfide" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Prospettive future: Il percorso di ricostruzione nelle sfide</h2><p>Il futuro dell’ecosistema Terra ha preso due percorsi diversi dopo la divisione.</p>
<h3 id="h3-Terra20Classic20LUNC20affronta20sfide20fondamentali529523"><a name="Terra Classic (LUNC) affronta sfide fondamentali" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Terra Classic (LUNC) affronta sfide fondamentali</h3><ul>
<li>Immensa offerta: Con un’offerta circolante di oltre 5,4 trilioni e un design di offerta illimitata, il suo miglioramento di valore affronta dilemmi matematici.</li><li>Mancanza di applicazioni ecologiche: Dalla caduta di UST, c’è stata una mancanza di dApp influenti o protocolli innovativi on-chain. Sebbene la comunità abbia proposto di creare Sub-DAO, i progressi sostanziali sono stati limitati.</li><li>Alta speculazione: Gli indicatori tecnici mostrano che è in una tendenza ribassista da molto tempo, con il RSI a 14 giorni costantemente sotto 50, riflettendo una fiducia di mercato debole.<h3 id="h3-Opportunit20di20trasformazione20per20il20nuovo20LUNA638134"><a name="Opportunità di trasformazione per il nuovo LUNA" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Opportunità di trasformazione per il nuovo LUNA</h3></li><li>Approfondimento del valore di governance: L’attività della piattaforma di governance della comunità è aumentata, con diverse proposte relative all’allocazione dei fondi per i ponti cross-chain e ai programmi di incentivazione delle DApp, promuovendo un orientamento delle risorse verso applicazioni DeFi e NFT.</li><li>Evoluzione della conformità: Di fronte a un quadro normativo globale unificato per le criptovalute promosso dal G7 e dal FMI, il nuovo LUNA si concentra su un design della funzione di governance che si allinea maggiormente alle direzioni normative.</li><li>Possibile partecipazione istituzionale: Poiché istituzioni finanziarie tradizionali come BlackRock si impegnano profondamente nel <a href="/price" rel="nofollow noopener noreferrer" target="_blank">mercato delle criptovalute</a>(come la gestione di 75 miliardi di dollari in ETF Bitcoin), i progetti di conformità sono più propensi ad attrarre il favore del capitale.</li></ul>
<p>Una volta valutato a cento dollari, il token ora è quotato con quattro decimali. La circolazione di oltre 5,4 trilioni di Terra Classic (LUNC) rende il suo cammino verso la rinascita arduo. La nuova versione di LUNA sta costruendo un fondo attorno a 0,17 dollari, scommettendo sulla governance della comunità e sullo sviluppo conforme.</p>
<p>Mentre il quadro normativo globale prende forma, questa entità gemella che è emersa dalle ceneri sta verificando una verità su traiettorie completamente diverse: nel mondo delle criptovalute, il codice può essere biforcato, ma la fiducia può essere ricostruita solo.</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 di tutti o di una parte dei Servizi da Località Riservate. Per ulteriori informazioni, si prega di leggere il Contratto dell'Utente tramite <a href="https://www.gate.com/legal/user-agreement" data-index="8">https://www.gate.com/legal/user-agreement</a>.<br><p></p><br></em></div></div></div>