U2luZ2Fwb3JlIFRlbWFzZWsgbm9taW5hdG8gaW4gRlRYIGluIG1lenpvIGFsbGUgZGlmZmljb2x0w6A=

2023-08-22, 12:10

<p><img src="https://gimg2.gateimg.com/image/article/1692705922RDZZ 1.jpeg" alt=""></p>
<h2 id="h2-TL20DR307940"><a name="TL; DR" class="reference-link"></a><span class="header-link octicon octicon-link"></span>TL; DR</h2><p>Temasek, Sino Global, Sequoia Capital, Softbank e altre società di venture capital stanno affrontando una causa negli Stati Uniti per aver sostenuto FTX nonostante la sua scarsa gestione finanziaria.</p>
<p>Temasek ha detto di aver perso la fiducia in Sam Bankman-Fried quando ha investito nello scambio di criptovalute FTX.</p>
<p>La maggior parte delle società di venture capital che hanno investito in FTX ha subito enormi perdite.</p>
<h2 id="h2-Introduzione548220"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>Quasi dieci mesi <a href="https://www.gate.io/blog_detail/1804/key-lessons-from-the-collapse-of-ftx-and-the-implosion-of-ftt" target="_blank">dopo il crollo della borsa criptovalute FTX</a> ci sono ancora diverse battaglie legali in corso. Le attuali cause coinvolgono diverse persone e aziende. Questo articolo discuterà di come Temasek e diversi progetti di investimento in criptovalute sono stati implicati in <a href="https://www.gate.io/price/ftx-ftt" target="_blank">assistendo FTX</a> nelle sue operazioni illegali.</p>
<h2 id="h2-Cause20legale20contro20Temasek20e20diversi20venture20capital968657"><a name="Cause legale contro Temasek e diversi venture capital" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Cause legale contro Temasek e diversi venture capital</h2><p>Temasek, una società statale di Singapore, e altre società di investimento di venture capital (VC), tra cui Sino Global di Hong Kong, Sequoia Capital e Softbank del Giappone, sono imputate in una causa collettiva presentata presso il Tribunale del distretto degli Stati Uniti per il distretto settentrionale della California per aver collaborato con l’attività illegale della borsa crittografica FTX, ora fallita.</p>
<p>La causa afferma che la società Temasek e le società di venture capital citate hanno fatto diverse dichiarazioni ingannevoli che hanno attirato molti clienti a fare investimenti cripto in FTX. Il querelante ha detto che l’obiettivo principale di queste società cripto era attirare individui e istituzioni a investire in FTX per il loro guadagno personale.</p>
<p>Leggi anche: <a href="https://www.gate.io/blog_detail/1806/ftx-s-collapse-affected-a-wide-cross-section-of-the-crypto-eco" target="_blank">Il crollo di FTX ha colpito una vasta gamma di ecosistemi crittografici</a></p>
<p>Una delle basi chiave per l’azione legale è che: “Anche i Multinational VC Defendants hanno fatto numerose affermazioni ingannevoli e fuorvianti sulla propria attività, finanze, operazioni e prospettive di FTX allo scopo di indurre i clienti a investire, fare trading e/o depositare asset con FTX.”<br>In sostanza, il querelante sta cercando un risarcimento per le perdite finanziarie subite quando lo scambio è stato chiuso e chiede azioni punitive contro i convenuti.</p>
<p>Durante le sue campagne pubblicitarie, FTX ha citato un “significativo supporto finanziario e pubblico” da parte di capitali di rischio e altri grandi partner commerciali come Temasek. Pertanto, il querelante sostiene che “senza i multinazionali VC imputati, la più grande frode finanziaria nella storia degli Stati Uniti non sarebbe mai avvenuta.”</p>
<p>Considerando questi fatti, i convenuti hanno partecipato attivamente alla “massiccia truffa globale da miliardi di dollari del FTX Group”. In altre parole, “hanno perpetrato, cospirato per perpetrare e/o aiutato e istigato le truffe da miliardi di dollari del FTX Group per il proprio guadagno finanziario e professionale.”</p>
<p>Anche la causa FTX afferma che i controlli diligenti effettuati dai convenuti hanno permesso loro di identificare varie omissioni, appropriazioni indebite di fondi degli investitori e condotte non veritiere, ma non le hanno rese pubbliche. Pertanto, è molto probabile che gli imputati fossero consapevoli che <a href="https://www.gate.io/explore/ftx-sbf" target="_blank">Sam Bankman-Fried e il suo team stavano dirottando i loro depositi.</a></p>
<p>La principale accusa contro Temasek e diverse società di venture capital è che, mentre l’exchange FTX rubava i fondi dei clienti e violava diverse leggi sui titoli, queste organizzazioni commerciali lo supportavano affermando di aver effettuato una dovuta diligenza prima di investire in esso.</p>
<p>Leggi anche: <a href="https://www.gate.io/blog_detail/3017/ftx-sues-sam-bankman-fried-and-former-_s-for-1-billion" target="_blank">FTX Fa Causa a Sam Bankman-Fried e ai Precedenti Dirigenti per 1 Miliardo di Dollari</a></p>
<h2 id="h2-Temasek861150"><a name="Temasek" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Temasek</h2><p>C’è una buona ragione per la denuncia da presentare contro Temasek, considerando che ha dichiarato di aver effettuato una revisione contabile finanziaria di otto mesi dello scambio di criptovalute FTX nel 2021. Inoltre, ha fortemente sostenuto di non aver trovato alcun problema di preoccupazione.</p>
<p>Purtroppo, Temasek ha perso un investimento di $275 milioni a causa del crollo di FTX. Come misura punitiva ha ridotto il compenso dei suoi dirigenti senior responsabili degli investimenti nella borsa criptovalutaria. Tuttavia, l’azienda ha chiaramente ammesso di aver perso fiducia in Sam Bankman-Fried.</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">Il suo portavoce ha detto</a>“È evidente da questo investimento che forse la nostra fiducia nelle azioni, nel giudizio e nella leadership di Sam Bankman-Fried, formata dalle nostre interazioni con lui e dalle opinioni espresse nelle nostre discussioni con altri, sembrerebbe essere stata fuorviante.”</p>
<p>Aggiungeva: “Ci aspettiamo che le aziende in cui investiamo rispettino i loro obblighi ai sensi delle leggi e dei regolamenti delle giurisdizioni in cui hanno investimenti o operazioni, rispettino una sana governance aziendale e, soprattutto, agiscano sempre in modo etico”.</p>
<p>Tuttavia, Temasek ha mantenuto la parola che ha svolto un’indagine approfondita <a href="https://www.gate.io/learn/articles/what-is-ftx-token/397" target="_blank">audit e indagine su FTX prima di investire</a> In esso. Ha affermato di aver valutato la conformità legale e la cybersecurity di FTX. Ha anche cercato consigli da vari specialisti, tra cui esperti di cybersecurity e consulenti legali esterni. Inoltre, ha effettuato interviste con altri investitori, esperti del settore e il team di gestione dell’azienda.</p>
<p>Alla fine, ha concluso il portavoce di Temasek: “Riconosciamo che, sebbene i nostri processi di due diligence possano mitigare alcuni rischi, non è praticabile eliminare tutti i rischi”.</p>
<p>È importante notare che le altre società di investimento in VC hanno perso miliardi di dollari quando FTX è collassato in uno dei più grandi frodi criptovalutarie della storia. Ad esempio, Sino Global ha presentato una richiesta di risarcimento di $67,3 milioni contro l’exchange.</p>
<h2 id="h2-Conclusione839113"><a name="Conclusione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusione</h2><p>In una causa intentata il 7 agosto, il querelante accusa Temasek e diverse società di VC per aver ingannato il pubblico sulle cattive condotte finanziarie di FTX. D’altra parte, Temasek e altre società di investimento VC hanno detto di aver perso fiducia in Sam Bankman-Fried, il che ha portato alla loro perdita di fondi. Tuttavia, Temasek sostiene di aver esercitato la dovuta diligenza prima di investire nel mercato FTX.</p>
<p>Leggi anche: <a href="https://www.gate.io/blog_detail/1792/ftx-event-and-its-domino-effects" target="_blank">Evento FTX e i suoi effetti domino</a></p>
<h2 id="h2-Domande20frequenti20su20Temasek147735"><a name="Domande frequenti su Temasek" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Domande frequenti su Temasek</h2><h3 id="h3-Temasek20ha20investito20in20criptovalute437431"><a name="Temasek ha investito in criptovalute?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Temasek ha investito in criptovalute?</h3><p>Temasek, una società statale di Singapore, non ha investimenti in criptovalute. Il suo ultimo investimento in criptovalute è stato presso lo scambio FTX, dove ha perso più di $275 milioni di fondi di investimento quando lo scambio è collassato nel novembre 2022.</p>
<h3 id="h3-Quanto20ha20perso20Temasek20in20criptovaluta220117"><a name="Quanto ha perso Temasek in criptovaluta?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Quanto ha perso Temasek in criptovaluta?</h3><p>Temasek ha perso 275 milioni di dollari quando il exchange FTX è collassato nel novembre 2022. Non ha recuperato nessuna di quelle somme. Da allora, Temasek non ha più investito in criptovalute.</p>
<h3 id="h3-Temasek20detiene20bitcoin468317"><a name="Temasek detiene bitcoin?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Temasek detiene bitcoin?</h3><p>Temasek non possiede <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> o qualsiasi altra criptovaluta. Attualmente, non ha alcun piano di investire in criptovalute a causa dell’incertezza normativa nel settore.</p>
<h3 id="h3-Perch20Temasek20ha20investito20in20FTX799784"><a name="Perché Temasek ha investito in FTX?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Perché Temasek ha investito in FTX?</h3><p>Temasek ha investito in FTX perché si aspettava di ottenere un alto rendimento dal suo investimento. Prima di investire nell’azienda, ha effettuato un’audizione delle performance finanziarie di FTX, della sua sicurezza e della sua conformità legale. Inoltre, si è fidato del suo fondatore e CEO Sam Bankman-Fried.</p>
<div class="blog-details-info"><br><div>Autore:<strong> Mashell C.</strong>, Ricercatore di Gate.io<br><div class="info-tips"><em>Questo articolo rappresenta solo le opinioni del ricercatore e non costituisce alcun suggerimento di investimento.<br></em><div><em></em>Gate.io si riserva tutti i diritti su questo articolo. Sarà consentito il ripostaggio dell'articolo a condizione che venga citato Gate.io. In tutti i casi, saranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div>