Q3Jpc2kgRkRVU0Q6IFVuIGFsdHJvIHRlc3QgZGkgZmlkdWNpYSBuZWwgbWVyY2F0byBkZWxsZSBzdGFibGVjb2lu

<p><img src="https://gimg2.gateimg.com/image/article/1743659496HOTSPOT.png" alt=""></p>
<h2 id="h2-Introduzione347770"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>Il 3 aprile 2025, il mercato delle criptovalute ha di nuovo scatenato onde a causa di una stablecoin. Questa volta, il protagonista è stato FDUSD (First Digital USD), una stablecoin ancorata al dollaro statunitense emessa da First Digital Trust (FDT), una società fiduciaria di Hong Kong. Le esplosive accuse del fondatore di <a href="/price/tron-trx" target="_blank" class="blog_inner_link">Tron</a>, Justin Sun, hanno spinto FDUSD sotto i riflettori, facendo brevemente scendere il suo prezzo a $0.87 e scatenando il panico sul mercato.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1743658840111.png" alt=""></p>
<p>Si tratta di una deliberata campagna diffamatoria, o di un’esposizione di questioni profondamente radicate nell’industria delle stablecoin? Cominciamo dall’inizio per dipanare questa crisi e cogliere l’occasione per comprendere i principi operativi delle stablecoin.</p>
<h2 id="h2-Cos20un20stablecoin70803"><a name="Cos’è un stablecoin?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Cos’è un stablecoin?</h2><p>Prima di addentrarci nell’evento, parliamo di cosa sono gli stablecoin. Gli stablecoin sono un tipo di criptovaluta progettata per mantenere la stabilità dei prezzi, di solito ancorata 1:1 a valute fiat come il dollaro. Fungono da ‘ponte’ nel mondo della blockchain, consentendo agli utenti di detenere asset ‘stabili’ nel volatile mercato delle criptovalute per scopi di trading, pagamenti o copertura.</p>
<p>La stabilità delle stablecoin di solito viene raggiunta nei seguenti modi:</p>
<ol>
<li>Asset-backed: L’emittente detiene un importo equivalente di valuta fiat o attività (come USD, obbligazioni governative) come riserve, che gli utenti possono riscattare in qualsiasi momento. Ad esempio, USDT (<a href="/price/tether-usdt" target="_blank" class="blog_inner_link">Tether</a>) e USDC (Circle) sono rappresentanti di questa categoria.</li><li>Algoritmo: Stabilizzazione del prezzo mediante l’aggiustamento dell’offerta tramite smart contract, come l’early TerraUSD (UST), tuttavia, tali stablecoin comportano rischi più elevati, il crollo dell’UST nel 2022 serve da lezione.</li><li>Tipo misto: combinando il supporto degli asset e l’aggiustamento algoritmico, meno comune.</li></ol>
<p><img src="https://gimg2.gateimg.com/image/article/1743658882222.png" alt=""></p>
<p>FDUSD appartiene al primo tipo, che è garantito da FDT di essere supportato 1:1 da dollari statunitensi o equivalenti (come ad esempio titoli del Tesoro statunitense). Tuttavia, la ‘stabilità’ delle stablecoin non è naturalmente innata, ma si basa sulla reputazione dell’emittente e sulla trasparenza delle riserve. Una volta che la fiducia viene scossa, può verificarsi lo scollegamento - proprio ciò che sta vivendo FDUSD.</p>
<h2 id="h2-Contesto20dellevento20Controversia20da20TUSD20a20FDUSD749817"><a name="Contesto dell’evento: Controversia da TUSD a FDUSD" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Contesto dell’evento: Controversia da TUSD a FDUSD</h2><p>FDUSD è stato lanciato nel giugno 2023, supportato da Hong Kong’s FDT, salendo rapidamente ai primi quattro nel mercato delle stablecoin con una capitalizzazione di mercato di circa $3.3 miliardi. Tuttavia, FDT non è privo di controversie, poiché gestisce anche un’altra stablecoin, TUSD (<a href="/price/trueusd-tusd" target="_blank" class="blog_inner_link">TrueUSD</a>), che ha affrontato continui problemi negli ultimi anni.</p>
<p>Dal 2023 all’inizio del 2024, TUSD ha spesso fatto notizia a causa di problemi di gestione delle riserve. I documenti giudiziari a Hong Kong hanno rivelato che l’emittente TUSD, Techteryx, ha affrontato un gap finanziario di $456 milioni perché FDT ha investito le riserve in asset ad alto rischio, causando ritardi nei rimborsi. Il fondatore di Tron, Justin Sun, ha fornito prestiti di emergenza per aiutare TUSD, ma i rapporti con FDT sono poi peggiorati. Questo risentimento ha seminato i semi della crisi attuale di FDUSD.</p>
<h2 id="h2-Dalle20accuse20alla20tumultuosa20situazione20di20mercato652590"><a name="Dalle accuse alla tumultuosa situazione di mercato" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Dalle accuse alla tumultuosa situazione di mercato</h2><p>Il 2 aprile 2025, Justin Sun ha lasciato cadere una bomba sulla piattaforma X: ‘First Digital Trust è insolvente e non in grado di soddisfare gli obblighi di rimborso dei clienti.’ Ha affermato che FDT era coinvolta in una frode fino a 500 milioni di dollari e che la regolamentazione della fiducia a Hong Kong era praticamente inesistente, chiedendo prelievi da parte degli utenti e un intervento regolamentare. Sun ha anche annunciato una conferenza stampa il 3 aprile per rivelare ulteriori prove.</p>
<p>Questa accusa mira direttamente alla linea vitale di FDUSD - se FDT dovesse davvero fallire, sono al sicuro le riserve in USD di FDUSD? Il mercato è rapidamente piombato nel panico.</p>
<h3 id="h3-Decoupling20e20vendita20di20FDUSD662047"><a name="Decoupling e vendita di FDUSD" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Decoupling e vendita di FDUSD</h3><p>Dopo l’annuncio, il prezzo di FDUSD si è rapidamente scoppiato. Il 2 aprile è sceso fino a $0.87 (rispetto a USDT), e ha persino toccato brevemente $0.76 (rispetto a USDC), con un calo fino al 12%-24%. Il volume di trading delle ultime 24 ore è schizzato a $5.9 miliardi, con molti utenti che vendono FDUSD per evitare rischi.</p>
<h3 id="h3-Contro20attacco20FDT843066"><a name="Contro attacco FDT" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Contro attacco FDT</h3><p>Di fronte alla crisi, FDT ha emesso rapidamente una dichiarazione la sera del 2 aprile: ‘Le accuse contro Justin Sun sono puramente voci, non correlate a FDUSD, coinvolgono solo TUSD. Abbiamo piena solvibilità, con i 20,4 miliardi di circolazione di FDUSD garantiti da asset come 20 miliardi di obbligazioni del Tesoro degli Stati Uniti.’ Accusano Sun di diffondere FUD (paura, incertezza e dubbio) e annunciano azioni legali, pianificando nel frattempo di tenere un AMA presso X Spaces il 3 aprile alle 16:00 (ora di Hong Kong) per chiarimenti pubblici.</p>
<h2 id="h2-Perch20gli20stablecoin20sono20inclini20alla20destabilizzazione168107"><a name="Perché gli stablecoin sono inclini alla ‘destabilizzazione’?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Perché gli stablecoin sono inclini alla ‘destabilizzazione’?</h2><p>La disaccoppiamento di FDUSD non è un caso isolato. Nel 2022, TerraUSD è sceso a zero a causa di un fallimento dell’algoritmo e nel 2023, USDC è brevemente sceso a 0,88 USD a causa della crisi della banca della Silicon Valley. Le ragioni comuni dell’instabilità delle stablecoin includono:</p>
<ul>
<li>Riserve insufficienti o mancanza di trasparenza: l’emittente non possiede sufficienti attività, o investe in prodotti ad alto rischio.</li><li>Panico di mercato: una corsa che provoca un’onda di vendite, anche se le riserve vengono ricostituite, potrebbe non essere sufficiente per rispondere in tempo.</li><li>Mancanza di regolamentazione: Molti emittenti di stablecoin operano al di fuori della regolamentazione finanziaria tradizionale, facendo affidamento esclusivamente sull’autodisclosure per la fiducia.</li></ul>
<p>Nell’incidente FDUSD, le accuse di Sun colpiscono direttamente le fondamenta della fiducia e sarà determinante per il destino di FDT la sua capacità di dimostrare l’innocenza.</p>
<h2 id="h2-Prospettive20future20di20FDUSD322851"><a name="Prospettive future di FDUSD" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Prospettive future di FDUSD</h2><p>Breve termine: l’AMA di FDT e la conferenza stampa di Sun saranno cruciali. Se FDT può dimostrare riserve trasparenti, FDUSD potrebbe tornare a 1 USD; se Sun presenta prove concrete, potrebbe innescare una crisi più grande. Lungo termine: Il rafforzamento normativo sugli stablecoin a Hong Kong potrebbe cambiare il panorama della concorrenza del settore a causa del successo o del fallimento di FDUSD. USDT, USDC e persino <a href="/price/usdd-usdd" target="_blank" class="blog_inner_link">USDD</a> potrebbero trarne beneficio.</p>
<p>La crisi FDUSD è un’altra epítome di fiducia e rischio nel mercato delle stablecoin. Tecnicamente, le stablecoin sono la pietra angolare dell’economia blockchain; ma in realtà, la loro stabilità dipende dal gioco tra la natura umana e la regolamentazione.</p>
<div class="blog-details-info"><br><div>Autore: Rooick Z., Ricercatore di Gate.io<br><div class="info-tips"><em>Questo articolo rappresenta solo il punto di vista dell'autore e non costituisce alcun consiglio commerciale. Gli investimenti comportano rischi, le decisioni devono essere prudenti.<br></em><div><em></em>Questo articolo è originale, e il copyright appartiene a Gate.io. Si prega di indicare l'autore e la fonte se è necessario ripubblicare, altrimenti saranno perseguite responsabilità legali.<br></div><p></p><br></div></div></div>