TGEgdmVyaXTDoCBkaWV0cm8gbCdpbXBlbm5hdGEgZGVsIHF1YXNpIDQwMCUgZGkgVVNUQyBpbiBkdWUgZ2lvcm5p

2023-11-28, 08:19

<p><img src="https://gimg2.gateimg.com/image/article/1692587449analysis.jpeg" alt=""></p>
<h2 id="h2-TLDR57466"><a name="[TL;DR]:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL;DR]:</h2><p>I token USTC, LUNA e LUNC nel <a href="/price/terra-luna" rel="nofollow noopener noreferrer" target="_blank">Terra</a> I settori del fallimento sono aumentati notevolmente negli ultimi due giorni, in particolare l’USTC, che è aumentato di oltre il 400% negli ultimi due giorni.</p>
<p>L’interpretazione di mercato dell’aumento di USTC è dovuta a piani come l’empowerment dell’airdrop di Mint Cash e il ripristino del pegging dell’USTC al dollaro statunitense.</p>
<p>L’aumento significativo dei prezzi USTC rappresenta una visione positiva nel mercato, ma è comunque necessaria cautela per gli investimenti che non sono entrati in modo tempestivo.</p>
<h2 id="h2-Introduzione749951"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>Oltre a un aumento significativo di FTT di recente, settori in bancarotta come USTC, LUNA e LUNC hanno tutti sperimentato un’impennata sorprendente durante la notte. La popolarità della stablecoin algoritmica USTC è tornata in modo deciso, e il mercato sta speculando che ciò sia legato a proposte come l’empowerment dell’airdrop Mint Cash e il ripristino del pegging al dollaro statunitense di USTC sviluppato dai precedenti membri di Terra.</p>
<p>Quali sono i nuovi punti salienti dietro il trambusto e se c’è ancora spazio per l’arbitraggio in USTC e altri? Questo articolo ti fornirà una spiegazione dettagliata.</p>
<h2 id="h2-La20forte20tendenza20del20mercato20di20USTC20che2020aumentata20di20oltre20il2040020in20due20giorni711423"><a name="La forte tendenza del mercato di USTC, che è aumentata di oltre il 400% in due giorni" class="reference-link"></a><span class="header-link octicon octicon-link"></span>La forte tendenza del mercato di USTC, che è aumentata di oltre il 400% in due giorni</h2><p>A partire dalle 23:00 del 26 novembre, la stablecoin originale dell’ecosistema <a href="/price/terra-luna" target="_blank" class="blog_inner_link">Terra</a> USTC (Terra Classic UST) è improvvisamente decollata in linea retta, raggiungendo 0,05 USDT in un’ora da 0,02 USDT, un aumento fino al 250%.</p>
<p>Al momento della scrittura, il prezzo più alto della moneta ha raggiunto 0,075 USDT, ed attualmente si sta regolando intorno a 0,041 USDT. La crescita a breve termine ha raggiunto un nuovo massimo nell’ultimo anno.<br><img src="https://gimg2.gateimg.com/image/article/170115936415461701159284_.pic.jpg" alt=""><br>Origine: Gate.io</p>
<p>Nel frattempo, secondo il mercato di Gate.io, LUNC e LUNA, entrambi appartenenti al settore del fallimento di Terra, sono stati spinti a rimbalzare, con un aumento del volume di trading, e il prezzo della moneta è aumentato rispettivamente del 60% e del 40% nei due giorni scorsi.<img src="https://gimg2.gateimg.com/image/article/170115938215471701159295_.pic.jpg" alt=""><br>Sorgente: Gate.io</p>
<p>Molti nuovi lettori potrebbero non essere ancora familiari con il progetto Terra, quindi facciamo qui un breve supplemento.</p>
<p>Dopo il crollo dell’ecosistema Terra lo scorso maggio, il team ha ricostruito la nuova catena pubblica Terra 2.0, con il token che utilizza ancora il suo nome originale LUNA. La rete Terra originale è stata ribattezzata Terra Classic, e il suo token di governance LUNA è stato rinominato LUNA Classic (ovvero LUNC menzionato in precedenza). La stablecoin algoritmica corrispondente UST è stata rinominata Terra Classic UST (ovvero USTC menzionata in precedenza) secondo le stesse regole.</p>
<h2 id="h2-Il20team20di20Mint20Cash20chiede20ordini20per20agitare20USTC594420"><a name="Il team di Mint Cash chiede ordini per agitare USTC" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Il team di Mint Cash chiede ordini per agitare USTC</h2><p>Forse ispirato al popolare gameplay degli airdrop di SOL legati allo scambio di criptovalute Backpack, lanciato da ex dirigenti di FTX, il progetto Mint Cash dell’ecosistema di Terra ha continuato a diffondere notizie di essere stato distribuito gratuitamente dai detentori di USTC di recente, e ha finalmente acceso l’entusiasmo di mercato nel prossimo futuro.</p>
<p>Secondo il white paper, Mint Cash è un progetto stablecoin sviluppato dal team originale di Anchor basato sul repository del codice originale di Terra Classic, completamente supportato da <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> come garanzia, con l’obiettivo di raggiungere una missione di pagamento e risparmio completamente decentralizzata.</p>
<p>Si noti che attualmente il sito web ufficiale di Mint Cash ha solo white paper e account sui social media, e non ci sono versioni effettive o anche di prova dei prodotti disponibili.<br><img src="https://gimg2.gateimg.com/image/article/170115941315481701159307_.pic.jpg" alt=""><br>Origine: mintca.sh</p>
<p>Voglio dire, Mint Cash ha ottenuto l’effetto di trascinamento urlando ordini senza un forte endorsement KOL.</p>
<p>Secondo i membri del team, Mint Cash effettuerà un avvio a freddo in due modi, tra cui:</p>
<p>(1) Gli utenti che detengono $UST o $LUNA prima del 10 maggio 2022;</p>
<p>(2) Bloccare e distruggere una quantità specifica di $USTC tramite l’airdrop di Mint Cash.</p>
<p>Il leader del progetto Shin Hyojin ha chiaramente dichiarato nel tweet che i partecipanti devono bloccare USTC sulla catena Terra Classic per partecipare agli airdrop, e il tasso di cambio è di 1 USTC per 1 dollaro statunitense. Con la partecipazione di più utenti agli airdrop, il team del progetto distruggerà tutti gli USTC raccolti per ridurre la circolazione di mercato. Inoltre, Shin Hyojin ha anche dichiarato che anche i detentori di USTC che non hanno partecipato all’airdrop beneficeranno del piano.</p>
<p>Pertanto, se questo piano verrà effettivamente attuato, i detentori di USTC possono chiaramente ottenere enormi profitti, perché al 26 di questo mese, il prezzo di USTC era solo 0,02 USDT, indicando quasi 50 volte più spazio per la crescita dell’arbitraggio.<br><img src="https://gimg2.gateimg.com/image/article/170115945215491701159319_.pic.jpg" alt=""><br>Source: X@shinhyojin1031</p>
<p>Oltre all’annuncio ufficiale dell’airdrop previsto di Mint Cash, molte proposte della comunità per ravvivare USTC e LUNC sono state interpretate come un contesto ottimista per il FOMO di mercato.</p>
<p>Recentemente, la proposta 11885 per il rilascio del client Terrad v2.3.1 sulla blockchain è stata approvata dalla comunità. È importante notare che questo aggiornamento risolve i problemi chiave legati al decoratore ante dinamico e alla sequenza dell’account. La votazione è ancora in corso, ma la proposta è stata approvata in soli un giorno.</p>
<p>Il 21 novembre, l’amministratore della comunità di Terra Classic, Dfunk, ha proposto su un forum di riattivare il modulo Terra Marketplace e di regolare gradualmente l’USTC in modo che sia ancorato a $1, inclusa la fissazione della commissione di differenza di prezzo al 98% (gradualmente decrescente) per stabilizzare efficacemente il prezzo dell’USTC a $2 o addirittura aumentarlo a 3 o 4 centesimi, bruciando il 100% della commissione di differenza di prezzo anziché inviarla al pool Oracle, ecc. Tuttavia, la proposta non è ancora entrata nella fase di votazione a causa della quasi replicazione del 100% di LUNA.</p>
<p>Andando avanti, a settembre di quest’anno, la proposta della comunità di Terra Classic 11324 “Reancoraggio LUNC e UST” è stata approvata. Poco dopo, la comunità di Terra Classic ha votato di nuovo per fermare la coniazione di Terra Classic USD (USTC) ed è stata approvata con il 59% di sostegno. La proposta mira a proteggere le comunità e gli investitori esterni che attualmente stanno distruggendo USTC per aiutare a ripristinare l’ancoraggio.</p>
<h2 id="h2-USTC2020una20nuova20bottiglia20di20vino20vecchio20o2020il20ritorno20del20re71937"><a name="USTC è una nuova bottiglia di vino vecchio o è il ritorno del re?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>USTC è una nuova bottiglia di vino vecchio o è il ritorno del re?</h2><p>In poche parole, il progetto Mint Cash emetterà una nuova catena che sovrappone e raggruppa quasi tutte le varie bambole imbottite, tra cui Celestia (blockchain modulare focalizzata sul livello di disponibilità dei dati), il nuovo Anchor (protocollo di interesse per il risparmio UST di Luna), e Nomic DAO (protocollo nBTC, che porta il BTC nell’ecosistema Cosmos), tra gli altri.</p>
<p>Per gli utenti che hanno sperimentato la precedente ondata di decollo di Terra, sono molto familiari con questo modello di nidificazione, specialmente nei mercati rialzisti dove possono ottenere ritorni molto ricchi.</p>
<p>In qualche misura, l’aumento dei prezzi degli USTC ha avuto un impatto positivo sul mercato. In primo luogo, ciò indica la fiducia delle persone nell’ecosistema di Terra. In secondo luogo, ciò rafforza anche lo status di USTC come stablecoin.</p>
<p>Mint Cash ha effettivamente compiuto un tentativo benefico per promuovere l’espansione degli scenari d’uso di USTC verso la distruzione e la deflazione. Se l’operazione di Mint Cash può davvero essere implementata, senza dubbio darà vita a un nuovo progetto di nidificazione a spirale in avanti.</p>
<p>D’altra parte, i progetti iniziali nello stato di PPT affrontano anche rischi potenziali. Almeno basandosi sulle informazioni attualmente divulgate, non c’è molta correlazione tra USTC e gli scenari e i casi d’uso successivi di CASH e il nuovo Anchor. Tuttavia, il team di progetto di Mint Cash non ha chiaramente le riserve finanziarie e i nobili sentimenti per scambiare l’USTC massiccio, quindi c’è ancora molto lavoro da fare dietro al grande piano.<img src="https://gimg2.gateimg.com/image/article/170115949515501701159333_.pic.jpg" alt=""><br>Origine: X@cmdefi</p>
<p>Se prevediamo dal punto di vista del gioco di capitale, quando il prezzo dell’USTC è troppo alto, ciò porterà a un aumento del trading di arbitraggio, causando quindi un calo dei prezzi. Inoltre, se c’è un panico generale sul mercato, il prezzo dell’USTC potrebbe anche subire un significativo declino.</p>
<p>Le ultime notizie che abbiamo ricevuto alla conclusione di questo articolo sono che Shin Hyojin ha dichiarato che l’airdrop includerà più token e i dettagli specifici sono in fase di finalizzazione. Mint Cash cercherà investimenti da VC. Questa affermazione incoerente ha davvero smorzato l’entusiasmo del mercato e il prezzo della moneta è stato abbassato. È necessaria un’ulteriore osservazione in futuro.</p>
<p>In sintesi, l’aumento significativo dei prezzi delle USTC è il risultato della risposta positiva del mercato principale alle aspettative di Mint Cash airdrop e alle nuove proposte della comunità. Tuttavia, il mercato è ancora pieno di incertezze e per gli investitori che non sono entrati in precedenza, è comunque necessaria prudenza.</p>
<div class="blog-details-info"><br><div>Autore:<strong>Carl Y.</strong>, Ricercatore di Gate.io<br><div>Traduttore: Joy Z.<br><div class="info-tips"><em>Questo articolo rappresenta solo le opinioni del ricercatore e non costituisce alcun suggerimento di investimento.<br></em><div><em></em>Gate.io si riserva tutti i diritti su questo articolo. Sarà consentito il re-post dell'articolo a condizione che venga fatto riferimento a Gate.io. In tutti i casi, verranno intraprese azioni legali a causa della violazione del copyright.<br></div><p></p><br></div></div></div></div>