TGUgc3RhYmxlY29pbiBub24gc29ubyBwacO5IHN0YWJpbGksIGNvc2Egw6ggc3VjY2Vzc28gYSBGRFVTRD8=

2025-04-08, 06:30

<p><img src="https://gimg2.gateimg.com/image/article/1744093526INDUSTRYANALYSIS.png" alt=""></p>
<h2 id="h2-TLDR494073"><a name="[TL;DR]:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL;DR]:</h2><p>Recentemente, Justin Sun ha accusato First Digital Trust di bancarotta, causando al suo stablecoin in dollari statunitensi FDUSD di scollegarsi temporaneamente a $0.8799. Successivamente, è risalito sopra $0.9980 a causa della dichiarazione ufficiale che il rimborso fosse stabile.</p>
<p>Come stablecoin principale di un noto ecosistema di scambio, la crescita di FDUSD è strettamente legata al suo supporto strategico.</p>
<p>L’incidente di depegging di FDUSD ha rivelato problemi come la mancanza di trasparenza delle stablecoin, falle regolatorie e la fragile fiducia del mercato.</p>
<h2 id="h2-Introduzione244150"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>Ogni volta che il mercato cade in una panico ribassista, la traccia della stablecoin affronterà sempre una crisi di disimpegno, proprio come quando <a href="/price/terra-luna" rel="nofollow noopener noreferrer" target="_blank">Terra</a>(UST) ha subito un crollo a spirale mortale durante l’ultimo ciclo di rialzi e ribassi. Di recente, quando il mercato era debole e fragile, Justin Sun ha accusato First Digital Trust di essere insolvente e di aver causato un’immediata svalutazione del FDUSD del 20%, che ha fatto tornare tese i nervi già sensibili del mercato.</p>
<h2 id="h2-Registro20panoramico20dellevento20di20depegging20di20FDUSD581049"><a name="Registro panoramico dell’evento di depegging di FDUSD" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Registro panoramico dell’evento di depegging di FDUSD</h2><p>“Prima Trust Digitale è effettivamente fallita!” Alle 22:17 del 2 aprile, Justin Sun ha pubblicato questo tweet sulla piattaforma X, che ha istantaneamente fatto detonare il mercato delle stablecoin come una carica di profondità.<img src="https://gimg2.gateimg.com/image/article/17440935881.jpeg" alt=""><br>Fonte: @justinsuntron</p>
<p>Il prezzo della coppia di scambio FDUSD/USDT è rapidamente sceso su importanti borse, con Gate.io che mostra una diminuzione minima di 0,8799 USDT, una diminuzione del 12%. Durante questo periodo, il sistema di trading algoritmico del market maker Wintermute ha rilevato fluttuazioni anomale e ha attivato automaticamente un ordine di vendita da 120 milioni di dollari per proteggere la sua posizione.<br><img src="https://gimg2.gateimg.com/image/article/17440936062.jpeg" alt=""><br>Source: Gate.io</p>
<p>L’accusa di Justin Sun non è infondata. La miccia di questa tempesta può essere fatta risalire a tre settimane fa. Il 14 marzo, i documenti del caso Techteryx v. Aria Commodities divulgati dal tribunale di Hong Kong hanno dimostrato che la riserva di 456 milioni di dollari detenuta dall’operatore TUSD attraverso First Digital Trust è stata trasferita illegalmente all’entità di Dubai Aria DMCC. Sebbene Justin Sun abbia originariamente fornito un prestito di emergenza a Techteryx a suo nome personale per colmare il divario, i nervi del mercato sono diventati molto sensibili: dopotutto, solo sei mesi fa, TUSD, che appartiene anche al sistema TrueCoin, ha raggiunto un accordo di $ 500.000 con la SEC a causa di “appropriazione indebita di fondi di riserva”. Quando il panico si è diffuso a FDUSD, First Digital Trust ha rapidamente rilasciato una dichiarazione smentendo fermamente le voci di bancarotta, sottolineando che il suo FDUSD con un valore di mercato di $ 2,5 miliardi è completamente supportato da buoni del tesoro statunitensi 1:1 e ha divulgato l’International Securities Identification Number (ISIN) della riserva per mostrare trasparenza.</p>
<p>Nel frattempo, un grande scambio, come il più grande sostenitore di FDUSD, ha rilasciato anche buone notizie attraverso canali non ufficiali. Un membro, SiSi, ha dichiarato in un gruppo di utenti: “FDUSD può essere accettato con un rapporto di 1:1.” Questa affermazione è stata ufficialmente annunciata nelle prime ore del giorno successivo e si è rapidamente diffusa nella comunità, stabilizzando la fiducia di alcuni investitori.<img src="https://gimg2.gateimg.com/image/article/17440936263.jpeg" alt=""><br>Fonte: @FirstDigitalHQ</p>
<p>Alle 7:00 del 3 aprile, la piattaforma ha annunciato i dettagli dell’audit di Prescient Assurance, sottolineando che le riserve di FDUSD includono titoli del Tesoro degli Stati Uniti e depositi notturni, e ha promesso di rilasciare un rapporto di aggiornamento di marzo entro due settimane. Dopo la diffusione della notizia, il prezzo di FDUSD è rimbalzato da $0.98 a $0.995 entro due ore, ma la pressione di riscossione di $60 milioni ha causato uno sconto permanente.</p>
<h2 id="h2-Fame20Brings20Trouble20FDUSD20from20Hong20Kong20Label20to20Regulatory20Arbitrage481466"><a name="Fame Brings Trouble: FDUSD from Hong Kong Label to Regulatory Arbitrage" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Fame Brings Trouble: FDUSD from Hong Kong Label to Regulatory Arbitrage</h2><p>Le radici della crisi FDUSD possono essere ricondotte alla disputa tra FDT e Justin Sun cinque anni fa. FDUSD è emesso da First Digital Trust Limited (FDT), una società fiduciaria registrata a Hong Kong. È posizionato come un asset digitale ancorato al dollaro USA con un rapporto 1:1, e le sue riserve sono garantite da contanti o obbligazioni del Tesoro USA. La sua azienda madre, First Digital Group, può risalire alla sua storia fino a Legacy Trust, fondata nel 1992. I suoi clienti includono capitale tradizionale come l’ufficio di famiglia di Li Ka-shing. Questo background transfrontaliero ha rapidamente reso FDUSD popolare tra le istituzioni.<img src="https://gimg2.gateimg.com/image/article/17440936634.jpeg" alt=""><br>Sorgente: CoinDesk</p>
<p>Nel 2019, FDT è stata scissa da Legacy Trust come entità indipendente e ha completato un round di finanziamento da 20 milioni di dollari nel maggio 2022. Gli investitori includevano l’investitore iniziale di Telegram Nogle e la società di venture capital con sede a Hong Kong Kenetic Capital.</p>
<p>Nel 2020, FDT ha assunto la gestione delle riserve della stablecoin TUSD. Secondo i documenti giudiziari, FDT ha trasferito $456 milioni di riserve dal Fondo Aria alle Isole Cayman all’entità Aria DMCC a Dubai tra il 2022 e il 2023, il cui controllore effettivo è legato agli esecutivi di FDT. Dove sono alla fine andati i fondi? L’atto d’accusa mostra che $15 milioni dei fondi sono stati utilizzati per emettere prestiti illegali agli esecutivi di FDT, e il resto dei fondi è sospettato di essere stato investito in impianti di produzione ad alto rischio e progetti minerari.</p>
<p>Il coinvolgimento di Justin Sun è iniziato nel 2022. In quel momento, Techteryx (emittente di TUSD) ha richiesto fondi da FDT a causa del mancato rimborso. Il rifiuto di Aria di rimborsare ha portato a una carenza di TUSD. Justin Sun ha quindi fornito un prestito di emergenza nel suo nome personale per colmare il divario, ma i fondi pertinenti non sono stati ancora restituiti ad oggi. Questo debito è diventato alla fine la miccia per l’attacco di Justin Sun a FDT.<img src="https://gimg2.gateimg.com/image/article/17440937085.jpeg" alt=""><br>Fonte: ethersan.io</p>
<p>A giugno 2023, FDUSD è stato ufficialmente lanciato, proprio quando Hong Kong ha lanciato un sistema di licenze per i fornitori di servizi di attività virtuali. Questa coincidenza ha dato a FDUSD un forte “etichetta di Hong Kong” a causa del suo profondo legame con un grande scambio, circa il 94% (circa 2,35 miliardi di dollari) del valore di mercato totale di 2,5 miliardi di dollari è detenuto da esso. Questa dipendenza altamente concentrata ha fatto sì che FDUSD passasse dall’oscurità a un attore di primo piano nel mercato delle stablecoin.</p>
<h2 id="h2-Perch20le20stablecoin20non20sono20n20stabili20n20trasparenti529848"><a name="Perché le stablecoin non sono né stabili né trasparenti?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Perché le stablecoin non sono né stabili né trasparenti?</h2><p>Secondo me, la “stabilità” delle stablecoin non si è mai basata esclusivamente sulle riserve di attività, ma piuttosto sulla trasparenza e la parità di informazioni.</p>
<p>Per quanto riguarda le informazioni pubbliche finora disponibili, anche se FDT ha reso noto il suo numero ISIN, non ha reso noto in dettaglio la composizione del suo attivo e lo stato di liquidità, rendendo difficile per il mondo esterno verificare la sua vera solvibilità. In questo contesto, l’affermazione di Justin Sun di “insolvente” può scatenare vendite di panico, dimostrando quanto sia fragile il fondamento della fiducia degli investitori in FDT sotto l’impulso dell’asimmetria informativa e delle narrazioni esterne.<img src="https://gimg2.gateimg.com/image/article/17440937676.jpeg" alt=""><br>Origine: @FirstDigitalHQ</p>
<p>Su un livello più profondo, l’incidente FDUSD ha anche esposto un vuoto normativo. Il membro del Consiglio legislativo di Hong Kong Wu Jiezhuang ha sottolineato che l’incidente FDT ha messo in evidenza la mancanza di supervisione delle società fiduciarie nella <a href="/web3" rel="nofollow noopener noreferrer" target="_blank">Web3</a> campo e ha suggerito di includere “fiducia” nella supervisione legale. Questo rivela il dilemma regolamentare dei centri finanziari offshore: l’attuale “Ordinanza contro il riciclaggio di denaro” richiede solo che i fornitori di servizi di asset virtuali siano autorizzati, ma manca di regole dettagliate sull’isolamento degli asset e sull’ambito di investimento dei custodi di stablecoin.</p>
<p>Ciò che è ancora più meritevole di vigilanza è l’arbitraggio regolamentare transfrontaliero. Il business di finanziamento commerciale di Aria DMCC a Dubai si trova proprio nell’area grigia della regolamentazione finanziaria degli Emirati Arabi Uniti. Quando riserve per 456 milioni di dollari sono state investite in progetti fisici come miniere di nickel indonesiane e porti vietnamiti, non solo ha aggirato la lista delle sanzioni OFAC degli Stati Uniti, ma ha anche bypassato le regole di custodia degli asset virtuali di Hong Kong. Questa strategia di “depressione della conformità” è un percorso tipico per il globale <a href="/price/flow-flow" rel="nofollow noopener noreferrer" target="_blank">flusso</a> di capitale crittografico.</p>
<p>Alla data della stesura, il prezzo di FDUSD è tornato a $0.9982, e il mercato sembra essere tornato alla calma. Tuttavia, molti dettagli sospetti rappresentati da FDUSD non sono ancora stati definiti, e la trasparenza, la stabilità e la sicurezza della traccia stablecoin sono ancora meritevoli di attenzione. In futuro, se FDUSD potrà liberarsi della sua eccessiva dipendenza da Binance e ricostruire la fiducia degli investitori potrebbe non essere solo una sfida per se stessa, ma anche una proposta per l’intero mercato delle stablecoin.</p>
<div class="blog-details-info"><br><div>Autore:<strong>Charle Y.</strong>, Ricercatore di Gate.io<br><div>Traduttore: Joy Z.<br><div class="info-tips"><em>Questo articolo rappresenta solo le opinioni del ricercatore e non costituisce alcun suggerimento di investimento. Tutti gli investimenti comportano rischi intrinseci; è essenziale prendere decisioni oculate.<br></em><div><em></em>Gate.io si riserva tutti i diritti su questo articolo. La ripubblicazione dell'articolo sarà consentita a condizione che si faccia riferimento a Gate.io. In tutti i casi, saranno intraprese azioni legali a causa di violazione del copyright.<br></div><p></p><br></div></div></div></div>