RlRYIFN1ZXMgU2FtIEJhbmttYW4tRnJpZWQgYW5kIEZvcm1lciBFeGVjcyBmb3IgJDEgQmlsbGlvbg==

2023-08-03, 09:42

<p><img src="https://gimg2.gateimg.com/image/article/1691055577RDZZ.jpeg" alt=""></p>
<h2 id="h2-In20breve20non20ho20letto348310"><a name="In breve; non ho letto" class="reference-link"></a><span class="header-link octicon octicon-link"></span>In breve; non ho letto</h2><p>Citando Sam Bankman e i suoi ex dirigenti, FTX mira a recuperare alcuni fondi per pagare i clienti i cui asset sono stati congelati.</p>
<p>“Gary” Wang, Nishad Singh e Caroline Ellison sono gli altri dirigenti che stanno affrontando processi in tribunale negli Stati Uniti per l’appropriazione indebita di fondi dei clienti.</p>
<p>Mentre Ellison, Wang e Singh si sono dichiarati colpevoli delle accuse a loro contestate, Bankman-Fried si è dichiarato innocente.</p>
<h2 id="h2-Introduzione707231"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>Non c’è stata alcuna chiusura della questione dello scambio di criptovalute FTX in quanto ci sono ancora battaglie legali tra alcune parti coinvolte. Oltre ai creditori che ritengono di poter ottenere un risarcimento per le loro perdite, FTX ha recentemente citato in giudizio il suo fondatore Sam Bankman-Fried (SBF) e alcuni dei suoi ex dirigenti. In questo articolo esploriamo diversi problemi relativi alle cause di FTX contro i suoi ex dipendenti senior e il fondatore.</p>
<h2 id="h2-FTX20Sues20Sam20BankmanFried911392"><a name="FTX Sues Sam Bankman-Fried," class="reference-link"></a><span class="header-link octicon octicon-link"></span>FTX Sues Sam Bankman-Fried,</h2><p>Con una mossa che ha sorpreso molte persone, FTX ha intentato una causa contro il suo fondatore Sam Bankman-Fried, popolarmente noto come SBF, e i suoi ex dirigenti per appropriazione indebita di oltre 1 miliardo di dollari durante un periodo in cui l’exchange era finanziariamente instabile e anche dopo il fallimento di FTX.</p>
<p>In particolare, FTX ha citato in giudizio Samuel Bankman-Fried, suo fondatore e ex CEO, Zixiao “Gary” Wang, ex responsabile della tecnologia di FTX, Nishad Singh, direttore ingegneria, e Caroline Ellison, responsabile di Alameda Research, il fondo di copertura. Secondo i rappresentanti di FTX, l’appropriazione indebita di circa 1 miliardo di dollari, in un momento in cui la cripto exchange stava lottando finanziariamente, ha portato la cripto exchange al fallimento.</p>
<p>Il 20 luglio FTX ha presentato una causa presso il Tribunale fallimentare degli Stati Uniti accusando il fondatore e i precedenti dirigenti senior di violazione dei doveri fiduciari attraverso l’utilizzo dei fondi dei clienti a beneficio personale.</p>
<p>Secondo la denuncia, parte dei fondi è stata utilizzata per investimenti ad alto rischio, alloggi di lusso e donazioni a scopo politico e benefico. Per questo motivo, FTX sostiene che tale appropriazione indebita di fondi aziendali sia stata “una delle più grandi truffe finanziarie della storia.”</p>
<p>Inoltre, l’azienda sostiene che i convenuti abbiano creato un ambiente aziendale poco salutare in cui alcuni dipendenti esercitavano una grande influenza e avevano il controllo delle decisioni aziendali chiave, come l’utilizzo dei fondi istituzionali. Questo è il motivo per cui sono stati in grado di allocare criptoattività e valuta fiat in modo arbitrario per scopi dubbi e personali. Avevano anche un’enorme potere nel reclutamento dei dipendenti o nella risoluzione dei loro contratti.</p>
<h2 id="h2-Suddivisione20dei20fondi20appropriati20indebitamente590195"><a name="Suddivisione dei fondi appropriati indebitamente" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Suddivisione dei fondi appropriati indebitamente</h2><p>I fondi appropriati sono stati gestiti da diverse persone, tra cui Sam Bankman-Fried (SBF), Wang ed Ellison. Secondo i documenti depositati, gli ex dirigenti hanno appropriato un totale di 725 milioni di dollari di equità FTX per il loro beneficio personale senza fornire alcun valore equivalente all’organizzazione o alle sue aziende collegate.</p>
<p>Il querelante ha affermato che Bankman-Fried viveva una vita lussuosa e portava avanti vari progetti personali utilizzando i fondi di FTX. In particolare, Bankman-Fried ed Ellison hanno utilizzato 546 milioni di dollari per l’acquisto di beni personali. Ad esempio, SBF ha utilizzato la sua quota per acquistare azioni di Robinhood Markets, mentre Ellison ha ottenuto un bonus di 28,8 milioni di dollari. Ha inoltre investito 10 milioni di dollari nella sua attività di intelligenza artificiale.</p>
<p>Ancora una volta, FTX sostiene che SBF abbia regalato a suo padre, Joseph Bankman, professore di legge alla Stanford Law School, 10 milioni di dollari. Tuttavia, la denuncia ha anche affermato che Joseph Bankman ha utilizzato parte di quella somma per finanziare la difesa criminale di SBF.</p>
<p>Anche gli altri dirigenti, inclusi Wang e Singh, hanno tratto vantaggio dai fondi appropriati indebitamente. Oltre all’appropriazione indebita dei fondi, si sostiene che gli individui accusati abbiano omesso di tenere registrazioni appropriate delle varie transazioni effettuate.</p>
<p>Allo stesso modo, non c’era alcun controllo delle spese sostenute dall’organizzazione. Inoltre, hanno anche oscurato varie attività illegali.</p>
<p>Purtroppo, c’è stata anche una mancanza di sicurezza informatica per proteggere i fondi dei clienti, l’azienda e le sue attività affiliate da hacking e attività fraudolente. Secondo i documenti giudiziari, queste attività commerciali fraudolente sono avvenute tra febbraio 2020 e novembre 2022.</p>
<p>Ciò che rende le cose peggiori è che parte dell’appropriazione indebita dei fondi è avvenuta dopo che FTX ha presentato istanza di fallimento ai sensi del Capitolo 11. Fatto sta che FTX ha presentato istanza di fallimento ai sensi del Capitolo 11 nel novembre seguente all’implosione del suo token nativo FTT. Si sostiene anche che parte dei fondi dell’azienda sia stata trasferita ad Alameda Research, sua azienda controllata che ha perso oltre 8 miliardi di dollari dei clienti.</p>
<h2 id="h2-Cosa20rende20le20accuse20gravi164470"><a name="Cosa rende le accuse gravi?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Cosa rende le accuse gravi?</h2><p>Il fatto è che la maggior parte di queste transazioni fraudolente si sono verificate quando lo scambio FTX era già in uno stato di insolvenza, una cosa che gli imputati sapevano. Questa è la ragione per cui John Ray, il nuovo CEO, ha intrapreso la via legale per recuperare alcuni degli asset dei clienti che sono stati appropriati indebitamente.</p>
<p>La società ha anche reclamato danni che potrebbero aiutare a recuperare circa 1 miliardo di dollari nel tentativo di pagare i clienti i cui asset sono stati congelati dopo il crollo di FTX. È importante notare che ai sensi della legge fallimentare del Delaware o degli Stati Uniti, i trasferimenti presunti sono reversibili.</p>
<p>Ray è un noto avvocato che in passato ha recuperato molti fondi per aziende in bancarotta. È interessante notare che Caroline Allison, ex CEO di Alameda Research, sarà una testimone chiave nel processo agli ex dirigenti dell’exchange FTX. Ellison, Wang e Singh si sono già dichiarati colpevoli delle accuse, mentre Bankman-Fried si è dichiarato innocente delle accuse mosse contro di lui.</p>
<h2 id="h2-Conclusion991364"><a name="Conclusion" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusion</h2><p>Le cause di FTX contro i suoi ex dirigenti, compreso il suo fondatore e CEO Bankman-Fried, mirano a recuperare parte dei fondi rubati per ripagare i clienti i cui asset sono stati congelati quando lo scambio ha dichiarato bancarotta. Gli altri imputati sono “Gary” Wang, Nishad Singh e Caroline Ellison. Nel frattempo Ellison, Wang e Singh hanno dichiarato colpevole delle accuse a loro rivolte.</p>
<h2 id="h2-Domande20frequenti20su20FTX20Samuel20BankmanFried923955"><a name="Domande frequenti su FTX Samuel Bankman-Fried" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Domande frequenti su FTX Samuel Bankman-Fried</h2><p><strong>Cosa sta succedendo con Sam Bankman?</strong></p>
<p>Sam Bankman sta affrontando un processo negli Stati Uniti per l’appropriazione indebita dei fondi dei clienti della piattaforma di scambio di criptovalute FTX. Diversi altri ex dirigenti di FTX, tra cui Gary Wang, Nishad Singh e Caroline Ellison, affrontano accuse simili.</p>
<p><strong>Cosa è successo a FTX Bankman?</strong></p>
<p>FTX Bankman è sotto processo in tribunale negli Stati Uniti a seguito del crollo dello scambio di criptovalute. È accusato di appropriazione indebita dei fondi dei clienti.</p>
<p><strong>Dove si trova Bankman-Fried ora?</strong></p>
<p>Bankman-Fried è negli Stati Uniti dove sta affrontando un processo in tribunale per l’appropriazione indebita dei fondi dei clienti FTX. Tuttavia, si è dichiarato non colpevole delle accuse.</p>
<p><strong>Cosa ha fatto Sam Bankman-Fried per FTX?</strong></p>
<p>Sam Bankman-Fried è accusato di appropriazione indebita dei fondi dei clienti di FTX. Attualmente è sotto processo negli Stati Uniti.</p>
<div class="blog-details-info"><br><div>Autore:<strong> Mashell C.</strong>, Ricercatore 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. La ripubblicazione dell'articolo sarà consentita a condizione che si faccia riferimento a Gate.io. In tutti i casi, verranno intraprese azioni legali a causa di violazioni del copyright.<br></div><p></p><br></div></div></div>