VG9rZW4gSlNUOiBMJ0Fzc2V0IFN0YXIgZGVsbCdFY29zaXN0ZW1hIFRST04=

2025-04-28, 06:06

<p><img src="https://gimg2.gateimg.com/image/article/1745819735trading.png" alt=""></p>
<p>Il 27 aprile 2025, Sun Yuchen, il fondatore di <a href="/price/tron-trx" rel="nofollow noopener noreferrer" target="_blank">TRON</a>, ha fatto una dichiarazione sorprendente sulla piattaforma X, affermando che il Token JST ha raggiunto un’inversione fondamentale e ci si aspetta che diventi il ‘prossimo token moltiplicato per cento’. Con questa affermazione, il prezzo del Token JST è aumentato del 34% entro 24 ore, raggiungendo $0.04310, con un volume di scambi in rapida crescita e un entusiasmo di mercato molto alto. Sun Yuchen ha sottolineato che il Token JST, come asset di governance principale dell’ecosistema <a href="/price/tron-trx" target="_blank" class="blog_inner_link">TRON</a>, si basa su<img src="https://gimg2.gateimg.com/image/article/1745819735trading.png" alt="">JustLend e <a href="/price/usdd-usdd" rel="nofollow noopener noreferrer" target="_blank">USDD</a> La forte performance sta dimostrando un enorme potenziale di crescita.</p>
<h2 id="h2-Cos20il20Token20JST705646"><a name="Cos’è il Token JST?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Cos’è il Token JST?</h2><p>Il token JST (JUST) è il token di governance nativo della piattaforma Just sulla blockchain TRON, con l’obiettivo di sostenere l’ecosistema della finanza decentralizzata (DeFi) e delle stablecoin. I detentori di JST possono partecipare alle decisioni di governance della piattaforma Just, come ad esempio l’aggiustamento dei tassi di interesse di JustLend o dei parametri di garanzia di <a href="/price/usdd-usdd" rel="nofollow noopener noreferrer" target="_blank">USDD</a>. Sin dal suo lancio nel 2020, il Token JST è cresciuto fino a diventare un pilastro dell’ecosistema DeFi TRON, strettamente legato al successo di JustLend e <a href="/price/usdd-usdd" target="_blank" class="blog_inner_link">USDD</a>.</p>
<p>Sun Yuchen confronta il Token JST con <a href="/price/aave-aave" rel="nofollow noopener noreferrer" target="_blank">AAVE</a> Una combinazione con MakerDAO, enfatizzando il suo duplice ruolo nel prestito e nella governance della stablecoin. Prevede che il reddito annuale dell’ecosistema JST supererà i 100 milioni di dollari USA nel 2026 e promette di ricomprare e distruggere tutti i token JST con tutti i profitti per ridurre l’offerta circolante e aumentare il valore a lungo termine. Questo meccanismo deflazionistico è simile a quello di Binance. <a href="/price/bnb-bnb" rel="nofollow noopener noreferrer" target="_blank">BNB</a> Le strategie hanno suscitato ampie discussioni sul mercato riguardo al potenziale di investimento del token JST.</p>
<h2 id="h2-Motore20di20crescita20del20token20JST570264"><a name="Motore di crescita del token JST" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Motore di crescita del token JST</h2><h3 id="h3-JustLend20Il20leader20del20TRON20DeFi75221"><a name="JustLend: Il leader del TRON DeFi" class="reference-link"></a><span class="header-link octicon octicon-link"></span>JustLend: Il leader del <a href="/price/tron-trx" target="_blank" class="blog_inner_link">TRON</a> DeFi</h3><p>JustLend è una piattaforma di prestito decentralizzata nell’ecosistema TRON, che consente agli utenti di fornire asset ai pool di liquidità o di prendere in prestito contro garanzia. Con l’alta capacità di elaborazione di oltre 2000 transazioni al secondo (TPS) sulla blockchain TRON e commissioni di transazione basse fino a una frazione di un centesimo, JustLend offre un rendimento percentuale annuo (APY) fino al 30%, attirando una grande quantità di liquidità. Nel 2022, il suo valore totale bloccato (TVL) ha raggiunto 1,9 miliardi di dollari statunitensi, e Justin Sun afferma che il profitto netto annuo della piattaforma si attesta su decine di milioni di dollari.</p>
<p>Il token JST svolge un ruolo di governance in JustLend, consentendo ai detentori di votare su parametri chiave come i tassi di interesse e i rapporti di collaterale. Con il continuo aumento della base utenti e dell’importo bloccato di JustLend, ci si aspetta che la domanda e il valore del token JST aumentino ulteriormente. Tuttavia, l’alto rendimento dipende dal sostegno del TRON DAO e per garantire la sostenibilità a lungo termine sono necessarie ulteriori verifiche dei dati.</p>
<h3 id="h3-USDD20Crescita20esplosiva20delle20stablecoin20algoritmiche390874"><a name="USDD: Crescita esplosiva delle stablecoin algoritmiche" class="reference-link"></a><span class="header-link octicon octicon-link"></span>USDD: Crescita esplosiva delle stablecoin algoritmiche</h3><p>USDD è una stablecoin algoritmica lanciata da TRON nel 2022, mantenendo un ancoraggio di 1 USD attraverso un meccanismo di arbitraggio e riserve del TRON DAO (includendo asset come TRX, BTC). La <a href="/price/usdd-usdd" target="_blank" class="blog_inner_link">USDD</a> 2.0 lanciata nel 2025 ha attirato un gran numero di utenti con un APY del 20%, diventando un asset principale nell’ecosistema di TRON. Justin Sun ha dichiarato che la ‘crescita esplosiva’ di USDD ha ulteriormente solidificato il valore di governance del token JST. Tuttavia, il meccanismo algoritmico di USDD e <a href="/price/terra-luna" rel="nofollow noopener noreferrer" target="_blank">Terra</a> Simile a UST, quest’ultimo è crollato nel 2022, causando una perdita di $40 miliardi. Anche USDD si è scollegato a $0.97 a dicembre 2022, con rapporti nel 2023 che mettono in discussione la trasparenza delle sue riserve stUSDT, indicando flussi di fondi verso piattaforme controllate da Justin Sun. Questi eventi ricordano agli investitori che il futuro del token JST è strettamente legato alla stabilità di USDD.</p>
<h2 id="h2-Meccanismo20di20Riacquisto20e20Bruciatura20Potenziale20di20Deflazione20del20Token20JST535150"><a name="Meccanismo di Riacquisto e Bruciatura: Potenziale di Deflazione del Token JST" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Meccanismo di Riacquisto e Bruciatura: Potenziale di Deflazione del Token JST</h2><p>Sun Yuchen ha promesso di utilizzare tutti i profitti di JustLend e USDD per ricomprare e distruggere il token JST, riducendo l’offerta circolante, il che teoricamente potrebbe far aumentare il prezzo del token. Questo meccanismo è stato di successo nel <a href="/price" rel="nofollow noopener noreferrer" target="_blank">mercato criptovalutario</a>, ad esempio, Binance ha aumentato significativamente il valore di <a href="/price/bnb-bnb" rel="nofollow noopener noreferrer" target="_blank">BNB</a> attraverso il bruciare. Gli utenti sulla piattaforma X hanno risposto positivamente a questo piano, con alcuni che credono che l’effetto deflazionistico del token JST attirerà investitori a lungo termine.</p>
<p>Tuttavia, l’esecuzione di riacquisti e bruciature dipende dall’effettiva capacità redditizia dell’ecosistema. La parte ad alto rendimento di JustLend e USDD proviene dai sussidi del TRON DAO. Se l’ambiente di mercato peggiora o se i sussidi vengono ridotti, i profitti potrebbero essere limitati. Inoltre, Justin Sun non ha ancora divulgato dati finanziari dettagliati pubblicamente, gli investitori devono monitorare attentamente i rapporti sulle riserve del TRON DAO e l’esecuzione dei riacquisti per valutare il potenziale di deflazione del Token JST.</p>
<h2 id="h2-Ecosistema20TRON20solido20supporto20al20token20JST637330"><a name="Ecosistema TRON: solido supporto al token JST" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Ecosistema TRON: solido supporto al token JST</h2><p>Il valore del token JST è inscindibile dal supporto della blockchain TRON. Fondata da Justin Sun nel 2017, TRON è nota per le sue alte prestazioni e bassi costi, utilizzando il meccanismo Delegated Proof of Stake (DPoS). Entro il 2025, TRON ha oltre 10 milioni di utenti attivi al giorno, guidando l’industria nel numero di DApp. Il valore totale bloccato del suo ecosistema DeFi ha superato gli 8,1 miliardi di dollari nel 2023, secondo solo a <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a>.</p>
<p>L’ecosistema diversificato di TRON fornisce ampi scenari di applicazione per il token JST:</p>
<ul>
<li>Ecosistema DeFi: JustLend, SunSwap e JustStable formano un sistema finanziario completo, supportando servizi di prestito, trading e stablecoin.</li><li>Contenuto e Intrattenimento: Acquisendo <a href="/price/bittorrent-btt" rel="nofollow noopener noreferrer" target="_blank">BitTorrent</a>, TRON avvia i token BTFS e BTT per sostenere lo storage decentralizzato e il mercato NFT.</li><li>Collaborazione globale: Collaborare con giganti come Samsung, Opera, ecc., integrando TRX e l’ecosistema TRON nelle applicazioni mainstream, specialmente nei mercati asiatici e latinoamericani.</li></ul>
<p>I vantaggi tecnici di TRON e la distribuzione globale forniscono una solida base per la crescita del token JST, ma la governance centralizzata (molti super rappresentanti sono strettamente legati a Justin Sun) e la pressione regolamentare possono influenzare la fiducia nell’ecosistema.</p>
<h2 id="h2-Conclusione135472"><a name="Conclusione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusione</h2><p>Il token JST, come asset principale dell’ecosistema TRON DeFi, ha mostrato un significativo potenziale di investimento con la forte performance di JustLend e USDD, oltre al meccanismo di riacquisto e bruciatura promesso da Justin Sun. Il blockchain ad alte prestazioni di TRON e le diverse applicazioni forniscono un solido supporto per il token JST, in particolare nei campi DeFi e dei contenuti. Tuttavia, i rischi legati agli stablecoin algoritmici, alla sostenibilità dei rendimenti elevati, alle questioni di trasparenza e alle pressioni regolamentari ricordano agli investitori di rimanere cauti.</p>
<div class="blog-details-info"><br><div>Autore: Rooick Z., Ricercatore Gate.io<br><div class="info-tips"><em>Questo articolo rappresenta solo l'opinione 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 e il copyright appartiene a Gate.io. Se è necessario ristampare, si prega di indicare l'autore e la fonte, altrimenti saranno perseguite responsabilità legali.<br></div><p></p><br></div></div></div>