SnVzdGluIFN1biBzb3N0aWVuZSBjaGUgSlNUIGRpdmVudGVyw6AgdW4gJ1Rva2VuIGNlbnR1cGxpY2F0bycsIHN1c2NpdGFuZG8gZGlzY3Vzc2lvbmkgbmVsbCdlY29zaXN0ZW1hIFRyb24=

2025-04-28, 03:12

<p><img src="https://gimg2.gateimg.com/image/article/1745809801hot.png" alt=""><br>Il 27 aprile 2025, il fondatore di <a href="/price/tron-trx" target="_blank" class="blog_inner_link">Tron</a>, Justin Sun, ha rilasciato una dichiarazione sensazionale sulla piattaforma di social media X, affermando che il token JST (JUST) ha subito una inversione fondamentale e prevedendo che diventerà il “prossimo token centuplicato”. Questa affermazione ha rapidamente acceso l’entusiasmo del mercato e il prezzo di JST è schizzato del 34% entro 24 ore, raggiungendo $0.04310. La previsione ottimistica di Justin Sun si basa su JustLend e <a href="/price/usdd-usdd" rel="nofollow noopener noreferrer" target="_blank">USDD</a> La forte crescita di Gate, così come la promessa di futuri riacquisti e distruzioni di JST. Tuttavia, dietro l’entusiasmo del mercato, anche i potenziali rischi e le sfide sono degni di attenzione.</p>
<h2 id="h2-La20crescita20di20JST20JustLend20e20USDD20Dualwheel20Drive875105"><a name="La crescita di JST: JustLend e USDD Dual-wheel Drive" class="reference-link"></a><span class="header-link octicon octicon-link"></span>La crescita di JST: JustLend e <a href="/price/usdd-usdd" target="_blank" class="blog_inner_link">USDD</a> Dual-wheel Drive</h2><p>Justin Sun ha sottolineato nella dichiarazione che la piattaforma di prestiti decentralizzata JustLend, incubata da JST, è cresciuta in <a href="/price/tron-trx" rel="nofollow noopener noreferrer" target="_blank">Tron</a> La pietra angolare dell’ecosistema, si posiziona come una delle piattaforme di prestito più grandi con un profitto netto annuale di decine di milioni di dollari. JustLend è simile ad <a href="/price/aave-aave" target="_blank" class="blog_inner_link">AAVE</a> su <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a>, permettendo agli utenti di prendere in prestito asset attraverso i pool di liquidità. Con l’alto throughput e le basse commissioni di transazione della rete Tron, ha attirato un gran numero di utenti. Secondo i dati precedenti, il Total Value Locked (TVL) di JustLend ha raggiunto 1,9 miliardi di dollari nel 2022, mentre gli asset dell’ecosistema DeFi di <a href="/price/tron-trx" target="_blank" class="blog_inner_link">Tron</a> supereranno gli 8,1 miliardi di dollari nel 2023, secondi solo ad Ethereum.</p>
<p>Nel frattempo, lo stablecoin algoritmico <a href="/price/usdd-usdd" target="_blank" class="blog_inner_link">USDD</a> incubato da JST ha raggiunto anche una ‘crescita esplosiva’. Nel gennaio 2025, Justin Sun ha lanciato USDD 2.0, offrendo fino al 20% di rendimento percentuale annuo (APY), completamente sovvenzionato dalla riserva Tron DAO. Questa strategia ad alto rendimento ha promosso significativamente l’adozione di USDD, rendendolo un asset principale nell’ecosistema Tron. Justin Sun posiziona JST come una combinazione di <a href="/price/aave-aave" target="_blank" class="blog_inner_link">AAVE</a> e MKR nell’ecosistema Tron, sottolineando il suo duplice ruolo nel prestito e nella governance dello stablecoin.</p>
<h2 id="h2-Fiducia20nella20previsione20centuplicata20guidata20dal20profitto20e20dalla20distruzione20per20il20riacquisto643779"><a name="Fiducia nella previsione centuplicata: guidata dal profitto e dalla distruzione per il riacquisto" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Fiducia nella previsione centuplicata: guidata dal profitto e dalla distruzione per il riacquisto</h2><p>Justin Sun predice che il profitto netto annuo dell’ecosistema JST abbia raggiunto decine di milioni di dollari e supererà i 100 milioni di dollari nel 2026. Egli ritiene che la valutazione attuale di JST sia molto al di sotto dei suoi fondamentali e abbia un enorme potenziale di crescita. Per aumentare ulteriormente il valore del token, Justin Sun ha promesso di utilizzare tutti i profitti per riacquistare e distruggere i token JST al fine di ridurre l’offerta circolante. Questo meccanismo è simile a quello di Binance. <a href="/price/bnb-bnb" rel="nofollow noopener noreferrer" target="_blank">BNB</a> Strategia di distruzione, teoricamente può aumentare i prezzi attraverso aggiustamenti dell’offerta e della domanda.</p>
<p>Il mercato ha reagito fortemente alla dichiarazione di Justin Sun. I dati della piattaforma X mostrano che il volume degli scambi di JST è aumentato dopo la pubblicazione della dichiarazione, con alcuni utenti ottimisti riguardo al suo piano di riacquisto e bruciatura, credendo che porterà ricompense ai detentori a lungo termine. Tuttavia, alcuni utenti hanno avvertito dei rischi di ipercomprato a breve termine e consigliato agli investitori di acquistare durante le correzioni per evitare i pullback.</p>
<h2 id="h2-Rischi20potenziali20Preoccupazioni20nascoste20delle20stablecoin20e20trasparenza684270"><a name="Rischi potenziali: Preoccupazioni nascoste delle stablecoin e trasparenza" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Rischi potenziali: Preoccupazioni nascoste delle stablecoin e trasparenza</h2><p>Nonostante le previsioni ottimistiche di Justin Sun, JST e l’ecosistema Tron affrontano ancora molteplici sfide. In primo luogo, il meccanismo dell’algoritmo stabile di USDD e <a href="/price/terra-luna" rel="nofollow noopener noreferrer" target="_blank">Terra</a> Simile a UST, UST ha subito un crollo nel 2022 che ha portato a una perdita di 40 miliardi di dollari. Anche USDD si è scollegato arrivando a 0,97 dollari a dicembre 2022, sollevando dubbi sulla trasparenza delle riserve. Inoltre, gli alti rendimenti di JustLend e USDD (20%-30% APY) si basano su sovvenzioni dal Tron DAO, simili al protocollo <a href="/price/terra-luna" target="_blank" class="blog_inner_link">Terra</a> Anchor, e la sua sostenibilità a lungo termine deve ancora essere convalidata.</p>
<p>Anche le questioni di trasparenza hanno ricevuto attenzione. Nel 2023, un’analisi ha evidenziato che lo stUSDT (collaterale USDT) su JustLend coinvolge operazioni di attività opache, con una grande quantità di USDT in riserva trasferita a piattaforme controllate da Justin Sun. Inoltre, Justin Sun e i suoi progetti (come Tron e BTT) sono stati citati in giudizio dalla Securities and Exchange Commission (SEC) degli Stati Uniti per presunta frode sui titoli e manipolazione di mercato. Questi rischi legali potrebbero costituire una minaccia per la reputazione e lo sviluppo dell’ecosistema di JST.</p>
<h2 id="h2-Prospettive20di20mercato735692"><a name="Prospettive di mercato" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Prospettive di mercato</h2><p>La dichiarazione di Justin Sun ha senza dubbio iniettato nuova linfa vitale in JST, dipingendo un futuro luminoso per gli investitori con la rapida crescita dell’ecosistema Tron e il piano di buyback e burn. Tuttavia, i rischi legati agli stablecoin algoritmici, la sostenibilità dei rendimenti elevati e le sfide legate alla trasparenza e alla regolamentazione servono da promemoria per il mercato affinché rimanga cauto. Per gli investitori, monitorare attentamente i dati on-chain di JustLend e USDD, il report delle riserve di Tron DAO e l’attuazione del piano di buyback sarà cruciale per valutare il potenziale di JST.</p>
<p>Se JST può diventare un ‘token centuplicato’ ancora ha bisogno di tempo e di una valida conferma di mercato. Nell’intreccio di ambizione e sfide nell’ecosistema Tron, le audaci parole di Justin Sun hanno aggiunto un tocco di luminosità al mercato delle criptovalute, portando opportunità e riflessioni agli investitori.</p>
<p>Nota: Questo articolo si basa sulla dichiarazione pubblica di Justin Sun del 27 aprile 2025 e sui dati correlati. Le dinamiche di mercato possono cambiare in qualsiasi momento, quindi gli investimenti dovrebbero essere fatti con cautela.</p>
<div class="blog-details-info"><br> <div>Autore: Rooick Z., Ricercatore di Gate.io<br><div class="info-tips"><em>Questo articolo rappresenta solo il punto di vista dell'autore e non costituisce alcun consiglio di trading. Gli investimenti sono rischiosi e le decisioni devono essere prese con cautela.<br></em><div><em></em>Questo contenuto è originale e il copyright appartiene a Gate.io. Se hai bisogno di ristamparlo, indica l'autore e la fonte, altrimenti verrà perseguibile legalmente.<br></div><p></p><br></div></div></div>