RlRYIEZvdW5kZXIgU2FtIEJhbmttYW4tRnJpZWQgVHJvdmF0byBDb2xwZXZvbGUgZGkgVHV0dGUgbGUgQWNjdXNlOiBVbidBbmFsaXNpIERldHRhZ2xpYXRhIGRlbGxhIFNlbnRlbnph

2023-11-15, 04:53

<p><img src="https://gimg2.gateimg.com/image/article/1700023506SDFX 1.jpeg" alt=""></p>
<h2 id="h2-TL20DR164946"><a name="TL; DR" class="reference-link"></a><span class="header-link octicon octicon-link"></span>TL; DR</h2><p>Una giuria di New York ha condannato Sam Bankman-Fried per 7 capi d’accusa <a href="https://www.gate.io/explore/ftx-sbf" target="_blank">relativo al crollo di FTX</a>.</p>
<p>Gary Wang, Nishad Singh e Caroline Ellison hanno dichiarato di essere colpevoli delle accuse a loro rivolte riguardanti il collasso di FTX.</p>
<p>Il Tribunale Federale stabilirà la sentenza di Bankman-Fried nel marzo 2024.</p>
<h2 id="h2-Introduzione60866"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>Il processo di Sam Bankman-fried sta per giungere alla fine dopo che un tribunale federale ha stabilito che è colpevole di tutte le 7 accuse mosse contro di lui. Tuttavia, il giudice non ha ancora pronunciato la sentenza, che è probabile che arrivi nel marzo 2024. Vi è una forte probabilità che Sam Bankman-Fried possa passare decenni in prigione.</p>
<p>Questo articolo discuterà delle accuse di cui il tribunale ha ritenuto colpevole Bankman-Fried. Si concentrerà anche sulle possibili conseguenze del verdetto nei suoi confronti e sullo scambio di criptovalute FTX.</p>
<h2 id="h2-BankmanFried20condannato20per20tutte20le20accuse876883"><a name="Bankman-Fried condannato per tutte le accuse" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Bankman-Fried condannato per tutte le accuse</h2><p>Un tribunale federale ha trovato Sam Bankman-Fried, il fondatore di FTX e Alameda Research, colpevole di truffare investitori, creditori e altri clienti di miliardi di dollari in un caso che è stato etichettato come la più grande truffa finanziaria nella storia degli Stati Uniti d’America.</p>
<p>La giuria di New York ritiene che Bankman-Fried abbia truffato i clienti dello scambio di criptovalute FTX di più di 10 miliardi di dollari. Tuttavia, Bankman-Fried ha sempre negato di aver truffato gli investitori di FTX.</p>
<p>In breve, Bankman-Fried è stato condannato per frode via cavo ai danni di clienti e creditori, nonché per 5 capi di accusa di cospirazione in relazione a titoli, materie prime e riciclaggio di denaro.</p>
<p><strong>Frode tramite bonifico bancario/cospirazione per commettere frode tramite bonifico bancario ai danni dei clienti di FTX: </strong>Il problema più grande contro Bankman-Fried è stato la perdita dei fondi dei clienti. Bankman-Fried ha truffato i clienti permettendo ad Alameda Research di attingere ai fondi di FTX.</p>
<p>Nella maggior parte dei casi, i clienti hanno depositato i fondi che volevano scambiare nei conti bancari di Alameda Research. Di conseguenza, Alameda Research ha utilizzato i fondi come ha ritenuto necessario.</p>
<p><strong>Truffa telematica/cospirazione per commettere truffa telematica ai danni dei creditori di Alameda:</strong> Il problema principale qui è che Alameda Research ha manomesso il bilancio che ha inviato a società come Genesis e <a href="https://www.gate.io/blog_detail/1241/v2lsbcbcbg9ja0zpiejlifrozsbozxh0ifrviezhbgw" target="_blank">BlockFi</a> voleva prendere in prestito fondi da.</p>
<p>In termini semplici, l’azienda ha intenzionalmente falsificato i suoi rapporti finanziari inviati ai partner chiave. Il tribunale ha ritenuto responsabile Bankman-Fried perché ha approvato i rapporti.</p>
<p><strong>Cospirazione per commettere frode sui titoli contro gli investitori di FTX:</strong> L’exchange cripto FTX ha mentito ai suoi partner su come utilizza i suoi fondi. L’esecutivo ha anche fornito cifre errate sulle entrate che l’exchange generava dalle sue attività operative.</p>
<p>Ancora più importante, Alameda Research non ha divulgato le perdite che stava subendo. Tutto ciò ha portato i suoi partner commerciali a prendere decisioni di investimento errate. Aziende come Paradigm e Third Point hanno preso decisioni di investimento basate su informazioni errate.</p>
<p><strong>Cospirazione per commettere frodi sulle materie prime contro i clienti di FTX:</strong> Questo era una cospirazione per rubare criptovalute come <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Alessio</a> e ETH che la regolamentazione della SEC classifica come materie prime. Questa accusa è simile alla prima: frode via filo/congiura <a href="https://www.gate.io/blog_detail/3017/ftx-sues-sam-bankman-fried-and-former-_s-for-1-billion" target="_blank">commettere frodi bancarie contro i clienti FTX</a>. Tuttavia, l’accusa principale riguarda i fondi degli investitori mentre questa si occupa di criptovalute che rientrano nelle materie prime degli Stati Uniti.</p>
<p><strong>Concussione per commettere riciclaggio di denaro:</strong> La SEC accusa Bankman-Fried di spostare i fondi dei clienti dalla borsa FTX <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">a Alameda Research</a> dove è stato utilizzato per scopi non correlati come fare donazioni politiche. Principalmente, Bankman-Fried non è riuscito a scagionarsi da queste accuse che hanno portato alla sua condanna.</p>
<h2 id="h2-Background20della20saga20dellexchange20criptovalutario20FTX747987"><a name="Background della saga dell’exchange criptovalutario FTX" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Background della saga dell’exchange criptovalutario FTX</h2><p>In precedenza, abbiamo discusso<br><strong>7 accuse contro SBF</strong>. Capisci brevemente come si è svolta la saga nel 2022. Diversi eventi hanno portato al crollo di FTX e alla successiva causa della SEC.</p>
<p>Quasi 1 anno fa Ian Allison, un reporter presso <a href="https://www.coindesk.com/business/2022/11/02/divisions-in-sam-bankman-frieds-crypto-empire-blur-on-his-trading-titan-alamedas-balance-sheet/" rel="nofollow noopener noreferrer" target="_blank">CoinDesk ha pubblicato una richiesta</a> dopo che Alameda Research ha detenuto grandi quantità di FTT, il token nativo di FTX. Dopo questa rivelazione, Changpeng Zhao, CEO di Binance, ha dichiarato che si sarebbe ritirato da FTX. Questi due eventi hanno portato a una corsa su FTX che ha costretto lo scambio, Alameda Research e le sue altre sussidiarie a <a href="https://www.gate.io/blog_detail/3284" target="_blank">dichiarare bancarotta</a>.</p>
<p>Gli altri ex dirigenti di FTX, tra cui Gary Wang, Chief Technology Officer, Nishad Singh, ex responsabile dell’ingegneria e Caroline Ellison, ex CEO di Alameda Research, si sono dichiarati colpevoli di queste accuse.</p>
<p>In seguito, la maggior parte di loro è diventata testimone contro Bankman-Fried. Dopo il collasso di FTX, Bankman-Fried si è dimesso come CEO. Successivamente, è stato arrestato alle Bahamas ed estradato negli Stati Uniti per essere processato per le sue malefatte.</p>
<p>Ad agosto il giudice distrettuale degli Stati Uniti Lewis Kaplan ha revocato la cauzione a Bankman-Fried, accusandolo di aver cercato di influenzare le chiavi federali testimoni come Ellison, sua ex-ragazza. Da allora è stato in prigione al Metropolitan Detention Center di Brooklyn.</p>
<p>È importante notare che Bankman-Fried sarà comunque processato per altre 5 accuse nel marzo 2024. Le accuse includono gestire un’attività di trasmissione di denaro non autorizzata, frode bancaria e violazione dello statuto di corruzione attiva della legge sulle pratiche di corruzione straniera.</p>
<h2 id="h2-Conseguenze20del20verdetto20di20BankmanFried719737"><a name="Conseguenze del verdetto di Bankman-Fried" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conseguenze del verdetto di Bankman-Fried</h2><p>Ciascuna delle accuse di cui è stato riconosciuto colpevole Bankman-Fried comporta una condanna compresa tra 5 e 20 anni. Ciò significa che potrebbe trascorrere fino a 115 anni in prigione, a meno che non sconti alcune delle condanne contestualmente. Tuttavia, Bankman-Fried deve aspettare fino a marzo 2024 per sentire la sua condanna.</p>
<p>La procedura prevede che i pubblici ministeri raccomandino la sentenza entro il 15 marzo 2024. Ciononostante, il giudice della corte distrettuale degli Stati Uniti Lewis Kaplan avrà l’ultima parola su questo. È anche importante notare che Bankman-Fried ha il diritto di appellarsi sia contro la condanna che contro la sentenza.</p>
<p>Teddy Schleifer, un membro del team di difesa di Bankman-Fried, ha lasciato intendere la sua volontà di appellarsi contro la condanna. Pubblicando su X <a href="https://twitter.com/teddyschleifer/status/1720233526048510333" rel="nofollow noopener noreferrer" target="_blank">Schleifer ha detto</a>“Rispettiamo la decisione della giuria. Ma siamo molto delusi dal risultato. Il signor Bankman Fried afferma la sua innocenza e continuerà a combattere vigorosamente le accuse mosse contro di lui.”</p>
<p>Prima di ricevere la sua condanna, Bankman-Fried rimarrà nel Metropolitan Detention Center di Brooklyn, dove è stato collocato ad agosto.</p>
<h2 id="h2-La20conseguenza20della20condanna20di20BankmanFried20su20FTX795345"><a name="La conseguenza della condanna di Bankman-Fried su FTX" class="reference-link"></a><span class="header-link octicon octicon-link"></span>La conseguenza della condanna di Bankman-Fried su FTX</h2><p>Legalmente, FTX potrebbe continuare le sue operazioni sotto una nuova leadership. <a href="https://twitter.com/AFTXcreditor/status/1662816040231862275" rel="nofollow noopener noreferrer" target="_blank">Un account X, la Coalizione FTX 2.0, ha dato un’anticipazione</a> che ci sono diversi offerenti per FTX. Ha scritto: “Diversi potenziali offerenti per FTX 2.0 ci hanno contattato. Crediamo che incentivare i clienti-creditori attraverso un potenziale di guadagno aumenti notevolmente sia il tasso di successo che il potenziale. Una volta che tutte le opzioni sono sul tavolo, supporteremo l’offerta più favorevole al recupero ottimale dei creditori.”</p>
<p>Il verdetto su Bankman-Fried è improbabile che influenzi le prestazioni di FTX se un’azienda o un individuo affidabile lo acquisisce. CNBC cita Gary Gensler, presidente della SEC, dicendo che chiunque può acquisire e riavviare lo scambio di criptovalute FTX.</p>
<p><a href="https://www.cnbc.com/2023/11/08/secs-gensler-says-rebooted-ftx-is-possible-if-done-within-the-law.html" rel="nofollow noopener noreferrer" target="_blank">Secondo CNBC</a> Gensler ha detto: “Se Tom o chiunque altro volesse essere in questo settore, direi: ‘Fallo nel rispetto della legge. Costruisci la fiducia degli investitori in ciò che stai facendo e assicurati di fare le dovute divulgazioni - e anche di non mescolare tutte queste funzioni, fare trading contro i tuoi clienti. O utilizzare i loro asset criptati per i tuoi scopi.”</p>
<h2 id="h2-Conclusion100133"><a name="Conclusion" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusion</h2><p>Il fondatore di FTX, Sam Bankman-Fried, è stato condannato per 7 capi d’accusa derivanti dal crollo dello scambio. Allo stesso modo, gli altri dirigenti di FTX, tra cui Gary Wang, Nishad Singh e Caroline Ellison, hanno dichiarato di essere colpevoli delle stesse accuse. Il giudice emetterà la sentenza di Bankman-Fried il 28 marzo 2024. Nel frattempo, SBF rimarrà nel Metropolitan Detention Center a Brooklyn.</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 il ripostaggio dell'articolo a condizione che sia citato Gate.io. In tutti i casi, verranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div>