TGEgcHJvc3BldHRpdmEgZGkgU2FtIEJhbmttYW4tRnJpZWQgc3UgaW1wYXR0byBlIHJlc3BvbnNhYmlsaXTDoDogJ05vbiBjJ8OoIG51bGxhIGNoZSBwb3NzYSBmYXJlIHBlciByZW5kZXJsYSBwb3NpdGl2YSc=

2023-09-28, 03:07

<p><img src="https://gimg2.gateimg.com/image/article/1690791857hotspot.jpeg" alt=""></p>
<h2 id="h2-TL20DR476371"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p>Sam Bankman-Fried, che sta affrontando processi per diverse accuse penali, si sente depresso e senza speranza.</p>
<p>SBF ha dichiarato la sua innocenza rispetto alle accuse a lui rivolte, tra cui l’appropriazione indebita dei fondi dei clienti di FTX.</p>
<p>La cattiva gestione finanziaria e lo stile di vita sontuoso di Bankman-Fried potrebbero aver contribuito al crollo di FTX.</p>
<h2 id="h2-Introduzione17709"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>Prima <a href="https://www.gate.io/blog_detail/1777/ftx%E4%BA%8B%E4%BB%B6%E8%BF%9B%E8%A1%8C%E6%97%B6-%E5%A4%9A%E7%B1%B3%E8%AF%BA%E9%AA%A8%E7%89%8C%E5%80%92%E5%90%91%E4%BD%95%E6%96%B9" target="_blank">il crollo di FTX nel 2022</a>, Sam Bankman-Fried era diventato una delle persone più prominenti nel settore delle criptovalute poiché possedeva un vivace scambio di criptovalute. Alcune persone lo hanno acclamato come salvatore dell’industria delle criptovalute dopo aver salvato due società di criptovalute da un’imminente implosione. Tuttavia, la sua fama è svanita quando l’exchange FTX e la sua azienda affiliata Alameda Research hanno avuto un crollo.</p>
<p>In questo post, discuteremo di come Bankman-Fried sia diventato senza speranza e si sente incapace di avere un impatto positivo sul settore delle criptovalute. Includeremo anche una breve cronologia degli eventi che hanno portato al crollo del exchange di criptovalute FTX.</p>
<p>Notizie correlate: <a href="https://www.gate.io/de/blog_detail/3197/sbf-pays-witnesses-post-ftx-collapse" target="_blank">SBF vuole pagare i testimoni esperti $ 1200 all’ora</a></p>
<h2 id="h2-BankmanFried20Una20caduta20dalla20prominenza20alla20disgrazia749425"><a name="Bankman-Fried: Una caduta dalla prominenza alla disgrazia" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Bankman-Fried: Una caduta dalla prominenza alla disgrazia</h2><p>Al momento della stesura, Sam Bankman-Fried, fondatore e ex CEO dello scambio di criptovalute FTX, sente di essere ora impotente nell’avere un impatto sul settore delle criptovalute come in passato. Ecco perché ha detto: “Sono al verde, indosso un braccialetto elettronico e sono una delle persone più odiati al mondo. Probabilmente non ci sarà mai nulla che io possa fare per avere un impatto positivo netto durante la mia vita.”</p>
<p>Secondo le sue 250 pagine di scritti che ha compilato da quando è stato agli arresti domiciliari, iniziati nel dicembre 2022, Bankman-Fried, popolarmente conosciuto come SBF, ha detto che ora è molto difficile per lui cambiare la percezione negativa che le persone hanno di lui. Di conseguenza, ha detto che si sente “senza soldi” e “odiato”.</p>
<p>Al momento non è chiaro come Tiffany Fong, una giornalista/Youtuber di criptovalute, abbia ottenuto il pezzo di scrittura di Bankman-Fried che ha condiviso con il New York Times. Alcuni dei testi sono post pianificati su X (ex Twitter) che chiariscono il suo ruolo nel crollo di FTX e delle sue affiliate correlate.</p>
<p>Leggi anche: <a href="https://www.gate.io/de/blog_detail/2390/ftx-shows-massive-shortfalls-in-firms-assets" target="_blank">FTX Mostra enormi carenze negli asset della società</a></p>
<p>In modo significativo, Bankman-Fried attribuisce la colpa per il collasso di FTX ad alcuni dei suoi compatrioti, tra cui Caroline Ellison, la sua ex ragazza e l’ex CEO di Alameda Research.</p>
<p>Notizie correlate: <a href="https://www.gate.io/tr/blog_detail/2867/alameda-s-700m-pursuit-for-celebrity-political-access" target="_blank">La ricerca da 700 milioni di dollari di Alameda per l’accesso politico-celebrità</a></p>
<p>In un altro documento trapelato, Bankman-Fried ha fornito dettagli sul contributo di Ellison al <a href="https://www.gate.io/th/blog_detail/1748/disclosure-about-alameda-and-ftx-how-can-users-avoid-risks-when-organizations-are-in-chaos" target="_blank">fallimento della società di scambio FTX e Alameda Research</a>. Lui scrisse: “Lei evitava continuamente di parlare di gestione del rischio - eludendo i miei suggerimenti - fino a quando non era troppo tardi. […] Ogni volta che mi sono rivolto con dei suggerimenti, le faceva solo sentire peggio. Sono sicuro che essere ex non ha aiutato.”</p>
<p>Nel frattempo, Bankman-Fried sostiene di non essere a conoscenza del fatto che Alameda Research stesse appropriandosi indebitamente dei fondi dei clienti fino a quando non lo ha sentito da un gruppo di dipendenti che ne discutevano tra loro nella primavera del 2022.</p>
<p>Ultime notizie: <a href="https://www.gate.io/blog_detail/3102/-singapore-temasek-misplaced-trust-ftx" target="_blank">Singapore Temasek Named in FTX amidst Struggles</a></p>
<h2 id="h2-BankmanFried20dichiara20innocenza20nonostante20molte20prove20contro20di20lui920256"><a name="Bankman-Fried dichiara innocenza nonostante molte prove contro di lui" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Bankman-Fried dichiara innocenza nonostante molte prove contro di lui</h2><p>Bankman-Fried, accusato di <a href="https://www.gate.io/explore/ftx-sbf" target="_blank">vari reati tra cui l’uso improprio dei fondi dei clienti, frode telematica e riciclaggio di denaro, si è dichiarato innocente delle accuse</a>. Tuttavia, di recente il giudice Lewis A. Kaplan ha respinto la richiesta di Bankman-Fried di essere rilasciato prima del processo in modo da potersi preparare completamente per il caso.</p>
<p>Secondo il giudice Kaplan, la richiesta di rilascio prima del processo presentata da Bankman-Fried manca di merito. Ha detto: “L’imputato ignora in gran parte il fatto che ha avuto ampio accesso alla maggior parte dell’ESI (elettronicamente conservato scoperta e altro materiale) per 7 ½ mesi prima che la sua cauzione fosse revocata.”</p>
<p>Sam Bankman-Fried, nato nel 1992 e laureato in fisica presso il Massachusetts Institute of Technology (MIT), ha fondato l’exchange di criptovalute FTX nel 2018. Ha anche co-fondato Alameda Research, una società di trading quantitativo specializzata in criptovalute.</p>
<p>Secondo Forbes, <a href="https://www.gate.io/blog_detail/1792/ftx-event-and-its-domino-effects" target="_blank">prima del crollo di FTX</a>, La fortuna finanziaria di Bankman-Fried era di circa $26,5 miliardi. Di conseguenza, è diventato uno dei principali donatori per i Democratici negli Stati Uniti, contribuendo con oltre $5,2 milioni alla campagna politica del presidente Joe Biden nel 2020.</p>
<p>Non c’è dubbio che Bankman-Fried fosse una delle persone più ricche del mondo nel 2022 prima del crollo dello scambio di criptovalute. <a href="https://www.gate.io/price/ftx-ftt" target="_blank">FTX</a>, e Alameda Research. Tuttavia, la storia è diversa ora considerando che è agli arresti domiciliari e sta combattendo per dimostrare la sua innocenza a una moltitudine di gravi accuse penali di alto livello.</p>
<p>Purtroppo, Bankman-Fried è ora associato a uno dei più grandi frodi finanziarie della storia. Il 13 dicembre 2022, Damian Williams, il procuratore degli Stati Uniti per il distretto meridionale di New York, ha annunciato un’accusa di frode a otto punti contro di lui che includeva un grave maltrattamento dei fondi dei clienti.</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>
<h2 id="h2-Scambio20di20criptovalute20FTX20di20SBF764044"><a name="Scambio di criptovalute FTX di SBF" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Scambio di criptovalute FTX di SBF</h2><p>Una breve informazione di sfondo sulla borsa di criptovalute FTX di proprietà di SBF può permetterti di capire come Bankman-Fried sia caduto dal prestigio alla disgrazia.</p>
<p>Nel 2021 FTX, fondata nel 2018, è stata la terza più grande piattaforma di scambio di criptovalute al mondo. Il suo portafoglio comprendeva prodotti con leva finanziaria e derivati. Inoltre, forniva anche il trading spot per oltre 300 coppie di criptovalute come BTC/USDT, <a href="/price/xrp-xrp" rel="nofollow noopener noreferrer" target="_blank">XRP</a>/USDT, <a href="/trade/ETH_USDT" target="_blank" class="blog_inner_link">ETH/USDT</a> e FTT/USDT.</p>
<p>In generale, FTX aveva due unità, FTX con sede nelle Bahamas e la sua controparte FTX US, che avevano squadre di gestione sovrapposte, qualcosa che ha contribuito al suo declino. Tuttavia, le due unità avevano strutture di capitale separate.</p>
<p>Entrambi gli exchange offrivano prodotti simili che includevano mercati spot, futures, contratti MOVE, token con leva e opzioni. In un momento FTX è stato valutato a oltre $32 miliardi, equivalente a circa 25 miliardi di sterline britanniche. In passato aveva un volume di scambi giornaliero di $10-$15 miliardi, una cifra che solo pochi exchange di criptovalute raggiungeranno nel 2022.</p>
<p>Inoltre, l’exchange FTX aveva la sua criptovaluta nativa <a href="https://www.gate.io/learn/articles/what-is-ftx-token/397 &quot;called FTX token (FTT" rel="nofollow noopener noreferrer" target="_blank">chiamato token FTX (FTT)</a>”) che ha attirato molti trader. In particolare, lo scambio usava dare sconti ai clienti che scambiavano FTT. È importante notare che Alameda Research era uno dei maggiori detentori di FTT.</p>
<p>Inoltre, FTX supporta nove valute fiat, tra cui il dollaro americano, il dollaro australiano, il dollaro canadese, l’euro, la sterlina britannica, il cedi ghanese, il franco svizzero, il peso argentino e il real brasiliano.</p>
<p>Lo stile di vita di Bankman-Fried potrebbe aver contribuito all’implosione di FTX. Anche se si è dipinto al pubblico come un uomo semplice che una volta indossava abiti insignificanti, ha vissuto uno stile di vita sontuoso alle Bahamas che, tuttavia, ha attirato meno attenzione pubblica.</p>
<h2 id="h2-Come20FTX20Crypto20Exchange2020caduto20dalla20dominanza20al20fallimento640465"><a name="Come FTX Crypto Exchange è caduto dalla dominanza al fallimento" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Come FTX Crypto Exchange è caduto dalla dominanza al fallimento</h2><p>Durante la metà del 2022 nessuna persona sana avrebbe immaginato che lo scambio FTX avrebbe vacillato e fallito. Tuttavia, nell’ottobre dello stesso anno diversi eventi si sono svolti portando al totale fallimento dello scambio di criptovalute.</p>
<p>Un articolo di notizie crittografiche pubblicato da CoinDesk a ottobre ha scatenato la caduta di FTX. L’articolo suggeriva che la sostenibilità di Alameda Research dipendesse dal suo ampio possesso di FTT, non da un asset crittografico indipendente.</p>
<p>Intorno allo stesso tempo, il Wall Street Journal ha anche pubblicato l’informazione che Alameda Research aveva utilizzato i depositi dei clienti di FTX come garanzia per i suoi prestiti per il trading.</p>
<p>Qualche giorno dopo, Binance ha venduto la sua partecipazione in FTT al pubblico a seguito delle informazioni pubblicate da CoinDesk e Wall Street Journal. In effetti, i dettagli emergenti sui “fondi dei clienti mal gestiti e presunte indagini dell’agenzia statunitense” hanno costretto Binance a dissociarsi dall’exchange FTX.</p>
<p>Questi eventi hanno creato panico tra gli utenti di FTX che hanno iniziato a ritirare la maggior parte dei loro fondi. Infatti, nel giro di poco tempo i clienti hanno prelevato miliardi di dollari. Di conseguenza, lo scambio ha interrotto i prelievi mentre Bankman-Fried cercava modi per salvare lo scambio. Tuttavia, alla fine lo scambio è fallito.</p>
<p>Attualmente, Bankman-Fried è sotto processo negli Stati Uniti per i vari crimini che si ritiene abbia commesso. Già diversi ex dirigenti di FTX, tra cui Riyan Salame, Caroline Ellison (ex amministratore delegato di Alameda), Gary Wang (ex responsabile della tecnologia di FTX) e Nishad Singh (ex responsabile dell’ingegneria di FTX), hanno dichiarato colpevole delle accuse a loro rivolte.</p>
<h2 id="h2-Conclusione468647"><a name="Conclusione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusione</h2><p>Sam Bankman-Fried si sente depresso e odiato dopo il crollo dello scambio di criptovalute FTX nel 2022 e la causa legale che sta affrontando negli Stati Uniti. La verità è che molte persone che lo consideravano una figura importante nel settore delle criptovalute ora lo vedono come un truffatore.</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 su questo articolo. Sarà consentito ripostare l'articolo a condizione che si faccia riferimento a Gate.io. In tutti i casi, saranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div>