U3RhYmxlY29pbnMgemlqbiBuaWV0IGxhbmdlciBzdGFiaWVsLCB3YXQgaXMgZXIgZ2ViZXVyZCBtZXQgRkRVU0Q/

2025-04-08, 06:30

<p><img src="https://gimg2.gateimg.com/image/article/1744093526INDUSTRYANALYSIS.png" alt=""></p>
<h2 id="h2-TLDR982778"><a name="[TL;DR]:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL;DR]:</h2><p>Onlangs beschuldigde Justin Sun First Digital Trust van faillissement, waardoor de Amerikaanse dollar-stalcoin FDUSD tijdelijk losgekoppeld werd tot $0,8799. Later steeg het weer naar boven $0,9980 vanwege de officiële verklaring dat de inwisseling stabiel was.</p>
<p>Als de kernstabiele munt van een bekend uitwisselingsecosysteem, is de opkomst van FDUSD nauw verbonden met zijn strategische ondersteuning.</p>
<p>Het loskoppelen van FDUSD onthulde problemen zoals onvoldoende transparantie van stablecoins, regelgevende mazen en fragiel marktvertrouwen.</p>
<h2 id="h2-Kennismaking572018"><a name="Kennismaking" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Kennismaking</h2><p>Telkens wanneer de markt in een bearish paniek terechtkomt, zal de stablecoin-track altijd te maken krijgen met een crisis van loskoppeling, net zoals wanneer <a href="/price/terra-luna" rel="nofollow noopener noreferrer" target="_blank">Terra</a> (UST) onderging een neerwaartse spiraal tijdens de laatste cyclus van stier- en berenmarkten. Onlangs, toen de markt zwak en kwetsbaar was, beschuldigde Justin Sun First Digital Trust ervan insolvent te zijn en FDUSD direct met 20% te hebben ontvlochten, waardoor de toch al gevoelige zenuwen van de markt opnieuw gespannen raakten.</p>
<h2 id="h2-Panoramisch20Verslag20van20FDUSD20Ontkoppelingsevenement741414"><a name="Panoramisch Verslag van FDUSD Ontkoppelingsevenement" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Panoramisch Verslag van FDUSD Ontkoppelingsevenement</h2><p>“First Digital Trust is eigenlijk failliet!” Om 22:17 op 2 april plaatste Justin Sun deze tweet op het X-platform, wat de stablecoin-markt onmiddellijk deed ontploffen als een dieptebom.<img src="https://gimg2.gateimg.com/image/article/17440935881.jpeg" alt=""><br>Bron: @justinsuntron</p>
<p>De prijs van het handelspaar FDUSD/USDT daalde snel op grote beurzen, waarbij Gate.io een minimale daling van 0,8799 USDT liet zien, een daling van 12%. Tijdens deze periode detecteerde het algoritmische handelssysteem van market maker Wintermute abnormale schommelingen en activeerde automatisch een verkooporder van $120 miljoen om zijn positie te beschermen.<br><img src="https://gimg2.gateimg.com/image/article/17440936062.jpeg" alt=""><br>Bron: Gate.io</p>
<p>De beschuldiging van Justin Sun is niet ongegrond. De lont van deze storm kan worden teruggeleid tot drie weken geleden. Op 14 maart toonden de documenten van de zaak Techteryx v. Aria Commodities die door de rechtbank van Hong Kong werden onthuld, dat de $456 miljoen reserve die werd aangehouden door de TUSD-operator via First Digital Trust illegaal werd overgeboekt naar de Dubai-entiteit Aria DMCC. Hoewel Justin Sun oorspronkelijk een noodlening verstrekte aan Techteryx in zijn persoonlijke naam om het gat te vullen, zijn de marktzenuwen zeer gespannen geworden - immers, slechts een half jaar geleden bereikte TUSD, dat ook behoort tot het TrueCoin-systeem, een schikking van $500.000 met de SEC vanwege “misbruik van reservefondsen.” Toen de paniek zich verspreidde naar FDUSD, heeft First Digital Trust snel een verklaring uitgegeven waarin de geruchten over faillissement krachtig werden ontkend, waarbij werd benadrukt dat FDUSD met een marktwaarde van $2,5 miljard volledig wordt gedekt door Amerikaanse schatkistobligaties 1:1, en de International Securities Identification Number (ISIN) van de reserve openbaar werd gemaakt om de transparantie te tonen.</p>
<p>Ondertussen heeft een grote beurs, als de grootste voorstander van FDUSD, ook goed nieuws vrijgegeven via onofficiële kanalen. Een lid, SiSi, zei in een gebruikersgroep: ‘FDUSD kan worden geaccepteerd tegen een verhouding van 1:1.’ Deze verklaring werd de volgende ochtend officieel aangekondigd en verspreidde zich snel in de gemeenschap, wat het vertrouwen van sommige investeerders stabiliseerde.<img src="https://gimg2.gateimg.com/image/article/17440936263.jpeg" alt=""><br>Bron: @FirstDigitalHQ</p>
<p>Om 7:00 uur op 3 april kondigde het platform de controlegegevens van Prescient Assurance aan, waarbij werd benadrukt dat FDUSD-reserves Amerikaanse staatsobligaties en overnachtingsdeposito’s omvatten, en beloofde binnen twee weken een updateverslag van maart vrij te geven. Na het nieuws steeg de prijs van FDUSD binnen twee uur van $0,98 naar $0,995, maar de inkoopdruk van $60 miljoen heeft een blijvende korting veroorzaakt.</p>
<h2 id="h2-Roem20Brengt20Problemen20FDUSD20van20Hong20Kong20Label20naar20Regelgevende20Arbitrage363193"><a name="Roem Brengt Problemen: FDUSD van Hong Kong Label naar Regelgevende Arbitrage" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Roem Brengt Problemen: FDUSD van Hong Kong Label naar Regelgevende Arbitrage</h2><p>De wortel van de FDUSD-crisis kan worden herleid tot het geschil tussen FDT en Justin Sun vijf jaar geleden. FDUSD wordt uitgegeven door First Digital Trust Limited (FDT), een trustmaatschappij geregistreerd in Hong Kong. Het is gepositioneerd als een digitale activa gekoppeld aan de Amerikaanse dollar in een verhouding van 1:1, en de reserves zijn gedekt door contanten of Amerikaanse schatkistobligaties. De moedermaatschappij, First Digital Group, kan haar geschiedenis herleiden tot Legacy Trust, dat werd opgericht in 1992. Haar klanten omvatten traditioneel kapitaal, zoals het familiekantoor van Li Ka-shing. Deze grensoverschrijdende achtergrond heeft FDUSD snel populair gemaakt bij instellingen.<img src="https://gimg2.gateimg.com/image/article/17440936634.jpeg" alt=""><br>Bron: CoinDesk</p>
<p>In 2019 werd FDT afgesplitst van Legacy Trust als een onafhankelijke entiteit en voltooide een financieringsronde van $20 miljoen in mei 2022. Investeerders waren onder andere de vroege investeerder van Telegram Nogle en het in Hong Kong gevestigde durfkapitaalfonds Kenetic Capital.</p>
<p>In 2020 heeft FDT het beheer van de reserves van de stablecoin TUSD overgenomen. Volgens gerechtelijke documenten heeft FDT tussen 2022 en 2023 $456 miljoen aan reserves overgeboekt van het Aria Fund op de Kaaimaneilanden naar de entiteit Aria DMCC in Dubai, waarvan de feitelijke controleur gerelateerd is aan FDT-utives. Waar zijn de fondsen uiteindelijk terechtgekomen? Uit de aanklacht blijkt dat $15 miljoen van de fondsen is gebruikt om illegale leningen te verstrekken aan FDT-utives, en de rest van de fondsen werd verdacht van investeringen in risicovolle productie-installaties en mijnbouwprojecten.</p>
<p>Justin Sun’s betrokkenheid begon in 2022. Op dat moment eiste Techteryx (TUSD uitgever) fondsen van FDT vanwege mislukte terugkoop. Het weigeren van Aria om terug te kopen leidde tot een tekort aan TUSD. Justin Sun verstrekte vervolgens een noodlening op persoonlijke titel om het gat te vullen, maar de betreffende fondsen zijn tot op heden niet terugbetaald. Deze schuld werd uiteindelijk de lont in het kruitvat voor Justin Sun om FDT aan te vallen.<img src="https://gimg2.gateimg.com/image/article/17440937085.jpeg" alt=""><br>Bron: ethersan.io</p>
<p>In juni 2023 werd FDUSD officieel gelanceerd, net toen Hong Kong een licentiesysteem lanceerde voor aanbieders van virtuele activadiensten. Deze samenloop gaf FDUSD een sterk ‘Hong Kong label’ vanwege de diepe binding met een grote beurs, ongeveer 94% (ongeveer $2,35 miljard) van de totale marktwaarde van $2,5 miljard wordt door hen aangehouden. Deze zeer geconcentreerde afhankelijkheid heeft FDUSD doen opbloeien van obscuriteit tot een toonaangevende speler op de stabiele markt voor munten.</p>
<h2 id="h2-Waarom20zijn20stablecoins20noch20stabiel20noch20transparant349669"><a name="Waarom zijn stablecoins noch stabiel noch transparant?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Waarom zijn stablecoins noch stabiel noch transparant?</h2><p>Naar mijn mening heeft de ‘stabiliteit’ van stablecoins nooit uitsluitend geleund op activareserves, maar meer op transparantie en informatiepariteit.</p>
<p>Voor zover de tot nu toe beschikbare openbare informatie bekend is, heeft FDT weliswaar zijn ISIN-nummer bekendgemaakt, maar heeft het zijn activasamenstelling en liquiditeitsstatus niet in detail bekendgemaakt, waardoor het moeilijk is voor de buitenwereld om zijn ware solvabiliteit te verifiëren. In deze context kan de verklaring van Justin Sun dat het ‘insolvent’ is, paniekverkopen veroorzaken, wat laat zien hoe kwetsbaar het vertrouwen van investeerders in FDT is onder invloed van informatieasymmetrie en externe verhalen.<img src="https://gimg2.gateimg.com/image/article/17440937676.jpeg" alt=""><br>Bron: @FirstDigitalHQ</p>
<p>Op een dieper niveau heeft het FDUSD-incident ook een regelgevingsvacuüm blootgelegd. Lid van de Wetgevende Raad van Hong Kong, Wu Jiezhuang, wees erop dat het FDT-incident het gebrek aan toezicht op trustmaatschappijen in <a href="/web3" rel="nofollow noopener noreferrer" target="_blank">Web3</a> veld en stelde voor om ‘vertrouwen’ op te nemen in wettelijk toezicht. Dit onthult het regelgevende dilemma van offshore financiële centra: de huidige ‘Anti-Money Laundering Ordinance’ vereist alleen dat virtuele activiteitendienstverleners een vergunning hebben, maar mist gedetailleerde regels over vermogensisolatie en investeringsbereik van stablecoin-bewaarders.</p>
<p>Wat meer waakzaamheid verdient, is grensoverschrijdende regelgevingsarbitrage. De handelsfinancieringsactiviteiten van Aria DMCC in Dubai bevinden zich tolig in het grijze gebied van de financiële regelgeving van de VAE. Toen de reserve van $ 456 miljoen werd geïnvesteerd in fysieke projecten zoals Indonesische nikkelmijnen en Vietnamese havens, omzeilde het niet alleen de herziening van de Amerikaanse OFAC-sanctielijst, maar omzeilde het ook de regels voor de bewaring van virtuele activa in Hong Kong. Deze strategie van “compliance-depressie” is een typisch pad voor de wereldwijde <a href="/price/flow-flow" rel="nofollow noopener noreferrer" target="_blank">stroom</a> van cryptokapitaal.</p>
<p>Op de datum van schrijven is de prijs van FDUSD hersteld tot $0.9982, en de markt lijkt terug te zijn gekeerd naar rust. Maar veel verdachte details die worden vertegenwoordigd door FDUSD zijn nog niet afgerond, en de transparantie, stabiliteit en veiligheid van de stablecoin track zijn nog steeds het waard om op te letten. In de toekomst is het niet alleen een uitdaging voor FDUSD zelf, maar ook een vraagstuk voor de hele stablecoinmarkt, of FDUSD zijn te grote afhankelijkheid van Binance kan afschudden en het vertrouwen van investeerders kan herstellen.</p>
<div class="blog-details-info"><br><div>Auteur:<strong>Charle Y.</strong>, Gate.io Onderzoeker<br><div>Vertaler: Joy Z.<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de opvattingen van de onderzoeker en vormt geen beleggingsadvies. Alle investeringen brengen inherente risico's met zich mee; verstandig besluitvorming is essentieel.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het opnieuw plaatsen van het artikel zal worden toegestaan mits Gate.io wordt genoemd. In alle glen zullen juridische stappen worden ondernomen wegens inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div></div>