UHJvc3NpbWkgY2FzaSBnaXVkaXppYXJpIHN1bGxlIGNyaXB0b3ZhbHV0ZTogbGUgYmF0dGFnbGllIGxlZ2FsaSBwb3N0LVNCRiBkYSB0ZW5lcmUgZCdvY2NoaW8=

2024-04-17, 05:43

<p><img src="https://gimg2.gateimg.com/image/article/1713331869rdzz.jpeg" alt=""></p>
<h2 id="h2-TL20DR313337"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p>Il processo di diversi leader cripto come Changpeng Zhao, Do Kwon e Alex Mashinsky continuerà nel periodo successivo al processo di SBF.</p>
<p>Le battaglie legali sulla criptovaluta negli Stati Uniti probabilmente stabiliranno importanti precedenti per il settore.</p>
<p>Il processo di Sam Bankman-Fried e altri leader di progetti crypto dovrebbe rendere coscienti le società basate su blockchain di conformarsi ai requisiti legali pertinenti nella giurisdizione in cui operano.</p>
<h2 id="h2-Introduzione72999"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>Anche se il processo di Sam Bankman-Fried, soprannominato il caso crypto di tutti i tempi, è stato concluso, ci sono diverse altre battaglie legali che coinvolgono prominenti imprenditori crypto come Do Kwon, Changpeng Zhao e Alex Mashinsky. Lo scopo di questo articolo è discutere gli altri significativi casi giudiziari crypto che seguono l’incarcerazione di Bankman-Fried.</p>
<p>Scenario legale dopo la saga di Sam Bankman-Fried (SBF)<br>Come accennato in precedenza, ci sono diversi casi giudiziari crittografici di alto profilo che potrebbero concludersi nel 2024. Questi includono i processi di Celsius Alex Mashinsky, Changpeng Zhao- l’ex CEO di Binance- Avi Eisenberg, Roman Storm di Tornado Cash, <a href="/price/safemoon-sfm" rel="nofollow noopener noreferrer" target="_blank">SafeMoon</a> John Karony di Gate.io così come <a href="/price/kucoin-kcs" rel="nofollow noopener noreferrer" target="_blank">KuCoin</a> La maggior parte dei casi durante il panorama legale post-SBF ruotano intorno al riciclaggio di denaro, alla manipolazione di mercato, alle frodi e alla vendita di titoli non registrati negli Stati Uniti.</p>
<p>Sebbene questi casi colpiscano singoli individui e progetti cripto specifici come gli exchange, hanno conseguenze di vasta portata nell’industria. Questo perché queste cause legali cripto della SEC stabiliscono precedenti per la futura conformità normativa cripto.</p>
<p>Leggi anche: <a href="https://www.gate.io/blog_detail/3364/daily-news-sbfs-sentence-is-expected-to-be-no-less-than-40-years-musk-plans-to-turn-the-x-platform-into-a-digital-bank-next-year" target="_blank">Si prevede che la condanna di SBF sia di almeno 40 anni</a></p>
<p>La condanna di SBF e la successiva incarcerazione hanno inviato un messaggio forte ai progetti di criptovaluta affinché le loro attività rispettino le leggi delle giurisdizioni in cui operano. Ora, discutiamo alcune delle principali battaglie legali nel settore delle criptovalute, iniziando con quella del <a href="https://www.gate.io/blog_detail/2823/binance-vs-sec-epic-peaked" target="_blank">SEC vs. Changpeng Zhao</a>, affettuosamente conosciuto come CZ nel settore delle criptovalute.</p>
<h2 id="h2-La20battaglia20legale20tra20la20SEC20e20Changpeng20Zhao470384"><a name="La battaglia legale tra la SEC e Changpeng Zhao" class="reference-link"></a><span class="header-link octicon octicon-link"></span>La battaglia legale tra la SEC e Changpeng Zhao</h2><p>Nel novembre 2023 Changpeng Zhao <a href="https://www.gate.io/learn/articles/why-are-crypto-exchange-founders-always-accused-of-money-laundering/2362" target="_blank">ha dichiarato colpevole di riciclaggio di denaro e finanziamento del terrorismo attraverso regole KYC deboli</a>. In base al peso delle accuse del processo CB, gli Stati Uniti potrebbero condannare Zhao ip a 18 anni di prigione. Tuttavia, alcuni esperti legali ritengono che è probabile che abbia una condanna più leggera poiché ha cooperato bene con le autorità regolatorie e legali degli Stati Uniti.</p>
<p>Il processo di CZ Binance probabilmente indicherà come le autorità regolatorie degli Stati Uniti affronteranno le leggi AML e CTF promuovendo al contempo l’innovazione e la crescita del settore. La Securities and Exchange Commission degli Stati Uniti (SEC) ha presentato una causa cripto contro Zhao nel giugno 2023 accusandolo di “una rete di inganni” e di gestire un exchange non registrato nonché di gestire un programma di conformità regolamentare “fittizio”.</p>
<p>La SEC ha inoltre affermato che l’exchange Binance ha gonfiato le cifre del volume di trading, ingannando così gli investitori. Si è anche affermato che l’exchange ha deviato i fondi dei clienti e ha ingannato i clienti riguardo al suo sistema di controllo della sorveglianza di mercato. È importante notare che l’ex CEO di Binance sarà condannato questo mese. Al momento, Zhao è bloccato negli Stati Uniti, in attesa del pronunciamento della sua condanna.</p>
<h2 id="h2-Aggiornamento20sulla20battaglia20legale20di20Do20Kwon20di20Terraform20Labs20e20sullo20stato20di20estradizione998246"><a name="Aggiornamento sulla battaglia legale di Do Kwon di Terraform Labs e sullo stato di estradizione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Aggiornamento sulla battaglia legale di Do Kwon di Terraform Labs e sullo stato di estradizione</h2><p>Il prossimo interessante caso legale è quello di Do Kwon, co-fondatore di Terraform Labs e innovatore delle criptovalute TerraUSD e Luna. Do Kwon è accusato di frode negli Stati Uniti. L’accusa chiave della SEC contro Kwon è che ha mentito agli investitori sulla stabilità di TerraUSD, la cosiddetta “stablecoin algoritmica”.</p>
<p><a href="/price/terra-luna" rel="nofollow noopener noreferrer" target="_blank">Terra</a> USD, ancorato al dollaro degli Stati Uniti utilizzando un meccanismo di creazione e distruzione in-chain contro il suo token gemello LUNA, de-ancorato a maggio 2022, cancellando oltre 60 miliardi di dollari di capitalizzazione di mercato. La SEC sostiene che Kwon abbia ingannato i clienti affermando che l’UST si sarebbe “guarito naturalmente” o si sarebbe “autoguarito automaticamente”.</p>
<p>Leggi anche: <a href="https://www.gate.io/explore/terra-luna" target="_blank">LUNA si riprenderà mai?</a></p>
<p>Finora, gli Stati Uniti hanno provato Kwon in contumacia poiché si trova in Montenegro dopo aver scontato una pena detentiva di 4 mesi per falsificazione di documenti di viaggio. Le autorità montenegrine non hanno ancora approvato l’estradizione di Do Kwon negli Stati Uniti o in Corea del Sud. Lo stato balcanico sta ancora valutando la possibilità di concedere l’ordine di estradizione di Kwon.</p>
<h2 id="h2-Processo20di20Avraham20Avi20Eisenberg20per20presunta20sfruttamento20del20protocollo20DeFi244076"><a name="Processo di Avraham “Avi” Eisenberg per presunta sfruttamento del protocollo DeFi" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Processo di Avraham “Avi” Eisenberg per presunta sfruttamento del protocollo DeFi</h2><p>Il processo di Avi Eisenberg è una delle battaglie legali crittografiche in corso negli Stati Uniti. I pubblici ministeri degli Stati Uniti a Manhattan hanno accusato Eisenberg di diverse accuse penali che includono la manipolazione delle materie prime e la frode telematica. Tuttavia, Eisenberg ha dichiarato la sua innocenza a queste accuse.</p>
<p>Il caso dello stato è che nell’ottobre 2022 Eisenberg ha sifonato oltre 110 milioni di dollari da Mango Markets, una società. <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> protocollo, attraverso ciò che ha definito una ‘strategia di trading altamente redditizia’. Tuttavia, le autorità degli Stati Uniti sostengono che abbia ottenuto in modo fraudolento criptovalute per un valore superiore a $110 da Mango Markets, che ha causato il blocco delle sue operazioni. Hanno affermato che Eisenberg ha manipolato il prezzo del token MNGO e ha preso in prestito tutti i depositi Mango contro le sue posizioni di mercato.</p>
<p>In seguito, Eisenberg ha restituito una parte dell’importo con l’accordo che Mango Markets non avrebbe intrapreso azioni legali contro di lui. Tuttavia, sostiene che ciò che ha fatto era legale in quanto il contratto intelligente di Mango Markets lo permetteva. In ottobre 2022 ha pubblicato la seguente dichiarazione.<br><img src="https://gimg2.gateimg.com/image/article/17133323261.jpeg" alt=""><br>Origine: <a href="https://twitter.com/avi_eisen/status/1581326199682265088" rel="nofollow noopener noreferrer" target="_blank">x.com</a></p>
<p>Il processo di Eisenberg, che avrebbe dovuto iniziare il 4 dicembre 2023, continuerà questo mese. Nel frattempo, si trova in un carcere portoricano in attesa dell’inizio del processo.</p>
<h2 id="h2-Panoramica20del20processo20penale20e20dellaccusa20del20fondatore20di20Celsius20Alex20Mashinsky409576"><a name="Panoramica del processo penale e dell’accusa del fondatore di Celsius, Alex Mashinsky" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Panoramica del processo penale e dell’accusa del fondatore di Celsius, Alex Mashinsky</h2><p>Un altro imprenditore di criptovalute di alto rango che sta affrontando accuse penali negli Stati Uniti è Alex Mashinsky, il fondatore di Celsius. Le accuse contro Alex Mashinsky di Celsius includono manipolazione di mercato e cospirazione per commettere frode.</p>
<p>Notizie correlate: <a href="https://www.gate.io/blog_detail/3767/crypto-bankruptcies-kirkland-ellis-secures-120m" target="_blank">Fallimenti nel settore delle criptovalute: Kirkland &amp; Ellis garantisce $120 milioni nei casi di Celsius, Core Scientific, BlockFi, Voyager</a></p>
<p>Al culmine della sua attività, Celsius, una piattaforma di prestito crittografico, aveva asset per oltre 25 miliardi di dollari e affermava di essere il “posto più sicuro per la tua criptovaluta”. Tuttavia, a seguito del crollo della rete <a href="/price/terra-luna" target="_blank" class="blog_inner_link">Terra</a> di Do Kwon nel maggio 2022, Celsius ha cessato le sue operazioni e ha presentato istanza di fallimento. Sosteneva che il suo bilancio avesse un buco di 1,2 miliardi di dollari.</p>
<p>In seguito, i pubblici ministeri degli Stati Uniti hanno intentato una causa sostenendo che Alex Mashinsky e il suo team esecutivo hanno gonfiato artificialmente il valore del token Celsius (CEL), ingannando così i propri clienti.</p>
<p>La Federal Trade Commission (FTC) degli Stati Uniti, la SEC e la CFTC hanno anche presentato accuse contro Mashinsky per posizionare Celsius come una destinazione di investimento sicura, anche se stavano prendendo passi rischiosi nel loro tentativo di mantenere la promessa di un rendimento del 17% sull’investimento.</p>
<p>Nel frattempo, Mashinsky non ha dichiarato colpevolezza rispetto alle accuse che gli Stati Uniti hanno mosso nei suoi confronti. Il fondatore di Celsius è stato rilasciato su cauzione di 40 milioni di dollari ed è in attesa che il suo processo continui a settembre 2024.</p>
<h2 id="h2-Problemi20legali20per20la20leadership20di20Safemoon800748"><a name="Problemi legali per la leadership di Safemoon" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Problemi legali per la leadership di Safemoon</h2><p>La battaglia legale di <a href="/price/safemoon-sfm" target="_blank" class="blog_inner_link">Safemoon</a> mostra anche la necessità che i progetti di criptovalute si attengano alle disposizioni normative dei paesi in cui operano. Le autorità degli Stati Uniti hanno presentato accuse di cospirazione per riciclaggio di denaro e frode telematica contro Braden John Karony, CEO di SafeMoon. Se condannato per questi reati, Karony potrebbe passare fino a 45 anni in prigione.</p>
<p>Nel frattempo, Karony ha dichiarato la sua innocenza rispetto tutte le accuse. Per questo caso, gli Stati Uniti hanno anche accusato Kyle Nagy, il creatore di SafeMoon, e Thomas Smith, il suo chief technology officer, per gli stessi reati. Il trio affronterà anche le accuse della SEC per l’appropriazione indebita di fondi e l’offerta di vendite di titoli non registrati. Attualmente, Karony è in libertà su cauzione, Nagy è latitante e Smith sta cercando di avviare una trattativa.</p>
<h2 id="h2-Sfide20legali20che20affrontano20Roman20Storm20e20Roman20Semenov20di20Tornado20Cash518599"><a name="Sfide legali che affrontano Roman Storm e Roman Semenov di Tornado Cash" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Sfide legali che affrontano Roman Storm e Roman Semenov di Tornado Cash</h2><p>Il processo di Roman Storm, lo sviluppatore di Tornado Cash, continuerà nel 2024. Gli Stati Uniti hanno mosso diverse accuse contro di lui, tra cui l’operatività di un’attività di trasmissione di denaro non autorizzata, la cospirazione per commettere riciclaggio di denaro e la violazione della Legge sulle emergenze economiche internazionali.<br>Roman Semenov è attualmente latitante e si ritiene che si trovi in Russia. Nel frattempo, Roman Storm non si è dichiarato colpevole delle accuse a suo carico, ma sta lottando per farle cadere, sostenendo che non potevano fare nulla per impedire ai cittadini statunitensi di accedere ai servizi di Tornado Cash.<br>Panoramica sulle procedure legali e le possibili condanne degli esecutivi di FTX.</p>
<p>Una delle principali battaglie legali cripto è quella degli esecutivi di FTX. Dopo la condanna di SBF, le autorità degli Stati Uniti hanno rivolto la loro attenzione agli esecutivi di FTX, tra cui Zixiao “Gary” Wang, co-fondatore di FTX, Nishad Singh, responsabile dell’ingegneria, e Caroline Ellison, ex CEO di Alameda Research.</p>
<p>In sostanza, questi ex membri dirigenti di FTX sono accusati di frode per le malefatte commesse sulla loro piattaforma di criptovalute. Di fatto, la frode dei dirigenti di FTX ha portato al collasso della piattaforma nell’ottobre 2022, causando una perdita complessiva di oltre 8 miliardi di dollari per i clienti.</p>
<p>Leggi anche: <a href="https://www.gate.io/explore/ftx-sbf" target="_blank">Il crollo FTX di SBF è uno schema Ponzi o una frode?</a></p>
<h2 id="h2-Accuse20di20KuCoin20e20dei20fondatori20da20parte20del20governo20degli20Stati20Uniti246893"><a name="Accuse di KuCoin e dei fondatori da parte del governo degli Stati Uniti" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Accuse di <a href="/price/kucoin-kcs" target="_blank" class="blog_inner_link">KuCoin</a> e dei fondatori da parte del governo degli Stati Uniti</h2><p>La SEC degli Stati Uniti ha accusato KuCoin e altre importanti borse di criptovalute come Kraken, Coinbase e Gemini di violare le sue leggi sulla sicurezza attraverso la vendita di titoli non registrati. Le accuse del fondatore di KuCoin includono la mancata implementazione di un programma di antiriciclaggio e l’operatività di un’attività di trasferimento di denaro non registrata. Se condannati, Gan e Tang, cittadini cinesi, rischiano una condanna a oltre un decennio di prigione.</p>
<h2 id="h2-Cause20legali20della20SEC20e20della20CFTC527326"><a name="Cause legali della SEC e della CFTC" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Cause legali della SEC e della CFTC</h2><p>La SEC degli Stati Uniti e la CFTC sono le due agenzie legali del paese che svolgono un ruolo attivo nella persecuzione dei criminali della criptovaluta. Oltre ai casi discussi in questo articolo, la SEC ha citato in giudizio diverse altre imprese cripto per l’operazione di attività non autorizzate e la vendita di titoli non registrati. Una nota battaglia legale della SEC nel settore delle criptovalute coinvolge Ripple, che viene accusato di offrire titoli non registrati.</p>
<p>D’altra parte, la US Commodity Futures Trading Commission ha intentato cause contro progetti di criptovalute che hanno violato le regole di trading e derivati criptovalutari del paese. Ad esempio, nel maggio 2023 la CFTC ha citato in giudizio Binance e Zhao per la vendita di prodotti derivati criptovalutari non registrati ai clienti statunitensi.</p>
<p>Inoltre, nel giugno 2023 la CFTC ha presentato una causa legale contro Ooki DAO, un’organizzazione autonoma decentralizzata (DAO), per l’offerta di commodities non registrate. Come risultato, il giudice distrettuale degli Stati Uniti William H. Orrick ha deciso a favore della CFTC e ha ordinato alla società di pagare una multa di $643,542 e di interrompere le sue attività. Le azioni di contrasto attive della CFTC e della SEC indicano che le organizzazioni di finanza decentralizzata (DeFi) non possono più sfuggire alla legge negli Stati Uniti.</p>
<h2 id="h2-Conclusione52145"><a name="Conclusione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusione</h2><p>Gli Stati Uniti stanno prendendo l’iniziativa nel perseguire i leader delle aziende cripto che sono riluttanti a rispettare i requisiti legali del paese. La condanna a 25 anni di prigione di SBF dovrebbe mettere in guardia i dirigenti dei progetti cripto affinché si conformino alla legislazione pertinente esistente in diversi paesi. Chanpeng Zhao, Roman Storm e Alex Mashinsky sono alcuni dei leader cripto le cui battaglie legali continueranno nel 2024.</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 relativi a questo articolo. La ripubblicazione dell'articolo sarà consentita a condizione Gate.io sia referenziato. In tutti i casi, verranno intraprese azioni legali a causa della violazione del copyright.<br></div><p></p><br></div></div></div>