R2VuZXNpcyByZWdlbHQgdm9vciBtaWxqb2VuZW4gbWV0IEFtZXJpa2FhbnNlIHRvZXppY2h0aG91ZGVy

2024-02-19, 09:49

<p><img src="https://gimg2.gateimg.com/image/article/1700024128RDZZ 1.jpeg" alt=""></p>
<p>Genesis heeft een schikking getroffen met de SEC om een langdurige juridische zaak over het Gemini Earn-programma te voorkomen.</p>
<p>Het Amerikaanse ministerie van Justitie heeft bezwaar ingediend tegen het faillissementsplan van Genesis.</p>
<p>Gemini beweert dat het omstreden bedrag van $282 miljoen is gebruikt om een reservefonds op te richten voor het bedienen van haar Earn-gebruikersprogramma.</p>
<p>Trefwoorden: genesis Gemini debat, SEC schikking, Gemini crypto beurs, Genesis Faillissement, Gemini Earn klanten, Gemini Earn gebruikers, Gemini Earn programma, Failliet cryptocurrency geldschieter, Failliete crypto geldschieter, rechtszaak met US SEC, schendingen van de beveiligingswetgeving</p>
<h2 id="h2-Introductie578272"><a name="Introductie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introductie</h2><p>Tijdens 2022 en 2023 <a href="https://www.gate.io/learn/articles/the-wild-west-of-the-crypto-world/670" target="_blank">De Verenigde Staten heeft verschillende rechtszaken aangespannen tegen cryptobedrijven</a> Het beschuldigde van het overtreden van de effectenwet van het land. In plaats van juridisch te strijden met de SEC, kozen sommige bedrijven voor vriendelijke schikkingen ermee. Vandaag bespreken we een schikking tussen Genesis en de SEC. We zullen ook kijken naar de voortgang van Genesis in zijn Chapter 11 Bankruptcy Plan.</p>
<p>Lees over recente faillissementen van crypto-bedrijven: <a href="https://www.gate.io/blog_detail/3767/crypto-bankruptcies-kirkland-ellis-secures-120-million-in-celsius-core-scientific-blockfi-voyager-cases" target="_blank">Crypto Faillissementen: Kirkland &amp; Ellis beveiligt $120 miljoen in Celsius, Core Scientific, BlockFi, Voyager Zaken</a></p>
<h2 id="h2-Genesis20betaalt202120miljoen20aan20SEC20in20schikking20over20overtredingen20van20het20Gemini20Earnprogramma192138"><a name="Genesis betaalt $21 miljoen aan SEC in schikking over overtredingen van het Gemini Earn-programma" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Genesis betaalt $21 miljoen aan SEC in schikking over overtredingen van het Gemini Earn-programma</h2><p>Crypto-lener Genesis Global heeft een schikking getroffen met de Amerikaanse SEC waarbij het $21 miljoen zal betalen voor zijn Gemini Earn-leningenprogramma. Deze schikking is echter alleen van toepassing als Genesis in staat is om zijn klanten volledig terug te betalen.</p>
<p>Deze overeenkomst stelt Genesis in staat om kosten en risico’s verbonden aan een juridische strijd tegen de SEC, die het beschuldigt van de verkoop van niet-geregistreerde effecten, te voorkomen. Daarnaast stelt de schikking het crypto-bedrijf in staat om zich te richten op het betalen van zijn cryptocurrency-crediteuren in faillissement en de Gemini-klanten die verdienen.</p>
<p>Ondertussen heeft Genesis geen schuld bekend of ontkend met betrekking tot overtredingen van de Amerikaanse veiligheidswetgeving. De SEC heeft in januari 2023 een rechtszaak tegen Genesis aangespannen. Die rechtszaak met de Amerikaanse SEC beweert dat Genesis en zijn partner Gemini crypto exchange effecten hebben verkocht via Gemini Earn, hun gezamenlijke cryptouitleenprogramma.</p>
<p>Ter context, hebben de twee bedrijven gezamenlijk het Gemini Earn Programma opgezet, waardoor Gemini-klanten hun crypto-activa aan Genesis konden uitlenen in ruil voor rente. Als gevolg hiervan verzamelde Genesis cryptocurrencies ter waarde van miljarden dollars van crypto-investeerders, wat een van de belangrijkste klachten van de SEC werd.</p>
<p>Via een persbericht, <a href="https://www.sec.gov/news/press-release/2023-7" rel="nofollow noopener noreferrer" target="_blank">Gary Gensler, de voorzitter van de SEC zei</a>, “Wij beweren dat Genesis en Gemini niet-geregistreerde effecten aan het publiek hebben aangeboden, waarbij ze de openbaarmakingsvereisten hebben omzeild die bedoeld zijn om investeerders te beschermen.”</p>
<p>Hij voegde eraan toe: “Deze aanklachten bouwen voort op eerdere acties om duidelijk te maken aan de markt en het beleggende publiek dat crypto-uitleningsplatforms en andere tussenpersonen moeten voldoen aan onze beproefde effectenwetten. Dit beschermt investeerders het beste. Het bevordert vertrouwen in markten.”</p>
<p>Het is vermeldenswaard dat de twee crypto-bedrijven het Gemini Earn Programma in november 2023 hebben stopgezet, <a href="https://www.gate.io/blog_detail/158/the-1st-cryptocurrency-investments-grayscale-what-is-gbtc" target="_blank">het aanwakkeren van gerechtelijke procedures met Digital Currency Group</a>, De moedermaatschappij van Genesis - gerund door de Winklevoss-tweeling.</p>
<p>Ondertussen gaat Genesis door met haar plan om haar klanten terug te betalen in cryptoactiva of contanten, afhankelijk van de valuta die ze hebben gestort. Om dit te vergemakkelijken, streeft het bedrijf ernaar om op 14 februari goedkeuring van de rechtbank te verkrijgen voor haar faillissementsplan.</p>
<p>Hoewel Digital Currency Group Genesis $1,7 miljard verschuldigd is, is de kans groot dat de gebruikers van Gemini Earn 100% van hun activa krijgen. De grootste uitdaging waar Genesis op dit moment voor staat, is het gebrek aan voldoende liquiditeit om aan zijn kortlopende financiële verplichtingen aan de crediteuren te voldoen.</p>
<p>Er waren echter een paar opties om het benodigde geld binnen een redelijke termijn te verhogen. Zo stelde een crediteurencommissie in november 2022 een plan voor om enkele van de activa van de failliete crypto-leider te liquideren na de cryptocrash die veroorzaakt werd door het instorten van FTX. Dezelfde voorstel kan werken als Genesis niet genoeg geld kan ophalen om de crediteuren te betalen.</p>
<h2 id="h2-Het20faillissementsplan20van20Genesis20Chapter201120stuit20op20een20probleem321262"><a name="Het faillissementsplan van Genesis ‘Chapter 11 stuit op een probleem" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Het faillissementsplan van Genesis ‘Chapter 11 stuit op een probleem</h2><p>Genesis Global heeft in januari 2023 faillissement aangevraagd vanwege de financiële beperkingen die de crypto-winter van 2022 veroorzaakte. Onlangs heeft het juridische team van Genesis 14 februari voorgesteld als een hoorzitting om de SEC-schikking als onderdeel van de faillissementszaak te erkennen.</p>
<p>Desalniettemin ondervindt Gemini beperkingen van Digital Currency Group en het Amerikaanse ministerie van Justitie met betrekking tot het faillissementsplan van hoofdstuk 11. Allereerst heeft het Amerikaanse ministerie van Justitie bezwaar gemaakt tegen het faillissementsplan van hoofdstuk 11 van Genesis.</p>
<p>Ten tweede heeft Digital Currency Group ook bezwaar gemaakt tegen het faillissementsplan van Genesis. De belangrijkste reden hiervoor is dat Genesis zijn crediteuren al heeft overbetaald. Volgens <a href="https://blockworks.co/news/dcg-opposes-genesis-bankruptcy-plan" rel="nofollow noopener noreferrer" target="_blank">TheBlock, Digital Currency Group zei</a>“DCG zou een plan ondersteunen dat crediteuren honderd cent op de dollar betaalt, en de Estates hebben momenteel voldoende activa om dit te doen.”</p>
<p>Het voegde eraan toe dat het plan ‘onevenredig bevoordeelt een kleine controle groep van schuldeisers ten opzichte van anderen’ en ‘betaalt ongedekte schuldeisers honderden miljoenen dollars meer dan het volledige bedrag van hun claims op de datum van het verzoek’<br>‘Het ontnam DCG ook andere waardevolle economische en corporate governance rechten, wat verder in strijd is met de Faillissementswet en een gebrek aan goede trouw aantoont’, beweerde het verder.</p>
<h2 id="h2-Genesis20wordt20onderzocht20voor20het20terugtrekken20van2028220miljoen20dollar20voordat20ze20insolventie20verklaart385882"><a name="Genesis wordt onderzocht voor het terugtrekken van 282 miljoen dollar voordat ze insolventie verklaart" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Genesis wordt onderzocht voor het terugtrekken van 282 miljoen dollar voordat ze insolventie verklaart</h2><p>Intussen is er controverse rond de $282 miljoen die Genesis enkele maanden voor het faillissement in 2023 heeft opgenomen. In feite heeft het bedrijf het bedrag ongeveer 5 maanden voor het faillissement op 20 januari 2023 opgenomen. Gemini zou dit gedaan kunnen hebben om zijn reserves te vergroten.</p>
<p>In een X-bericht bevestigde Gemini Trust Company dat het $282 miljoen gebruikte, dat het geld van Gemini Earn-gebruikers is, om een reservefonds op te zetten.</p>
<p><img src="https://gimg2.gateimg.com/image/article/170833615911.png" alt=""><br>Bron: x.com</p>
<p>Om duidelijk te maken wat er gebeurde met de $282 miljoen, <a href="https://twitter.com/GeminiTrustCo/status/1707385495796228469" rel="nofollow noopener noreferrer" target="_blank">Gemini Trust Company zei</a>, ‘De voorwaarden van het Gemini Earn-programma gaven Gemini toestemming om een ‘liquiditeitsreserve’ op te bouwen ten behoeve van Earn-gebruikers door een deel van het geld dat ze in het Earn-programma stortten achter te houden.’</p>
<p>“Temidden van de brede marktonrust in de zomer van 2022, hebben we besloten om de liquiditeitsreserve te vergroten. Als gevolg hiervan hebben we op 9 augustus 2022 $282 miljoen aan fondsen van Earn-gebruikers teruggetrokken uit Genesis en deze fondsen in de liquiditeitsreserve aangehouden voor hun voordeel,” voegde het toe.</p>
<h2 id="h2-Conclusie625531"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>Genesis heeft een financiële schikking getroffen met de SEC om een langdurige juridische strijd te voorkomen die tot hoge kosten en regelgevingsrisico’s zou kunnen leiden. Intussen is het bedrijf bereid zijn crediteuren en klanten terug te betalen zodra de rechtbank zijn faillissementsplan goedkeurt. Ook heeft Gemini Trust Company verklaard dat het $282 miljoen heeft gebruikt om een ‘liquiditeitsreserve’ op te zetten ten behoeve van Earn-gebruikers.</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 enkele beleggingssuggestie.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het opnieuw plaatsen van het artikel zal worden toegestaan mits Gate.io wordt vermeld. In alle glen zullen juridische stappen worden ondernomen vanwege schending van het auteursrecht.<br></div><p></p><br></div></div></div>