U0JGIHZ1b2xlIHBhZ2FyZSBpIHRlc3RpbW9uaSBlc3BlcnRpICQxLjIwMCBhbGwnb3Jh

2023-09-13, 10:36

<p><img src="https://gimg2.gateimg.com/image/article/1694601156RDZZ 1.jpeg" alt=""></p>
<h2 id="h2-In20poche20parole20in20breve779458"><a name="In poche parole; in breve" class="reference-link"></a><span class="header-link octicon octicon-link"></span>In poche parole; in breve</h2><p>Bankman-Fried è disposto a pagare i testimoni esperti fino a $1.200 all’ora.</p>
<p>I pubblici ministeri federali intendono vietare i testimoni specialisti di SBF.<br>La difesa legale di SFB ha affermato che l’aumento continuo dei documenti di prova dello stato contro Bankman-Fried è probabile che ostacoli un processo equo contro di lui.</p>
<h2 id="h2-Introduzione789979"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>Il caso di Sam Bankman-Fried, accusato di appropriazione indebita dei fondi dei clienti di FTX, sta per riprendere in qualsiasi momento tra ottobre e marzo 2024. Ciò segue la possibilità del rinvio del processo da ottobre a marzo 2024. Secondo il giudice Kaplan, <a href="https://www.gate.io/blog_detail/2394/market-trend-sbf-pleads-not-guilty-bribery-unicef-plans-prototype-dao-following-crypto-injection &quot;Bankman-Fried (SBF" rel="nofollow noopener noreferrer" target="_blank">Bankman-Fried (SBF)</a>”) ha il diritto di richiedere un rinvio del suo processo all’anno prossimo, qualora sia necessario.</p>
<p>Nel frattempo, SBF ha richiesto di presentare diversi esperti come suoi testimoni. Questo articolo discuterà del motivo per cui SBF ha assunto alcuni esperti come testimoni. Esamineremo anche perché alcuni pubblici ministeri potrebbero ostacolare i testimoni di SBF.</p>
<h2 id="h2-Sam20BankmanFried20assume20esperti20come20testimoni261325"><a name="Sam Bankman-Fried assume esperti come testimoni" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Sam Bankman-Fried assume esperti come testimoni</h2><p>Sam Bankman-Fried, il fondatore in difficoltà di FTX, sta cercando di utilizzare esperti come testimoni quando il suo processo riprende. La complessità del caso, che include varie accuse tra cui una cattiva governance aziendale internazionale e appropriazione indebita di <a href="https://www.gate.io/blog_detail/3102/singapore-temasek-misplaced-trust-ftx" target="_blank">Fondi dei clienti FTX</a>, ha costretto Bankman-Fried ad assumere esperti per testimoniare a suo favore.</p>
<p>Gli otto specialisti che Bankman-Fried desidera coinvolgere come suoi testimoni chiave includono un avvocato inglese e un direttore di una società di consulenza elettronica. Secondo le informazioni contenute in una lettera depositata in tribunale federale a Manhattan, il testimone testimonierà su diversi aspetti chiave che includono la legge sul finanziamento della campagna FTX, le valutazioni di FTX e Alameda Research, nonché i termini di servizio dello scambio e l’infrastruttura software.</p>
<p>Brian Kim, Joseph Pimbley, Lawrence Akka, Thomas Bishop, Peter Vinella, Andrew Di Wu e Bradley Smith sono alcuni dei testimoni esperti proposti da Bankman-Fried.</p>
<p>Secondo un rapporto di Bloomberg Law, Bankman-Fried è disposto a pagare a ciascun testimone specializzato fino a $1.200 all’ora. Tuttavia, non tutti riceveranno una tariffa fissa. Ad esempio, Bradley Smith, l’ex presidente della Commissione Federale delle Elezioni, vuole $1.200 all’ora per testimoniare su questioni legate ai prestanome degli Stati Uniti e alle leggi sul finanziamento elettorale.</p>
<p>Secondo Smith l’importo è un pagamento per il suo tempo e lo sforzo poiché non ha interesse nell’esito del caso. Ha detto: “Non ho interesse finanziario nell’esito di questo caso. Vengo compensato per il mio tempo e i miei servizi su base oraria al tasso di fatturazione di $1.200 all’ora.”</p>
<p>Le tariffe orarie per gli altri testimoni sono di $1,175; 800 sterline britanniche ($1,000); $720; $400 e $650. È fondamentale notare che Bankman-Fried, che sta negando le accuse a suo carico, non ha dichiarato la propria colpevolezza per nessuna delle accuse, tra cui l’utilizzo dei fondi dei clienti dello scambio FTX per investire in Alameda Research, l’acquisto di lussuose proprietà immobiliari e la donazione di fondi ai politici.</p>
<p>Bankman-Fried è coinvolto in una causa legale contro la SEC a seguito del crollo di FTX avvenuto nel novembre 2022. Dopo il <a href="https://www.gate.io/blog_detail/3017/ftx-sues-sam-bankman-fried-and-former-s-for-dollar1-billion" target="_blank">Crash di FTX</a> SBF ha affrontato diverse accuse tra cui riciclaggio di denaro, frode via filo nonché frodi di materie prime e titoli. Oltre alla causa della SEC, FTX contesta SBF per accuse simili nel tentativo di recuperare alcuni fondi rubati.</p>
<h2 id="h2-Probabilmente20i20pubblici20ministeri20impediranno20lutilizzo20di20testimoni20esperti175694"><a name="Probabilmente i pubblici ministeri impediranno l’utilizzo di testimoni esperti" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Probabilmente i pubblici ministeri impediranno l’utilizzo di testimoni esperti</h2><p>Secondo una fonte, i pubblici ministeri del Dipartimento di Giustizia degli Stati Uniti stanno pianificando di impedire ai testimoni esperti di Bankman-Fried di testimoniare. Hanno sostenuto che SBF desidera assumere gli esperti per sostenere la sua affermazione di innocenza.</p>
<p>Fondamentalmente, il loro punto di vista è che i testimoni esperti “invaderanno l’ambito della Corte e della giuria” e “non serviranno ad altro scopo se non quello di fornire una patina esperta a testimonianze inammissibili per sentito dire”. Impedendo le testimonianze degli esperti SBF, il tribunale sta esercitando il suo ruolo di gatekeeping.</p>
<p>Nel caso di Lawrence Akka, un avvocato inglese, gli accusatori sostengono che sia a conoscenza della giurisprudenza inglese, che serve a poco per la difesa di SBF. In realtà, gli accusatori hanno messo in dubbio la rilevanza di ciascuno dei periti proposti.</p>
<p>Nel frattempo, gli avvocati della difesa di SBF hanno depositato documenti in tribunale il 1 settembre opponendosi a diverse mozioni presentate dai pubblici ministeri federali. Ad esempio, il team di difesa ha sostenuto di non sollevare prove per le accuse che erano state precedentemente separate o abbandonate dal caso, come le violazioni del Foreign Corrupt Practices Act in cui SBF era accusata di tentare di corrompere funzionari nelle Bahamas.</p>
<p>La squadra di difesa dell’ex CEO di FTX ha sostenuto che il governo non ha fornito a Bankman-Fried l’accesso affidabile a Internet necessario per preparare il caso e discutere con il suo avvocato difensore. Sulla base di questa lamentela, il tribunale ha dichiarato che SBF può richiedere un rinvio del caso in modo da avere abbastanza tempo per prepararsi.</p>
<p>A tal proposito, <a href="https://twitter.com/innercitypress/status/1696938560396365840" rel="nofollow noopener noreferrer" target="_blank">Il giudice Kaplan ha detto</a> Se l’imputato ritiene di aver bisogno di una proroga, può chiederla. Non sto dicendo che gliela concederei necessariamente. Dovrebbero dimostrare un bisogno - non solo elencare il numero di documenti.</p>
<p>L’altra denuncia legale sollevata dal team legale di SBF è che i pubblici ministeri federali stanno condividendo milioni di pagine contenenti nuove informazioni che SBF in prigione potrebbe non avere le risorse per leggere e capire.</p>
<p>Il <a href="https://storage.courtlistener.com/recap/gov.uscourts.nysd.590939/gov.uscourts.nysd.590939.233.0.pdf" rel="nofollow noopener noreferrer" target="_blank">team ha detto</a>, “Il governo ha inviato per email alla difesa una lettera di presentazione in cui afferma che produrrà circa 3,7 milioni di pagine di scoperte da varie fonti. Ciò si aggiunge alle circa 4 milioni di pagine di scoperte che abbiamo ricevuto dal governo giovedì 24 agosto.”</p>
<p>Ha aggiunto: “Questo è solo un altro esempio del Governo che viola il calendario delle scoperte che ha promesso al Tribunale di seguire. Come stabilito nella nostra lettera del 25 agosto 2023, al Governo non dovrebbe essere permesso di scaricare enormi volumi di scoperte così vicino al processo, specialmente quando il signor Bankman-Fried non ha la possibilità pratica di rivederle date le condizioni del suo confinamento.”</p>
<p>L’argomento chiave è che dare a SBF in prigione una quantità così significativa di prove aggiuntive è probabile che ostacoli un processo equo.</p>
<h2 id="h2-Sviluppi20recenti20degni20di20nota20di20SBF20in20tempi20recenti734934"><a name="Sviluppi recenti degni di nota di SBF in tempi recenti" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Sviluppi recenti degni di nota di SBF in tempi recenti</h2><p>Come detto, la tensione è aumentata tra il team di difesa della causa FTX e i pubblici ministeri federali su diverse questioni, tra cui l’assunzione da parte di SBF di nuovi testimoni esperti. Ciò che rende la situazione peggiore è il fatto che SBF è attualmente in prigione dopo aver violato le condizioni della cauzione.</p>
<p>I pubblici ministeri federali hanno revocato la cauzione di Bankman-Fried perché ha manomesso i testimoni di stato, tra cui la sua ex ragazza Caroline Ellison. A quanto pare, Bankman-Fried ha fatto trapelare i “giornali privati di Ellison” al New York Times. Pertanto, i pubblici ministeri federali hanno interpretato l’azione di Bankman-Fried come un mezzo di intimidazione nei confronti di Ellison, una chiave testimone di stato contro di lui.</p>
<h2 id="h2-Conclusione338470"><a name="Conclusione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusione</h2><p>Uno degli ultimi sviluppi nel processo dell’ex CEO di FTX, Bankman-Fried, è l’assunzione da parte di SBF di testimoni esperti per le future udienze in tribunale. Fonti recenti hanno affermato che Bankman-Fried è disposto a pagare questi testimoni fino a $1.200 all’ora. D’altro canto, i pubblici ministeri federali stanno combattendo contro i testimoni specialisti proposti da Bankman-Fried.</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 il punto di vista 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 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>