U2luZ2Fwb3JlIFRlbWFzZWsgZ2Vub2VtZCBpbiBGVFggdGUgbWlkZGVuIHZhbiBzdHJpamQ=

2023-08-22, 12:10

<p><img src="https://gimg2.gateimg.com/image/article/1692705922RDZZ 1.jpeg" alt=""></p>
<h2 id="h2-Te20lang20niet20gelezen465596"><a name="Te lang; niet gelezen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Te lang; niet gelezen</h2><p>Temasek, Sino Global, Sequoia Capital, Softbank en andere durfkapitaalbedrijven worden in de Verenigde Staten geconfronteerd met een rechtszaak omdat ze FTX steunen ondanks zijn slechte financiële beheersrecord.</p>
<p>Temasek heeft gezegd dat het zijn vertrouwen heeft verloren in Sam Bankman-Fried toen het investeerde in de FTX-crypto-uitwisseling.</p>
<p>De meeste VC-bedrijven die in FTX investeerden, leden enorme verliezen.</p>
<h2 id="h2-Introductie98473"><a name="Introductie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introductie</h2><p>Bijna tien maanden <a href="https://www.gate.io/blog_detail/1804/key-lessons-from-the-collapse-of-ftx-and-the-implosion-of-ftt" target="_blank">na de ineenstorting van de FTX crypto-uitwisseling</a> er lopen nog steeds verschillende juridische geschillen. De huidige rechtszaken hebben verschillende personen en bedrijven betrokken. Dit artikel zal bespreken hoe Temasek en verschillende crypto-investeringsprojecten betrokken zijn geraakt bij <a href="https://www.gate.io/price/ftx-ftt" target="_blank">assisteren bij FTX</a> in zijn illegale praktijken.</p>
<h2 id="h2-Rechtszaak20tegen20Temasek20en20verschillende20durfkapitalen213414"><a name="Rechtszaak tegen Temasek en verschillende durfkapitalen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Rechtszaak tegen Temasek en verschillende durfkapitalen</h2><p>Temasek, een staatsbedrijf uit Singapore, en andere durfkapitaalinvesteringsfirma’s zoals Sino Global uit Hong Kong, Sequoia Capital en Japan’s Softbank, zijn gedaagden in een class-action rechtszaak die is ingediend bij de Amerikaanse districtsrechtbank voor het noordelijke district van Californië wegens hun medewerking aan de illegale activiteiten van de nu failliete crypto exchange FTX.</p>
<p>De rechtszaak beweert dat Temasek Company en de genoemde VC-bedrijven verschillende misleidende verklaringen hebben afgelegd die veel klanten hebben verleid om crypto-investeringen te doen in FTX. De eiser zei dat het belangrijkste doel van deze crypto-bedrijven was om individuen en instellingen te lokken om te investeren in FTX voor hun persoonlijke winst.</p>
<p>Lees ook: <a href="https://www.gate.io/blog_detail/1806/ftx-s-collapse-affected-a-wide-cross-section-of-the-crypto-eco" target="_blank">De ineenstorting van FTX beïnvloedde een brede dwarsdoorsnede van het crypto-ecosysteem</a></p>
<p>Eén van de belangrijkste grondslagen voor de juridische actie is dat: “De Multinationale VC Verdachten hebben ook talrijke misleidende en misleidende verklaringen afgelegd over FTX’s bedrijf, financiën, operaties en vooruitzichten met als doel klanten aan te zetten om te investeren, te handelen en/of activa bij FTX te storten.” Kortom, de eiser zoekt compensatie voor de financiële verliezen die zij hebben geleden toen de beurs werd gesloten en roept op tot strafmaatregelen tegen de verdachten.</p>
<p>Tijdens haar advertentiecampagnes verwees FTX naar ‘aanzienlijke financiële en publieke steun’ van durfkapitalen en andere grote zakelijke partners zoals Temasek. Daarom beweert de eiser dat ‘zonder de multinationale VC-verdachten, de grootste financiële fraude in de geschiedenis van de VS niet zou hebben plaatsgevonden.’</p>
<p>Gelet op deze feiten namen de verdachten actief deel aan de ‘massale, multibiljoen-dollar wereldwijde fraude van de FTX Group’. Anders gezegd ‘pleegden zij, samenspanden zij om te plegen, en/of hielpen en begunstigden zij de multibiljoen-dollar fraude van de FTX Group voor hun eigen financieel en professioneel gewin.’</p>
<p>De FTX-rechtszaak stelt ook dat de ijverige controles die de beklaagden hebben uitgevoerd, hen in staat hebben gesteld om verschillende omissies, verduistering van beleggersgelden en onwaarachtig gedrag te identificeren, maar deze niet hebben gepubliceerd. Het is dan ook zeer aannemelijk dat de verdachten op de hoogte waren van <a href="https://www.gate.io/explore/ftx-sbf" target="_blank">Sam Bankman-Fried en zijn team misbruikten hun stortingen.</a></p>
<p>De belangrijkste beschuldiging tegen Temasek en verschillende durfkapitaalbedrijven is dat terwijl FTX Exchange de gelden van klanten stal en diverse effectenwetten overtrad, deze bedrijfsorganisaties het steunden door te beweren dat ze een gedegen onderzoek hadden uitgevoerd voordat ze erin investeerden.</p>
<p>Lees ook: <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 utives aan voor $1 miljard</a></p>
<h2 id="h2-Temasek580591"><a name="Temasek" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Temasek</h2><p>Er is een goede reden voor de klacht om een rechtszaak aan te spannen tegen Temasek, gezien het feit dat het beweerde een financiële audit van acht maanden te hebben uitgevoerd van FTX crypto exchange in 2021. Ook beweerde het stellig dat het geen enkel punt van zorg heeft gevonden.</p>
<p>Helaas verloor Temasek $275 miljoen investering als gevolg van de ineenstorting van FTX. Als strafmaatregel heeft het de compensatie van zijn senior utives die verantwoordelijk waren voor investeringen in de cryptobeurs verlaagd. Het bedrijf heeft echter duidelijk toegegeven dat het zijn vertrouwen in Sam Bankman-fried heeft misplaatst.</p>
<p><a href="https://www.channelnewsasia.com/business/ftx-crypto-bankrupt-founder-sam-bankman-fried-wealth-sbf-3066191" rel="nofollow noopener noreferrer" target="_blank">Haar woordvoerder zei</a> Het is duidelijk uit deze investering dat ons geloof in de acties, het oordeel en leiderschap van Sam Bankman-Fried, gevormd door onze interacties met hem en meningen geuit in onze gesprekken met anderen, mogelijk ongepast was.</p>
<p>Het voegde toe: “We verwachten dat bedrijven waarin we investeren voldoen aan hun verplichtingen volgens de wet- en regelgeving van de rechtsgebieden waarin ze investeringen hebben of actief zijn, zich houden aan een degelijk ondernemingsbestuur en bovenal altijd ethisch handelen.”</p>
<p>Desalniettemin stond Temasek erop dat het een grondig onderzoek uitvoerde <a href="https://www.gate.io/learn/articles/what-is-ftx-token/397" target="_blank">audit en onderzoek van FTX voordat u investeert</a> Het beweerde dat het de wettelijke naleving en cyberbeveiliging van FTX heeft geëvalueerd. Het zocht ook advies van verschillende specialisten, waaronder cyberbeveiligingsexperts en externe juridische adviseurs. Daarnaast voerde het interviews met andere investeerders, branche-experts en het managementteam van het bedrijf.</p>
<p>Uiteindelijk concludeerde de woordvoerder van Temasek: “We erkennen dat onze due diligence-processen bepaalde risico’s kunnen verminderen, maar het is niet praktisch om alle risico’s uit te sluiten.”</p>
<p>Het is belangrijk op te merken dat de andere VC-investeringsmaatschappijen miljarden dollars verloren toen FTX instortte in een van de grootste cryptozwendel in de geschiedenis. Zo diende bijvoorbeeld Sino Global een vordering in van $67,3 miljoen tegen de beurs.</p>
<h2 id="h2-Conclusie427539"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>In een op 7 augustus ingediende rechtszaak beschuldigt de klager Temasek en verschillende VC-firma’s ervan het publiek te hebben misleid over de financiële misstappen van FTX. Aan de andere kant zeiden Temasek en andere VC-investeringsfirma’s dat ze hun vertrouwen in Sam Bankman-Fried verkeerd hadden geplaatst, wat leidde tot hun verlies van fondsen. Temasek blijft echter volhouden dat het zorgvuldigheid betrachtte voordat het investeerde in de FTX-beurs.</p>
<p>Lees ook: <a href="https://www.gate.io/blog_detail/1792/ftx-event-and-its-domino-effects" target="_blank">FTX-evenement en de domino-effecten ervan</a></p>
<h2 id="h2-Veelgestelde20vragen20over20Temasek813447"><a name="Veelgestelde vragen over Temasek" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Veelgestelde vragen over Temasek</h2><h3 id="h3-Is20Temasek20genvesteerd20in20crypto235985"><a name="Is Temasek geïnvesteerd in crypto?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Is Temasek geïnvesteerd in crypto?</h3><p>Temasek, een Singaporees staatsbedrijf, heeft geen investeringen in cryptocurrencies. Haar laatste crypto-investering was in FTX exchange waar het meer dan $275 miljoen aan investeringsfondsen verloor toen de exchange in november 2022 instortte.</p>
<h3 id="h3-Hoeveel20heeft20Temasek20verloren20in20cryptocurrency760912"><a name="Hoeveel heeft Temasek verloren in cryptocurrency?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Hoeveel heeft Temasek verloren in cryptocurrency?</h3><p>Temasek verloor $275 miljoen toen de FTX-beurs in november 2022 instortte. Het heeft geen van dat bedrag teruggekregen. Sindsdien heeft Temasek niet meer geïnvesteerd in cryptocurrency.</p>
<h3 id="h3-Heeft20Temasek20bitcoin20in20bezit544724"><a name="Heeft Temasek bitcoin in bezit?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Heeft Temasek <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">bitcoin</a> in bezit?</h3><p>Temasek bezit niet <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> of in een andere cryptocurrency. Momenteel heeft het geen plannen om te investeren in cryptocurrencies vanwege de onzekerheid op het gebied van regelgeving.</p>
<h3 id="h3-Waarom20heeft20Temasek20genvesteerd20in20FTX958942"><a name="Waarom heeft Temasek geïnvesteerd in FTX?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Waarom heeft Temasek geïnvesteerd in FTX?</h3><p>Temasek investeerde in FTX omdat het verwachtte een hoog rendement op zijn investering te krijgen. Voordat het in het bedrijf investeerde, controleerde het de financiële prestaties van FTX, de beveiliging en de wettelijke naleving. Bovendien vertrouwde het op de oprichter en CEO Sam Bankman-Fried.</p>
<div class="blog-details-info"><br><div>Auteur: <strong>Mashell C.</strong>, Onderzoeker Gate.io<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de standpunten 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 er juridische actie worden ondernomen vanwege schending van het auteursrecht.<br></div><p></p><br></div></div></div>