SnVzdGluIFN1biBiZXdlZXJ0IGRhdCBKU1QgZWVuICdob25kZXJkdm91ZGlnZSBUb2tlbicgemFsIHdvcmRlbiwgd2F0IGRpc2N1c3NpZXMgaW4gaGV0IFRyb24tZWNvc3lzdGVlbSB2ZXJvb3J6YWFrdA==

2025-04-28, 03:12

<p><img src="https://gimg2.gateimg.com/image/article/1745809801hot.png" alt=""><br>Op 27 april 2025 deed <a href="/price/tron-trx" target="_blank" class="blog_inner_link">Tron</a>-oprichter Justin Sun een spraakmakende verklaring op het socialemediaplatform X, waarin hij verklaarde dat de JST (JUST)-token een fundamentele ommekeer heeft ervaren en voorspelde dat het de ‘volgende honderdvoudige token’ zal worden. Deze verklaring wakkerde snel de marktenthousiasme aan en de prijs van JST steeg met 34% binnen 24 uur, tot $0.04310. Justin Sun’s optimistische voorspelling is gebaseerd op JustLend en <a href="/price/usdd-usdd" rel="nofollow noopener noreferrer" target="_blank">USDD</a> De sterke groei van Gate, evenals de belofte van toekomstige terugkoop en vernietiging van JST. Echter, achter de markthype, zijn ook potentiële risico’s en uitdagingen het waard om aandacht aan te besteden.</p>
<h2 id="h2-De20opkomst20van20JST20JustLend20en20USDD20Dualwheel20Drive452909"><a name="De opkomst van JST: JustLend en USDD Dual-wheel Drive" class="reference-link"></a><span class="header-link octicon octicon-link"></span>De opkomst van JST: JustLend en <a href="/price/usdd-usdd" target="_blank" class="blog_inner_link">USDD</a> Dual-wheel Drive</h2><p>Justin Sun wees er in de verklaring op dat het gedecentraliseerde uitleenplatform JustLend, geïncubeerd door JST, is uitgegroeid tot <a href="/price/tron-trx" rel="nofollow noopener noreferrer" target="_blank">Tron</a> De hoeksteen van het ecosysteem, staat bekend als een van de grootste uitleenplatforms met een jaarlijkse nettowinst van tientallen miljoenen dollars. JustLend is vergelijkbaar met <a href="/price/aave-aave" target="_blank" class="blog_inner_link">AAVE</a> op <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a>, waardoor gebruikers activa kunnen lenen via liquiditeitspools. Met de hoge doorvoer en lage transactiekosten van het Tron-netwerk heeft het een groot aantal gebruikers aangetrokken. Volgens eerdere gegevens heeft JustLend’s Total Value Locked (TVL) in 2022 $1,9 miljard bereikt, terwijl de DeFi-ecosysteemactiva van <a href="/price/tron-trx" target="_blank" class="blog_inner_link">Tron</a> in 2023 naar verwachting $8,1 miljard zullen overtreffen, op één na alleen Ethereum.</p>
<p>Ondertussen heeft de door JST geïncubeerde algoritmische stablecoin <a href="/price/usdd-usdd" target="_blank" class="blog_inner_link">USDD</a> ook ‘explosieve groei’ bereikt. In januari 2025 lanceerde Justin Sun USDD 2.0, met een jaarlijks rendement van maximaal 20%, volledig gesubsidieerd door de Tron DAO-reserve. Deze hoogrenderende strategie heeft de adoptie van USDD aanzienlijk bevorderd, waardoor het een kernactivum is geworden in het Tron-ecosysteem. Justin Sun positioneert JST als een combinatie van <a href="/price/aave-aave" target="_blank" class="blog_inner_link">AAVE</a> en MKR in het Tron-ecosysteem, waarbij hij de dubbele rol benadrukt in lenen en stablecoin-governance.</p>
<h2 id="h2-Vertrouwen20in20voorspellingen20van20honderdvoud20Gedreven20door20winst20en20vernietiging20van20terugkoop226094"><a name="Vertrouwen in voorspellingen van honderdvoud: Gedreven door winst en vernietiging van terugkoop" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Vertrouwen in voorspellingen van honderdvoud: Gedreven door winst en vernietiging van terugkoop</h2><p>Justin Sun voorspelt dat de jaarlijkse nettowinst van het JST-ecosysteem tientallen miljoenen dollars heeft bereikt en in 2026 meer dan 100 miljoen dollar zal overtreffen. Hij gelooft dat de huidige waardering van JST ver onder zijn fundamentele waarde ligt en een enorm groeipotentieel heeft. Om de tokenwaarde verder te versterken, heeft Justin Sun beloofd om alle winsten te gebruiken om JST-tokens terug te kopen en te vernietigen om de circulerende voorraad te verminderen. Dit mechanisme lijkt op dat van Binance. <a href="/price/bnb-bnb" rel="nofollow noopener noreferrer" target="_blank">BNB</a> Vernietigingsstrategie kan theoretisch gezien prijzen verhogen door aanpassingen in vraag en aanbod.</p>
<p>De markt heeft sterk gereageerd op de verklaring van Justin Sun. Gegevens van platform X tonen aan dat het handelsvolume van JST is gestegen na de publicatie van de verklaring, waarbij sommige gebruikers optimistisch zijn over het terugkoop- en verbrandingsplan, in de overtuiging dat het beloningen zal opleveren voor langetermijnbezitters. Sommige gebruikers hebben echter gewaarschuwd voor risico’s van kortetermijn overgekocht zijn en adviseerden investeerders om bij dips te kopen om terugvallen te voorkomen.</p>
<h2 id="h2-Potentile20Risicos20Verborgen20Zorgen20over20Stablecoins20en20Transparantie293474"><a name="Potentiële Risico’s: Verborgen Zorgen over Stablecoins en Transparantie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Potentiële Risico’s: Verborgen Zorgen over Stablecoins en Transparantie</h2><p>Ondanks de optimistische voorspellingen van Justin Sun, hebben JST en het Tron-ecosysteem nog steeds te maken met meerdere uitdagingen. Ten eerste, het stabiele algoritme mechanisme van USDD en <a href="/price/terra-luna" rel="nofollow noopener noreferrer" target="_blank">Terra</a> Net als UST heeft UST in 2022 een crash meegemaakt die leidde tot een verlies van $40 miljard. USDD zelf ontkoppelde ook naar $0,97 in december 2022, wat vragen opriep over de transparantie van de reserves. Bovendien steunen de hoge opbrengsten van JustLend en USDD (20%-30% APY) op subsidies van Tron DAO, vergelijkbaar met het <a href="/price/terra-luna" target="_blank" class="blog_inner_link">Terra</a> Anchor-protocol, en de langetermijnduurzaamheid moet nog worden bevestigd.</p>
<p>Transparantieproblemen hebben ook aandacht gekregen. In 2023 wees een analyse erop dat stUSDT (USDT-onderpand) op JustLend betrokken is bij ondoorzichtige activa-operaties, waarbij een grote hoeveelheid USDT in reserve wordt overgedragen naar platforms die gecontroleerd worden door Justin Sun. Bovendien zijn Justin Sun en zijn projecten (zoals Tron en BTT) aangeklaagd door de U.S. Securities and Exchange Commission (SEC) voor vermeende effectenfraude en marktmanipulatie. Deze juridische risico’s kunnen een bedreiging vormen voor de reputatie en ecosysteemontwikkeling van JST.</p>
<h2 id="h2-Marktperspectief285961"><a name="Marktperspectief" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Marktperspectief</h2><p>Justin Sun’s verklaring heeft ongetwijfeld een boost gegeven aan JST, met een rooskleurig vooruitzicht voor investeerders dankzij de snelle groei van het Tron-ecosysteem en het inkoop- en verbrandingsplan. De risico’s van algoritmische stablecoins, de duurzaamheid van hoge rendementen en de uitdagingen op het gebied van transparantie en regulering dienen echter als een herinnering voor de markt om voorzichtig te blijven. Voor investeerders is het cruciaal om de on-chain gegevens van JustLend en USDD, het reserveverslag van Tron DAO en de uitvoering van het inkoopplan nauwlettend in de gaten te houden bij het ueren van het potentieel van JST.</p>
<p>Of JST een ‘honderdvoudige token’ kan worden, heeft nog steeds tijd en marktvalidatie nodig. In het verweven van ambitie en uitdagingen in het Tron-ecosysteem, hebben Justin Sun’s gedurfde woorden een vleugje helderheid aan de cryptomarkt toegevoegd, kansen en reflecties gebracht voor investeerders.</p>
<p>Let op: Dit artikel is gebaseerd op de openbare verklaring van Justin Sun van 27 april 2025 en gerelateerde gegevens. Marktdynamiek kan op elk moment veranderen, dus beleggingen moeten voorzichtig zijn.</p>
<div class="blog-details-info"><br> <div>Auteur: Rooick Z., Gate.io onderzoeker<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen het standpunt van de auteur en vormt geen handelsadvies. Beleggen is riskant en beslissingen moeten voorzichtig worden genomen.<br></em><div><em></em>Deze inhoud is origineel en het auteursrecht behoort toe aan Gate.io. Als u wilt herdrukken, geef dan de auteur en bron aan, anders zal er juridische aansprakelijkheid worden gesteld.<br></div><p></p><br></div></div></div>