RGUgaGVldHN0ZSBjcnlwdG8tdGlwcyB2YW4gU2FtIEJhbmttYW4tRnJpZWQ=

2023-12-07, 08:38

<p><img src="https://gimg2.gateimg.com/image/article/1701939592JYZN .jpeg" alt=""></p>
<h2 id="h2-Te20lang20niet20gelezen362008"><a name="Te lang; niet gelezen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Te lang; niet gelezen</h2><p>Sam Bankman-Fried biedt advies over cryptocurrency aan gevangenisbewaarders.</p>
<p>Het Metropolitan Detention Center in Brooklyn voorziet SBF van zijn voorkeursvegetarische dieet en medicatie.</p>
<p>Advocaten van SBF hebben plannen om in beroep te gaan tegen zijn uitspraak.</p>
<h2 id="h2-Introductie695760"><a name="Introductie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introductie</h2><p>Sam Bankman-Fried, die voorheen in een luxueuze villa op de Bahama’s woonde, verblijft momenteel in een laag beoordeelde gevangenis in de Verenigde Staten. De voormalige CEO van FTX Exchange, Bankman-Fried, ook wel bekend als SBF, werd in augustus gevangengezet toen een federale rechter zijn borgtocht introk voor het beïnvloeden van getuigen van de staat.</p>
<p>Onlangs heeft een federale jury <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">veroordeelde SBF voor meerdere aanklachten, waaronder het oplichten van investeerders en geldverstrekkers</a>. Ondertussen zal hij zijn straf ontvangen op 28 maart 2024.</p>
<p>Dit artikel richt zich op hoe Sam Bankman-Fried omgaat met het leven in de gevangenis en hoe hij verschillende uitdagingen navigeert. We zullen ook zijn mogelijke stappen bespreken na zijn recente veroordeling.</p>
<p>Lees ook: <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">“Er is niets wat ik kan doen om het positief te maken”</a></p>
<h2 id="h2-BankmanFried20blijft20ondernemend20tijdens20zijn20gevangenschap913460"><a name="Bankman-Fried blijft ondernemend tijdens zijn gevangenschap" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Bankman-Fried blijft ondernemend tijdens zijn gevangenschap</h2><p>Ondanks de toenemende problemen na zijn veroordeling voor zeven aanklachten, blijft Bankman-Fried veerkrachtig en ondernemend. Hij doet veel terwijl hij in de gevangenis zit om zijn levensstijl te verbeteren en andere mensen te helpen begrijpen hoe cryptocurrencies werken.</p>
<p>Als teken van menselijkheid helpt Bankman-Fried gevangenisbewaarders om te begrijpen hoe cryptocurrency werkt. Hij deelt zijn kennis van crypto-activa met hen.</p>
<p>Het is niet duidelijk of een dergelijk gebaar heeft geleid tot het ontvangen van voorkeursbehandeling. Bankman-Fried heeft bijvoorbeeld toegang tot een laptop om juridische documenten te bestuderen, zij het onder beperking. Hij deelt ook een computerruimte met andere gevangenen.</p>
<p>Momenteel verblijft Bankman-Fried in het Metropolitan Detention Center in Brooklyn, waar hij sinds augustus van dit jaar verblijft. De voormalige <a href="https://www.gate.io/price/ftx-ftt" target="_blank">FTX</a> De CEO wacht op zijn veroordeling die in maart 2024 zal worden uitgesproken.</p>
<p>Ook de oprichter van de FTX-cryptobeurs toont zijn ondernemingsgeest terwijl hij in de gevangenis zit door vis te verhandelen. Net als veel andere gevangenen gebruikt Bankman-Fried zakjes makreel als valuta om toegang te krijgen tot diverse diensten, waaronder knipbeurten.</p>
<p><a href="https://twitter.com/AutismCapital/status/1727792599019446424?s=20" rel="nofollow noopener noreferrer" target="_blank">Autism Capital, een journalist, plaatste</a> details over hoe Bankman-Fried het doet in de gevangenis. Hij/zij zei: “Sam staat erom bekend dat hij Makreel, de vis, verhandelt als gevangeniscurrency, die vaker “Zakjes Mack” wordt genoemd. Makreel heeft sigaretten vervangen in de ruileconomie van de gevangenis.”</p>
<p>Gerelateerd nieuws: <a href="https://www.gate.io/blog_detail/3017/ftx-sues-sam-bankman-fried-and-former-_s-for-1-billion" target="_blank">FTX klaagt Sam Bankman-Fried en voormalige leidinggevenden aan voor $1 miljard</a></p>
<p>Elke makreel, die in 2020 $1 kostte, heeft momenteel een waarde van $1,30. Voorheen gebruikten gevangenen sigaretten als ruilmiddel. Desalniettemin werd het gebruik van sigaretten in Amerikaanse gevangenissen verboden in 2004, waardoor de gevangenen de keuze kregen om een andere vorm van valuta te vinden.</p>
<p>In feite is de makreelmunt, vaak aangeduid als Macks, populairder geworden dan alternatieven zoals soepzakken en postzegels.</p>
<h2 id="h2-SBF20aanpassen20aan20het20leven20achter20de20tralies20de20uitdagingen20van20het20gevangenisleven20navigeren562764"><a name="SBF aanpassen aan het leven achter de tralies: de uitdagingen van het gevangenisleven navigeren" class="reference-link"></a><span class="header-link octicon octicon-link"></span>SBF aanpassen aan het leven achter de tralies: de uitdagingen van het gevangenisleven navigeren</h2><p>Tijdens zijn eerste dagen in de gevangenis klaagde Bankman-Fried over het dieet en de medicatie die hij kreeg. Specifiek bestond SBF’s dieet alleen uit brood, pindakaas en water. Zijn belangrijkste uitdaging hierbij was het ontbreken van een vegetarisch dieet naar zijn voorkeur. Interessant genoeg krijgt hij nu het gewenste dieet dat groenten en makreel bevat.</p>
<p>Bovendien kon Bankman-Fried tijdens zijn eerste dagen in de gevangenis zijn voorkeursmedicatie voor aandachtstekortstoornis met hyperactiviteit (ADHD) niet krijgen. Desalniettemin geeft de gevangenis hem nu zijn ‘gewenste dosis Adderall’, iets dat zijn gevangenisleven heeft verbeterd.</p>
<p>Dergelijke verbeteringen kwamen nadat de advocaten van SBF zijn bezorgdheid aan de Manhattan Federal Court kenbaar maakten. Autism Capital, <a href="https://twitter.com/AutismCapital/status/1727792599019446424?s=20" rel="nofollow noopener noreferrer" target="_blank">de journalist is het ermee eens</a> op X dat Bankman-Fried zijn voorkeursmedicatie ontvangt. Hij plaatste: ‘Hij krijgt vegetarische maaltijden in zijn cel en ontvangt zijn gewenste dosis Adderall.’</p>
<h2 id="h2-Andere20gunstige20omstandigheden20voor20BankmanFried680866"><a name="Andere gunstige omstandigheden voor Bankman-Fried" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Andere gunstige omstandigheden voor Bankman-Fried</h2><p>Hoewel de gevangenisomstandigheden in het Metropolitan Detention Center in Brooklyn vreselijk zijn, heeft Bankman-Fried zo nu en dan goede momenten. De oprichter van de FTX-beurs heeft het recht om één bezoek per week van een niet-juridisch persoon te ontvangen.</p>
<p>Op dezelfde manier kan Bankman-Fried vrijelijk omgaan met verschillende gevangenen. Voorbeelden van andere populaire gevangenen waarmee hij omgaat, zijn onder andere Juan Orlando Hernández, de voormalige president van Honduras, die is aangeklaagd voor omkoping in een zaak van drugshandel, en Genaro García Luna, voormalig hoofd van de Mexicaanse politie, veroordeeld voor hulp aan drugskartels.</p>
<p>Gerelateerd artikel: <a href="https://www.gate.io/fr/blog_detail/3464/post-ftx-era-evolution-for-crypto-trading" target="_blank">Na de FTX-tijdperk: evolutie voor crypto-handel</a></p>
<p>Na zijn veroordeling in 2024 kan Bankman-Fried mogelijk worden overgeplaatst naar een andere gevangenis met betere omstandigheden. In dat g kan hij meer bewegingsvrijheid hebben. Hij kan ook toegang krijgen tot diverse recreatieve en educatieve voorzieningen. Bovendien kan het zijn dat hij in een gevangenis verblijft met minder gewelddadige gedetineerden.</p>
<p>Lees ook: <a href="https://www.gate.io/explore/ftx-sbf" target="_blank">SBF &amp; de Verdachte Activiteiten via FTX: Is dit een Ponzi-regeling of Fraude?</a></p>
<h2 id="h2-Recente20juridische20ontwikkelingen20rond20SBF666720"><a name="Recente juridische ontwikkelingen rond SBF" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Recente juridische ontwikkelingen rond SBF</h2><p>Zoals we weten, werd Bankman-Fried op 3 november veroordeeld door een jurypanel van 12 leden na een volledig frauduleus proces. Toch heeft SBF nog een andere geplande rechtszaak op 28 maart, waar hij wordt geconfronteerd met aanklachten van campagnefinancieringsfraude en omkoping van ambtenaren.</p>
<p>Intussen heeft het Hof van Beroep voor het Tweede Circuit van de VS het verzoek van Bankman-Fried om vrijlating afgewezen, wat betekent dat hij in de gevangenis zal blijven totdat hij zijn straf krijgt. Aangezien SBF echter volhoudt dat hij onschuldig is, zijn zijn advocaten bereid om zijn veroordeling aan te vechten via een beroep.</p>
<p>Het hof van beroep zal het dossier van zijn recente proces gebruiken om te beslissen of zijn verzoek tot hoger beroep al dan niet wordt goedgekeurd. Zijn belangrijkste gronden voor hoger beroep kunnen fouten omvatten die de overheidsfunctionarissen mogelijk hebben begaan tijdens het proces, het wangedrag van de jurylid en de fouten die de rechter heeft gemaakt bij het toepassen van de wet.</p>
<p>Afhankelijk van de aard van de fouten en misstanden die het hof vaststelt, kan het het hele vonnis of een deel ervan vernietigen. Desalniettemin kan het hof ook het verzoek van Sam Bankman-Fried om in beroep te gaan afwijzen.</p>
<h2 id="h2-Conclusie465619"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>Bankman-Fried, in het Metropolitan Detention Center in Brooklyn, lijkt zich te hebben aangepast aan het gevangenisleven, aangezien hij deelneemt aan diverse sociale en economische activiteiten. Zo geeft hij bijvoorbeeld advies aan gevangenisbewaarders over cryptocurrency.</p>
<p>Hij is ook betrokken bij de handel in makreel om toegang te krijgen tot essentiële diensten zoals knipbeurten. Bovendien heeft hij betekenisvol contact met andere bekende gevangenen, zoals Juan Orlando Hernández, de voormalige president van Honduras.</p>
<div class="blog-details-info"><br><div>Auteur:<strong> Mashell C.</strong>, Gate.io onderzoeker<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de mening van de onderzoeker en vormt geen enkele beleggingsaanbeveling.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het opnieuw plaatsen van het artikel is toegestaan mits Gate.io wordt vermeld. In alle glen zullen juridische stappen worden ondernomen vanwege schending van het auteursrecht.<br></div><p></p><br></div></div></div>