S3dvbiBjZXJjYSBkaSByaWFzc2VnbmFyZSBpbCBwcm9jZXNzbyBuZWwgY2FzbyBTRUMgdnMgVGVycmFmb3JtIExhYnM=

2024-01-23, 07:40

<p><img src="https://gimg2.gateimg.com/image/article/1700024128RDZZ 1.jpeg" alt=""><br>Do Kwon ha chiesto a un giudice federale di posticipare il suo processo a metà marzo.</p>
<p>Se il giudice Jed Rakoff non accetta la domanda di Kwon, potrebbe essere processato in absentia.</p>
<p>La Securities and Exchange Commission (SEC) degli Stati Uniti ha accusato Kwon e Terraform Labs di “orchestrare una frode di titoli di cripto-attività da miliardi di dollari.”</p>
<p>Parole chiave: <a href="/price/terra-luna" rel="nofollow noopener noreferrer" target="_blank">Terra</a> Luna Founder, Terraform labs, Do Kwon trial, SEC vs. Terraform, SEC vs. Do Kwon, <a href="/price/terra-luna" target="_blank" class="blog_inner_link">Terra</a> Luna, Terra crash, Terra Luna case, stablecoin TerraUSD, SEC Extradition Request</p>
<h2 id="h2-Introduzione897503"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>Ci sono diverse persone di spicco che hanno contribuito più di chiunque altro allo sviluppo del settore. Satoshi Nakamoto, Vitalik Buterin e Changpeng Zhao sono alcuni esempi di persone che hanno contribuito molto al settore.</p>
<p>Tuttavia, altre persone hanno contribuito molto al settore ma hanno affrontato battaglie legali. Persone come Zhao, fondatore e ex CEO di Binance, Sam Bankman-Fried, fondatore dello scambio fallito FTX e Do Kwon, <a href="https://www.gate.io/blog_detail/3436/-sec-lawsuit-against-do-kwon-terraform" target="_blank">Il fondatore di Terra Labs è stato perseguito per diversi comportamenti scorretti</a> potrebbero aver commesso nella sfera delle criptovalute.</p>
<p>In questo blog, analizziamo il processo di Do Kwon che ha istituito l’ecosistema Terra-Luna. Ci concentreremo anche sugli sviluppi legali passati e presenti che lo riguardano e riguardano Terraform Labs.</p>
<p>Leggi anche: <a href="https://www.gate.io/blog_detail/2430/terra-luna-tokens-fall-steeply-on-do-kwons-arrest" target="_blank">I token Terra LUNA cadono ripidamente dopo l’arresto di Do Kwon</a></p>
<h2 id="h2-Kwon20Richiede20la20Riassegnazione20del20Processo2088"><a name="Kwon Richiede la Riassegnazione del Processo" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Kwon Richiede la Riassegnazione del Processo</h2><p>Kwon, fondatore di Terra Luna, attualmente imprigionato in Montenegro, ha chiesto a un tribunale degli Stati Uniti di riprogrammare il suo processo per accuse di frode finanziaria. Il ritardo gli permetterà di comparire di persona durante il processo.</p>
<p>Attualmente, Kwon si trova in Montenegro dove è imprigionato per falsificazione di documenti di viaggio. In una presentazione che Inner City Press ha ottenuto, gli avvocati di Do Kwon hanno recentemente presentato la loro richiesta a un giudice di distretto degli Stati Uniti per posticipare <a href="https://www.gate.io/blog_detail/2238/kwon-erreicht-5-sterne-fahndungsstufe-da-die-sec-weitere-betrugsanklagen-erhebt" target="_blank">Prova Do Kwon nel caso SEC vs.Terraform</a> In particolare, il consulente legale di Kwon ha chiesto al tribunale di rinviare il processo a metà marzo.<br><img src="https://gimg2.gateimg.com/image/article/17059954451.png" alt=""><br>Fonte: X.com</p>
<p>La principale ragione della richiesta di rinvio del processo è che Kwon sta cercando il permesso dalle autorità montenegrine di viaggiare negli Stati Uniti.</p>
<p>Il giudice Jed Rakoff del Tribunale distrettuale degli Stati Uniti per il distretto meridionale di New York valuterà la richiesta e prenderà una decisione dopo aver ricevuto il parere della Commissione per la Borsa e i Titoli (SEC) e di Terraform Labs. Ognuna di queste organizzazioni avrebbe dovuto presentare una prova scritta a sostegno o in opposizione alla richiesta entro il 15 gennaio.</p>
<h2 id="h2-Il20tribunale20pu20condurre20il20processo20in20assenza20di20Kwon974890"><a name="Il tribunale può condurre il processo in assenza di Kwon" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Il tribunale può condurre il processo in assenza di Kwon</h2><p>Se il tribunale respinge la richiesta di Kwon, il processo si svolgerà in sua assenza, il che potrebbe essere dannoso per la sua ricerca di un processo equo. Secondo <a href="https://twitter.com/Cointelegraph/status/1746027697653096593" rel="nofollow noopener noreferrer" target="_blank">Post di Cointelegraph su X</a> Do Kwon chiede che, se il tribunale respinge la sua richiesta, la giuria sia informata della sua assenza e della sua “incapacità di testimoniare che non sia ingiustamente pregiudizievole nei suoi confronti.”</p>
<h2 id="h2-Caso20Sec20Vs20Do20Kwon48488"><a name="Caso Sec Vs. Do Kwon" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Caso Sec Vs. Do Kwon</h2><p>Nel febbraio 2023, la Securities and Exchange Commission degli Stati Uniti ha accusato Kwon e Terraform Labs di aver “orchestrato una frode di titoli di cripto-asset da miliardi di dollari”, a seguito del crollo di Terra.</p>
<p>In una dichiarazione stampa <a href="https://www.sec.gov/news/press-release/2023-32" rel="nofollow noopener noreferrer" target="_blank">la SEC ha detto</a>: “Sosteniamo che Terraform e Do Kwon non abbiano fornito al pubblico una divulgazione completa, equa e veritiera come richiesto per una serie di titoli di asset crittografici, soprattutto” <a href="https://www.gate.io/learn/articles/what-is-luna/114" target="_blank">per Luna</a> e <a href="https://www.gate.io/price/terra-luna" target="_blank">TerraUSD</a>.</p>
<p>Commentando il caso Terra Luna, <a href="https://www.sec.gov/news/press-release/2023-32" rel="nofollow noopener noreferrer" target="_blank">Gurbir S. Grewal, Direttore della Divisione di Applicazione della SEC, ha specificamente detto</a>, “L’azione odierna non solo rende i responsabili conto dei loro ruoli nel crollo di Terra, che ha devastato sia gli investitori al dettaglio che istituzionali e ha mandato un brivido <a href="/price/waves-waves" rel="nofollow noopener noreferrer" target="_blank">Onde</a> attraverso i mercati crittografici, ma ancora una volta sottolinea che guardiamo alle realtà economiche di un’offerta, non alle etichette ad essa apposte.</p>
<p>Ha aggiunto: “Come affermato nella nostra denuncia, l’ecosistema di Terraform non era né decentralizzato né finanziario. Era semplicemente una truffa sostenuta da una cosiddetta “stablecoin” algoritmica - il cui prezzo era controllato dagli imputati, non da alcun codice.”</p>
<p>Come hai notato, la SEC non ha mai considerato la criptovaluta stabile, <a href="https://www.gate.io/blog_detail/1228/following-terra-luna-celsius-network-3ac-take-a-nose-dive" target="_blank">TerraUSD crash</a>, un risultato di eventi imprevedibili e situazioni che esistevano nell’ecosistema cripto in quel momento ma una creazione di Kwon e della sua Terraform Labs.</p>
<p>In uno sviluppo simile, nel 2022, un <a href="https://www.gate.io/blog_detail/1191/the-current-investigations-on-terraform-labs-and-founder-do-kwon-following-luna-ust-crash?lang=en" target="_blank">La corte sudcoreana ha presentato una causa contro Kwon</a> e diverse altre persone nel caso di Terra Luna. Il governo credeva che Terraform Labs, registrata a Singapore e operante in Corea del Sud, avesse violato le leggi sui mercati finanziari.</p>
<h2 id="h2-Il20tribunale20del20Montenegro20revoca20lordine20di20estradizione591892"><a name="Il tribunale del Montenegro revoca l’ordine di estradizione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Il tribunale del Montenegro revoca l’ordine di estradizione</h2><p>La Corte d’Appello del Montenegro ha annullato la decisione della Corte suprema di consentire l’estradizione di Kwon negli Stati Uniti o in Corea del Sud. La Corte ha dichiarato che non vi erano motivi chiari per accogliere la richiesta di estradizione della SEC. In sostanza, il 19 dicembre 2023 la <a href="https://sudovi.me/ascg/sadrzaj/nm4D" rel="nofollow noopener noreferrer" target="_blank">Corte d’appello del Montenegro</a> ha accettato un appello dalla squadra di difesa di Kwon.</p>
<p>Riguardo a questo, <a href="https://twitter.com/Cointelegraph/status/1746027697653096593" rel="nofollow noopener noreferrer" target="_blank">Cointelegraph ha commentato</a>, “Nel dicembre 2023, la Corte d’Appello del Montenegro ha annullato una decisione del Tribunale di Podgorica che ha approvato l’estradizione di Kwon. Questo sviluppo complica il processo di estradizione verso gli Stati Uniti o la Corea del Sud.”</p>
<p>Di fatto, il 24 novembre la Corte suprema aveva approvato l’estradizione di Kwon, ma Kwon, attraverso il suo team legale, ha presentato appello contro quella sentenza. Ora, il caso è stato rinviato per un nuovo processo. Tuttavia, è importante notare che il Montenegro non ha trattati di estradizione con gli Stati Uniti o la Corea del Sud.</p>
<p>Nel frattempo, sia Kwon che la SEC hanno presentato una richiesta di giudizio abbreviato per la controversia legale SEC vs. Terraform. Entrambe le parti hanno sostenuto che l’altra parte non ha sufficientemente supportato il proprio caso. Il processo di Do Kwon doveva iniziare alla fine di gennaio.</p>
<p>Leggi anche: <a href="https://www.gate.io/blog_detail/3709/south-korea-regulators-propose-ban-on-crypto-purchases-using-credit-cards" target="_blank">I regolatori della Corea del Sud propongono il divieto di acquistare criptovalute con carte di credito</a></p>
<h2 id="h2-Sfondo20del20caso20SEC20vs20Terraform780614"><a name="Sfondo del caso SEC vs. Terraform" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Sfondo del caso SEC vs. Terraform</h2><p>Abbiamo esaminato gli sviluppi recenti nel caso SEC vs. Do Kwon, ora analizziamo brevemente il suo background. Nel 2020 Terraform Labs ha lanciato TerraUSD (UST), una stablecoin algoritmica che era ancorata al dollaro statunitense, ma era supportata da Luna, il suo token gemello.</p>
<p>TerraUSD è diventato popolare quando Kwon ha lanciato Anchor Protocol e ha offerto il 20% sui depositi in TerraUSD. Entro maggio 2022 il loro valore combinato aveva superato i 60 miliardi di dollari. Tuttavia, i problemi sono iniziati quando il mercato ha perso fiducia nella stablecoin. <a href="https://www.gate.io/how-to-buy/terra-luna" target="_blank">TerraUSD</a>.</p>
<p>Le cose sono peggiorate quando lo stablecoin si è staccato e ha scambiato al di sotto di 99 centesimi. Anche se Kwon e Terraform Labs hanno introdotto alcune misure per stabilizzare il valore, niente ha aiutato. In pochi giorni sia TerraUSD che LUNA erano diventati senza valore.</p>
<p>A seguito di quel disastro di Terra Luna, Kwon fuggì da Singapore e dalla Corea del Sud. Successivamente è stato arrestato in Montenegro, dove si nascondeva usando un passaporto falso.</p>
<h2 id="h2-Conclusione699757"><a name="Conclusione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusione</h2><p>Do Kwon ha richiesto il rinvio del suo processo negli Stati Uniti a seguito di un ritardo nella sua estradizione. Nel frattempo, il giudice Jed Rakoff del Tribunale distrettuale degli Stati Uniti per il distretto meridionale di New York prenderà una decisione sulla sua domanda. Purtroppo, c’è la possibilità che Kwon possa essere processato in absentia.</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. La ripubblicazione dell'articolo sarà consentita a condizione che si faccia riferimento a Gate.io. In tutti i casi, saranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div>