QWR2b2NhYXQgdmFuIE5ZIGtsYWFndCBHZW1pbmkgR2VuZXNpcyBhYW4gd2VnZW5zIHZlcm1lZW5kZSB2ZXJrZWVyZGUgdm9vcnN0ZWxsaW5nIHZhbiBpbnZlc3RlZXJkZXJzcmlzaWNvJ3M=

2023-10-31, 06:24

<p><img src="https://gimg2.gateimg.com/image/article/1690791857hotspot.jpeg" alt=""><br>Een advocaat uit New York heeft Genesis en Gemini Trust aangeklaagd wegens het oplichten van investeerders voor meer dan $1,1 miljard.</p>
<p>De advocaat zoekt vergoeding voor de opgelichte investeerders en het terugvorderen van hun onrechtmatig verkregen winsten.</p>
<p>De Verenigde Staten kunnen Gemini Trust, Genesis Global en Digital Currency Group verbieden om actief te zijn in de financiële investeringsindustrie.</p>
<p>Trefwoorden: Rechtszaak, crypto fraude, investeerdersrisico’s, crypto verboden, crypto zwendel, crypto wet, crypto criminaliteit, opgelichte investeerders, crypto bedrijven, rechtszaak tegen crypto bedrijven, crypto business</p>
<h2 id="h2-Introductie210488"><a name="Introductie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introductie</h2><p>De <a href="https://www.gate.io/id/blog_detail/3284/ftx-bankruptcy-claims-rise-in-otc-markets-estate-recovers-7.3-billion" target="_blank">effecten van FTX ineenstorting</a> is merkbaar in sommige sectoren van de cryptoeconomie, aangezien sommige bedrijven nog steeds juridische geschillen hebben in verband daarmee. Afgezien van het lopende proces tegen Sam Bankman-Fried, de oprichter van FTX, is er een rechtszaak tegen cryptobedrijven zoals Gemini en Genesis. In deze post bespreken we de rechtszaak tegen Gemini en Genesis.</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 heeft een breed scala aan de crypto-ecosysteem beïnvloed</a></p>
<h2 id="h2-New20Yorkse20advocaat20klaagt20Gemini20en20Genesis20aan546066"><a name="New Yorkse advocaat klaagt Gemini en Genesis aan" class="reference-link"></a><span class="header-link octicon octicon-link"></span>New Yorkse advocaat klaagt Gemini en Genesis aan</h2><p>Generaal Letitia James, een advocaat uit New York, heeft een rechtszaak aangespannen tegen cryptobedrijven, Gemini Trust, Genesis Global en Digital Currency Group (DCG), omdat ze naar verluidt meer dan 230.000 investeerders hebben opgelicht, waaronder meer dan 29.000 New Yorkers, voor meer dan $1 miljard.</p>
<p>James zoekt vergoeding voor de opgelichte investeerders, teruggave van onrechtmatig verkregen winsten en een verbod voor deze bedrijven om actief te zijn in de financiële investeringssector. Kort gezegd, Gemini en Genesis, een door DCG beheerd bedrijf, boden een cryptouitleenprogramma aan zonder effectieve risicobeheersingsmaatregelen te treffen.</p>
<p>Voordat we dieper ingaan op de beschuldigingen, laten we eerst de achtergrond van deze financiële investeringsmaatschappijen begrijpen.</p>
<h2 id="h2-Overzicht20van20Gemini20Trust20Genesis20Global20en20Digital20Currency20Group42848"><a name="Overzicht van Gemini Trust, Genesis Global en Digital Currency Group" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Overzicht van Gemini Trust, Genesis Global en Digital Currency Group</h2><p>De Digital Currency Group, opgericht door Barry Silbert, is een durfkapitaalfirma met verschillende dochterondernemingen, waaronder Genesis Global Trading, Inc., een bedrijf dat in 2013 is opgericht. Deze groep bezit ook andere bedrijven zoals Coindesk.</p>
<p>Aan de andere kant bestaat Genesis uit verschillende entiteiten die verlening, handel en bewaring van digitale activa bieden aan institutionele klanten, vermogende zakenmensen en andere bekende personen.</p>
<p>Enkele van de bedrijven die Genesis bezit, zijn GGC International Limited (GGCI), Genesis Custody Limited, Genesis Global Trading, Inc. (GGT), Genesis Asia Pacific Pte. Ltd. (GAP) en Genesis Global Capital, LLC (GGC).</p>
<p>Aan de andere kant is Gemini Trust Company, LLC, algemeen bekend als Gemini, opgericht in 2014, een in de Verenigde Staten gevestigde cryptocurrency-uitwisseling en bewaarbank. Als beurs stelt het investeerders in staat om verschillende digitale activa te kopen en verkopen, waaronder cryptocurrencies.</p>
<p>Lees ook: <a href="https://www.gate.io/how-to-buy/gemini-dollar-gusd" target="_blank">Hoe koop je Gemini Dollar (GUSD) - HODL of Handel Crypto</a></p>
<h2 id="h2-De20rechtszaken20tegen20Gemini20en20Genesis367706"><a name="De rechtszaken tegen Gemini en Genesis" class="reference-link"></a><span class="header-link octicon octicon-link"></span>De rechtszaken tegen Gemini en Genesis</h2><p>De rechtszaak van advocaat James draait om een investeringsprogramma dat werd uitgevoerd door de crypto-bedrijven Gemini en Genesis, genaamd “Gemini Earn”, waarmee investeerders hun cryptocurrencies konden uitlenen zoals <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> en ETH naar Genesis en krijg rendementen daarvoor.</p>
<p>Lees ook: <a href="https://www.gate.io/blog_detail/1374/why-people-think-sec-is-indecisive-on-which-crypto-assets-are-securities" target="_blank">Waarom mensen denken dat de SEC onbeslist is over welke cryptografische activa effecten zijn</a></p>
<h2 id="h2-Beschuldigingen20tegen20Gemini630383"><a name="Beschuldigingen tegen Gemini" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Beschuldigingen tegen Gemini</h2><p>Gemini, eigendom van de Winklevoss-tweeling, positioneerde het programma als een laag risicoinvestering, hoewel de interne analyses aangaven dat het een hoog risico was. Wat het risico van het investeringsprogramma verhoogde, was het feit dat het onderbeveiligd was.</p>
<p>Opmerkelijk genoeg waren de risicobeoordeling en -beheersmaatregelen van Gemini ook erg slecht. Zo informeerde Gemini bijvoorbeeld de investeerders van Gemini Earn niet over de lening die het verstrekte aan Alameda Research, die op een gegeven moment ongeveer 60% van het gehele investeringsfonds bedroeg. Volgens advocaat James heeft Gemini de informatie verkeerd voorgesteld aan de investeerders.</p>
<p>De beschuldiging luidde dan ook dat Gemini misbruik maakte van de ongereguleerde cryptosector in de Verenigde Staten om investeerders te exploiteren en hen op die manier op te lichten. Ook de valse belofte die Gemini aan de investeerders deed, kwam neer op een cryptocrime. Dit komt doordat Gemini de investeerders verzekerde dat Gemini Earn een investeringsprogramma met een laag risico was, wat betekende dat ze hun kapitaal waarschijnlijk niet zouden verliezen.</p>
<p>Een deel van de rechtszaak beschuldigt ook Genesis, Barry Silbert, CEO van DCG, Soichiro Moro, voormalig CEO van Genesis en de Digital Currency Group van het oplichten van het publiek en de investeerders door te proberen $1,1 miljard verliezen die het leed te verbergen. Daarom werkte het schema als een crypto-zwendel.</p>
<p>Lees ook: <a href="https://www.gate.io/blog_detail/3173/crypto-scam-target-eldery-americans" target="_blank">Cryptocurrency Scams breiden zich verder uit naar het hart van Amerika</a></p>
<h2 id="h2-New20Yorkse20advocaat20beschuldigt20Genesis20en20DCG20van20crypto20fraude251076"><a name="New Yorkse advocaat beschuldigt Genesis en DCG van crypto fraude" class="reference-link"></a><span class="header-link octicon octicon-link"></span>New Yorkse advocaat beschuldigt Genesis en DCG van crypto fraude</h2><p>De advocaat van New York zei ook dat DCG en Genesis niet voldeden aan de crypto wetgeving van het land, omdat zij de opgelichte investeerders niet op de hoogte stelden van het risico dat gepaard gaat met investeren in het Gemini Earn programma. Als gevolg hiervan hebben zij nagelaten de investeerders en het publiek te beschermen tegen onnodige financiële verliezen.</p>
<p>Evenzo beweert de rechtszaak dat de twee cryptobedrijven er niet in slaagden om het risico voor investeerders te verminderen door zorgvuldige controle van de financiële situatie van de leners. Zo heeft Genesis bijvoorbeeld geen gecontroleerde financiële overzichten van Three Arrows Capital ontvangen binnen twee jaar. Genesis heeft ook haar ware financiële positie voor Gemini verborgen gehouden, wat de verliezen die de investeerders leden heeft verergerd.</p>
<p>De advocaat is verbitterd over hoe dergelijke cryptobedrijven beleggers hebben opgelicht. Hij zei: “Deze cryptocurrencybedrijven hebben tegen beleggers gelogen en geprobeerd meer dan een miljard dollar aan verliezen te verbergen, en het waren de middenklasse beleggers die hierdoor hebben geleden.”</p>
<p>Hij voegde eraan toe: ‘Hardwerkende New Yorkers en investeerders in het hele land verloren meer dan een miljard dollar omdat ze botweg leugens werden gevoed dat hun geld veilig zou zijn en zou groeien als ze het in Gemini Earn investeerden. In plaats daarvan verborg Gemini de risico’s van investeren met Genesis en loog Genesis tegen het publiek over zijn verliezen.’</p>
<p>Als gevolg van dergelijke grove financiële nalatigheid strijdt procureur-generaal James om ervoor te zorgen dat Gemini, Genesis en DCG verboden worden om actief te zijn in de financiële investeringsindustrie in New York. Hij vroeg ook aan de rechtbank om vergoeding voor investeerders toe te kennen en om teruggave te eisen van hun onrechtmatig verkregen winsten.</p>
<h2 id="h2-Wat20is20de20volgende20stap20voor20Gemini20als20het20verboden20is20in20de20Verenigde20Staten3509"><a name="Wat is de volgende stap voor Gemini als het verboden is in de Verenigde Staten?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wat is de volgende stap voor Gemini als het verboden is in de Verenigde Staten?</h2><p>Als Gemini in de Verenigde Staten “crypto verboden” is, is het waarschijnlijk dat het zich zal vestigen in landen waarvan de cryptocurrency-markten groeien. Volgens recente rapporten heeft het cryptobedrijf als doel zijn bedrijf te vestigen in het Verenigd Koninkrijk, Singapore, Hong Kong en India, onder andere. Zoals we al weten, zijn Singapore en Hong Kong bereid om meer crypto-investeringsbedrijven te hebben.</p>
<p>Lees ook: <a href="https://www.gate.io/blog_detail/378/how-are-cryptocurrencies-currently-regulated-in-countries-around-the-world" target="_blank">Hoe worden cryptocurrencies momenteel gereguleerd in verschillende landen</a></p>
<h2 id="h2-Hoe20benvloedt20de20uitkomst20van20de20rechtszaak20tegen20Gemini20en20Genesis20toekomstige20cryptoregulering822737"><a name="Hoe beïnvloedt de uitkomst van de rechtszaak tegen Gemini en Genesis toekomstige cryptoregulering?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Hoe beïnvloedt de uitkomst van de rechtszaak tegen Gemini en Genesis toekomstige cryptoregulering?</h2><p>De uitkomst van de Gemini-Genesis-rechtszaak zal waarschijnlijk invloed hebben op de hele cryptosector in de Verenigde Staten. In brede zin kunnen de verschillende regelgevende instanties in de Verenigde Staten, zoals de SEC, extra maatregelen nemen om de investeerders te beschermen.</p>
<p>Lees ook: <a href="https://www.gate.io/blog_detail/384/cryptocurrency-laws-in-united-states-and-other-countries" target="_blank">Cryptocurrency wetten in de Verenigde Staten en andere landen</a></p>
<p>Als voorbeeld kan de zaak van Gemini en Genesis de SEC aanzetten om kritisch te zijn over de goedkeuring van beleggingsactiva zoals crypto exchange traded funds (ETF’s), omdat het moet verifiëren dat dergelijke producten veilig zijn voor de investeerders.</p>
<p>Bovendien kunnen de regelgevende autoriteiten strenge straffen opnemen als onderdeel van de crypto wetgeving in het land. Het kan ook zorgen voor langdurige gevangenisstraf voor dergelijke overtreders met als doel toekomstige crypto-zwendel en misdaden te voorkomen.</p>
<p>Geïnteresseerde partijen zoals lobbygroepen kunnen dergelijke glen aanhalen bij het voorstellen van nieuwe cryptowetten gericht op het beschermen van investeerders en het publiek. Advocaat James heeft bijvoorbeeld beloofd om dergelijke incidenten te gebruiken om in de toekomst aan te dringen op strengere cryptoregels.</p>
<p>Onlangs zei hij: “Mijn kantoor zal doorgaan met onze inspanningen om bedrieglijke cryptocurrency-bedrijven te stoppen en te pleiten voor strengere regelgeving om alle investeerders te beschermen.”</p>
<h2 id="h2-Conclusie20778"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>New Yorkse advocaat James heeft rechtszaken aangespannen tegen drie crypto-bedrijven wegens het oplichten van crypto-investeerders. Een van de rechtszaken beweert dat zowel Gemini als Genesis misleidende informatie aan het publiek en investeerders hebben verstrekt. Als gevolg hiervan streeft hij naar een passende vergoeding en teruggave van hun onrechtmatig verkregen winsten.</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 beleggingsadvies.<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 zullen juridische stappen worden ondernomen wegens schending van het auteursrecht.<br></div><p></p><br></div></div></div>