RlRYIGtsYWFndCBTYW0gQmFua21hbi1GcmllZCBlbiB2b29ybWFsaWdlIGxlaWRpbmdnZXZlbmRlbiBhYW4gdm9vciAkMSBtaWxqYXJk

<p><img src="https://gimg2.gateimg.com/image/article/1691055577RDZZ.jpeg" alt=""></p>
<h2 id="h2-Te20lang20niet20gelezen55222"><a name="Te lang; niet gelezen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Te lang; niet gelezen</h2><p>Door Sam Bankman en zijn voormalige leidinggevenden aan te klagen, streeft FTX ernaar om wat geld terug te vorderen om de klanten te betalen wiens activa bevroren waren.</p>
<p>“Gary” Wang, Nishad Singh en Caroline Ellison zijn de andere leidinggevenden die in de Verenigde Staten voor de rechter staan ​​wegens verduistering van klantenfondsen.</p>
<p>Terwijl Ellison, Wang en Singh schuldig hebben gepleit aan de tegen hen ingebrachte beschuldigingen, heeft Bankman-Fried onschuldig gepleit.</p>
<h2 id="h2-Kennismaking712634"><a name="Kennismaking" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Kennismaking</h2><p>Er is geen afsluiting gekomen van het probleem met de FTX-crypto-uitwisseling, aangezien er nog steeds juridische gevechten zijn tussen sommige betrokken partijen. Naast de crediteuren die geloven dat ze compensatie kunnen krijgen voor hun verliezen, heeft FTX onlangs zijn oprichter Sam Bankman-Fried (SBF) en enkele van zijn voormalige leidinggevenden aangeklaagd. In dit artikel gaan we in op verschillende kwesties die verband houden met de rechtszaken van FTX tegen zijn voormalige leidinggevenden en oprichter.</p>
<h2 id="h2-FTX20klaagt20Sam20BankmanFried20aan703706"><a name="FTX klaagt Sam Bankman-Fried aan," class="reference-link"></a><span class="header-link octicon octicon-link"></span>FTX klaagt Sam Bankman-Fried aan,</h2><p>In een stap die veel mensen heeft verrast, heeft FTX een rechtszaak aangespannen tegen zijn oprichter Sam Bankman-Fried, algemeen bekend als SBF, en zijn voormalige leidinggevenden wegens verduistering van meer dan 1 miljard dollar tijdens een periode waarin de beurs financieel instabiel was en zelfs na het faillissement van FTX.</p>
<p>FTX heeft specifiek Samuel Bankman-Fried, zijn oprichter en voormalig CEO, Zixiao “Gary” Wang, de voormalige FTX technologiechef, Nishad Singh, de technisch directeur en Caroline Ellison, het hoofd van Alameda Research, het hedgefonds aangeklaagd. Volgens vertegenwoordigers van FTX heeft de verduistering van ongeveer $1 miljard, op een moment dat de crypto-beurs financieel worstelde, de crypto-beurs in faillissement gedreven.</p>
<p>Op 20 juli diende FTX een rechtszaak in bij de faillissementsrechtbank van de Verenigde Staten waarin de oprichter en de voormalige senior leiders ervan worden beschuldigd van schending van hun fiduciaire plichten door klantengelden te gebruiken voor hun persoonlijk voordeel.</p>
<p>Volgens de rechtszaak werd een deel van de fondsen gebruikt voor risicovolle investeringen, luxe accommodaties en donaties voor politieke en liefdadige doeleinden. Om die reden beweert FTX dat deze verduistering van zakelijke fondsen ‘een van de grootste financiële fraudezaken in de geschiedenis’ is geweest.</p>
<p>Bovendien beweert het bedrijf dat de beklaagden een ongezonde bedrijfscultuur hebben gecreëerd waarin een paar werknemers een enorme invloed hadden en controle hadden over belangrijke zakelijke beslissingen zoals het gebruik van institutionele fondsen. Daarom konden ze crypto-activa en fiatvaluta willekeurig toewijzen voor dubieuze en persoonlijke doeleinden. Ze hadden ook enorme macht bij het aannemen of beëindigen van werknemerscontracten.</p>
<h2 id="h2-Overzicht20van20verduisterde20fondsen360098"><a name="Overzicht van verduisterde fondsen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Overzicht van verduisterde fondsen</h2><p>De verduisterde fondsen werden beheerd door verschillende mensen, waaronder Sam Bankman-Fried (SBF), Wang en Ellison. Volgens de ingediende documenten hebben de voormalige leidinggevenden in totaal $725 miljoen aan FTX-aandelen verduisterd voor hun persoonlijk voordeel, zonder enige gelijkwaardige waarde te bieden aan de organisatie of haar zusterondernemingen.</p>
<p>De klager heeft gezegd dat Bankman-Fried een luxueus leven leidde en verschillende persoonlijke projecten uitvoerde met behulp van de FTX-fondsen. Specifiek hebben Bankman-Fried en Ellison $546 miljoen gebruikt voor de aankoop van persoonlijke activa. SBF heeft bijvoorbeeld zijn aandeel gebruikt om aandelen van Robinhood Markets te kopen, terwijl Ellison een bonus ter waarde van $28,8 miljoen kreeg. Hij heeft ook $10 miljoen geïnvesteerd in zijn kunstmatige intelligentiebedrijf.</p>
<p>Opnieuw beweert FTX dat SBF zijn vader, Joseph Bankman, een professor in de rechten aan de Stanford Law School, $10 miljoen heeft gegeven als cadeau. Echter, de klacht heeft ook beweerd dat Joseph Bankman een deel van dat bedrag heeft gebruikt om de strafverdediging van SBF te financieren.</p>
<p>De andere utives, waaronder Wang en Singh, hebben ook geprofiteerd van de verduisterde fondsen. Naast de verduistering van de fondsen wordt beweerd dat de beschuldigde personen geen adequate verslagen hebben bijgehouden van de verschillende transacties die zij hebben uitgevoerd.</p>
<p>Evenzo was er geen controle over de kosten die de organisatie maakte. Bovendien hebben ze ook verschillende illegale activiteiten verduisterd.</p>
<p>Helaas ontbrak het ook aan cybersecurity om de klantfondsen, het bedrijf en zijn gelieerde ondernemingen te beschermen tegen hacken en frauduleuze activiteiten. Volgens de gerechtelijke stukken vonden deze frauduleuze zakelijke activiteiten plaats tussen februari 2020 en november 2022.</p>
<p>Wat het nog erger maakt, is dat een deel van de verduistering van de fondsen plaatsvond nadat FTX faillissement had aangevraagd volgens hoofdstuk 11. In feite heeft FTX in november faillissement aangevraagd na de implosie van zijn eigen token FTT. Er wordt ook beweerd dat een deel van de bedrijfsfondsen is overgeboekt naar Alameda Research, het zusterbedrijf dat ook meer dan $8 miljard aan klanten geld heeft verloren.</p>
<h2 id="h2-Wat20maakt20de20aanklachten20ernstig492879"><a name="Wat maakt de aanklachten ernstig?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wat maakt de aanklachten ernstig?</h2><p>Het feit is dat de meeste van deze frauduleuze transacties plaatsvonden toen de FTX-beurs al insolvent was, iets waar de beklaagden van op de hoogte waren. Dit is de reden waarom John Ray, de nieuwe CEO, de juridische weg heeft gekozen om een deel van de activa van de klanten terug te vorderen die zijn verduisterd.</p>
<p>Het bedrijf heeft ook schadevergoeding geëist, wat kan helpen om ongeveer $1 miljard terug te vorderen om de klanten te betalen wiens activa waren bevroren na de ineenstorting van FTX. Het is belangrijk op te merken dat volgens het faillissementsrecht van Delaware of de Verenigde Staten de vermeende overdrachten omkeerbaar zijn.</p>
<p>Ray is een bekende advocaat die in het verleden veel geld heeft hersteld voor failliete bedrijven. Interessant genoeg zal Caroline Allison, de voormalige CEO van Alameda Research, een belangrijke getuige zijn in het proces tegen de voormalige FTX-uitvoerend bestuurders. Ellison, Wang en Singh hebben al schuld bekend aan de aanklachten, terwijl Bankman-Fried onschuldig heeft gepleit tegen de aanklachten die tegen hem zijn ingebracht.</p>
<h2 id="h2-Conclusie658263"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>De rechtszaken van FTX tegen haar voormalige leidinggevenden, waaronder haar oprichter en CEO Bankman-Fried, zijn gericht op het terugvorderen van een deel van de gestolen fondsen om de klanten terug te betalen van wie de activa bevroren waren toen de beurs faillissement aanvroeg. De andere beklaagden zijn “Gary” Wang, Nishad Singh en Caroline Ellison. Ondertussen hebben Ellison, Wang en Singh schuldig gepleit aan de tegen hen ingebrachte beschuldigingen.</p>
<h2 id="h2-Veelgestelde20vragen20over20FTX20Samuel20BankmanFried142358"><a name="Veelgestelde vragen over FTX Samuel Bankman-Fried" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Veelgestelde vragen over FTX Samuel Bankman-Fried</h2><p><strong>Wat gebeurt er met Sam Bankman?</strong></p>
<p>Sam Bankman staat terecht in de Verenigde Staten wegens verduistering van klantengelden van FTX crypto exchange. Verschillende andere voormalige FTX-utives, waaronder Gary Wang, Nishad Singh en Caroline Ellison, worden geconfronteerd met soortgelijke aanklachten.</p>
<p><strong>Wat is er gebeurd met FTX Bankman?</strong></p>
<p>FTX Bankman staat terecht in de Verenigde Staten na de ineenstorting van de crypto-uitwisseling. Hij wordt beschuldigd van verduistering van klantengelden.</p>
<p><strong>Waar is Bankman-Fried nu?</strong></p>
<p>Bankman-Fried bevindt zich in de Verenigde Staten waar hij een rechtszaak ondergaat voor het verduisteren van FTX-klantfondsen. Hij heeft echter niet schuldig gepleit aan de aanklachten.</p>
<p><strong>Wat heeft Sam Bankman-Fried gedaan voor FTX?</strong></p>
<p>Sam Bankman-Fried wordt ervan beschuldigd FTX klantengelden verkeerd te hebben aangewend. Hij staat momenteel terecht in de Verenigde Staten.</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 visie 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 zal juridische actie worden ondernomen vanwege auteursrechtinbreuk.<br></div><p></p><br></div></div></div>