VWx0aW1lIG5vdGl6aWUgc3UgRlRYOiBJbml6aWEgaWwgcmltYm9yc28gZGkgMTAgbWlsaWFyZGkgZGkgZG9sbGFyaSwgaWwgOTglIGRlZ2xpIHV0ZW50aSBzYXLDoCByaXNhcmNpdG8gcXVlc3RcJ2Fubm8=

2025-06-11, 03:42

<p><img src="https://gimg2.gateimg.com/image/ftx202506111141259477983550.png" alt="">
</p><p>Il tribunale fallimentare del Delaware ha ufficialmente approvato il piano di fallimento di FTX il 7 ottobre 2024, consentendole di avviare il processo di compensazione dei creditori utilizzando fino a 16,5 miliardi di dollari in attivi recuperati.</p>
<p>Questa decisione segna un notevole progresso nei rimborsi per i creditori di FTX dalla caduta nel novembre 2022.</p>
<p>Secondo il piano, FTX darà priorità a coprire il 98% degli utenti entro 60 giorni dopo l’entrata in vigore del piano di fallimento, in particolare i creditori i cui attivi di conto erano ≤ $50.000 al momento del fallimento.</p>
<h2 id="h2-Dettagli20Fondamentali20del20Piano20di20Compensazione485887"><a name="Dettagli Fondamentali del Piano di Compensazione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Dettagli Fondamentali del Piano di Compensazione</h2><ul>
<li>Importo e tempistiche del risarcimento: il valore totale degli attivi disponibili per il risarcimento da FTX è compreso tra 14,5 miliardi di dollari e 16,3 miliardi di dollari. Il risarcimento sarà effettuato in fasi: circa 1,1 miliardi di dollari saranno pagati al 98% degli utenti entro la fine del 2024, con l’importo rimanente da completare entro il secondo trimestre del 2025.</li><li>Standard di compensazione: Basato sul valore in dollari delle richieste al momento del fallimento nel novembre 2022. I piccoli creditori (≤ 50.000 USD) riceveranno il 118%, mentre i grandi creditori riceveranno il 100% + compensazione degli interessi.</li><li>Controversia Focus: Alcuni creditori richiedono un risarcimento in forma fisica (valuta originale), opponendosi a un accordo basato sul valore del dollaro del 2022. Ad esempio, il prezzo di <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> era solo $16.000 in quel momento, ma attualmente (giugno 2025) ha superato $110.000. Tuttavia, il tribunale supporta il risarcimento in contante, poiché FTX ha un enorme deficit di attivi (solo lo 0,1% di BTC rimanente, l’1,2% di ETH rimanente), e il risarcimento fisico richiederebbe l’acquisto di monete sul mercato, che è “incredibilmente costoso.”</li></ul>
<h2 id="h2-Progresso20Attuale20della20Compensazione20e20Categorie20Utente285998"><a name="Progresso Attuale della Compensazione e Categorie Utente" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Progresso Attuale della Compensazione e Categorie Utente</h2><ul>
<li>Data di entrata in vigore del piano: inizialmente prevista per il 31 ottobre 2024, ma a causa della complessità del processo, alcuni pagamenti saranno ritardati fino all’inizio del 2025.</li><li><p>Gruppo di compensazione prioritario:</p>
<ul>
<li>Classe 7A: Gli utenti con debito ≤ $50.000 godono di un tasso di rimborso prioritario del 120,5% (compresi gli interessi). Ad esempio, un certo caso mostra che è stato allocato il 18 febbraio 2025.</li><li>Classe 5A: Gli utenti con debiti superiori a $50.000 devono attendere i successivi lotti.</li></ul>
</li><li>Atteggiamento dei creditori: il 94,48% dei creditori (valore totale del credito di 6,83 miliardi di dollari) ha votato a favore del piano. Tuttavia, gli oppositori sono preoccupati che il risarcimento in contante possa comportare costi fiscali significativi.</li></ul>
<h2 id="h2-Guida20allOperazione20di20Richiesta20Processo20in20Cinque20Passaggi149461"><a name="Guida all’Operazione di Richiesta (Processo in Cinque Passaggi)" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Guida all’Operazione di Richiesta (Processo in Cinque Passaggi)</h2><p>Nel marzo 2024, PwC attiverà il portale delle richieste di FTX Digital Markets come liquidatore congiunto, e gli utenti devono completare la registrazione elettronica delle richieste prima della scadenza del 15 maggio 2024:</p>
<ol>
<li>Registrazione dell’account: Fornire informazioni come nome, numero di telefono, email, data di apertura dell’account, ecc., e selezionare il tipo di richiedente (individuale/istituzione/creditore non cliente).</li><li><a href="/price/link-ln" rel="nofollow noopener noreferrer" target="_blank">Collegamento</a> Account FTX: Compila le informazioni di identità (numero di passaporto/ID), <a href="/price/link-ln" rel="nofollow noopener noreferrer" target="_blank">collegamento</a> l’email originale dell’account FTX e verifica i permessi.</li><li>Conferma o contesta il saldo: Controlla i dati del saldo dell’account visualizzati dal sistema. Se c’è una controversia, è necessario caricare documenti di prova (come registrazioni di posizione, schermate di transazione, ecc.).</li><li>Verifica dell’identità (KYC/AML): L’agente di compensazione esamina i documenti d’identità in background e notifica l’utente via email una volta approvato.</li><li>In attesa dell’allocazione della liquidazione: i pagamenti saranno effettuati in lotti dopo il completamento del giudizio, con la prima allocazione prevista per iniziare dalla fine del 2024 all’inizio del 2025.</li></ol>
<h2 id="h2-Domande20Frequenti20e20Avvisi20di20Rischio633272"><a name="Domande Frequenti e Avvisi di Rischio" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Domande Frequenti e Avvisi di Rischio</h2><ul>
<li>“Richiesta di Credito Controverso”: Questo può verificarsi a causa di dichiarazioni duplicate, discrepanze nei registri di possesso o conflitti giurisdizionali (come quelli che coinvolgono gli utenti di Liquid Global a Singapore). Tali richieste possono comunque essere impugnate e, una volta approvate, possono ricevere successivi allocamenti.</li><li>Aspettative per il Capitale <a href="/price/flow-flow" rel="nofollow noopener noreferrer" target="_blank">Flusso</a> Tornare al mercato: Circa il 50% delle richieste di debito originali sono state trasferite a istituzioni professionali e alcuni fondi potrebbero non tornare nel mercato delle criptovalute. Tuttavia, l’analista Su Zhu crede che il rilascio di decine di miliardi di fondi possa ancora stimolare il mercato.</li><li>Avviso di sicurezza: Fare attenzione alle email di phishing e operare solo attraverso il portale ufficiale di richiesta FTX (è richiesta la verifica a due fattori).</li></ul>
<p>A partire da febbraio 2025, alcuni utenti di Classe 7A hanno ricevuto un rimborso del 120,5% (inclusi gli interessi). Per gli utenti il cui stato del debito mostra “in contestazione”, il team di liquidazione sta ancora avanzando con la riconciliazione degli attivi e il coordinamento giurisdizionale, con l’allocazione finale o la continuazione che si estende alla metà o alla fine del 2025.</p>
<p>Per i richiedenti che non presentano la domanda in tempo, alcune giurisdizioni possono aprire canali supplementari, ma il tasso di recupero dei fondi sarà significativamente ridotto. Questa liquidazione fallimentare di due anni e mezzo sta giungendo al termine con miliardi di liquidità in contante, segnando la conclusione del capitolo più oscuro nella storia delle criptovalute.</p>
<div class="blog-details-info"><br><div>Autore: <strong>Team del blog</strong><br><div class="info-tips"><em>Il contenuto qui non costituisce alcuna offerta, sollecitazione o raccomandazione. Dovresti sempre cercare un consiglio professionale indipendente prima di prendere qualsiasi decisione di investimento.<br><div></div>Si prega di notare che Gate potrebbe limitare o vietare l'uso di tutti o di una parte dei Servizi da Località Riservate. Per ulteriori informazioni, si prega di leggere il Contratto Utente tramite <a href="https://www.gate.com/legal/user-agreement" data-index="5">https://www.gate.com/legal/user-agreement</a>.<br><p></p><br></em></div></div></div>