TGEgQ0ZUQyB2aW5jZSB1bmEgc3RvcmljYSBtdWx0YSBkYSAzLDQgbWlsaWFyZGkgZGkgZG9sbGFyaSBpbiB1biBlbm9ybWUgY2FzbyBkaSBmcm9kZSBkZWwgQml0Y29pbg==

<p><img src="https://gimg2.gateimg.com/blog/1679447253155655279redian.jpeg" alt=""></p>
<h2 id="h2-TL20DR443014"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p>La CFTC ha vinto una storica multa di 3,4 miliardi di dollari per le accuse di frode di MTI e Steynberg.</p>
<p>La vittoria da 3,4 miliardi di dollari scoraggerà <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> truffatori e altri criminali crittografici di frodare gli investitori.</p>
<p>Il caso CFTC contro la frode MTI evidenzia la necessità di regolamentazioni standard per le criptovalute.</p>
<h2 id="h2-Introduzione253439"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>L’ambiente normativo delle criptovalute sta cambiando con importanti casi di precedenti che vengono registrati. Abbiamo visto casi in cui paesi, in particolare gli Stati Uniti, hanno perseguito persone e aziende di criptovalute di altre nazioni perché hanno effettuato transazioni digitali che hanno portato alla perdita di fondi per i cittadini statunitensi. Questo articolo discute la recente vittoria di <a href="https://www.gate.io/blog_detail/1158/main-takeaways-from-the-crypto-bipartisan-bill-by-cynthia-lummis-and-kirsten-gillibrand" target="_blank">CFTC</a> nel suo caso contro Steynberg e MTI.</p>
<h2 id="h2-La20vittoria20di20CFTU20contro20Mirror20Trading20International20Proprietary20Limited20MTI288922"><a name="La vittoria di CFTU contro Mirror Trading International Proprietary Limited (MTI)" class="reference-link"></a><span class="header-link octicon octicon-link"></span>La vittoria di CFTU contro Mirror Trading International Proprietary Limited (MTI)</h2><p>La vittoria storica dell’ente di regolamentazione finanziaria statunitense Commodity Futures Trading Commission (CFTC) contro Steynberg, fondatore e CEO di Mirror Trading International Proprietary Limited (MTI) e della sua azienda (MTI), una società di criptovalute dietro la più grande <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> la frode, stabilisce un grande precedente nell’industria.</p>
<p><img src="https://gimg2.gateimg.com/image/article/16837761762001683776135_.pic_hd.jpg" alt=""><br>CFTC - Coindesk</p>
<p>La CFTC ha vinto una multa di $3,4 milioni contro MIT e Steynberg per <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Alessio</a> caso di frode correlato in cui sono stati accusati di truffare denaro a molti cittadini degli Stati Uniti e altri investitori di tutto il mondo.</p>
<p>Il giudice Lee Yeakel, giudice della Corte Distrettuale del Texas, ha ordinato a Cornelius Johannes Steynberg e a MTI di pagare la somma per il regime fraudolento delle materie prime che coinvolge <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">bitcoin</a> e valuta estera. 1,73 miliardi di dollari saranno destinati a risarcire le vittime della frode criptata, mentre ulteriori 1,73 miliardi di dollari costituiscono una sanzione pecuniaria civile.</p>
<p>Anche se la penalità di 3,4 milioni di dollari è la più grande nella storia dei casi di criptovalute, è stata assegnata sulla base del fatto che lo schema fraudolento del MIT e di Steynberg è stato anche il più grande nella storia del <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> e altri asset digitali. Come tale, la penalità è destinata a servire come un severo avvertimento contro <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> truffatori e altri autori di schemi cripto fraudolenti che sperano di sfuggire all’ira della legge.</p>
<p>Leggi anche: <a href="https://www.gate.io/es/blog_detail/1698/recent-regulatory-actions-and-reports-show-the-cftc-is-more-eager-to-oversee-non-security-cryptocurrencies?lang=en" target="_blank">Recenti azioni normative e relazioni mostrano che la CFTC è più desiderosa di supervisionare le criptovalute non sicurezza</a></p>
<h2 id="h2-Informazioni20di20background787787"><a name="Informazioni di background" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Informazioni di background</h2><p>A giugno 2022, la Commodity Futures Trading Commission ha intentato un’azione di esecuzione civile contro Cornelius Johannes Steynberg di Stellenbosch, cittadino sudafricano e amministratore delegato di Mirror Trading International Proprietary Limited (MTI), un’azienda registrata e operante in Sudafrica, per frode e violazione dei suoi termini di registrazione.</p>
<p>Il caso è che Steynberg, attraverso MTI, ha creato e gestito un pool globale di materie prime valutarie estere che ha permesso agli investitori di investire <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> e valuta estera per generare flussi di entrate. Di conseguenza, i depositanti hanno contribuito con un totale di $ 1.733.838.372 allo schema.</p>
<p>Nella sua controversia, <a href="https://www.cftc.gov/PressRoom/PressReleases/8549-22" rel="nofollow noopener noreferrer" target="_blank">la CFTC ha dichiarato che</a> ha cercato “il pieno risarcimento agli investitori defraudati, la confisca dei guadagni illeciti, sanzioni pecuniarie civili, divieti permanenti di registrazione e di negoziazione, nonché un’inibizione permanente dalle future violazioni del Commodity Exchange Act e dei regolamenti della CFTC.”</p>
<p>Fondamentalmente, Steynberg ha utilizzato piattaforme di social media per attirare investitori ignari a partecipare allo schema di pool di materie prime di cui MTI si occupava. In totale, l’azienda ha ottenuto 29.421. <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> da 23.000 non-ECP dagli Stati Uniti e da altri paesi di tutto il mondo. La CFTC ha sostenuto che il convenuto abbia truffato gli investitori direttamente e indirettamente.</p>
<p>Tuttavia, la CFTC ha chiarito che le vittime potrebbero non essere in grado di ottenere il risarcimento poiché l’imputato potrebbe non avere i fondi necessari per farlo. Attraverso un comunicato stampa, <a href="https://www.cftc.gov/PressRoom/PressReleases/8696-23" rel="nofollow noopener noreferrer" target="_blank">La CFTC ha anche detto che</a> “A Steynberg è ingiunto in modo permanente di impegnarsi in comportamenti che violano il Commodity Exchange Act (CEA), come accusato, di registrarsi presso la CFTC e di fare trading in qualsiasi mercato regolamentato dalla CFTC”.</p>
<p>Tuttavia, dal loro lato, Steynberg e MTI hanno affermato di essere in esecuzione di una <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> pool di investimento in cui hanno scambiato BTC fuori catena tramite un programma software o algoritmi di trading di bot. In pratica, hanno affermato che i bot di trading generavano profitti giornalieri dalle attività di trading che condividevano con i depositanti.</p>
<p>In risposta, la CFTC afferma che i bot del software di trading erano una truffa e non sono mai stati utilizzati. Invece, i fondi che alcuni degli investitori hanno ricevuto provenivano da altri depositanti. Inoltre, la CFTC sostiene che MTI ha nascosto le perdite che ha subito.</p>
<p>L’accusa nei confronti di Steynberg e dei suoi associati è che hanno investito parte dei fondi in orologi costosi, immobili di lusso e veicoli di lusso. Dopo lo schema di marketing multinivello che coinvolge <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> fallito, Steynberg è diventato un fuggitivo ma è stato catturato da Interpol, l’organizzazione internazionale di polizia criminale, ed è detenuto nella Repubblica del Brasile.</p>
<p><img src="https://gimg2.gateimg.com/image/article/16837763012011683776148_.pic.jpg" alt=""><br>Interpol segue i criminali - Bitcoinnews</p>
<h2 id="h2-Implicazioni20della20storica20multa20di203420miliardi20a20Steynberg20e20MTI659661"><a name="Implicazioni della storica multa di $3,4 miliardi a Steynberg e MTI" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Implicazioni della storica multa di $3,4 miliardi a Steynberg e MTI</h2><p>Questo caso ha mostrato che ci sono individui che escogitano schemi per truffare molti investitori pensando che la legge non possa prenderli. Il fatto che Steynberg e MTI con sede in Sudafrica siano stati condannati da un tribunale statunitense è un importante precedente che dovrebbe impedire ai futuri truffatori di creare schemi simili di truffa BTC o <a href="https://www.gate.io/learn/articles/pyramid-and-ponzi-schemes/154" target="_blank">quelle correlate</a>.</p>
<p>In secondo luogo, questo caso ha dimostrato l’importanza della cooperazione tra diversi paesi e organizzazioni. In questo caso, il governo sudafricano e il governo del Brasile hanno collaborato con gli Stati Uniti per arrestare e condannare Steynberg.</p>
<p>In tale contesto, <a href="https://www.cftc.gov/PressRoom/PressReleases/8696-23" rel="nofollow noopener noreferrer" target="_blank">La CFTC ha detto</a>, “La CFTC apprezza l’assistenza della South African Financial Sector Conduct Authority, della Financial Services Commission del Belize, del Texas State Securities Board, dell’Alabama Securities Commission, del Segretario di Stato della Carolina del Nord, della Securities Division e del Mississippi”.</p>
<p>In un senso correlato, il coinvolgimento di Interpol mostra che non importa dove un truffatore di criptovalute possa trasferirsi, può essere arrestato e affrontare la legge pertinente.</p>
<p>Leggi anche: <a href="https://www.gate.io/blog_detail/384/" target="_blank">Leggi sulle criptovalute negli Stati Uniti e in altri paesi</a></p>
<p>Inoltre, la CFTC ha confermato che rimarrà sempre vigile nel affrontare individui che violano la sua legge truffando i suoi cittadini. Ha affermato: “La CFTC continuerà a combattere vigorosamente per la protezione dei clienti e per assicurarsi che i responsabili siano chiamati a rispondere delle loro azioni.”</p>
<p>L’accusa a Steynberg ha dimostrato che i governi agiscono in modo proattivo nel contrastare i reati legati alle criptovalute. Ciò dimostra anche che i governi nazionali non possono più restare passivi quando i criminali truffano la loro popolazione. Al momento, il mercato prevede che i governi continueranno a svolgere un ruolo di vigilanza su ciò che accade nel settore delle criptovalute.</p>
<p>Leggi anche: <a href="https://www.gate.io/blog_detail/768/crypto-pump-and-dump-scams-are-never-worth-it-here-is-why" target="_blank">Le truffe di Crypto Pump and Dump non ne valgono mai la pena, ecco perché</a></p>
<p>Ancora una volta, il successo del perseguimento penale di MTI e Steynberg per il caso di frode criptata è un messaggio chiaro per le imprese criptate che dovrebbero attenersi alle leggi nazionali e alle legislazioni criptate nei paesi in cui vivono i loro clienti. È inoltre notevole che gli Stati Uniti non possono permettere a nessuna impresa di truffare i propri cittadini. Pertanto, i progetti criptati dovrebbero essere trasparenti e responsabili nelle loro attività.</p>
<p>Tuttavia, la dichiarazione della CFTC secondo cui la sua vittoria in questo caso potrebbe non comportare il ripristino dei fondi degli investitori dovrebbe indurre i governi a stabilire legislazioni rigorose per proteggere gli investitori cripto.</p>
<h2 id="h2-Conclusione455914"><a name="Conclusione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusione</h2><p>La vittoria della CFTC nella sua battaglia legale contro Steynberg e MTI ha stabilito un forte precedente secondo cui i criminali crittografici come i truffatori possono essere arrestati e perseguiti indipendentemente dalla loro posizione geografica. Ha anche evidenziato la necessità di collaborazione tra governi e altre organizzazioni quando si tratta di crimini di criptovaluta.</p>
<h2 id="h2-FAQ601967"><a name="FAQ" class="reference-link"></a><span class="header-link octicon octicon-link"></span>FAQ</h2><h3 id="h3-Come20si20indaga20sulle20frodi20criptovalutarie285742"><a name="Come si indaga sulle frodi criptovalutarie?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Come si indaga sulle frodi criptovalutarie?</h3><p>È possibile investigare su una truffa di criptovaluta utilizzando l’intelligence open-source e il sistema Know Your Customer per identificare il proprietario dell’indirizzo che ha effettuato la truffa. Da lì, si coinvolgono gli agenti di forze dell’ordine per raccogliere ulteriori dettagli.</p>
<h3 id="h3-Posso20recuperare20i20soldi20se20vengo20truffato20dal20bitcoin736444"><a name="Posso recuperare i soldi se vengo truffato dal bitcoin?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Posso recuperare i soldi se vengo truffato dal bitcoin?</h3><p>Poiché non è possibile invertire una <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Alessio</a> transazione, puoi solo ottenere il tuo <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> indietro se la persona a cui lo invii decide di restituirlo. Puoi anche recuperarlo se il truffatore identificato e perseguito accetta di restituirlo.</p>
<h3 id="h3-20possibile20rintracciare20un20truffatore20di20criptovaluta846125"><a name="È possibile rintracciare un truffatore di criptovaluta?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>È possibile rintracciare un truffatore di criptovaluta?</h3><p>Un truffatore crittografico può essere rintracciato utilizzando l’intelligence open-source e il Know Your Customer (KYC). Tuttavia, non tutti i truffatori crittografici possono essere rintracciati.</p>
<h3 id="h3-Bitcoin20pu20essere20rintracciato20fino20a20me294164"><a name="Bitcoin può essere rintracciato fino a me?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Bitcoin può essere rintracciato fino a me?</h3><p>L’unico modo in cui le persone possono identificare il mittente di <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> è attraverso il suo indirizzo del portafoglio digitale. Non sono in grado di identificarla per nome o altri dettagli.</p>
<h3 id="h3-Cosa20puoi20fare20se20sei20truffato20con20le20criptovalute598063"><a name="Cosa puoi fare se sei truffato con le criptovalute?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Cosa puoi fare se sei truffato con le criptovalute?</h3><p>Se sei truffato con la criptovaluta, puoi segnalare la transazione all’autorità competente nel tuo paese. Se non vi è un’autorità che gestisce transazioni sospette di criptovaluta nel tuo paese, non puoi fare nulla.</p>
<h3 id="h3-Chi20pu20aiutarti20con20le20frodi20criptate826761"><a name="Chi può aiutarti con le frodi criptate?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Chi può aiutarti con le frodi criptate?</h3><p>Un’autorità competente nel tuo paese può aiutarti se tu <a href="https://www.gate.io/learn/course/crypto-security-fraud-safety-and-hack" target="_blank">incontrare una truffa crittografica</a> Tuttavia, se non esiste un’autorità autorizzata nel tuo paese per gestire casi di frode criptata, non puoi fare nulla a riguardo.</p>
<div class="blog-details-info"><br><div>Autore: <strong>Mashell C.</strong>, Ricercatore di 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 Gate.io venga citato. In tutti i casi, saranno intraprese azioni legali a causa di violazione del copyright.<br></div><p></p><br></div></div></div>