TCdhdnZvY2F0byBkaSBOWSBmYSBjYXVzYSBhIEdlbWluaSBHZW5lc2lzIHBlciBwcmVzdW50YSByYXBwcmVzZW50YXppb25lIGVycmF0YSBkZWkgcmlzY2hpIHBlciBnbGkgaW52ZXN0aXRvcmk=

2023-10-31, 06:24

<p><img src="https://gimg2.gateimg.com/image/article/1690791857hotspot.jpeg" alt=""><br>Un avvocato di New York ha citato in giudizio Genesis e Gemini Trust per aver truffato gli investitori di oltre 1,1 miliardi di dollari.</p>
<p>L’avvocato sta cercando il risarcimento per gli investitori truffati e il disgorgemento dei loro profitti illeciti.</p>
<p>Gli Stati Uniti potrebbero vietare a Gemini Trust, Genesis Global e Digital Currency Group di operare nell’industria degli investimenti finanziari.</p>
<p>Parole chiave: Cause legali, frodi criptate, rischi degli investitori, cripto vietata, truffa cripto, legge cripto, crimini cripto, investitori defraudati, aziende cripto, causa legale contro le aziende cripto, impresa cripto</p>
<h2 id="h2-Introduzione33513"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>Il <a href="https://www.gate.io/id/blog_detail/3284/ftx-bankruptcy-claims-rise-in-otc-markets-estate-recovers-7.3-billion" target="_blank">effetti del collasso di FTX</a> è evidente in alcuni settori dell’economia crypto poiché alcune aziende ancora affrontano battaglie legali correlate a questo. Oltre al processo in corso di Sam Bankman-Fried, fondatore di FTX, c’è una causa legale contro aziende crypto come Gemini e Genesis. In questo post, discutiamo la causa legale contro Gemini e Genesis.</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 influenzato una vasta sezione trasversale dell’ecosistema crittografico</a></p>
<h2 id="h2-Lavvocato20di20New20York20fa20causa20a20Gemini20e20Genesis506990"><a name="L’avvocato di New York fa causa a Gemini e Genesis" class="reference-link"></a><span class="header-link octicon octicon-link"></span>L’avvocato di New York fa causa a Gemini e Genesis</h2><p>La procuratrice generale Letitia James, un avvocato di New York, ha intentato una causa contro le società di criptovalute Gemini Trust, Genesis Global e Digital Currency Group (DCG), per presunta truffa nei confronti di almeno 230.000 investitori, tra cui più di 29.000 newyorchesi, per oltre 1 miliardo di dollari.</p>
<p>James sta cercando un risarcimento per gli investitori truffati, la confisca dei guadagni illeciti e il divieto per queste aziende di operare nel settore degli investimenti finanziari. Fondamentalmente, Gemini e Genesis, una società di proprietà di DCG, hanno offerto un programma di prestito di criptovalute senza attuare misure efficaci di gestione del rischio.</p>
<p>Prima di approfondire le accuse, comprendiamo innanzitutto il background di queste società di investimento finanziario.</p>
<h2 id="h2-Panoramica20di20Gemini20Trust20Genesis20Global20e20Digital20Currency20Group727656"><a name="Panoramica di Gemini Trust, Genesis Global e Digital Currency Group" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Panoramica di Gemini Trust, Genesis Global e Digital Currency Group</h2><p>Il gruppo Digital Currency, fondato da Barry Silbert, è una società di venture capital che ha diverse sussidiarie, tra cui Genesis Global Trading, Inc., una società fondata nel 2013. Questo gruppo possiede anche altre società come Coindesk.</p>
<p>D’altra parte, Genesis è composto da diverse entità che offrono servizi di prestito, trading e custodia di asset digitali a clienti istituzionali e persone di alto valore netto e ad altre persone di fama.</p>
<p>Alcune delle aziende di proprietà di Genesis includono GGC International Limited (GGCI), Genesis Custody Limited, Genesis Global Trading, Inc. (GGT), Genesis Asia Pacific Pte. Ltd. (GAP) e Genesis Global Capital, LLC (GGC).</p>
<p>D’altra parte, Gemini Trust Company, LLC, popolarmente conosciuta come Gemini, fondata nel 2014, è un exchange di criptovalute con sede negli Stati Uniti e una banca custode. Come exchange consente agli investitori di acquistare e vendere diversi asset digitali tra cui le criptovalute.</p>
<p>Leggi anche: <a href="https://www.gate.io/how-to-buy/gemini-dollar-gusd &quot;How to Buy Gemini Dollar (GUSD" rel="nofollow noopener noreferrer" target="_blank">Come comprare il Gemini Dollar (GUSD) - HODL o scambiare Crypto</a>- HODL o Trade Crypto”</p>
<h2 id="h2-Le20cause20legali20contro20Gemini20e20Genesis524076"><a name="Le cause legali contro Gemini e Genesis" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Le cause legali contro Gemini e Genesis</h2><p>La causa dell’avvocato James ruota attorno a un programma di investimento gestito dalle società cripto Gemini e Genesis noto come “Gemini Earn”, che ha permesso agli investitori di prestare le proprie criptovalute come <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> e ETH a Genesis e ottieni rendimenti per quello.</p>
<p>Leggi anche: <a href="https://www.gate.io/blog_detail/1374/why-people-think-sec-is-indecisive-on-which-crypto-assets-are-securities" target="_blank">Perché le persone pensano che la SEC sia indecisa su quali asset crittografici siano titoli</a></p>
<h2 id="h2-Accuse20contro20Gemini878433"><a name="Accuse contro Gemini" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Accuse contro Gemini</h2><p>Gemini, di proprietà dei gemelli Winklevoss, ha posizionato il programma come un investimento a basso rischio, anche se le sue analisi interne indicavano che fosse ad alto rischio. Ciò che ha aumentato il rischio del programma di investimento è stato il fatto che fosse poco sicuro.</p>
<p>In particolare, le valutazioni del rischio e le misure di controllo di Gemini erano molto scadenti. Ad esempio, Gemini non ha informato gli investitori di Gemini Earn del prestito concesso a Alameda Research, che in un certo momento rappresentava circa il 60% dell’intero fondo di investimento. Secondo l’avvocato James, Gemini ha fornito informazioni erronee agli investitori.</p>
<p>L’accusa, quindi, afferma che Gemini ha approfittato del settore cripto non regolamentato negli Stati Uniti per sfruttare gli investitori e quindi truffarli. Inoltre, la falsa promessa fatta da Gemini agli investitori si è configurata come un crimine cripto. Questo perché Gemini ha assicurato agli investitori che Gemini Earn era un programma di investimento a basso rischio, il che significa che era improbabile che perdessero il loro capitale.</p>
<p>Parte della causa accusa anche Genesis, Barry Silbert, CEO di DCG, Soichiro Moro, ex CEO di Genesis e Digital Currency Group di aver truffato il pubblico e gli investitori cercando di nascondere perdite di 1,1 miliardi di dollari che ha subito. Pertanto, il sistema ha operato come una truffa crittografica.</p>
<p>Leggi anche: <a href="https://www.gate.io/blog_detail/3173/crypto-scam-target-eldery-americans" target="_blank">Le truffe legate alle criptovalute si diffondono sempre di più nel cuore dell’America</a></p>
<h2 id="h2-Lavvocato20di20New20York20accusa20Genesis20e20DCG20di20frode20criptata883889"><a name="L’avvocato di New York accusa Genesis e DCG di frode criptata" class="reference-link"></a><span class="header-link octicon octicon-link"></span>L’avvocato di New York accusa Genesis e DCG di frode criptata</h2><p>L’avvocato di New York ha anche affermato che DCG e Genesis non hanno rispettato la legge criptata del paese poiché non hanno informato gli investitori defraudati del rischio associato all’investimento nel programma Gemini Earn. Pertanto, non hanno protetto gli investitori e il pubblico dalle perdite finanziarie ingiustificate.</p>
<p>Allo stesso modo, la causa sostiene che le due società di criptovalute non siano riuscite a ridurre i rischi per gli investitori attraverso una attenta revisione della situazione finanziaria dei mutuatari. Ad esempio, Genesis non ha ottenuto dichiarazioni finanziarie certificate da Three Arrows Capital entro due anni. Genesis, inoltre, ha nascosto la sua vera posizione finanziaria a Gemini, aggravando le perdite subite dagli investitori.</p>
<p>L’avvocato è stato amareggiato su come tali aziende di criptovalute abbiano truffato gli investitori. Ha detto: ‘Queste aziende di criptovalute hanno mentito agli investitori e hanno cercato di nascondere più di un miliardo di dollari di perdite, e sono stati gli investitori della classe media a soffrirne’.</p>
<p>Ha aggiunto: ‘I laboriosi newyorkesi e gli investitori di tutto il paese hanno perso più di un miliardo di dollari perché sono state loro raccontate bugie spudorate, che i loro soldi sarebbero stati al sicuro e avrebbero cresciuto se li avessero investiti in Gemini Earn. Invece, Gemini ha nascosto i rischi degli investimenti con Genesis e Genesis ha mentito al pubblico sulle sue perdite.’</p>
<p>A seguito di una così grave negligenza finanziaria, l’Avvocato Generale James sta lottando per garantire che Gemini, Genesis e DCG siano vietati dal operare nell’industria degli investimenti finanziari a New York. Ha inoltre chiesto al tribunale di concedere il risarcimento agli investitori e di chiedere il ripristino dei loro profitti illeciti.</p>
<h2 id="h2-Quali20sono20i20prossimi20passi20per20Gemini20se20viene20vietato20negli20Stati20Uniti405653"><a name="Quali sono i prossimi passi per Gemini se viene vietato negli Stati Uniti?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Quali sono i prossimi passi per Gemini se viene vietato negli Stati Uniti?</h2><p>Se Gemini è “crypto banned” negli Stati Uniti, è probabile che si trasferisca in paesi i cui mercati delle criptovalute sono in espansione. Secondo recenti rapporti, la società di criptovalute mira a stabilire la propria attività nel Regno Unito, a Singapore, a Hong Kong e in India, tra gli altri. Come già sappiamo, Singapore e Hong Kong sono disposte ad avere più attività di investimento in criptovalute.</p>
<p>Leggi anche: <a href="https://www.gate.io/blog_detail/378/how-are-cryptocurrencies-currently-regulated-in-countries-around-the-world" target="_blank">Come sono attualmente regolamentate le criptovalute in diversi paesi</a></p>
<h2 id="h2-Come20lesito20del20processo20contro20Gemini20e20Genesis20influisce20sulle20future20regolamentazioni20delle20criptovalute252243"><a name="Come l’esito del processo contro Gemini e Genesis influisce sulle future regolamentazioni delle criptovalute?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Come l’esito del processo contro Gemini e Genesis influisce sulle future regolamentazioni delle criptovalute?</h2><p>L’esito della causa Gemini-Genesis potrebbe influenzare l’intero settore criptato degli Stati Uniti. In termini generali, le varie autorità regolamentari degli Stati Uniti come la SEC potrebbero adottare misure extra per proteggere gli investitori.</p>
<p>Leggi anche: <a href="https://www.gate.io/blog_detail/384/cryptocurrency-laws-in-united-states-and-other-countries" target="_blank">Leggi sulle criptovalute negli Stati Uniti e in altri paesi</a></p>
<p>Ad esempio, il caso di Gemini e Genesis potrebbe motivare la SEC a essere critica riguardo all’approvazione di asset di investimento come gli exchange traded fund (ETF) criptovalutari, poiché sarebbe necessario verificare che tali prodotti siano sicuri per gli investitori.</p>
<p>Inoltre, le autorità di regolamentazione potrebbero prevedere severe sanzioni come parte della legge cripto nel paese. Potrebbe anche garantire lunghe condanne detentive per tali trasgressori con l’obiettivo di prevenire futuri scandali e crimini cripto.</p>
<p>Le parti interessate come i gruppi di pressione possono citare casi simili quando propongono nuove leggi criptate volte a proteggere gli investitori e il pubblico. L’avvocato James, ad esempio, ha promesso di utilizzare tali incidenti per spingere per normative cripto più rigide in futuro.</p>
<p>Recentemente, ha detto: ‘Il mio ufficio continuerà i nostri sforzi per fermare le aziende criptovalutarie ingannevoli e per spingere per regolamenti più forti per proteggere tutti gli investitori.’</p>
<h2 id="h2-Conclusione854588"><a name="Conclusione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusione</h2><p>L’avvocato James di New York ha presentato cause legali contro tre società di criptovaluta per aver truffato gli investitori di criptovaluta. Una delle cause afferma che sia Gemini che Genesis hanno fornito informazioni ingannevoli al pubblico e agli investitori. Di conseguenza, sta cercando un adeguato risarcimento e confisca dei loro profitti illeciti.</p>
<div class="blog-details-info"><br><div>Autore:<strong> Mashell C.</strong>, Ricercatore 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 fatto riferimento a Gate.io. In tutti i casi, saranno intraprese azioni legali a causa di violazioni del copyright.<br></div><p></p><br></div></div></div>