SSB0b2tlbiBUZXJyYSBMVU5BIGNhZG9ubyBicnVzY2FtZW50ZSBjb24gbCdhcnJlc3RvIGRpIERvIEt3b24=

2023-04-10, 01:15

<p><img src="https://gimg2.gateimg.com/image/article/1681088709RDZZ.jpeg" alt=""></p>
<h2 id="h2-TL20DR508097"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p>Do Kwon, il fondatore di <a href="/price/terra-luna" rel="nofollow noopener noreferrer" target="_blank">Terra</a> Blockchain, è stato arrestato in Montenegro poiché aveva un mandato di arresto per il suo schema di frode crypto che coinvolgeva <a href="/price/terra-luna" rel="nofollow noopener noreferrer" target="_blank">Terra</a> LUNA.</p>
<p>I prezzi dei token LUNA sono diminuiti dell’8% a seguito della notizia dell’arresto di Do Kwon.</p>
<p>Non è chiaro, al momento, se il Montenegro deporterà il signor Kwon in Corea del Sud o negli Stati Uniti.</p>
<h2 id="h2-Introduzione768322"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>Gli effetti di certi eventi nella sfera cripto possono durare a lungo. Ad esempio, quasi un anno dopo il crollo di <a href="/price/terra-luna" rel="nofollow noopener noreferrer" target="_blank">Terra</a> USD (UST) e LUNA il mercato crittografico continua a subire gli effetti a catena. L’arresto recente di Do Kwon, il fondatore di <a href="/price/terra-luna" rel="nofollow noopener noreferrer" target="_blank">Terra</a>, ha portato al ribasso il prezzo dei token LUNA. Questo articolo esplora le reazioni del mercato all’arresto di Do Kwon e le possibili azioni legali che gli Stati Uniti intraprenderanno nei suoi confronti.</p>
<p>Il prezzo dei token LUNA è sceso dopo l’arresto di Do Kwon<br>I token nativi di <a href="/price/terra-luna" rel="nofollow noopener noreferrer" target="_blank">Terra</a> La blockchain LUNA è scesa del 8% a seguito dell’arresto del suo fondatore Do Kwon. Il recente rapporto afferma che Kwon è stato arrestato in Montenegro, all’aeroporto di Podgorica. L’agenzia internazionale di polizia, Interpol, ha confermato l’arresto di Kwon insieme al responsabile finanziario di Terraform, Han Chang Joon. L’identità di Kwon è stata confermata utilizzando le sue impronte digitali.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1681089025DO KWON 1.png" alt=""></p>
<p>Kwon era in fuga dopo il crollo della sua criptovaluta stabile da 40 miliardi di dollari, <a href="/price/terra-luna" rel="nofollow noopener noreferrer" target="_blank">Terra</a> USD (UST) e la sua moneta sorella, LUNA, a maggio 2022. Filip Adzic, ministro degli interni di Montenegro, ha confermato l’arresto di Kwon sia su Twitter che su Facebook.</p>
<p>Leggi anche: <a href="https://www.gate.io/ru/blog_detail/2238/do-kwon-reaches-5-star-wanted-level-as-sec-brings-more-fraud-charges?lang=en" target="_blank">Do Kwon raggiunge il livello di ricerca a 5 stelle mentre la SEC porta ulteriori accuse di frode</a></p>
<p><img src="https://gimg2.gateimg.com/image/article/1681089077DO KWON 2.png" alt=""></p>
<p>Il signor Adzic ha aggiunto: “La polizia montenegrina ha detenuto una persona sospettata di essere uno dei fuggitivi più ricercati, il cittadino sudcoreano Do Kwon, co-fondatore e CEO di Terraform Labs con sede a Singapore.”</p>
<p>L’arresto di Kwon segue un mandato di arresto emesso da un tribunale di Seoul nel settembre 2022 per la sua violazione della legge sui mercati finanziari della Corea del Sud e la successiva notifica rossa di Interpol. Attualmente, non è chiaro dove si trovi Montegro. <a href="https://www.gate.io/blog_detail/1019/daily-flash-do-kwon-tried-to-escape-south-korea-before-luna-collapsed-the-total-on-chain-nft-volume-transaction-on-ethereum-exceeded-10-millions-it-is-only-a-matter-of-time-before-cryptocurrency-is-legalized-in-russia" target="_blank">invia il signor Kwon perché la Corea del Sud</a>, il suo paese e gli Stati Uniti vogliono che risponda alle accuse di contenzioso.</p>
<p>Poche ore dopo il suo arresto, i pubblici ministeri federali a New York hanno accusato Kwon di frode coinvolgente <a href="/price/terra-luna" rel="nofollow noopener noreferrer" target="_blank">Terra</a> scontro. In effetti, Kwon deve affrontare otto accuse che includono frode sulle materie prime, frode sui titoli, frode telematica, cospirazione per frode e manipolazione del mercato.</p>
<h2 id="h2-Storia20di202020Terra2020monete869123"><a name="Storia di   Terra  monete" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Storia di <a href="/price/terra-luna" rel="nofollow noopener noreferrer" target="_blank">Terra</a> monete</h2><p>Il signor Kwon, 31enne e laureato all’Università di Stanford, ha fondato il <a href="https://www.gate.io/explore/terra-luna" target="_blank">La blockchain di Terra che ha emesso LUNA e la stablecoin</a>, <a href="/price/terra-luna" rel="nofollow noopener noreferrer" target="_blank">Terra</a> USD (UST), ancorato a 1.1 con il dollaro degli Stati Uniti. Tuttavia, queste due monete erano collegate poiché LUNA ha contribuito a mantenere il valore di UST.</p>
<p>Una cosa triste è che il signor Kwon non ha ascoltato le preoccupazioni di alcuni analisti che hanno sottolineato alcune carenze del suo <a href="/price/terra-luna" rel="nofollow noopener noreferrer" target="_blank">Terra crypto</a> Tuttavia, a maggio 2022 il valore di LUNA è sceso significativamente, innescando la cosiddetta spirale della morte che ha portato al <a href="/price/terra-luna" rel="nofollow noopener noreferrer" target="_blank">Terra</a> crash. Il crollo di LUNA ha causato la perdita di oltre decine di miliardi di dollari e ha persino influenzato il valore di altre criptovalute non correlate come <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> e ETH.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1681089147DO KWON 3.png" alt=""></p>
<h2 id="h2-Reazione20del20mercato20al20crollo20di202020Terra2020LUNA176114"><a name="Reazione del mercato al crollo di   Terra  LUNA" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Reazione del mercato al crollo di <a href="/price/terra-luna" rel="nofollow noopener noreferrer" target="_blank">Terra</a> LUNA</h2><p>Il mercato delle criptovalute ha risposto prontamente alla notizia dell’arresto di Do Kwon, con il prezzo di LUNA che è diminuito di 10 centesimi, passando da $1,40. Secondo CoinGecko, il valore del LUNA Classic è diminuito del 3,7%. Tuttavia, il resto delle principali criptovalute non è stato influenzato in alcun modo riscontrabile alla <a href="/price/terra-luna" rel="nofollow noopener noreferrer" target="_blank">Terra</a> crash. Al momento della scrittura, è ancora sicuro <a href="/how-to-buy/terra-luna" rel="nofollow noopener noreferrer" target="_blank">acquistare luna</a>.</p>
<h2 id="h2-Come20evitare20le20truffe20criptate2020Suggerimenti20da20Gateio867662"><a name="Come evitare le truffe criptate - Suggerimenti da Gate.io" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Come evitare le truffe criptate - Suggerimenti da Gate.io</h2><p>Il mercato delle criptovalute ha imparato molto <a href="https://www.gate.io/blog_detail/989/terra-luna-crash-recovery-plan-announced" target="_blank">dal crollo di Terra LUNA nel 2022</a> In generale, abbiamo imparato la necessità di fare una ricerca approfondita e altri modi per identificare le truffe.</p>
<p><strong>Ricerca approfondita</strong>: La lezione più grande che abbiamo imparato dal collasso di <a href="/price/terra-luna" rel="nofollow noopener noreferrer" target="_blank">Terra</a> è necessario svolgere una ricerca approfondita su una criptovaluta in cui si intende investire. Gli utenti dovrebbero leggere il whitepaper, in particolare la sua road map, la tokenomica e il team. Inoltre, è necessario scoprire il sentimento del mercato nei confronti di quella criptovaluta.</p>
<p>Leggi anche: <a href="https://www.gate.io/blog_detail/674/top-crypto-scams-to-avoid" target="_blank">Top Crypto Scams da evitare</a></p>
<p><strong>Ignora l’esagerazione sui social media</strong>: L’eccitazione che si verifica su piattaforme di social media come Twitter e Facebook potrebbe ingannarti. In alcuni casi, i team dei progetti pagano influencer e celebrità per diffondere informazioni che potrebbero non essere accurate. La cosa più importante è ottenere consigli da persone che conosci personalmente e che hanno molta conoscenza ed esperienza di ciò che sta accadendo nel settore delle criptovalute.</p>
<p><strong>Verifica i siti web online</strong>: Alcuni attori malintenzionati creano siti web o applicazioni che sembrano identici a quelli legittimi. Tuttavia, se li studi attentamente, noterai alcune differenze minori soprattutto nei nomi di dominio. Se inserisci le tue informazioni personali in essi, potresti perdere le tue criptovalute. Ad esempio, le truffe potrebbero chiedere le chiavi private di determinati portafogli come MetaMask.</p>
<p><strong>Rifiuta offerte gratuite</strong>: In alcuni casi, gli truffatori promuovono progetti cripto in cui promettono offerte gratuite. È importante evitare offerte che richiedano di pagare una piccola quantità in criptovaluta. Inoltre, controlla sempre le recensioni sui siti web, le applicazioni e i prodotti cripto prima di usarli.</p>
<p>Leggi anche: <a href="https://www.gate.io/blog_detail/2148/how-to-avoid-nft-scam" target="_blank">Come non cadere nelle truffe degli NFT</a></p>
<p><strong>Altri consigli</strong>: Ci sono altri consigli diffusi che dovresti usare. Ad esempio, dovresti utilizzare l’autenticazione a più fattori, i firewall e la VPN, tra gli altri. È importante anche evitare di condividere le tue chiavi private e le frasi di recupero. Infine, considera di utilizzare portafogli crittografici diversi per gestire i tuoi asset digitali.</p>
<h2 id="h2-Conclusione320291"><a name="Conclusione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusione</h2><p>In breve, Do Kwon, il fondatore di <a href="/price/terra-luna" rel="nofollow noopener noreferrer" target="_blank">Terra</a> Il blockchain è stato recentemente arrestato in Montenegro. Gli Stati Uniti e la Corea del Sud vogliono che risponda alle accuse a suo carico di gestire una criptovaluta utilizzando varie tecniche truffaldine. Notevolmente, i prezzi di <a href="/price/terra-luna" rel="nofollow noopener noreferrer" target="_blank">Terra</a> I token di Luna sono crollati bruscamente quando la notizia dell’arresto di Kwon è giunta al mercato.</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 suggerimenti di investimento.<br></em><div><em></em>Gate.io si riserva tutti i diritti su questo articolo. Il ripostaggio dell'articolo sarà consentito a condizione che venga citato Gate.io. In tutti i casi, saranno intraprese azioni legali a causa della violazione del copyright.<br></div><p></p><br></div></div></div>