TGUgcmljaGllc3RlIGRpIGZhbGxpbWVudG8gRlRYIGF1bWVudGFubyBuZWkgbWVyY2F0aSBPVEMsIGwnYW1taW5pc3RyYXppb25lIHJlY3VwZXJhIDcsMyBtaWxpYXJkaSBkaSBkb2xsYXJp

2023-10-10, 03:54

<p><img src="https://gimg2.gateimg.com/image/article/1690791857hotspot.jpeg" alt=""><br>La borsa FTX ha recuperato asset per un valore superiore a 7,3 miliardi di dollari.</p>
<p>I piani per il riavvio dello scambio di criptovalute FTX sono in una fase avanzata.</p>
<p>Il tribunale ha negato a Sam Bankman-Fried un rilascio temporaneo dal carcere.</p>
<p>Parole chiave: Cosa è successo a FTX, Accuse contro Bankman-Fried, crollo di FTX, FTX crash, Fallimento dello scambio criptato FTX, Notizie su FTX, FTX ha presentato istanza di fallimento, Creditori di FTX, Recupero degli asset di FTX</p>
<h2 id="h2-Introduzione128728"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>Nonostante la tristezza che il <a href="https://www.gate.io/blog_detail/3017/ftx-sues-sam-bankman-fried-and-former-_s-for-1-billion" target="_blank">Il fondatore di FTX, Sam Bankman-Fried, affronta l’imprigionamento e i processi in tribunale</a>, ci sono alcuni sviluppi positivi riguardo al processo di recupero degli asset di FTX e all’aumento delle richieste di fallimento nei mercati OTC.</p>
<p>Oggi, copriamo alcuni sviluppi positivi per FTX. Parliamo anche delle questioni generali legate al fondatore di FTX, Sam Bankman-Fried.</p>
<h2 id="h2-I20pagamenti20ai20creditori20di20FTX20triplicano392532"><a name="I pagamenti ai creditori di FTX triplicano" class="reference-link"></a><span class="header-link octicon octicon-link"></span>I pagamenti ai creditori di FTX triplicano</h2><p>Matrixport, una piattaforma di asset digitali, ha recentemente riferito che i valori di mercato delle richieste di fallimento di FTX sono triplicati nel 2023. Le richieste di fallimento di FTX, un tempo ad alto rischio, sono ora pubblicizzate come le “più calde” del mercato.</p>
<p>Quando FTX ha presentato la domanda <a href="https://www.gate.io/explore/ftx-sbf" target="_blank">fallimento nel novembre 2022</a> le richieste erano molto basse a causa della natura complessa dei problemi dell’ex scambio di criptovalute. A quel tempo molti dei suoi ex dirigenti erano sotto processo e nessuno di loro aveva dichiarato colpevolezza delle accuse a loro rivolte.</p>
<p>I dati pubblicati da Matrixport indicano che il valore delle richieste di fallimento di FTX è salito a una media di 37 centesimi per dollaro, il più alto dal novembre 2022. Nei primi giorni, il valore medio delle richieste era leggermente superiore ai 10 centesimi.</p>
<h2 id="h2-Perch20conta20il20valore20delle20richieste20di20fallimento710817"><a name="Perché conta il valore delle richieste di fallimento?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Perché conta il valore delle richieste di fallimento?</h2><p>Le pretese dei creditori sorgono quando un’azienda diventa insolvente e presenta istanza di fallimento, come ha fatto FTX nel 2022. In tal caso, ci sono due tipi di creditori.</p>
<p>Ci sono creditori che aspettano di ricevere i loro pagamenti dopo le procedure di risoluzione. Tuttavia, altri creditori possono scegliere di disporre dei loro crediti a speculatori sul mercato.</p>
<p>I valori di tali pagamenti dipenderanno dalla domanda di richieste nel mercato. Nel novembre 2022 i valori delle richieste dei creditori del fallimento della cripto-borsa FTX erano molto bassi perché il caso FTX era uno dei casi di fallimento più complicati negli Stati Uniti. Di conseguenza, ha anche spese legali elevate, oltre i 200 milioni di dollari.</p>
<h2 id="h2-Le20ragioni20dietro20laumento20dei20valori20dei20crediti20dei20creditori20di20FTX596163"><a name="Le ragioni dietro l’aumento dei valori dei crediti dei creditori di FTX" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Le ragioni dietro l’aumento dei valori dei crediti dei creditori di FTX</h2><p>Ci sono diverse ragioni per l’impennata recente nei valori delle richieste di fallimento di FTX. Tuttavia, il fattore principale che contribuisce è <a href="https://www.gate.io/blog_detail/3199/daily-news-ftx-has-been-approved-to-liquidate-its-crypto-assets-ethereum-futures-premiums-are-low-crypto-market-is-experiencing-a-serious-liquidity-crisis" target="_blank">il successo del processo di recupero dell’attivo</a>.</p>
<p>Dopo la presentazione del caso di fallimento <a href="https://www.gate.io/blog_detail/1806/FTX-s-collapse--Affected-a-Wide-Cross-section-of-the-Crypto-Eco-" target="_blank">a seguito del crollo di FTX</a>, la borsa di criptovalute ha affidato a John Ray III, un avvocato esperto in fallimenti di Wall Street, il compito di gestire il processo di recupero degli asset. Pertanto, sotto la guida di Ray III, il processo di recupero degli asset di FTX è stato rapido ed efficiente, poiché finora la borsa ha recuperato più di $7,3 miliardi.</p>
<p>Gli asset recuperati includono criptovalute del valore di 3,4 miliardi di dollari, 1,1 miliardi di dollari in contanti e immobili situati nelle Bahamas, valutati oltre 200 milioni di dollari. Tuttavia, il team di recupero degli asset di FTX deve ancora recuperare altri asset, tra cui donazioni minori. C’è anche una richiesta di risarcimento di 2,1 miliardi di dollari contro Binance e 700 milioni di dollari contro K5, una società di investimento.</p>
<h2 id="h2-Pool20di20asset20da20720miliardi20di20FTX20in20Anthropic585020"><a name="Pool di asset da 7 miliardi di FTX in Anthropic" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Pool di asset da 7 miliardi di FTX in Anthropic</h2><p>Secondo le ultime notizie di FTX, la criptovaluta ha avuto una quota di 500 milioni di dollari in Anthropic, una società di intelligenza artificiale (AI). Prima del suo crollo, FTX ha utilizzato i fondi dei clienti per investire nella start-up sostenuta da Amazon. Di conseguenza, i creditori di FTX hanno un credito su Anthropic.</p>
<p>Recentemente, Amazon ha dichiarato di avere l’intenzione di iniettare fino a $4 miliardi nella start-up. Questa notizia ha contribuito a aumentare il valore dei crediti da fallimento di FTX.</p>
<h2 id="h2-La20prospettiva20di20FTX2020367501"><a name="La prospettiva di FTX 2.0" class="reference-link"></a><span class="header-link octicon octicon-link"></span>La prospettiva di FTX 2.0</h2><p>L’altro motivo dell’attuale aumento del valore dei crediti dei creditori di FTX è l’alta possibilità del rilancio dello scambio di criptovalute FTX, comunemente chiamato FTX 2.0. Il fatto che la riattivazione di FTX potrebbe trasformare ogni creditore in un proprietario di azioni ha spinto il valore dei crediti al rialzo.</p>
<p>Matrixport ha fortemente suggerito la possibilità di un nuovo lancio di FTX, cosa che non è nuova nello spazio cripto. Ha detto: “La ricapitalizzazione di successo di uno scambio è stata raggiunta in passato, con ogni creditore che diventa un proprietario di equità. Comprendere questa dinamica potrebbe essere di significato materiale per i detentori di crediti”.</p>
<p>Thomas Braziel, co-fondatore e managing partner di 507 Capital, una società di investimento patrimoniale, ha anche dichiarato: “FTX [crediti] è probabilmente il biglietto più caldo in città. Il mercato è così caldo che gli investitori in distressed asset stanno assolutamente facendo a gara l’uno sull’altro per i crediti”.</p>
<h2 id="h2-Lottimismo20alimenta20la20frenesia20delle20richieste20di20fallimento20di20FTX14117"><a name="L’ottimismo alimenta la frenesia delle richieste di fallimento di FTX" class="reference-link"></a><span class="header-link octicon octicon-link"></span>L’ottimismo alimenta la frenesia delle richieste di fallimento di FTX</h2><p>Secondo CNBC, c’è molto <a href="/price/optimism-op" rel="nofollow noopener noreferrer" target="_blank">Ottimismo</a> tra i creditori di FTX. La maggior parte di loro crede ancora fortemente nelle criptovalute e è disposta a investire di più in esse. Ad esempio, Evan Luthra, investitore angelo e sviluppatore di app, ha dichiarato che il crollo di FTX non indica il fallimento di <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> o altre criptovalute.</p>
<p>In un’intervista con CNBC Luthra, che ha perso 2 milioni di dollari quando FTX ha chiesto il fallimento, ha detto: “Voglio che tutti capiscano che l’errore qui non è stato il bitcoin, l’errore non è stato la criptovaluta. La ragione fondamentale per cui noi <a href="/how-to-buy/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">comprare Bitcoin</a> Perché l’utilizzo di <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">bitcoin</a> non è cambiato.</p>
<p>Un altro ex cliente di FTX, Jake Thacker, ha detto: “Al momento sono in una situazione piuttosto difficile.” Tuttavia, ha aggiunto che “incoraggerei comunque le persone ad investire in criptovalute.”</p>
<p>Sunil Kavuri, un altro cliente di FTX, ha detto di non aver perso la speranza nelle criptovalute. Ha dichiarato che il crollo di FTX non ha scosso la sua fede nelle criptovalute. Ha detto: ‘Penso che le criptovalute… dovrebbero restare qui’.</p>
<h2 id="h2-Ultime20notizie20su20FTX20e20SBF133418"><a name="Ultime notizie su FTX e SBF" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Ultime notizie su FTX e SBF</h2><p>L’impatto di quanto accaduto a FTX è di vasta portata. Ad esempio, il tribunale si sta ancora occupando di varie accuse contro Bankman-Fried. E SBF è ancora in carcere a seguito del crollo di FTX. Esaminiamo brevemente le questioni di tendenza che compongono le recenti notizie su FTX.</p>
<p><strong>Sam Bankman-Fried negato rilascio temporaneo</strong>: Il giudice Lewis Kaplan ha negato a Bankman-Fried il rilascio temporaneo per la durata del suo processo. Gli avvocati che rappresentano Bankman avevano richiesto il suo rilascio per consentire loro di esaminare insieme il materiale. Secondo i pubblici ministeri, gli avvocati di Bankman-Fried non hanno fornito prove convincenti della necessità del rilascio temporaneo.</p>
<p>Leggi anche: <a href="https://www.gate.io/blog_detail/3251" target="_blank">“Non c’è niente che io possa fare per renderlo positivo” La prospettiva di Sam Bankman-Fried su impatto e responsabilità</a></p>
<p><strong>CoinDesk vince un premio Loeb</strong>: CoinDesk ha vinto un importante premio giornalistico per aver trattato varie questioni di attualità relative a FTX e ai suoi <a href="https://www.gate.io/blog_detail/1748/disclosure-about-alameda-and-ftx-how-can-users-avoid-risks-when-organizations-are-in-chaos" target="_blank">società sorella Alameda Research</a>. Tracy Wang, Nick Baker, Ian Allison, Nikhilesh De, Cheyenne Ligon di Reilly Decker, Sam Reynolds e Sam Kessler hanno riportato ciò che è successo a FTX.</p>
<p>Leggi anche: <a href="https://www.gate.io/blog_detail/3219/former-ftx--utive-guilty-plea" target="_blank">L’ex dirigente di FTX, Riyan Salame, si dichiara colpevole</a></p>
<p><strong>Sam Bankman-Fried può utilizzare un laptop ‘Air-Gapped’</strong> Il tribunale ha permesso a Bankman-Fried di utilizzare un laptop ‘Air-Gapped’ per prendere appunti durante il suo processo in tribunale. Tuttavia, il laptop non avrà servizio internet. Inoltre, SBF non conserverà il laptop dopo le udienze in tribunale.</p>
<p>Leggi anche: <a href="https://www.gate.io/blog_detail/3017/ftx-sues-sam-bankman-fried-and-former-_s-for-1-billion" target="_blank">FTX cita in giudizio Sam Bankman-Fried e gli ex dirigenti per 1 miliardo di dollari</a></p>
<p><strong>La più grande truffa di Sam Bankman-Fried?</strong> Sam Bankman-Fried ha utilizzato mezzi fraudolenti, non etici, non professionali e manipolativi per far crescere il suo exchange di criptovalute FTX. Ad esempio, l’exchange è rimasto indietro durante la volatilità del mercato. Il suo servizio clienti era pessimo, mentre diversi venture capitalist hanno ingannato i clienti attraverso <a href="https://www.gate.io/explore/ftx-sbf" target="_blank">il loro clamore su SBF e l’exchange</a>.</p>
<h2 id="h2-Conclusione535023"><a name="Conclusione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusione</h2><p>I valori delle richieste di fallimento di FTX sono aumentati nel 2023 a causa di diversi fattori, tra cui la prospettiva del riavvio dello scambio FTX, la sua quota in Anthropic e l’aumento dei beni recuperati. Nel frattempo, il processo di Bankman-Fried è destinato a continuare.</p>
<h2 id="h2-Domande20frequenti20sullexchange20di20criptovalute20FTX418313"><a name="Domande frequenti sull’exchange di criptovalute FTX" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Domande frequenti sull’exchange di criptovalute FTX</h2><h3 id="h3-Cosa2020successo20con20il20fallimento20di20FTX935"><a name="Cosa è successo con il fallimento di FTX?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Cosa è successo con il fallimento di FTX?</h3><p>scambio di criptovalute FTX <a href="https://www.gate.io/explore/ftx-sbf" target="_blank">ha presentato istanza di fallimento nel novembre 2022</a> dopo essere diventata insolvente. Da allora ad oggi, ha recuperato parte dei suoi beni. Finora, ha recuperato più di $7,3 miliardi e gli sforzi di recupero sono ancora in corso.</p>
<h3 id="h3-Il20denaro20di20FTX20sar20recuperato667875"><a name="Il denaro di FTX sarà recuperato?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Il denaro di FTX sarà recuperato?</h3><p>La cripto exchange fallita FTX è in fase di recupero dei suoi fondi. Finora ha recuperato più di $7,3 miliardi. Tuttavia, c’è ancora la prospettiva di recuperare ulteriori fondi da alcune altre organizzazioni.</p>
<h3 id="h3-FTX20sta20chiudendo595694"><a name="FTX sta chiudendo?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>FTX sta chiudendo?</h3><p>FTX è stato chiuso nel novembre 2022 quando è diventato insolvente. Tuttavia, gli sforzi sono in corso per rilanciarlo dopo aver recuperato molti fondi. Lo scambio fallito ha già presentato una serie di documenti in tribunale nel tentativo di ri-lanciare lo scambio di criptovalute. Ci sono più di 75 offerenti interessati a ri-lanciare lo scambio.</p>
<h3 id="h3-Quanto20durer20il20fallimento20di20FTX93865"><a name="Quanto durerà il fallimento di FTX?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Quanto durerà il fallimento di FTX?</h3><p>Secondo le leggi degli Stati Uniti, un’azienda può rimanere in bancarotta per un massimo di 10 anni dalla data in cui ha presentato la documentazione in tribunale. Poiché FTX ha presentato la sua richiesta di fallimento ai sensi del Chapter 11, può riorganizzarsi e riavviare le sue operazioni prima che trascorrano i 10 anni.</p>
<div class="blog-details-info"><br><div>Autore:<strong> Mashell C.</strong>, Ricercatore di Gate.io<br><div class="info-tips"><em>Questo articolo rappresenta solo le opinioni del ricercatore e non costituisce alcun suggerimento di investimento.<br></em><div><em></em>Gate.io si riserva tutti i diritti relativi a questo articolo. La ripubblicazione dell'articolo sarà consentita a condizione Gate.io sia referenziato. In tutti i casi, verranno intraprese azioni legali a causa della violazione del copyright.<br></div><p></p><br></div></div></div>