SlNULXRva2VuOiBIZXQgc3RlcnJlbnZlcm1vZ2VuIHZhbiBoZXQgVFJPTi1lY29zeXN0ZWVt

2025-04-28, 06:06

<p><img src="https://gimg2.gateimg.com/image/article/1745819735trading.png" alt=""></p>
<p>Op 27 april 2025, Sun Yuchen, de oprichter van <a href="/price/tron-trx" rel="nofollow noopener noreferrer" target="_blank">TRON</a>, heeft een verbluffende verklaring afgelegd op het Gate-platform waarin wordt beweerd dat de JST-token een fundamentele ommekeer heeft bereikt en wordt verwacht de ‘volgende honderdvoudige token’ te worden. Met deze verklaring steeg de prijs van de JST-token met 34% binnen 24 uur, tot $0.04310, waarbij de handelsvolumes sterk stegen en de marktenthousiasme hoog was. Sun Yuchen wees erop dat de JST-token, als de kerngovernance-asset van het <a href="/price/tron-trx" target="_blank" class="blog_inner_link">TRON</a>-ecosysteem, vertrouwt op<img src="https://gimg2.gateimg.com/image/article/1745819735trading.png" alt="">JustLend en <a href="/price/usdd-usdd" rel="nofollow noopener noreferrer" target="_blank">USDD</a> De sterke prestaties tonen een enorm groeipotentieel aan.</p>
<h2 id="h2-Wat20is20JST20Token872779"><a name="Wat is JST Token?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wat is JST Token?</h2><p>JST-token (JUST) is de inheemse bestuurstoken van het Just-platform op de TRON-blockchain, met als doel de ondersteuning van gedecentraliseerde financiën (DeFi) en de stablecoin-ecosysteem. JST-houders kunnen deelnemen aan bestuursbeslissingen van het Just-platform, zoals het aanpassen van de rentetarieven van JustLend of de onderpandparameters van <a href="/price/usdd-usdd" rel="nofollow noopener noreferrer" target="_blank">USDD</a> Sinds de lancering in 2020 is JST Token uitgegroeid tot een pijler van het <a href="/price/tron-trx" target="_blank" class="blog_inner_link">TRON</a> DeFi-ecosysteem, nauw verbonden met het succes van JustLend en <a href="/price/usdd-usdd" target="_blank" class="blog_inner_link">USDD</a>.</p>
<p>Sun Yuchen vergelijkt JST Token met <a href="/price/aave-aave" rel="nofollow noopener noreferrer" target="_blank">AAVE</a> Een combinatie met MakerDAO, waarbij de nadruk ligt op zijn dubbele rol in lenen en stablecoin-governance. Hij voorspelt dat de jaarlijkse omzet van het JST-ecosysteem in 2026 meer dan 100 miljoen Amerikaanse dollars zal bedragen, en belooft alle JST-tokens terug te kopen en te vernietigen met alle winsten om de circulatievoorraad te verminderen en de langetermijnwaarde te verhogen. Dit deflatiemechanisme is vergelijkbaar met dat van Binance. <a href="/price/bnb-bnb" rel="nofollow noopener noreferrer" target="_blank">BNB</a> Strategieën hebben in de markt breeduit discussies aangewakkerd over het investeringspotentieel van de JST-token.</p>
<h2 id="h2-JSTtokens20groeimotor689534"><a name="JST-token’s groeimotor" class="reference-link"></a><span class="header-link octicon octicon-link"></span>JST-token’s groeimotor</h2><h3 id="h3-JustLend20De20leider20van20TRON20DeFi315800"><a name="JustLend: De leider van TRON DeFi" class="reference-link"></a><span class="header-link octicon octicon-link"></span>JustLend: De leider van TRON DeFi</h3><p>JustLend is een gedecentraliseerd uitleenplatform in het TRON-ecosysteem, waarmee gebruikers activa aan liquiditeitspools kunnen verstrekken of kunnen lenen tegen onderpand. Met een hoge doorvoer van meer dan 2000 transacties per seconde (TPS) op de TRON-blockchain en transactiekosten zo laag als een fractie van een cent, biedt JustLend een jaarlijks rendement van maximaal 30% (APY) en trekt het een grote hoeveelheid liquiditeit aan. In 2022 heeft de totale waarde die is vergrendeld (TVL) 1,9 miljard Amerikaanse dollars bereikt, en Justin Sun beweert dat de jaarlijkse nettowinst van het platform in de tientallen miljoenen dollars ligt.</p>
<p>JST Token speelt een governance rol in JustLend, waardoor houders kunnen stemmen over belangrijke parameters zoals rentetarieven en onderpandratio’s. Naarmate de gebruikersbasis en het lock-up bedrag van JustLend blijven groeien, wordt verwacht dat de vraag en waarde van JST Token verder zullen toenemen. De hoge opbrengst is echter afhankelijk van de subsidie van TRON DAO, en meer gegevensverificatie is nodig voor langetermijnduurzaamheid.</p>
<h3 id="h3-USDD20Explosieve20groei20van20algoritmische20stablecoins933890"><a name="USDD: Explosieve groei van algoritmische stablecoins" class="reference-link"></a><span class="header-link octicon octicon-link"></span>USDD: Explosieve groei van algoritmische stablecoins</h3><p>USDD is een algoritmische stablecoin gelanceerd door TRON in 2022, met behoud van een peg van 1 USD via arbitrage mechanisme en TRON DAO-reserves (inclusief activa zoals TRX, BTC). De <a href="/price/usdd-usdd" target="_blank" class="blog_inner_link">USDD</a> 2.0 gelanceerd in 2025 trok een groot aantal gebruikers aan met een 20% APY, en werd een kernactivum in het TRON-ecosysteem. Justin Sun verklaarde dat de ‘explosieve groei’ van USDD de governance waarde van de JST-token verder heeft versterkt. Echter, het algoritmische mechanisme van USDD en <a href="/price/terra-luna" rel="nofollow noopener noreferrer" target="_blank">Terra</a> Vergelijkbaar met UST, stortte laatstgenoemde in 2022 in, waardoor een verlies van $40 miljard ontstond. USDD koppelde ook los naar $0,97 in december 2022, met meldingen in 2023 die de transparantie van zijn stUSDT-reserves in twijfel trekken en wijzen op geldstromen naar platforms die worden gecontroleerd door Justin Sun. Deze gebeurtenissen herinneren investeerders eraan dat de toekomst van de JST-token nauw verbonden is met de stabiliteit van USDD.</p>
<h2 id="h2-Terugkoop20en20verbrandingsmechanisme20JST20Tokens20deflatiepotentieel153442"><a name="Terugkoop- en verbrandingsmechanisme: JST Token’s deflatiepotentieel" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Terugkoop- en verbrandingsmechanisme: JST Token’s deflatiepotentieel</h2><p>Sun Yuchen heeft beloofd om alle winsten van JustLend en USDD te gebruiken om de JST-token terug te kopen en te vernietigen, waardoor de circulerende voorraad theoretisch gezien kan worden verminderd, wat de tokenprijs zou kunnen opdrijven. Dit mechanisme is succesvol geweest in de <a href="/price" rel="nofollow noopener noreferrer" target="_blank">crypto markt</a>, bijvoorbeeld, Binance heeft aanzienlijk de waarde van <a href="/price/bnb-bnb" rel="nofollow noopener noreferrer" target="_blank">BNB</a> door verbranding. Gebruikers op het X-platform hebben positief gereageerd op dit plan, waarbij sommigen geloven dat het deflatoire effect van JST-token lange termijn investeerders zal aantrekken.</p>
<p>Echter is de uitvoering van terugkopen en verbrandingen afhankelijk van de daadwerkelijke winstgevendheid van het ecosysteem. Het hoge opbrengstgedeelte van JustLend en USDD komt voort uit TRON DAO-subsidies. Als de marktomgeving verslechtert of subsidies worden verminderd, kunnen de winsten beperkt zijn. Daarnaast heeft Justin Sun geen gedetailleerde financiële gegevens openbaar gemaakt, investeerders moeten de TRON DAO-reserverapporten en terugkoopuitvoering nauwlettend in de gaten houden om het deflatiepotentieel van de JST Token te beoordelen.</p>
<h2 id="h2-TRONecosysteem20JST20Tokens20solide20ondersteuning597404"><a name="TRON-ecosysteem: JST Token’s solide ondersteuning" class="reference-link"></a><span class="header-link octicon octicon-link"></span>TRON-ecosysteem: JST Token’s solide ondersteuning</h2><p>De waarde van JST Token is onlosmakelijk verbonden met de ondersteuning van de TRON-blockchain. TRON, opgericht door Justin Sun in 2017, staat bekend om zijn hoge prestaties en lage kosten, met behulp van het Delegated Proof of Stake (DPoS)-mechanisme. Tegen 2025 heeft TRON meer dan 10 miljoen dagelijkse actieve gebruikers, waarmee het de industrie leidt in het aantal DApps. De totale vergrendelde waarde van het DeFi-ecosysteem bedroeg in 2023 meer dan $ 8,1 miljard, de op één na <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a>.</p>
<p>TRON’s diverse ecosysteem biedt brede toepassingsscenario’s voor JST Token:</p>
<ul>
<li>DeFi-ecosysteem: JustLend, SunSwap en JustStable vormen een compleet financieel systeem, met ondersteuning voor lenen, handelen en stablecoin-diensten.</li><li>Content and Entertainment: Door het verwerven <a href="/price/bittorrent-btt" rel="nofollow noopener noreferrer" target="_blank">BitTorrent</a>, TRON lanceert BTFS en BTT tokens om gedecentraliseerde opslag en de NFT-markt te ondersteunen.</li><li>Mondiale samenwerking: Samenwerken met giganten zoals Samsung, Opera, enz., integreren TRX en TRON-ecosysteem in mainstream toepassingen, vooral in Aziatische en Latijns-Amerikaanse markten.</li></ul>
<p>TRON’s technische voordelen en wereldwijde lay-out bieden een solide basis voor de groei van JST Token, maar gecentraliseerd bestuur (veel supervertegenwoordigers zijn nauw verwant aan Justin Sun) en regelgevende druk kunnen het vertrouwen in het ecosysteem beïnvloeden.</p>
<h2 id="h2-Conclusie284925"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>JST Token, als de kernactiva van het TRON DeFi-ecosysteem, heeft een aanzienlijk investeringspotentieel laten zien met de sterke prestaties van JustLend en USDD, evenals het inkoop- en verbrandingsmechanisme beloofd door Justin Sun. De hoogwaardige blockchain van TRON en diverse toepassingen bieden solide ondersteuning voor de JST Token, vooral in de DeFi- en contentvelden. Risico’s van algoritmische stablecoins, duurzaamheid van hoge rendementen, transparantieproblemen en regelgevingsdruk herinneren investeerders eraan voorzichtig te blijven.</p>
<div class="blog-details-info"><br><div>Auteur: Rooick Z., Gate.io-onderzoeker<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de mening van de auteur en vormt geen handelsadvies. Beleggen brengt risico's met zich mee 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 zullen er juridische verantwoordelijkheden worden nagestreefd.<br></div><p></p><br></div></div></div>