V2llIGlzIFNCRj8gV2VsayBuaWV1d3MgaGVlZnQgU0JGIG9ubGFuZ3MgZ2VoYWQ/

2025-02-28, 09:10

<p><img src="https://gimg2.gateimg.com/image/article/1739245364JYZN.png" alt=""></p>
<h2 id="h2-Inleiding973025"><a name="Inleiding" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Inleiding</h2><p>Hoe viel de mythe van de voormalige ster uit de cryptocurrency-industrie, van de oprichter van FTX tot de blockchain-ondernemer, uiteen? Dit artikel zal je kennis laten maken met SBF’s legendarische ervaring, waarbij wordt onthuld hoe hij een miljarden dollars cryptocurrency exchange-imperium heeft opgebouwd en uiteindelijk vernietigde, en de diepgaande impact van dit incident op de hele industrie.</p>
<p><strong>Handel nu FTT: </strong> <a href="https://www.gate.io/trade/FTT_USDT" target="_blank">https://www.gate.io/trade/FTT_USDT</a></p>
<h2 id="h2-Wie20is20Sam20BankmanFried20SBF907120"><a name="Wie is Sam Bankman-Fried (SBF)?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wie is Sam Bankman-Fried (SBF)?</h2><p>Sam Bankman-Fried, ook wel bekend als SBF, was ooit een bekende ondernemer in de cryptocurrency-industrie. Hij richtte de cryptocurrency-beurs FTX op in april 2019 en ontwikkelde deze al snel tot een van ‘s werelds grootste cryptocurrency-handelsplatforms. Op het hoogtepunt van FTX werd de persoonlijke nettowaarde van SBF geschat op $26 miljard, waarmee hij een van de rijkste mensen in de cryptocurrency-industrie werd.</p>
<p>Als jongeman met een academische achtergrond werkte SBF aanvankelijk bij Jane Street Capital, een kwantitatief handelsbedrijf op Wall Street, nadat hij natuurkunde en wiskunde had gestudeerd aan het MIT. Hier begon hij in aanraking te komen met de wereld van cryptocurrency en zag hij de enorme mogelijkheden die daarin schuilen. In 2017 besloot SBF te investeren in de cryptocurrency-industrie en richtte hij Alameda Research op, een kwantitatief handelsbedrijf dat zich richt op cryptocurrency-contracthandel.</p>
<p>FTX was ooit ‘s werelds op twee na grootste cryptocurrencybeurs, met meer dan 1 miljoen gebruikers en een waardering van maximaal $32 miljard. Echter, in 2022 stortte dit enorme financiële rijk binnen enkele dagen in, wat een enorme schok teweegbracht in de hele cryptocurrency-industrie.</p>
<h2 id="h2-Hoe20is20FTX20van20een20cryptocurrencyreus20naar20een20failliet20bedrijf20gegaan908636"><a name="Hoe is FTX van een cryptocurrencyreus naar een failliet bedrijf gegaan?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Hoe is FTX van een cryptocurrencyreus naar een failliet bedrijf gegaan?</h2><p>De directe aanleiding voor de ondergang van FTX was de onjuiste financiële transacties tussen FTX en zijn gelieerde onderneming Alameda Research. Op 2 november 2022 onthulde CoinDesk dat Alameda Research een groot aantal FTT-tokens in handen had die waren uitgegeven door FTX zelf, wat marktzorgen opwekte over de financiële situatie van FTX. Dit nieuws veroorzaakte paniekverkopen van FTX’s platformvaluta (FTT) en het terugtrekken van fondsen van het FTX-platform door investeerders. FTX raakte in een liquiditeitscrisis doordat het niet kon voldoen aan de opnamebehoeften van gebruikers.</p>
<p>Het volgende is een tijdlijn van gebeurtenissen:</p>
<table>
<thead>
<tr>
<th style="text-align:center">Tijd</th>
<th style="text-align:center">Gebeurtenissen</th>
</tr>
</thead>
<tbody>
<tr>
<td style="text-align:center">2 november 2022</td>
<td style="text-align:center">CoinDesk onthulde dat Alameda Research een groot aantal FTT-tokens in bezit had</td>
</tr>
<tr>
<td style="text-align:center">8 november 2022</td>
<td style="text-align:center">Binance heeft de verkoop van zijn FTT-tokens aangekondigd, wat heeft geleid tot paniek op de markt</td>
</tr>
<tr>
<td style="text-align:center">11 november 2022</td>
<td style="text-align:center">FTX en meer dan 100 gelieerde entiteiten hebben faillissementsbescherming aangevraagd</td>
</tr>
<tr>
<td style="text-align:center">12 december 2022</td>
<td style="text-align:center">Sam Bankman-Fried werd gearresteerd in de Bahama’s</td>
</tr>
<tr>
<td style="text-align:center">28 maart 2024</td>
<td style="text-align:center">De rechtbank van de Verenigde Staten voor het zuidelijke district van New York veroordeelde SBF tot 25 jaar gevangenisstraf. Het vonnis wees erop dat de acties van SBF “een van de grootste financiële fraudeglen in de geschiedenis” vormden.</td>
</tr>
</tbody>
</table>
<p>De redenen voor het faillissement van FTX kunnen worden toegeschreven aan de volgende aspecten:</p>
<p>FTX heeft een belangenconflict met Alameda Research. FTX leende klantenfondsen uit aan Alameda voor transacties met een hoog risico, in strijd met de gebruikersovereenkomst.</p>
<p>FTX ontbeert effectieve bedrijfsgovernance en risicobeheersingsmechanismen, en de nieuwe CEO John J. Ray III noemde FTX de “meest grondige mislukking in bedrijfsbeheer” die hij ooit heeft gezien.</p>
<p>FTX heeft ernstige problemen in financieel beheer, waaronder een gebrek aan nauwkeurige bankrekeninginformatie en gebruikersgegevens.</p>
<p>FTX-oprichter Sam Bankman-Fried wordt verdacht van fraude en verduistering van geld van klanten, wat de hoofdoorzaak werd van de ondergang van FTX.</p>
<h2 id="h2-What20impact20had20de20ineenstorting20van20FTX20op20de20cryptocurrencymarkt531960"><a name="What impact had de ineenstorting van FTX op de cryptocurrency-markt?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>What impact had de ineenstorting van FTX op de cryptocurrency-markt?</h2><p>De ineenstorting van FTX had een grote impact op de hele markt voor digitale activa en veroorzaakte niet alleen een scherpe daling van de <a href="/price" rel="nofollow noopener noreferrer" target="_blank">cryptocurrencyprijzen</a>, maar ook een reeks kettingreacties op gang bracht die meerdere gerelateerde bedrijven en investeerders troffen.</p>
<p>De ineenstorting van FTX leidde direct tot een grootschalige verkoop in de <a href="/price" rel="nofollow noopener noreferrer" target="_blank">cryptocurrency markt</a>.<br><a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin prijzen</a> daalde tot het laagste punt in twee jaar, en andere reguliere cryptocurrencies daalden ook in verschillende mate. Deze onrust op de markt trof niet alleen individuele beleggers, maar veroorzaakte ook enorme verliezen voor institutionele beleggers. Verschillende institutionele beleggers die in FTX investeerden, werden gedwongen om volledige verliezen op hun beleggingen op te bouwen, waaronder bekende beleggingsinstellingen zoals SoftBank Group en Sequoia Capital.</p>
<p>De ineenstorting van FTX veroorzaakte een vertrouwenscrisis in andere cryptocurrency-beurzen.<br>Beleggers begonnen op grote schaal fondsen terug te trekken uit grote beurzen, waardoor er liquiditeitsdruk ontstond op veel beurzen. Als reactie op deze situatie moesten sommige beurzen gebruikersopnames opschorten of de opnamebedragen beperken, waardoor de marktpaniek verder verergerde.</p>
<p>Het faillissement van FTX had ook een kettingreactie op het gehele cryptocurrency-ecosysteem. Veel bedrijven die zaken deden met FTX leden verschillende mate van verliezen, en sommige bedrijven liepen zelfs het risico op faillissement. Zo heeft het cryptocurrency uitleenplatform BlockFi faillissementsbescherming aangevraagd vanwege de ineenstorting van FTX.</p>
<p>Het FTX-incident heeft meer aandacht getrokken van toezichthouders naar de cryptocurrency-industrie.<br>Overheden en toezichthouders zijn begonnen met het herzien van het bestaande regelgevingskader en overwegen de supervisie van cryptocurrencybeurzen te versterken. Dit kan leiden tot een strengere regelgeving voor de cryptocurrency-industrie in de toekomst, wat een diepgaande impact zal hebben op de ontwikkeling van de industrie.</p>
<h2 id="h2-Welk20nieuws20en20ontwikkelingen20heeft20SBF20recent20gehad789777"><a name="Welk nieuws en ontwikkelingen heeft SBF recent gehad?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Welk nieuws en ontwikkelingen heeft SBF recent gehad?</h2><p>Sinds zijn veroordeling draaien de ontwikkelingen van SBF voornamelijk om zijn levensomstandigheden in de gevangenis en de beroepspogingen van zijn juridisch team. Onlangs is een foto van SBF die poseert met voormalige leden van de Bloods-bende in het Brooklyn Metropolitan Detention Center (MDC) online verspreid en heeft veel aandacht getrokken. SBF op de foto heeft lang haar en een baard, wat heel anders is dan zijn imago in de rechtbank.</p>
<p><img src="https://gimg2.gateimg.com/image/article/174073374379ee350a-9ede-439f-9519-99dcba2c7f48.png" alt=""><br>Afbeeldingsbron: X</p>
<p>Op juridisch vlak heeft het juridische team van SBF beroep aangetekend, waarbij ze de eerlijkheid van het vonnis en de rationaliteit van de strafmaat in twijfel trekken. Ze zijn van mening dat de straf van 25 jaar te streng is en niet overeenkomt met de werkelijke omvang van de misdaden van SBF. Tegelijkertijd zoeken ze ook naar andere mogelijke juridische remedies, waaronder het verkennen van de mogelijkheid van het verkrijgen van een presidentieel pardon.</p>
<p>Het is het vermelden waard dat na twee jaar van stilte SBF een reeks berichten plaatste over ontslagen en werkgelegenheidskwesties op het sociale platform X, wat een wijdverbreide discussie veroorzaakte en de prijs van de gelijknamige Meme-munt en FTX-platformmunt FTT stimuleerde. Nadat SBF het bericht had geplaatst, steeg de prijs van zijn gelijknamige mememunt SBF met meer dan 2.400% in één uur, en bereikte op een gegeven moment $0,0022. FTT steeg ook met ongeveer 40% in 15 minuten.</p>
<p>De inhoud van het bericht van SBF leek een reactie te zijn op de recente opmerkingen van Elon Musk over de efficiëntie van overheidsmedewerkers, wat speculatie op gang bracht of SBF probeerde zijn openbare imago te hervormen.</p>
<p><img src="https://gimg2.gateimg.com/image/article/174073377906be1876-a174-4a95-b8c1-442eb0783465.png" alt=""><br>Bron afbeelding: X</p>
<h2 id="h2-Conclusion525985"><a name="Conclusion" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusion</h2><p>De ineenstorting van FTX onthult niet alleen de potentiële risico’s van de cryptocurrency-industrie, maar benadrukt ook de urgentie van het verbeteren van het regelgevingssysteem. Dit incident zette marktdeelnemers ertoe aan de industrienormen opnieuw te onderzoeken en regelgevers ertoe aan te zetten het toezicht op beurzen te versterken. In de toekomst zullen cryptocurrency-handelsplatforms te maken krijgen met strengere financiële audits, bescherming van klantenfondsen en vereisten op het gebied van corporate governance. Alleen door een transparant en verantwoord bedrijfsmodel op te zetten, kunnen we het vertrouwen van investeerders herstellen en de gezonde ontwikkeling van de industrie bevorderen.</p>
<p>Risicowaarschuwing: The <a href="/price" rel="nofollow noopener noreferrer" target="_blank">cryptocurrency markt</a> is nog steeds zeer volatiel, en veranderingen in regelgevingsbeleid kunnen onvoorziene gevolgen hebben. Beleggers dienen de risico’s nauwkeurig te beoordelen.</p>
<div class="blog-details-info"><br><div>Auteur: Gate.io-onderzoeker JJ M.<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de standpunten van de auteur en vormt geen handelsadvies. Beleggen is riskant en beslissingen moeten met voorzichtigheid worden genomen.<br></em><div><em></em>De inhoud van dit artikel is origineel en het auteursrecht behoort toe aan Gate.io. Indien u het wenst te herdrukken, gelieve de auteur en bron te vermelden, anders zal er juridische aansprakelijkheid worden nagestreefd.<br></div><p></p><br></div></div></div>