U0VDIGJlc2NodWxkaWd0IEdlb3N5biBNaW5pbmcgdmFuICQ1LDYgbWlsam9lbiBmcmF1ZGU6IGVlbiBkaWVwZ2FhbmRlIGFuYWx5c2U=

2024-05-08, 02:53

<p><img src="https://gimg2.gateimg.com/image/article/1690791857hotspot.jpeg" alt=""></p>
<h2 id="h2-TL20DR374334"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p>Op 24 april heeft de Amerikaanse SEC een rechtszaak aangespannen tegen Geosyn en de oprichters ervan wegens het verduisteren van investeringsfondsen en het exploiteren van een illegaal crypto mining bedrijf.</p>
<p>Geosyn oprichters hebben meer dan $1.2 miljoen aan investeringsfondsen verduisterd.</p>
<p>Een gecoördineerde wereldwijde aanpak is essentieel om snelle reacties te ondersteunen wanneer frauduleuze activiteiten zoals hacking zich voordoen.</p>
<h2 id="h2-Introductie76559"><a name="Introductie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introductie</h2><p>De handhavingsactie van de Verenigde Staten tegen GeosYN, een in Texas gevestigd crypto-asset miningbedrijf, duidt op haar vastberadenheid om de sector onder controle te brengen. Op 24 april, <a href="https://www.gate.io/learn/articles/the-sec-is-everywhere-what-challenges-does-the-ethereum-spot-etf-face/2503 &quot;US Securities and Exchange Commission (SEC" rel="nofollow noopener noreferrer" target="_blank">US Securities and Exchange Commission (SEC)</a> Heeft een rechtszaak aangespannen tegen GeosYN wegens het oplichten van 64 investeerders voor meer dan $5,6 miljoen in een slechte crypto mining deal. Dit artikel behandelt de beschuldigingen van de SEC tegen GeosYN.</p>
<h2 id="h2-Aanklachten20van20de20SEC20tegen20Geosyn20Mining214273"><a name="Aanklachten van de SEC tegen Geosyn Mining" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Aanklachten van de SEC tegen Geosyn Mining</h2><p>Zoals hierboven aangegeven, heeft de Amerikaanse SEC een rechtszaak aangespannen tegen GeosYN en zijn oprichters, Caleb Joseph Ward en Jeremy George McNutt, wegens het plegen van verschillende overtredingen, waaronder het exploiteren van een niet-gelicentieerd crypto mining bedrijf en het oplichten van investeerders.</p>
<p>Gerelateerd nieuws: <a href="https://www.gate.io/learn/articles/uniswaps-defense-against-sec-regulatory-actions/2688" target="_blank">Uniswap’s verdediging tegen SEC-regulerende acties</a></p>
<p>Ward en McNutt zijn in 2021 begonnen met GeosYN met als doel cryptominingdiensten aan te bieden aan investeerders die het technische vakmanschap van het bedrijf, de aanschaf van mijnwerkers en het cryptominingproces willen uitbesteden. Zoals verwacht hebben veel individuen geïnvesteerd in het bedrijf.</p>
<p>Nu is de belangrijkste beschuldiging van de SEC dat GeosYN 64 investeerders voor meer dan $5,6 miljoen heeft opgelicht via een crypto mining investeringsdeal. Om hun doel te bereiken, hebben Ward en McNutt bepaalde informatie verkeerd voorgesteld om veel investering aan te trekken.</p>
<p>GeosYN beweerde in eerste instantie dat zijn miningactiviteiten winstgevend waren omdat het contracten had met elektriciteitsleveranciers die de stroomvoorziening tegen lagere tarieven zouden leveren dan normaal. In werkelijkheid lagen de tarieven waartegen ze elektriciteit verkregen echter 40-50% hoger dan wat ze beweerden.</p>
<p>De SEC beweert ook dat GeosYN tegen zijn investeerders heeft gelogen over zijn operationele activiteiten. Zo heeft het bijvoorbeeld serviceovereenkomsten gesloten om namens de investeerders 1.400 mining rigs aan te schaffen, maar heeft het gedurende de hele periode minder dan 400 gekocht.</p>
<p>Bovendien bepaalden de overeenkomsten tussen het bedrijf en de investeerders dat zij hun favoriete cryptocurrencies konden kiezen om te mijnen. Desalniettemin wees GeosYN later de verzoeken van de investeerders af om andere cryptocurrencies te mijnen dan <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a>.</p>
<p>De rechtszaak van de SEC beweert dat het bedrijf enkele documenten heeft vervalst om aan te tonen dat bitcoin-mining winstgevend was. Zo hebben ze bijvoorbeeld de productiesnelheden van bitcoin-mining en de gegenereerde winst gefabriceerd. Om hun wandaden te verdoezelen, heeft het bedrijf extra <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">bitcoin</a> gekocht om te verdelen onder de investeerders.</p>
<p>Lees over andere rechtszaken van de SEC:<br><a href="https://www.gate.io/blog_detail/3436/sec-moves-to-summary-judgement-in-lawsuit-against-terraform-and-do-kwon" target="_blank">SEC’s rechtszaak tegen Terraform en Do Kwon</a> <a href="https://www.gate.io/blog_detail/4071/sec-vs-uniswap-battle" target="_blank">SEC vs Uniswap Juridische Strijd</a> <a href="https://www.gate.io/blog_detail/3319/sec-vs-ripple-case-extended-to-end-2024" target="_blank">SEC vs Ripple-zaak</a> <a href="https://www.gate.io/blog_detail/3221/lbry-vs-sec-etf-appeal-process" target="_blank">LBRY tegen de SEC</a></p>
<p>Als voorbeeld verdeelde het bedrijf $354.500 aan bitcoin aan investeerders, ondanks dat ze slechts BTC ter waarde van $320.000 hadden gedolven. Hun motief was om de investeerders te misleiden door ze te laten geloven dat de cryptocurrency-mijnbouw winstgevend was.</p>
<p>Hierover, <a href="https://www.sec.gov/files/litigation/complaints/2024/comp25983.pdf" rel="nofollow noopener noreferrer" target="_blank">de rechtszaak van de SEC verklaarde</a>: “Geosyn verspreidde ook valse documenten naar investeerders om de schijn van winstgevendheid te creëren. Ward bereidde en stuurde investeerders maandelijkse uitsplitsingsverklaringen waarin gefabriceerde mijnproductiepercentages en winsten werden getoond voor Geosyn en voor de vermeende aandelen van de productie van de klanten.”</p>
<h2 id="h2-Verduistering20van20investeringsfondsen25729"><a name="Verduistering van investeringsfondsen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Verduistering van investeringsfondsen</h2><p>De SEC beweert ook dat de oprichters van GeosYN meer dan $1,2 miljoen aan investeringsfondsen voor persoonlijk gebruik hebben verduisterd, waaronder het kopen van maaltijden en wapens, evenals het betalen van hun vakanties en juridische kosten. <a href="https://www.sec.gov/files/litigation/complaints/2024/comp25983.pdf" rel="nofollow noopener noreferrer" target="_blank">De SEC-rechtszaak verklaarde</a>“Ward heeft ongeveer $402.455,35 verduisterd van Geosyn in de vorm van contante opnames, bankoverschrijvingen en creditcardbetalingen van het bedrijf.”</p>
<p><a href="https://www.sec.gov/files/litigation/complaints/2024/comp25983.pdf" rel="nofollow noopener noreferrer" target="_blank">Het voegde ook toe</a>: “McNutt heeft ongeveer $862.095,13 verduisterd van Geosyn in de vorm van contante opnames, bankoverschrijvingen en bedrijfscreditcardkosten.” Volgens het document gebruikte McNutt de fondsen om goederen zoals bouwmateriaal te kopen.</p>
<p>Het is duidelijk dat de twee oprichters van Geosyn een deel van het verduisterde geld hebben gebruikt om een weelderige levensstijl te financieren. Zo kochten ze dure maaltijden, evenals andere items zoals vuurwapens en polshorloges. Bovendien betaalden ze voor entertainmentdiensten en vakantiereiskosten.</p>
<p>Helaas ontstond er tegen het einde van 2022 een conflict tussen de twee oprichters van Geosyn toen Ward McNutt de schuld gaf van de ineenstorting van het bedrijf. Als gevolg van het misverstand gaf McNutt zijn eigendomsbelang in het bedrijf op na het ondertekenen van een vrijwaringsovereenkomst. In december 2022 meldde Ward McNutt echter bij de strafrechtelijke autoriteiten wegens verduistering van de bedrijfsfondsen. Hij gaf echter geen details over de verduistering van de fondsen en de crypto mining rig zwendel.</p>
<p>Door afnemende investeerdersfondsen moest het bedrijf zijn activiteiten in 2023 stopzetten. Ward liquideerde de Geosyn crypto-activawallet en bleef achter met $57.000.</p>
<p>Het is belangrijk om op te merken dat de <a href="https://www.sec.gov/litigation/litreleases/lr-25983" rel="nofollow noopener noreferrer" target="_blank">SEC beschuldigt ook de beklaagden</a> van het schenden van de ‘antifraude- en effectenregistratiebepalingen van de federale effectenwetten’, waarbij het ‘terugvordering met vooroordeelrentes en civiele boetes tegen Ward en McNutt’ zoekt.</p>
<h2 id="h2-De20gevolgen20van20de20acties20van20Geosyn20Mining667538"><a name="De gevolgen van de acties van Geosyn Mining" class="reference-link"></a><span class="header-link octicon octicon-link"></span>De gevolgen van de acties van Geosyn Mining</h2><p>De rechtszaak van de SEC tegen Geosyn mining brengt veel onzekerheid en wantrouwen in de cryptosector met zich mee. Ten eerste vermindert de beschuldiging tegen het bedrijf het vertrouwen van investeerders binnen de cryptosector. Dit kan leiden tot een afname van de activiteit in crypto-investeringen.</p>
<p>Veel investeerders zullen weigeren te investeren in de digitale sector van blockchain totdat de meeste landen, vooral de Verenigde Staten, duidelijke crypto-regelgeving aannemen. Dit betekent ook dat het vertrouwen van investeerders zal toenemen als crypto-bedrijven voldoen aan bestaande financiële wetgeving.</p>
<p>De zaak SEC vs. Geosyn kan brede onderzoeken naar de activiteiten van veel crypto-miningbedrijven in gang zetten, wat de goede werking van sommige blockchains die afhankelijk zijn van het proof-of-work-consensusmechanisme kan verstoren. Zoals verwacht, kunnen er in de toekomst nog veel meer SEC-rechtszaken komen.</p>
<p>Op een positievere noot kan de huidige SEC-aanpak van onethische cryptoprojecten, zoals Geosyn, sterk aangeven dat bedrijven in de sector moeten voldoen aan cryptocurrencyregelgeving, zoals de antiwitwas- (AML) en Ken Uw Klant-bepalingen.</p>
<h2 id="h2-Hoe20investeerders20te20beschermen20tegen20frauduleuze20schemas702863"><a name="Hoe investeerders te beschermen tegen frauduleuze schema’s" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Hoe investeerders te beschermen tegen frauduleuze schema’s</h2><p>Crypto projecten moeten verschillende maatregelen nemen om de fondsen van investeerders te beschermen. Echter, overheden moeten ook hun rol spelen door regelgeving in te voeren die innovatie in de sector bevordert en investeerders beschermt. Dit houdt ook in dat crypto bedrijven zich aan de wetgeving van de overheid moeten houden, inclusief het implementeren van Anti-Witwas (AML) en Ken-Uw-Klant (KYC) wetten.</p>
<p>Elk crypto bedrijf zou strenge beveiligingsmaatregelen moeten implementeren, waaronder tweestapsverificatie en robuuste encryptie. Ze zouden ook gebruik moeten maken van multi-signature wallets en cold wallets om het aantal hackincidenten te verminderen.</p>
<p>Ten derde moeten cryptobedrijven hun gebruikers voorlichten over hoe ze hun digitale bezittingen kunnen beschermen en ook over hoe ze <a href="https://www.gate.io/learn/articles/10000-word-in-depth-investigation-how-did-cryptocurrency-become-a-tool-for-cybercriminals/1341" target="_blank">identificeer criminele activiteiten met betrekking tot crypto</a> zoals phishing. Echter zou de overheid en enkele andere financiële instellingen moeten helpen bij het voorlichten van mensen over het beveiligen van hun digitale activa en het voorkomen van oplichting vergelijkbaar met de Geosyn bitcoin miner fraude.</p>
<p>Lees ook: <a href="https://www.gate.io/post/CryptoNews_/status/5562154" target="_blank">Web3 Verloor in april 2024 meer dan $53 miljoen aan hackers</a></p>
<p>Ten slotte zouden verschillende belanghebbenden in de crypto-industrie en andere relevante spelers moeten samenwerken om <a href="https://www.gate.io/learn/articles/top-10-crypto-scams-and-how-to-avoid-them/2556" target="_blank">voorkomen van glen van crypto fraude</a> Bijvoorbeeld zouden beurzen, crypto bedrijven, regelgevende instanties en wetshandhavingsinstanties moeten samenwerken om manieren te vinden om crypto-criminele activiteiten aan te pakken. Ze zouden communicatiekanalen en wereldwijde taskforces moeten hebben die snelle reacties coördineren op frauduleuze activiteiten zoals hacking. Daarmee zullen ze beter in staat zijn om veel gestolen cryptocurrencies terug te krijgen.</p>
<h2 id="h2-Conclusie706967"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>Op 24 April heeft de Amerikaanse SEC een rechtszaak aangespannen tegen Geosyn omdat ze een onvergunde onderneming exploiteerden en investeerdersfondsen verduisterden. Ward en McNutt hebben meer dan $1,2 miljoen aan investeerdersfondsen verduisterd. Ze hebben ook vervalste verklaringen en documenten gebruikt om individuen te misleiden om te investeren in hun crypto mining bedrijf. Ondertussen kan een gezamenlijke wereldwijde inspanning de omvang van crypto-criminele activiteiten verminderen.</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 beleggingsaanbevelingen.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het opnieuw plaatsen van het artikel is toegestaan ​​op voorwaarde dat 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>