RlRYLW9wcmljaHRlciBTYW0gQmFua21hbi1GcmllZCBzY2h1bGRpZyBiZXZvbmRlbiBhYW4gYWxsZSBhYW5rbGFjaHRlbjogRWVuIGdlZGV0YWlsbGVlcmRlIGJsaWsgb3AgaGV0IHZvbm5pcw==

2023-11-15, 04:53

<p><img src="https://gimg2.gateimg.com/image/article/1700023506SDFX 1.jpeg" alt=""></p>
<h2 id="h2-Te20lang20niet20gelezen784888"><a name="Te lang; niet gelezen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Te lang; niet gelezen</h2><p>Een New Yorkse jury heeft Sam Bankman-Fried schuldig bevonden aan 7 aanklachten <a href="https://www.gate.io/explore/ftx-sbf" target="_blank">gerelateerd aan de ineenstorting van FTX</a>.</p>
<p>Gary Wang, Nishad Singh en Caroline Ellison hebben schuldig gepleit aan de aanklachten tegen hen in verband met de ineenstorting van FTX.</p>
<p>De federale rechtbank zal de straf van Bankman-Fried bepalen in maart 2024.</p>
<h2 id="h2-Inleiding924431"><a name="Inleiding" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Inleiding</h2><p>Het proces van Sam Bankman-fried loopt ten einde nadat een federale rechtbank heeft vastgesteld dat hij schuldig is aan alle 7 aanklachten tegen hem. De rechter heeft echter nog geen vonnis uitgesproken dat waarschijnlijk in maart 2024 zal komen. Er is een grote kans dat Sam Bankman-Fried tientallen jaren in de gevangenis zal doorbrengen.</p>
<p>Dit artikel zal de aanklachten bespreken waarvoor de rechtbank Bankman-Fried schuldig bevond. Het zal ook ingaan op de mogelijke gevolgen van het vonnis voor hem en de FTX crypto exchange.</p>
<h2 id="h2-BankmanFried20veroordeeld20voor20alle20aanklachten184347"><a name="Bankman-Fried veroordeeld voor alle aanklachten" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Bankman-Fried veroordeeld voor alle aanklachten</h2><p>Een federale rechtbank heeft Sam Bankman-Fried, de oprichter van FTX en Alameda Research, schuldig bevonden aan het oplichten van investeerders, geldschieters en andere klanten voor miljarden dollars in een zaak die is bestempeld als de grootste financiële fraude in de geschiedenis van de Verenigde Staten van Amerika.</p>
<p>De jury in New York gelooft dat Bankman-Fried de klanten van de FTX Crypto-uitwisseling voor meer dan $10 miljard heeft opgelicht. Bankman-Fried heeft echter altijd ontkend dat hij de investeerders van FTX heeft bedrogen.</p>
<p>Kortom, Bankman-Fried is veroordeeld voor draadfraude jegens klanten en kredietverstrekkers, evenals 5 samenzweringsaanklachten met betrekking tot effecten, grondstoffen en witwassen van geld.</p>
<p><strong>Wirefraude/samenzwering tot het plegen van wirefraude tegen FTX-klanten:</strong> Het grootste probleem tegen Bankman-Fried was het verlies van klantengelden. Bankman-Fried heeft de klanten bedrogen door Alameda Research in staat te stellen FTX-fondsen te gebruiken.</p>
<p>In de meeste glen stortten de klanten de fondsen die ze wilden verhandelen op bankrekeningen van Alameda Research. Als gevolg hiervan gebruikte Alameda Research de fondsen zoals het nodig achtte.</p>
<p><strong>Draadfraude/samenzwering om draadfraude te plegen tegen de geldschieters van Alameda:</strong> Het belangrijkste probleem hier is dat Alameda Research de balans die het naar bedrijven zoals Genesis en stuurde heeft gemanipuleerd. <a href="https://www.gate.io/blog_detail/1241/v2lsbcbcbg9ja0zpiejlifrozsbozxh0ifrviezhbgw" target="_blank">BlockFi</a> het wilde geld lenen van.</p>
<p>In eenvoudige bewoordingen heeft het bedrijf opzettelijk zijn financiële rapporten verkeerd voorgesteld aan belangrijke partners. De rechtbank hield Bankman-Fried verantwoordelijk omdat hij de rapporten heeft goedgekeurd.</p>
<p><strong>Samenzwering om effectenfraude te plegen tegen investeerders van FTX:</strong> De FTX Crypto-beurs heeft tegen haar partners gelogen over hoe zij haar fondsen gebruikt. De leidinggevende gaf ook verkeerde cijfers over de omzet die de beurs genereerde uit haar operationele activiteiten.</p>
<p>Belangrijker nog, Alameda Research heeft niet bekendgemaakt welke verliezen het leed. Dit heeft ertoe geleid dat zijn zakelijke partners verkeerde investeringsbeslissingen hebben genomen. Bedrijven zoals Paradigm en Third Point hebben investeringsbeslissingen genomen op basis van verkeerd gepresenteerde informatie.</p>
<p><strong>Samenzwering om grondstoffenfraude te plegen tegen FTX-klanten:</strong> Dit was een samenzwering om cryptocurrencies zoals te stelen. <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> en ETH, die door de SEC-regelgeving worden geclassificeerd als grondstoffen. Deze beschuldiging is vergelijkbaar met de eerste: draadfraude/samenzwering <a href="https://www.gate.io/blog_detail/3017/ftx-sues-sam-bankman-fried-and-former-_s-for-1-billion" target="_blank">om draadfraude te plegen tegen FTX-klanten</a>. Echter heeft de eerste aanklacht betrekking op investeringsfondsen, terwijl deze betrekking heeft op cryptocurrencies die onder Amerikaanse grondstoffen vallen.</p>
<p><strong>Samenzwering tot het plegen van witwassen van geld:</strong> De SEC beschuldigt Bankman-Fried ervan klantengelden te verplaatsen van de FTX-beurs <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">naar Alameda Research</a> waar het werd gebruikt voor ongerelateerde doeleinden zoals het doen van politieke donaties. Primair slaagde Bankman-Fried er niet in zichzelf van deze beschuldigingen te zuiveren, wat leidde tot zijn veroordeling.</p>
<h2 id="h2-Achtergrond20van20de20FTX20Crypto20Exchange20Saga508238"><a name="Achtergrond van de FTX Crypto Exchange Saga" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Achtergrond van de FTX Crypto Exchange Saga</h2><p>Eerder bespraken we het<br><strong>7 aanklachten tegen SBF</strong>. Laten we kort begrijpen hoe de saga zich ontvouwde in 2022. Verschillende gebeurtenissen leidden tot de ineenstorting van FTX en de daaropvolgende SEC-rechtszaak.</p>
<p>Bijna 1 jaar geleden, Ian Allison, een verslaggever bij <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 publiceerde een bewering</a> dat Alameda Research grote hoeveelheden FTT, de inheemse token van FTX, vasthield. Na die onthulling verklaarde Changpeng Zhao, CEO van Binance, dat hij zich zou terugtrekken uit FTX. Deze twee gebeurtenissen leidden tot een run op FTX, wat de uitwisseling, Alameda Research en haar andere dochterondernemingen dwong om <a href="https://www.gate.io/blog_detail/3284" target="_blank">faillissement aanvragen</a>.</p>
<p>De andere voormalige FTX-utives, waaronder Gary Wang, Chief Technology Officer, Nishad Singh, de voormalige Head of Engineering en Caroline Ellison, de voormalige CEO van Alameda Research, hebben schuld bekend aan deze aanklachten.</p>
<p>Later werden de meesten van hen getuigen tegen Bankman-Fried. Na de ineenstorting van FTX nam Bankman-Fried ontslag als CEO. Later werd hij gearresteerd in de Bahama’s en uitgeleverd aan de Verenigde Staten om terecht te staan voor zijn misdaden.</p>
<p>In augustus heeft de Amerikaanse districtsrechter Lewis Kaplan de borgtocht van Bankman-Fried ingetrokken en beschuldigde hem ervan te proberen invloed uit te oefenen op belangrijke getuigen zoals Ellison, zijn ex-vriendin. Sindsdien zit hij in de gevangenis in het Metropolitan Detention Center in Brooklyn.</p>
<p>Het is belangrijk om op te merken dat Bankman-Fried nog steeds terecht zal staan voor 5 andere aanklachten in maart 2024. De aanklachten omvatten het runnen van een niet-geautoriseerde geldovermakingsbedrijf, bankfraude en de schending van het omkoopstatuut van de Foreign Corrupt Practices Act.</p>
<h2 id="h2-Gevolgen20van20het20vonnis20van20BankmanFried578812"><a name="Gevolgen van het vonnis van Bankman-Fried" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Gevolgen van het vonnis van Bankman-Fried</h2><p>Elk van de aanklachten waarvoor Bankman-Fried schuldig is bevonden, draagt een straf van tussen de 5 en 20 jaar met zich mee. Dit betekent dat hij mogelijk tot 115 jaar in de gevangenis kan doorbrengen, tenzij hij sommige van de straffen tegelijkertijd uitzit. Bankman-Fried moet echter wachten tot maart 2024 om zijn straf te horen.</p>
<p>De procedure is dat de aanklagers de straf zullen aanbevelen tegen 15 maart 2024. Niettemin zal rechter Lewis Kaplan van de Amerikaanse arrondissementsrechtbank het laatste woord hebben. Het is ook belangrijk op te merken dat Bankman-Fried het recht heeft om zowel tegen de veroordeling als tegen de straf in beroep te gaan.</p>
<p>Teddy Schleifer, lid van het verdedigingsteam van Bankman-Fried, gaf een hint dat hij van plan is om in beroep te gaan tegen de veroordeling. Postend op X <a href="https://twitter.com/teddyschleifer/status/1720233526048510333" rel="nofollow noopener noreferrer" target="_blank">Schleifer zei</a> We respect the jury’s decision. But we are very disappointed with the result. Mr Bankman Fried maintains his innocence and will continue to vigorously fight the charges against him.</p>
<p>Voordat hij zijn straf krijgt, zal Bankman-Fried in het Metropolitan Detention Center in Brooklyn blijven, waar hij in augustus werd geplaatst.</p>
<h2 id="h2-De20gevolgen20van20de20veroordeling20van20BankmanFried20voor20FTX15445"><a name="De gevolgen van de veroordeling van Bankman-Fried voor FTX" class="reference-link"></a><span class="header-link octicon octicon-link"></span>De gevolgen van de veroordeling van Bankman-Fried voor FTX</h2><p>Wettelijk gezien kan FTX zijn activiteiten voortzetten onder nieuw leiderschap. <a href="https://twitter.com/AFTXcreditor/status/1662816040231862275" rel="nofollow noopener noreferrer" target="_blank">Een X-account, FTX 2.0 Coalitie, heeft gehint</a> dat er meerdere bieders zijn voor FTX. Hij/zij plaatste: ‘Meerdere potentiële FTX 2.0 bieders hebben bij ons geïnformeerd. We geloven dat het stimuleren van klant-schuldeisers door middel van opwaarts potentieel zowel het succespercentage als het potentieel verhoogt. Zodra alle opties op tafel liggen, zullen we de bieding ondersteunen die het meest bevorderlijk is voor een optimale schuldeiserherstel.’</p>
<p>Het vonnis over Bankman-Fried zal naar verwachting geen invloed hebben op de prestaties van FTX als een gerenommeerd bedrijf of individu het overneemt. CNBC citeerde Gary Gensler, de voorzitter van de SEC, die zei dat iedereen FTX crypto exchange kan overnemen en nieuw leven kan inblazen.</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">Volgens CNBC</a>, zei Gensler: ‘Als Tom of wie dan ook in dit veld wilde zijn, zou ik zeggen: ‘Doe het volgens de wet. Bouw het vertrouwen van investeerders op in wat je doet en zorg ervoor dat je de juiste openbaarmakingen doet - en ook dat je deze functies niet vermengt, handelt tegen je klanten. Of gebruik hun crypto-activa voor je eigen doeleinden.’</p>
<h2 id="h2-Conclusie414273"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>De oprichter van FTX, Sam Bankman-Fried, werd schuldig bevonden aan 7 aanklachten naar aanleiding van de ineenstorting van de beurs. Op dezelfde wijze hebben de andere FTX-utives, waaronder Gary Wang, Nishad Singh en Caroline Ellison, schuldig gepleit aan dezelfde aanklachten. De rechter zal de straf van Bankman-Fried op 28 maart 2024 uitspreken. Ondertussen zal SBF verblijven in het Metropolitan Detention Center in Brooklyn.</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 standpunten van de onderzoeker en vormt geen enkele beleggingssuggestie.<br></em><div><em></em>Gate.io behoudt alle rechten voor op dit artikel. Het opnieuw plaatsen van het artikel is toegestaan op voorwaarde dat Gate.io wordt vermeld. In alle glen zal juridische actie worden ondernomen wegens auteursrechtinbreuk.<br></div><p></p><br></div></div></div>