RXIgaXMgbmlldHMgZGF0IGlrIGthbiBkb2VuIG9tIGhldCBwb3NpdGllZiB0ZSBtYWtlbiIgU2FtIEJhbmttYW4tRnJpZWQncyBwZXJzcGVjdGllZiBvcCBpbXBhY3QgZW4gdmVyYW50d29vcmRlbGlqa2hlaWQ=

2023-09-28, 03:07

<p><img src="https://gimg2.gateimg.com/image/article/1690791857hotspot.jpeg" alt=""></p>
<h2 id="h2-TL20DR317971"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p>Sam Bankman-Fried, die terechtstaat voor verschillende criminele aanklachten, voelt zich terneergeslagen en hopeloos.</p>
<p>SBF heeft onschuld gepleit aan de beschuldigingen tegen hem, waaronder de verduistering van FTX-klantenfondsen.</p>
<p>Financieel wanbeheer en de weelderige levensstijl van Bankman-Fried zouden hebben bijgedragen aan de ineenstorting van FTX.</p>
<h2 id="h2-Kennismaking623156"><a name="Kennismaking" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Kennismaking</h2><p>Voor <a href="https://www.gate.io/blog_detail/1777/ftx%E4%BA%8B%E4%BB%B6%E8%BF%9B%E8%A1%8C%E6%97%B6-%E5%A4%9A%E7%B1%B3%E8%AF%BA%E9%AA%A8%E7%89%8C%E5%80%92%E5%90%91%E4%BD%95%E6%96%B9" target="_blank">de ineenstorting van FTX in 2022</a>, Sam Bankman-Fried was een van de meest prominente figuren in de cryptosector geworden sinds hij een levendige cryptocurrency-beurs bezat. Sommige mensen verwelkomden hem als de redder van de cryptobranche nadat hij twee cryptocurrency-bedrijven van een dreigende implosie had gered. Zijn roem ebde echter weg toen FTX-beurs en zijn zusterbedrijf Alameda Research crashten.</p>
<p>In deze post zullen we bespreken hoe Bankman-Fried hopeloos is geworden en zich niet in staat voelt om een positieve impact te hebben op de crypto sector. We zullen ook een korte chronologie van gebeurtenissen opnemen die hebben geleid tot de ineenstorting van de FTX-crypto-uitwisseling.</p>
<p>Gerelateerd nieuws: <a href="https://www.gate.io/de/blog_detail/3197/sbf-pays-witnesses-post-ftx-collapse" target="_blank">SBF wil expert getuigen $1200 per uur betalen</a></p>
<h2 id="h2-BankmanFried20Een20val20van20prominentie20naar20schande333639"><a name="Bankman-Fried: Een val van prominentie naar schande" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Bankman-Fried: Een val van prominentie naar schande</h2><p>Op het moment van schrijven voelt Sam Bankman-Fried, de oprichter en voormalig CEO van FTX crypto exchange, dat hij nu machteloos is om een impact te hebben op de crypto sector zoals vroeger. Daarom zei hij: ‘Ik ben blut en draag een enkelband en ben een van de meest gehate personen ter wereld. Er zal waarschijnlijk nooit iets zijn dat ik kan doen om mijn levenslange impact netto positief te maken.’</p>
<p>Volgens zijn 250 pagina’s aan geschriften die hij heeft samengesteld sinds de tijd dat hij onder huisarrest stond, die begon in december 2022, zei Bankman-Fried, in de volksmond bekend als SBF, dat het nu erg moeilijk voor hem is om de negatieve perceptie die mensen over hem hebben te veranderen. Als gevolg hiervan zei hij dat hij zich “blut” en “gehaat” voelt.</p>
<p>Het is momenteel niet duidelijk hoe Tiffany Fong, een crypto journalist/Youtuber, in het bezit kwam van Bankman-Fried’s geschreven stuk, dat hij deelde met de New York Times. Sommige van de teksten zijn geplande X (voorheen Twitter) berichten die zijn rol bij de ineenstorting van FTX en haar gerelateerde partners verduidelijken.</p>
<p>Lees ook: <a href="https://www.gate.io/de/blog_detail/2390/ftx-shows-massive-shortfalls-in-firms-assets" target="_blank">FTX toont enorme tekorten in de activa van het bedrijf</a></p>
<p>Opmerkelijk genoeg legt Bankman-Fried de schuld voor de ineenstorting van FTX deels bij enkele van zijn landgenoten, waaronder Caroline Ellison, zijn ex-vriendin en voormalig CEO van Alameda Research.</p>
<p>Gerelateerd nieuws: <a href="https://www.gate.io/tr/blog_detail/2867/alameda-s-700m-pursuit-for-celebrity-political-access" target="_blank">Alameda’s $700M streven naar toegang tot beroemdheden en politiek</a></p>
<p>In een ander gelekt document gaf Bankman-Fried details over de bijdrage van Ellison aan de <a href="https://www.gate.io/th/blog_detail/1748/disclosure-about-alameda-and-ftx-how-can-users-avoid-risks-when-organizations-are-in-chaos" target="_blank">ineenstorting van FTX en handelsfirma Alameda Research</a>. Hij schreef: “Ze bleef voortdurend het praten over risicobeheer vermijden - mijn suggesties ontwijken - totdat het te laat was. […] Elke keer dat ik met suggesties kwam, voelde ze zich alleen maar slechter. Ik weet zeker dat het feit dat we exen waren niet hielp.”</p>
<p>Bankman-Fried houdt tegelijkertijd vol dat hij niet op de hoogte was van het feit dat Alameda Research klantengelden verduisterde totdat hij daar in het voorjaar van 2022 van een groep medewerkers over hoorde die het onderling bespraken.</p>
<p>Recent nieuws: <a href="https://www.gate.io/blog_detail/3102/-singapore-temasek-misplaced-trust-ftx" target="_blank">Singapore Temasek genoemd in FTX te midden van moeilijkheden</a></p>
<h2 id="h2-BankmanFried20pleit20onschuldig20ondanks20veel20bewijs20tegen20hem168206"><a name="Bankman-Fried pleit onschuldig ondanks veel bewijs tegen hem" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Bankman-Fried pleit onschuldig ondanks veel bewijs tegen hem</h2><p>Bankman-Fried, beschuldigd van <a href="https://www.gate.io/explore/ftx-sbf" target="_blank">verschillende misdaden, waaronder het misbruiken van klantengelden, draadfraude en witwassen van geld, heeft onschuld gepleit tegen de aanklachten</a>. Echter heeft rechter Lewis A. Kaplan onlangs de aanvraag van Bankman-Fried voor voorlopige invrijheidstelling afgewezen, zodat hij zich volledig kan voorbereiden op de zaak.</p>
<p>Volgens rechter Kaplan ontbreekt het aan verdienste in de aanvraag van Bankman-Fried voor voorlopige vrijlating. Hij zei: “De verdachte negeert grotendeels het feit dat hij 7 ½ maanden uitgebreide toegang had tot de meeste ESI (elektronisch opgeslagen ontdekking en ander materiaal) voordat zijn borgtocht werd ingetrokken.”</p>
<p>Sam Bankman-Fried, geboren in 1992 en in het bezit van een bachelor’s degree in natuurkunde van het Massachusetts Institute of Technology (MIT), richtte in 2018 de cryptocurrency exchange FTX op. Hij was ook medeoprichter van Alameda Research, een kwantitatieve handelsfirma die gespecialiseerd is in cryptocurrencies.</p>
<p>Volgens Forbes, <a href="https://www.gate.io/blog_detail/1792/ftx-event-and-its-domino-effects" target="_blank">voor de FTX-crash</a>, Bankman-Fried’s financiële fortuin bedroeg ongeveer $26,5 miljard. Als gevolg daarvan werd hij een van de grootste donateurs voor de Democraten in de Verenigde Staten, waarbij hij meer dan $5,2 miljoen bijdroeg aan de politieke campagne van president Joe Biden in 2020.</p>
<p>Er is geen twijfel dat Bankman-Fried een van de rijkste personen ter wereld was in 2022 vóór de ineenstorting van de cryptocurrencybeurs. <a href="https://www.gate.io/price/ftx-ftt" target="_blank">FTX</a>, en Alameda Research. Desalniettemin is het verhaal nu anders gezien het feit dat hij onder huisarrest staat en vecht om zichzelf onschuldig te bewijzen tegenover een overvloed aan zware criminele aanklachten.</p>
<p>Helaas wordt Bankman-Fried nu geassocieerd met een van de grootste financiële fraudes in de geschiedenis. Op 13 december 2022 kondigde Damian Williams, de Amerikaanse aanklager voor het zuidelijke district van New York, een aanklacht van acht punten tegen hem aan, waarbij sprake was van grove nalatigheid bij het beheer van klantenfondsen.</p>
<p>Lees ook: <a href="https://www.gate.io/blog_detail/3219/former-ftx--utive-guilty-plea" target="_blank">Voormalig FTX utive Riyan Salame pleit schuldig</a></p>
<h2 id="h2-SBFs20FTX20Cryptocurrency20Exchange658497"><a name="SBF’s FTX Cryptocurrency Exchange" class="reference-link"></a><span class="header-link octicon octicon-link"></span>SBF’s FTX Cryptocurrency Exchange</h2><p>Een korte achtergrondinformatie over SBF bezeten FTX cryptocurrency exchange kan u helpen te begrijpen hoe Bankman-Fried van prominentie naar schande is glen.</p>
<p>In 2021 was FTX, opgericht in 2018, de op twee na grootste cryptocurrency-beurs ter wereld. Haar portefeuille omvatte producten met een hefboomwerking en derivaten. Daarnaast bood het ook spot trading aan voor meer dan 300 crypto-paren zoals BTC/USDT, <a href="/price/xrp-xrp" rel="nofollow noopener noreferrer" target="_blank">XRP</a>/USDT, <a href="/trade/ETH_USDT" target="_blank" class="blog_inner_link">ETH/USDT</a> en FTT/USDT.</p>
<p>In het algemeen had FTX twee eenheden, het in de Bahama’s gevestigde FTX en zijn Amerikaanse zusteronderneming FTX US, die overlappende managementteams hadden, iets dat heeft bijgedragen aan de ondergang ervan. De twee eenheden hadden echter afzonderlijke kapitaalstructuren.</p>
<p>Beide eenheden boden echter vergelijkbare producten aan, waaronder spotmarkten, futures, MOVE-contracten, gehevelde tokens en opties. Op een gegeven moment werd FTX gewaardeerd op meer dan $32 miljard, wat overeenkwam met ongeveer 25 miljard Britse pond. Het had ooit een dagelijks handelsvolume van $10-$15 miljard, iets wat slechts een paar crypto-beurzen in 2022 zouden bereiken.</p>
<p>Bovendien had de FTX-beurs zijn eigen cryptocurrency <a href="https://www.gate.io/learn/articles/what-is-ftx-token/397 &quot;called FTX token (FTT" rel="nofollow noopener noreferrer" target="_blank">genaamd FTX-token (FTT)</a>”) wat veel handelaren aantrok. Specifiek gaf de beurs vroeger kortingen aan klanten die FTT verhandelden. Opmerkelijk genoeg was Alameda Research een van de grootste houders van FTT.</p>
<p>Bovendien ondersteunde FTX negen fiatvaluta’s, waaronder de Amerikaanse dollar, Australische dollar, Canadese dollar, euro, Britse pond, Ghanese cedi, Zwitserse frank, Argentijnse peso en Braziliaanse real.</p>
<p>Bankman-Fried’s levensstijl heeft mogelijk bijgedragen aan de implosie van FTX. Hoewel hij zichzelf in het openbaar afschilderde als een eenvoudige man die gewone kleding droeg, leidde hij een weelderige levensstijl op de Bahama’s, wat echter minder aandacht trok van het publiek.</p>
<h2 id="h2-Hoe20FTX20Crypto20Exchange20van20dominantie20naar20faillissement20viel652948"><a name="Hoe FTX Crypto Exchange van dominantie naar faillissement viel" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Hoe FTX Crypto Exchange van dominantie naar faillissement viel</h2><p>In het midden van 2022 zou niemand in zijn volle verstand hebben gedacht dat de FTX-uitwisseling zou falen. Maar in oktober van datzelfde jaar hebben zich verschillende gebeurtenissen voorgedaan die hebben geleid tot de totale mislukking van de crypto-uitwisseling.</p>
<p>Een crypto nieuwsartikel dat CoinDesk in oktober publiceerde, veroorzaakte de ondergang van FTX. In het artikel werd gesuggereerd dat de levensvatbaarheid van Alameda Research afhankelijk was van haar grote hoeveelheid FTT, niet van een onafhankelijk crypto-actief.</p>
<p>Ongeveer tegelijkertijd publiceerde de Wall Street Journal ook de informatie dat Alameda Research de klantendeposito’s van FTX had gebruikt als onderpand voor zijn leningen voor handel.</p>
<p>Een paar dagen later verkocht Binance zijn FTT-aandeel aan het publiek als gevolg van de informatie die CoinDesk en Wall Street Journal hadden gepubliceerd. In feite dwongen de opkomende details over de ‘verkeerd behandelde klantfondsen en vermeende Amerikaanse overheidsinstantiesonderzoeken’ Binance om zich te distantiëren van de FTX-beurs.</p>
<p>Deze gebeurtenissen veroorzaakten paniek onder FTX-gebruikers die het grootste deel van hun fondsen begonnen op te nemen. Sterker nog, binnen korte tijd haalden de klanten miljarden dollars op. Als gevolg hiervan werden de opnames opgeschort terwijl Bankman-Fried manieren zocht om de beurs te redden. Uiteindelijk ging de beurs echter failliet.</p>
<p>Op dit moment staat Bankman-Fried terecht in de Verenigde Staten voor de verschillende misdaden die hij geacht wordt te hebben gepleegd. Verschillende voormalige leidinggevenden van FTX, waaronder Riyan Salame, Caroline Ellison (voormalig CEO van Alameda), Gary Wang (voormalig technisch directeur van FTX) en Nishad Singh (voormalig technisch directeur van FTX), hebben al schuld bekend aan de aanklachten tegen hen.</p>
<h2 id="h2-Conclusie707826"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>Sam Bankman-Fried voelt zich neerslachtig en gehaat na de ineenstorting van de FTX-cryptobeurs in 2022 en de rechtszaak waarmee hij geconfronteerd wordt in de Verenigde Staten. De waarheid is dat veel mensen die hem vroeger als een belangrijk persoon in de cryptosector zagen, hem nu als een oplichter beschouwen.</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 mits Gate.io wordt vermeld. In alle glen zullen juridische stappen worden ondernomen vanwege auteursrechtinbreuk.<br></div><p></p><br></div></div></div>