TGEgU0VDIGFjY3VzYSBHZW9zeW4gTWluaW5nIGRpIGZyb2RlIGRhIDUsNiBtaWxpb25pIGRpIGRvbGxhcmk6IHVuJ2FuYWxpc2kgYXBwcm9mb25kaXRh

2024-05-08, 02:53

<p><img src="https://gimg2.gateimg.com/image/article/1690791857hotspot.jpeg" alt=""></p>
<h2 id="h2-TL20DR999993"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p>Il 24 aprile la SEC degli Stati Uniti ha intentato una causa contro Geosyn e i suoi fondatori per aver sottratto fondi degli investitori e per aver gestito illegalmente un’attività mineraria di criptovalute.</p>
<p>I fondatori di Geosyn hanno appropriato indebitamente più di $1,2 milioni di fondi degli investitori.</p>
<p>Un approccio globale coordinato è fondamentale per sostenere risposte rapide quando si verificano attività fraudolente come l’hacking.</p>
<h2 id="h2-Introduzione188709"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>L’azione di applicazione della legge degli Stati Uniti contro GeosYN, un’azienda mineraria di criptoasset con sede in Texas, indica la sua determinazione nel portare il settore sotto il suo controllo. Il 24 aprile, <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">Commissione per la Sicurezza e gli Scambi degli Stati Uniti (SEC)</a> La SEC ha intentato una causa contro GeosYN per aver truffato 64 investitori di oltre 5,6 milioni di dollari in una discutibile operazione di mining di criptovalute. Questo articolo riguarda le accuse della SEC contro GeosYN.</p>
<h2 id="h2-Reclami20della20SEC20contro20Geosyn20Mining365152"><a name="Reclami della SEC contro Geosyn Mining" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Reclami della SEC contro Geosyn Mining</h2><p>Come accennato in precedenza, la SEC degli Stati Uniti ha intentato una causa contro GeosYN e i suoi fondatori, Caleb Joseph Ward e Jeremy George McNutt, per aver commesso vari reati tra cui l’operazione di un’attività mineraria di criptovalute non autorizzata e il fraudolento inganno degli investitori.</p>
<p>Notizie correlate: <a href="https://www.gate.io/learn/articles/uniswaps-defense-against-sec-regulatory-actions/2688" target="_blank">La difesa di Uniswap contro le azioni regolatorie della SEC</a></p>
<p>Ward e McNutt hanno avviato GeosYN nel 2021 con l’obiettivo di offrire servizi di mining di criptovalute agli investitori che avrebbero esternalizzato l’esperienza tecnica dell’azienda, l’approvvigionamento di miner nonché il processo di mining di criptovalute. Come previsto, molte persone hanno investito nell’azienda.</p>
<p>Ora, l’accusa chiave della SEC è che GeosYN ha truffato 64 investitori di oltre $5.6 milioni attraverso un accordo di investimento in cripto mining. Per raggiungere il loro obiettivo, Ward e McNutt hanno fornito informazioni errate per attirare molti investimenti.</p>
<p>In primo luogo, GeosYN ha affermato che la sua attività di mining era redditizia poiché aveva contratti con fornitori di elettricità che avrebbero fornito i suoi requisiti energetici a tariffe più basse del solito. Tuttavia, in realtà le tariffe a cui hanno ottenuto l’elettricità erano del 40-50% superiori a quelle dichiarate.</p>
<p>La SEC sostiene anche che GeosYN abbia mentito ai suoi investitori sulle sue attività operative. Ad esempio, sebbene abbia stipulato accordi di servizio per l’acquisto di 1.400 mining rig per conto degli investitori, ne ha acquistati meno di 400 durante l’intero periodo.</p>
<p>Inoltre, gli accordi tra l’azienda e gli investitori stabilivano che essi potevano scegliere le criptovalute da minare. Tuttavia, successivamente GeosYN ha respinto le richieste degli investitori di minare altre criptovalute diverse da <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a>.</p>
<p>La causa della SEC afferma che l’azienda ha falsificato alcuni documenti per mostrare che il mining di <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">bitcoin</a> era redditizio. Ad esempio, hanno fabbricato i tassi di produzione del mining di bitcoin e il profitto generato. Per coprire le loro malefatte, l’azienda ha acquistato ulteriori bitcoin da distribuire agli investitori.</p>
<p>Leggi altre cause della 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">Causa della SEC contro Terraform e Do Kwon</a> <a href="https://www.gate.io/blog_detail/4071/sec-vs-uniswap-battle" target="_blank">Battaglia legale SEC vs Uniswap</a> <a href="https://www.gate.io/blog_detail/3319/sec-vs-ripple-case-extended-to-end-2024" target="_blank">Caso SEC vs Ripple</a> <a href="https://www.gate.io/blog_detail/3221/lbry-vs-sec-etf-appeal-process" target="_blank">LBRY contro la SEC</a></p>
<p>Ad esempio, l’azienda ha distribuito bitcoin del valore di $354.500 agli investitori nonostante avesse estratto solo BTC del valore di $320.000. Il loro movente era quello di ingannare gli investitori facendo loro credere che le operazioni di mining di criptovalute fossero redditizie.</p>
<p>A riguardo di questo, <a href="https://www.sec.gov/files/litigation/complaints/2024/comp25983.pdf" rel="nofollow noopener noreferrer" target="_blank">la causa della SEC ha dichiarato</a>: “Geosyn ha anche distribuito documenti falsi agli investitori per creare l’apparenza di redditività. Ward ha preparato e inviato agli investitori rendiconti mensili di distribuzione mostrando tassi di produzione mineraria e profitti fabbricati per Geosyn e per le presunte quote di produzione dei clienti.”</p>
<h2 id="h2-Appropriazione20indebita20dei20fondi20degli20investitori409671"><a name="Appropriazione indebita dei fondi degli investitori" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Appropriazione indebita dei fondi degli investitori</h2><p>La SEC sostiene anche che i fondatori di GeosYN abbiano appropriato indebitamente oltre 1,2 milioni di dollari di fondi degli investitori per uso personale, che includono l’acquisto di pasti e armi, nonché il pagamento delle loro vacanze e delle spese legali. <a href="https://www.sec.gov/files/litigation/complaints/2024/comp25983.pdf" rel="nofollow noopener noreferrer" target="_blank">La causa intentata dalla SEC ha dichiarato</a>: “Ward si è appropriato indebitamente di circa $ 402.455,35 da Geosyn sotto forma di prelievi di contanti, bonifici bancari e addebiti su carte di credito aziendali”.</p>
<p><a href="https://www.sec.gov/files/litigation/complaints/2024/comp25983.pdf" rel="nofollow noopener noreferrer" target="_blank">Ha anche aggiunto</a>: “McNutt ha appropriato circa $862,095.13 da Geosyn sotto forma di prelievi in contanti, bonifici bancari e addebiti sulla carta di credito aziendale.” Secondo il documento McNutt ha utilizzato i fondi per acquistare beni come materiali da costruzione.</p>
<p>È chiaro che i due fondatori di Geosyn hanno utilizzato parte dei soldi appropriati per finanziare uno stile di vita sontuoso. Ad esempio, hanno acquistato pasti costosi, nonché altri articoli come armi da fuoco e orologi da polso. Inoltre, hanno pagato per servizi di intrattenimento e spese di viaggio per le vacanze.</p>
<p>Purtroppo, verso la fine del 2022 è scoppiata una disputa tra i due fondatori di Geosyn, poiché Ward ha incolpato McNutt per il crollo dell’azienda. A causa del malinteso, McNutt ha rinunciato al proprio interesse di proprietà nella società dopo aver firmato un accordo di risoluzione. Di conseguenza, nel dicembre 2022, Ward ha segnalato McNutt alle autorità penali per l’appropriazione indebita dei fondi dell’azienda. Tuttavia, non ha fornito i dettagli sull’appropriazione dei fondi e sullo scandalo del mining rig di criptovalute.</p>
<p>La diminuzione dei fondi degli investitori ha costretto l’azienda a interrompere le sue operazioni nel 2023. Ward ha liquidato il portafoglio di cripto-attività Geosyn e si è rimasto con $57,000.</p>
<p>È importante notare che <a href="https://www.sec.gov/litigation/litreleases/lr-25983" rel="nofollow noopener noreferrer" target="_blank">La SEC accusa anche gli imputati</a> di violazione delle disposizioni federali in materia di frodi e registrazione di titoli, dove si sta cercando il “risarcimento con interessi ante causam, e sanzioni civili contro Ward e McNutt.”</p>
<h2 id="h2-Le20conseguenze20delle20azioni20di20Geosyn20Mining750445"><a name="Le conseguenze delle azioni di Geosyn Mining" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Le conseguenze delle azioni di Geosyn Mining</h2><p>La causa della SEC contro Geosyn mining porta molta incertezza e diffidenza nel settore delle criptovalute. Innanzitutto, le accuse contro l’azienda riducono la fiducia degli investitori all’interno del settore delle criptovalute. Questo potrebbe portare a una diminuzione dell’attività di investimento nelle criptovalute.</p>
<p>Molti investitori potrebbero declinare di investire nel settore digitale della blockchain fino a quando la maggior parte dei paesi, in particolare gli Stati Uniti, adotterà regolamenti chiari sulle criptovalute. Ciò significa anche che la fiducia degli investitori aumenterà se le imprese di criptovalute rispetteranno la normativa finanziaria esistente.</p>
<p>Il caso SEC vs. Geosyn potrebbe scatenare ampie indagini sulle operazioni di molte società minerarie di criptovalute che potrebbero disturbare il corretto funzionamento di alcune blockchain che dipendono dal meccanismo di consenso del proof-of-work. Come previsto, potrebbero arrivare molti altri contenziosi SEC in futuro.</p>
<p>Ad una luce più favorevole, la recente repressione della SEC sui progetti crittografici non etici come Geosyn potrebbe fortemente indicare che le aziende del settore dovrebbero conformarsi alle normative sulle criptovalute, come quelle sull’antiriciclaggio (AML) e sulle disposizioni di conoscer il cliente.</p>
<h2 id="h2-Come20proteggere20gli20investitori20dai20schemi20fraudolenti749913"><a name="Come proteggere gli investitori dai schemi fraudolenti" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Come proteggere gli investitori dai schemi fraudolenti</h2><p>I progetti di criptovaluta dovrebbero adottare diverse misure per proteggere i fondi degli investitori. Tuttavia, anche i governi dovrebbero svolgere il proprio ruolo introducendo regolamentazioni che promuovano l’innovazione nel settore ma proteggano anche gli investitori. Questo implica anche che le aziende di criptovaluta dovrebbero seguire la legislazione governativa, compresa l’attuazione delle leggi contro il riciclaggio di denaro (AML) e le leggi conosce-il-tuo-cliente (KYC).</p>
<p>Ogni azienda di criptovalute dovrebbe implementare misure di sicurezza elevate che includono l’autenticazione a due fattori e una crittografia robusta. Dovrebbero inoltre utilizzare portafogli con firma multipla e portafogli offline per ridurre gli incidenti di hacking.</p>
<p>In terzo luogo, le aziende cripto dovrebbero educare i propri utenti su come proteggere i propri asset digitali e su come <a href="https://www.gate.io/learn/articles/10000-word-in-depth-investigation-how-did-cryptocurrency-become-a-tool-for-cybercriminals/1341" target="_blank">identificare attività criminali criptate</a> come il phishing. Tuttavia, il governo e alcune altre istituzioni finanziarie dovrebbero aiutare a educare le persone sulla sicurezza dei loro asset digitali e sulla prevenzione di truffe simili alla frode del minatore di bitcoin Geosyn.</p>
<p>Leggi anche: <a href="https://www.gate.io/post/CryptoNews_/status/5562154" target="_blank">Web3 ha perso oltre 53 milioni di dollari a causa di hacker nel mese di aprile 2024</a></p>
<p>Infine, i diversi portatori di interessi dell’industria crittografica e altri attori pertinenti dovrebbero cooperare per <a href="https://www.gate.io/learn/articles/top-10-crypto-scams-and-how-to-avoid-them/2556" target="_blank">prevenire casi di frode criptovalutaria</a> Ad esempio, gli scambi, le società crittografiche, i regolatori e le agenzie di applicazione della legge dovrebbero collaborare per trovare modi di affrontare le attività criminali legate alle criptovalute. Dovrebbero avere canali di comunicazione e task force globali che coordinano risposte rapide alle attività fraudolente come l’hacking. In questo modo saranno in una posizione migliore per recuperare molte criptovalute rubate.</p>
<h2 id="h2-Conclusione449567"><a name="Conclusione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusione</h2><p>Il 24 aprile la SEC degli Stati Uniti ha intentato una causa contro Geosyn per la gestione di un’attività non autorizzata e per l’appropriazione indebita di fondi degli investitori. Ward e McNutt hanno appropriato indebitamente più di $1,2 milioni di fondi degli investitori. Inoltre, hanno utilizzato dichiarazioni e documenti falsificati per indurre gli individui a investire nella loro attività di mining di criptovalute. Nel frattempo, un’azione concertata a livello globale potrebbe ridurre la portata delle attività criminali legate alle criptovalute.</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. La ripubblicazione dell'articolo sarà consentita a condizione che si faccia riferimento a Gate.io. In tutti i casi, saranno intraprese azioni legali a causa della violazione del copyright.<br></div><p></p></div></div></div>