RkRVU0QgQ3Jpc2lzOiBBbm90aGVyIFRydXN0IFRlc3QgaW4gdGhlIFN0YWJsZWNvaW4gTWFya2V0

<p><img src="https://gimg2.gateimg.com/image/article/1743659496HOTSPOT.png" alt=""></p>
<h2 id="h2-Introductie662328"><a name="Introductie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introductie</h2><p>Op 3 april 2025 werd de cryptocurrency-markt opnieuw opgeschud door een stablecoin. Deze keer was de hoofdrolspeler FDUSD (First Digital USD), een op de Amerikaanse dollar gekoppelde stablecoin uitgegeven door First Digital Trust (FDT), een Hongkongs vertrouwensbedrijf. Explosieve beschuldigingen door <a href="/price/tron-trx" target="_blank" class="blog_inner_link">Tron</a>-oprichter Justin Sun brachten FDUSD in de schijnwerpers, waardoor de prijs kortstondig daalde tot $0,87 en marktpaniek veroorzaakte.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1743658840111.png" alt=""></p>
<p>Is dit een opzettelijke lastercampagne, of een blootlegging van diepgewortelde problemen in de stablecoin-industrie? Laten we vanaf het begin beginnen om deze crisis te ontrafelen en de gelegenheid te baat nemen om de operationele principes van stablecoins te begrijpen.</p>
<h2 id="h2-Wat20is20een20stablecoin977590"><a name="Wat is een stablecoin?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wat is een stablecoin?</h2><p>Voordat we op het evenement ingaan, laten we het hebben over wat stablecoins zijn. Stablecoins zijn een soort cryptocurrency die is ontworpen om prijsstabiliteit te behouden, meestal gekoppeld aan fiatvaluta’s zoals de dollar met een verhouding van 1:1. Ze fungeren als een ‘brug’ in de blockchainwereld, waardoor gebruikers ‘stabiele’ activa kunnen aanhouden in de volatiele cryptomarkt voor handels-, betalings- of afdekkingsdoeleinden.</p>
<p>De stabiliteit van stablecoins wordt meestal op de volgende manieren bereikt:</p>
<ol>
<li>Asset-backed: De uitgever houdt een equivalent bedrag aan fiatvaluta of activa (zoals USD, overheidsobligaties) als reserves, die gebruikers te allen tijde kunnen inlossen. Bijvoorbeeld, USDT (<a href="/price/tether-usdt" target="_blank" class="blog_inner_link">Tether</a>) en USDC (Circle) zijn vertegenwoordigers van deze categorie.</li><li>Algorithmisch: Prijsstabilisatie door aanpassing van het aanbod via slimme contracten, zoals de vroege TerraUSD (UST), echter, dergelijke stablecoins dragen hogere risico’s, de UST-crash in 2022 dient als een les.</li><li>Gemengd type: combinatie van activasondersteuning en algoritmische aanpassing, minder gebruikelijk.</li></ol>
<p><img src="https://gimg2.gateimg.com/image/article/1743658882222.png" alt=""></p>
<p>FDUSD behoort tot het eerste type, wat beloofd wordt door FDT om 1:1 gedekt te zijn door Amerikaanse dollars of equivalente activa (zoals Amerikaanse schatkistobligaties). Echter, de ‘stabiliteit’ van stablecoins is niet inherent natuurlijk, maar gebouwd op de reputatie van de uitgever en transparantie van de reserves. Zodra het vertrouwen geschaad is, kan het loskoppelen plaatsvinden - precies wat FDUSD doormaakt.</p>
<h2 id="h2-Achtergrond20van20het20Evenement20Controverse20van20TUSD20naar20FDUSD843793"><a name="Achtergrond van het Evenement: Controverse van TUSD naar FDUSD" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Achtergrond van het Evenement: Controverse van TUSD naar FDUSD</h2><p>FDUSD werd gelanceerd in juni 2023, gesteund door Hong Kong’s FDT, en steeg snel naar de top vier op de stablecoin-markt met een marktkapitalisatie van ongeveer $3,3 miljard. Echter, FDT is niet zonder controverse, aangezien het ook een andere stablecoin beheert, TUSD (<a href="/price/trueusd-tusd" target="_blank" class="blog_inner_link">TrueUSD</a>), die de afgelopen jaren voortdurende problemen heeft ondervonden.</p>
<p>Van 2023 tot begin 2024 maakte TUSD vaak krantenkoppen vanwege kwesties met reservebeheer. Gerechtelijke documenten in Hongkong onthulden dat uitgever van TUSD, Techteryx, te maken had met een financieringstekort van $456 miljoen omdat FDT reserves investeerde in hoogrisico-activa, wat leidde tot vertraagde inlossingen. Tron-oprichter Justin Sun verstrekte noodleningen om TUSD te helpen, maar de relaties met FDT verslechterden daarna. Deze vete zaaide de kiemen van de huidige FDUSD-crisis.</p>
<h2 id="h2-Van20beschuldigingen20tot20marktverstoring832689"><a name="Van beschuldigingen tot marktverstoring" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Van beschuldigingen tot marktverstoring</h2><p>Op 2 april 2025 liet Justin Sun een bom vallen op het X-platform: ‘First Digital Trust is insolvent en kan niet aan zijn verplichtingen tot klantterugbetaling voldoen.’ Hij beweerde dat FDT betrokken was bij een fraude van maximaal $500 miljoen, en dat het vertrouwen in regelgeving in Hong Kong vrijwel niet bestond, en riep op tot gebruikersopnames en regelgevende tussenkomst. Sun kondigde ook een persconferentie aan op 3 april om meer bewijs te onthullen.</p>
<p>Deze beschuldiging richt zich rechtstreeks op de levensader van FDUSD - als FDT echt failliet gaat, zijn de USD-reserves van FDUSD dan veilig? De markt verviel snel in paniek.</p>
<h3 id="h3-FDUSD20ontkoppeling20en20verkoop951191"><a name="FDUSD ontkoppeling en verkoop" class="reference-link"></a><span class="header-link octicon octicon-link"></span>FDUSD ontkoppeling en verkoop</h3><p>Na de bekendmaking ontkoppelde de prijs van FDUSD snel. Op 2 april daalde het zelfs tot $0.87 (vergeleken met USDT) en raakte zelfs kort $0.76 (vergeleken met USDC), met een daling tot wel 12%-24%. Het handelsvolume van 24 uur steeg naar $5.9 miljard, waarbij veel gebruikers FDUSD verkochten om risico’s te vermijden.</p>
<h3 id="h3-FDT20tegenaanval405374"><a name="FDT tegenaanval" class="reference-link"></a><span class="header-link octicon octicon-link"></span>FDT tegenaanval</h3><p>In het gezicht van de crisis heeft FDT snel een verklaring uitgegeven op de avond van 2 april: ‘De beschuldigingen tegen Justin Sun zijn puur geruchten, niet gerelateerd aan FDUSD, alleen betrokken bij TUSD. We hebben volledige solvabiliteit, met de 20,4 miljard circulatie van FDUSD gedekt door activa zoals 20 miljard Amerikaanse schatkistpapier.’ Ze beschuldigen Sun van het verspreiden van FUD (angst, onzekerheid en twijfel) en kondigen juridische stappen aan, terwijl ze van plan zijn om op 3 april om 16:00 (Hong Kong tijd) een AMA te houden in X Spaces voor publieke verduidelijking.</p>
<h2 id="h2-Waarom20zijn20stablecoins20vatbaar20voor20destabilisatie441375"><a name="Waarom zijn stablecoins vatbaar voor ‘destabilisatie’?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Waarom zijn stablecoins vatbaar voor ‘destabilisatie’?</h2><p>Het loskoppelen van FDUSD is geen geïsoleerd g. In 2022 ging TerraUSD naar nul als gevolg van een algoritme storing, en in 2023 daalde USDC kortstondig naar 0.88 USD als gevolg van de crisis bij de Silicon Valley bank. Gemeenschappelijke redenen voor de instabiliteit van stablecoins zijn:</p>
<ul>
<li>Onvoldoende reserves of gebrek aan transparantie: de uitgever heeft niet voldoende activa of investeert in hoogrisicoproducten.</li><li>Marktpaniek: een run die een verkoopgolf veroorzaakt, zelfs als de reserves worden aangevuld, is het misschien niet genoeg om op tijd te reageren.</li><li>Gebrek aan regulering: Veel stablecoin-uitgevers opereren buiten de traditionele financiële regulering, en vertrouwen uitsluitend op zelfopenbaarmaking voor vertrouwen.</li></ul>
<p>Bij het FDUSD-incident raakten de beschuldigingen van Sun rechtstreeks de basis van vertrouwen, en of FDT zijn onschuld kan bewijzen zal zijn lot bepalen.</p>
<h2 id="h2-Toekomstperspectief20van20FDUSD164533"><a name="Toekomstperspectief van FDUSD" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Toekomstperspectief van FDUSD</h2><p>Korte termijn: FDT’s AMA en Suns persconferentie zullen cruciaal zijn. Als FDT transparante reserves kan aantonen, kan FDUSD terugkeren naar 1 USD; als Sun concrete bewijzen presenteert, kan dit een grotere crisis veroorzaken. Lange termijn: Regulering van stablecoins in Hong Kong kan het concurrentielandschap in de sector veranderen door het succes of falen van FDUSD. USDT, USDC en zelfs <a href="/price/usdd-usdd" target="_blank" class="blog_inner_link">USDD</a> kunnen hiervan profiteren.</p>
<p>De FDUSD-crisis is een ander toonbeeld van vertrouwen en risico in de stablecoin-markt. Technisch gezien zijn stablecoins de hoeksteen van de blockchain-economie; maar in werkelijkheid hangt hun stabiliteit af van het spel tussen menselijke aard en regulering.</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 enkel handelsadvies. Beleggen brengt risico's met zich mee, beslissingen moeten voorzichtig worden genomen.<br></em><div><em></em>Dit artikel is origineel en het auteursrecht behoort toe aan Gate.io. Geef de auteur en bron aan als u wilt herdrukken, anders zullen er juridische verantwoordelijkheden worden nagestreefd.<br></div><p></p><br></div></div></div>