SSBjb25zaWdsaSBzdWxsZSBjcmlwdG92YWx1dGUgcGnDuSBjYWxkaSBkYSBTYW0gQmFua21hbi1GcmllZA==

2023-12-07, 08:38

<p><img src="https://gimg2.gateimg.com/image/article/1701939592JYZN .jpeg" alt=""></p>
<h2 id="h2-In20breve20troppo20lungo20da20leggere452374"><a name="In breve; troppo lungo da leggere" class="reference-link"></a><span class="header-link octicon octicon-link"></span>In breve; troppo lungo da leggere</h2><p>Sam Bankman-Fried sta offrendo consigli sulla criptovaluta ai guardie carcerarie.</p>
<p>Il Metropolitan Detention Center di Brooklyn sta fornendo a SBF la sua dieta vegetariana preferita e la medicina.</p>
<p>Gli avvocati di SBF hanno intenzione di fare appello contro il suo verdetto.</p>
<h2 id="h2-Introduzione592755"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>Sam Bankman-Fried, che una volta viveva in una lussuosa villa alle Bahamas, è detenuto in una prigione a basso livello negli Stati Uniti. Il precedente CEO dello scambio FTX, Bankman-Fried, popolarmente conosciuto come SBF, è stato imprigionato ad agosto quando un giudice federale ha revocato la sua cauzione per interferenza con i testimoni dello stato.</p>
<p>Recentemente, una giuria federale <a href="https://www.gate.io/blog_detail/3435/ftx-founder-sam-bankman-fried-found-guilty-of-all-charges-a-detailed-look-at-the-verdict" target="_blank">condannato SBF per diversi capi d’accusa che includono truffa agli investitori e creditori</a> Nel frattempo, riceverà la sua condanna il 28 marzo 2024.</p>
<p>Questo articolo si concentra su come Sam Bankman-Fried sta affrontando la vita in prigione e come sta affrontando diverse sfide. Copriremo anche le sue possibili mosse dopo la sua recente condanna.</p>
<p>Leggi anche: <a href="https://www.gate.io/blog_detail/3251/there-is-nothing-i-can-do-to-make-it-positive-sam-bankman-fried-s-perspective-on-impact-and-responsibility" target="_blank">Non c’è nulla che io possa fare per renderlo positivo</a></p>
<h2 id="h2-BankmanFried20rimane20imprenditoriale20mentre2020in20prigione740383"><a name="Bankman-Fried rimane imprenditoriale mentre è in prigione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Bankman-Fried rimane imprenditoriale mentre è in prigione</h2><p>Nonostante i crescenti problemi seguenti alla sua condanna per sette capi d’accusa, Bankman-Fried rimane resiliente e intraprendente. Sta facendo molto mentre è in prigione per migliorare il suo stile di vita e aiutare altre persone a capire come funzionano le criptovalute.</p>
<p>In segno di umanità, Bankman-Fried sta aiutando le guardie di prigione a capire come funziona la criptovaluta. Sta condividendo la sua conoscenza degli asset crittografici con loro.</p>
<p>Non è chiaro se un tale gesto lo abbia portato a ricevere un trattamento preferenziale. Ad esempio, Bankman-Fried ha accesso a un laptop per studiare documenti legali, anche se con restrizioni. Condivide anche una sala computer con altri prigionieri.</p>
<p>Attualmente, Bankman-Fried si trova presso il Metropolitan Detention Center di Brooklyn, dove si trova da agosto di quest’anno. L’ex <a href="https://www.gate.io/price/ftx-ftt" target="_blank">FTX</a> Il CEO sta aspettando che venga pronunciata la sua sentenza nel marzo 2024.</p>
<p>Inoltre, il fondatore del cripto scambio FTX sta mostrando il suo spirito imprenditoriale mentre è in prigione scambiando pesci. Come molti altri prigionieri, Bankman-Fried sta usando sacchetti di pesce sgombro come moneta per accedere a vari servizi che includono tagli di capelli.</p>
<p><a href="https://twitter.com/AutismCapital/status/1727792599019446424?s=20" rel="nofollow noopener noreferrer" target="_blank">Autism Capital, un giornalista, ha pubblicato</a> dettagli su come Bankman-Fried sta andando in prigione. Ha detto: “Sam è conosciuto per scambiare il pesce Mackerel come valuta in prigione, più comunemente chiamato “Pouches of Mack.” Il Mackerel ha sostituito le sigarette nell’economia di scambio della prigione.”</p>
<p>Notizie correlate: <a href="https://www.gate.io/blog_detail/3017/ftx-sues-sam-bankman-fried-and-former-_s-for-1-billion" target="_blank">FTX denuncia Sam Bankman-Fried e gli ex dirigenti per 1 miliardo di dollari</a></p>
<p>Ogni sgombro, che nel 2020 costava $1, ora viene valutato a $1,30. In precedenza, i prigionieri usavano le sigarette come forma di baratto. Tuttavia, l’uso delle sigarette nelle carceri degli Stati Uniti è stato vietato nel 2004, lasciando ai prigionieri la scelta di trovare un’altra forma di valuta.</p>
<p>Fondamentalmente, la valuta del sgombro, spesso indicata come Macks, è diventata più popolare rispetto alle sue alternative come pacchetti di zuppa e francobolli.</p>
<h2 id="h2-SBF20Adattarsi20alla20Vita20dietro20le20Sbarre20Navigare20le20Sfide20della20Vita20in20Prigione806149"><a name="SBF Adattarsi alla Vita dietro le Sbarre: Navigare le Sfide della Vita in Prigione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>SBF Adattarsi alla Vita dietro le Sbarre: Navigare le Sfide della Vita in Prigione</h2><p>Durante i suoi primi giorni in prigione, Bankman-Fried si è lamentato della dieta e della medicina che gli veniva somministrata. In particolare, la dieta di SBF consisteva solo di pane, burro di arachidi e acqua. La sua principale sfida, in questo senso, era l’assenza di una dieta vegetariana che preferisce. È interessante notare che ora ottiene la dieta preferita che include verdure e sgombro.</p>
<p>Inoltre, durante i suoi primi giorni in prigione, Bankman-Fried non è stato in grado di ottenere la sua medicina preferita per il disturbo da deficit di attenzione e iperattività (ADHD). Tuttavia, la prigione ora gli sta dando la sua dose di Adderall desiderata, qualcosa che ha migliorato la sua vita in prigione.</p>
<p>Tali miglioramenti sono arrivati dopo che gli avvocati di SBF hanno sollevato le sue preoccupazioni presso il Tribunale Federale di Manhattan. Autism Capital, <a href="https://twitter.com/AutismCapital/status/1727792599019446424?s=20" rel="nofollow noopener noreferrer" target="_blank">il giornalista, concorda</a> su X che Bankman-Fried sta ricevendo la sua medicina preferita. Ha scritto: “Gli vengono serviti pasti vegetariani nella sua cella e riceve la sua dose desiderata di Adderall.”</p>
<h2 id="h2-Altre20condizioni20favorevoli20per20BankmanFried721631"><a name="Altre condizioni favorevoli per Bankman-Fried" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Altre condizioni favorevoli per Bankman-Fried</h2><p>Anche se le condizioni carcerarie al Metropolitan Detention Center di Brooklyn sono terribili, Bankman-Fried ha alcuni momenti positivi. Il fondatore dello scambio FTX ha il diritto di avere una visita non legale a settimana.</p>
<p>Allo stesso modo, Bankman-Fried può interagire liberamente con diversi detenuti. Esempi di altri prigionieri popolari con cui si mescola includono Juan Orlando Hernández, l’ex presidente dell’Honduras, accusato di corruzione in un caso di traffico di droga, e Genaro García Luna, ex capo della polizia messicana, condannato per aver aiutato i cartelli della droga.</p>
<p>Articolo correlato: <a href="https://www.gate.io/fr/blog_detail/3464/post-ftx-era-evolution-for-crypto-trading" target="_blank">Era post FTX: Evoluzione per il trading di criptovalute</a></p>
<p>Dopo aver ricevuto la sua condanna nel 2024, Bankman-Fried potrebbe essere trasferito in un’altra prigione con migliori condizioni. In tal caso, potrebbe avere una maggiore libertà di movimento. Potrebbe anche accedere a vari servizi ricreativi ed educativi. Inoltre, potrebbe rimanere in una prigione con detenuti meno violenti.</p>
<p>Leggi anche: <a href="https://www.gate.io/explore/ftx-sbf" target="_blank">SBF &amp; le attività sospette tramite FTX: si tratta di un sistema Ponzi o di frode?</a></p>
<h2 id="h2-Recenti20sviluppi20legali20riguardanti20SBF638920"><a name="Recenti sviluppi legali riguardanti SBF" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Recenti sviluppi legali riguardanti SBF</h2><p>Come sappiamo, Bankman-Fried è stato condannato il 3 novembre da una giuria composta da 12 membri dopo un intero processo per frode. Tuttavia, SBF ha un altro processo in sospeso previsto per il 28 marzo in cui è accusato di frode finanziaria per la campagna e di corruzione di funzionari.</p>
<p>Nel frattempo, la Corte d’Appello degli Stati Uniti per il Secondo Circuito ha respinto la richiesta di rilascio di Bankman-Fried, il che significa che continuerà a rimanere in prigione fino a quando non riceverà la sua condanna. Tuttavia, poiché SBF sostiene di essere innocente, i suoi avvocati sono disposti a contestare la sua sentenza attraverso un appello.</p>
<p>La Corte d’Appello utilizzerà il verbale del suo recente processo per prendere una decisione su approvare o meno la sua richiesta di appello. Le sue principali ragioni per un appello potrebbero includere gli errori che i funzionari governativi potrebbero aver commesso durante il processo di giudizio, il comportamento scorretto della giuria e gli errori commessi dal giudice nell’applicare la legge.</p>
<p>A seconda della natura degli errori e degli illeciti che la corte d’appello identifica, potrebbe annullare l’intera sentenza o parte di essa. Tuttavia, la corte potrebbe anche respingere la richiesta di appello di Sam Bankman-Fried.</p>
<h2 id="h2-Conclusione985458"><a name="Conclusione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusione</h2><p>Bankman-Fried, nel Metropolitan Detention Center di Brooklyn, sembra essersi adattato alla vita in prigione poiché sta partecipando a varie attività sociali ed economiche. Ad esempio, sta dando consigli ai guardiani di prigione riguardo alle criptovalute.</p>
<p>È anche coinvolto nel commercio di sgombri al fine di accedere a servizi essenziali come tagli di capelli. Oltre a ciò, sta interagendo in modo significativo con altri detenuti popolari come Juan Orlando Hernández, l’ex presidente honduregno.</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 si faccia riferimento a Gate.io. In tutti i casi, verranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div>