SSByZWdvbGF0b3JpIHN1ZGNvcmVhbmkgcHJvcG9uZ29ubyBpbCBkaXZpZXRvIGRpIGFjcXVpc3RvIGRpIGNyaXB0b3ZhbHV0ZSBjb24gY2FydGUgZGkgY3JlZGl0bw==

2024-01-17, 08:23

<p><img src="https://gimg2.gateimg.com/image/article/1705479445RDZZ 1.jpeg" alt=""></p>
<h2 id="h2-TL20DR695562"><a name="TL; DR" class="reference-link"></a><span class="header-link octicon octicon-link"></span>TL; DR</h2><p>La Corea del Sud ha proposto un divieto di utilizzo delle carte di credito per l’acquisto di criptovalute.</p>
<p>Attualmente, il governo coreano attende il feedback del pubblico sulla legge proposta.</p>
<p>I trader di criptovalute possono utilizzare le carte di credito per acquistare criptovalute su Gate.io.</p>
<h2 id="h2-Introduzione700474"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>La lista dei paesi che stanno elaborando la legislazione cripto sta crescendo. La Corea del Sud è uno dei paesi più recenti a proporre regolamenti per il settore cripto, in mezzo a diverse preoccupazioni, tra cui l’esternalizzazione dei fondi. Questo articolo esaminerà le proposte di regolamentazione cripto della Corea del Sud. Discuteremo anche i vantaggi dell’utilizzo della Gate Card.</p>
<h2 id="h2-LFSC20sostiene20il20divieto20delle20carte20di20credito20quando20si20acquista20criptovaluta633600"><a name="L’FSC sostiene il divieto delle carte di credito quando si acquista criptovaluta" class="reference-link"></a><span class="header-link octicon octicon-link"></span>L’FSC sostiene il divieto delle carte di credito quando si acquista criptovaluta</h2><p>La Corea del Sud, un paese con molti investitori di criptovaluta, si è unita a una comunità di nazioni che intende introdurre leggi sulla criptovaluta per regolare gli asset digitali.</p>
<p>Il 4 gennaio 2024, il governo sudcoreano attraverso il <a href="https://www.fsc.go.kr/po040301/view?noticeId=3954&amp;curPage=&amp;srchKey=&amp;srchText=&amp;srchBeginDt=&amp;srchEndDt= &quot;Financial Services Commission (FSC" rel="nofollow noopener noreferrer" target="_blank">Commissione per i Servizi Finanziari (FSC)</a> La società ha annunciato la sua intenzione di modificare il decreto di applicazione della legge sugli affari finanziari specializzati nel credito. Nel comunicato ha annunciato che mira a “diversificare i metodi di finanziamento delle società di credito finanziario.”</p>
<p>Innanzitutto, la Commissione per i servizi finanziari (FSC) della Corea del Sud ha redatto normative per vietare l’uso delle carte di credito per l’acquisto di criptovalute. La ragione ufficiale per vietare l’uso delle carte di credito per l’acquisto di criptovalute è <a href="https://www.fsc.go.kr/po040301/view?noticeId=3954&amp;curPage=&amp;srchKey=&amp;srchText=&amp;srchBeginDt=&amp;srchEndDt=" rel="nofollow noopener noreferrer" target="_blank">per prevenire la “fuoriuscita illegale di fondi nazionali all’estero</a> a causa dei pagamenti con carta su scambi di asset virtuali all’estero.</p>
<p>Leggi anche: <a href="https://www.gate.io/blog_detail/3246/south-korea-crypto-gaming" target="_blank">La Corea del Sud Crypto: il gioco regna sovrano nel mondo di Web3 in mezzo alla controversia di Terra</a></p>
<p>Prevenendo le persone dall’acquistare criptovalute con le carte di credito, il governo mira anche a prevenire il riciclaggio di denaro. Tuttavia, la proposta di regolamentazione delle criptovalute in Corea sarà sottoposta a un processo di revisione e votazione prima di essere implementata. Di conseguenza, i cittadini sudcoreani hanno fino al 13 febbraio 2024 per dare il loro feedback.</p>
<p>Riguardo a questo, <a href="https://www.fsc.go.kr/po040301/view?noticeId=3954&amp;curPage=&amp;srchKey=&amp;srchText=&amp;srchBeginDt=&amp;srchEndDt=" rel="nofollow noopener noreferrer" target="_blank">l’FSC ha detto</a>, “Organizzazioni o individui che hanno opinioni su questo emendamento possono inviare le loro opinioni online attraverso il Centro per la Legislazione Partecipativa entro il 13 febbraio 2024. Si prega di inviare la propria opinione scritta al Presidente della Commissione per i Servizi Finanziari.”</p>
<p>La FSC mira a mettere in atto diverse misure regolamentari per proteggere gli utenti degli scambi di criptovalute. Una delle proposte normative prevede che gli scambi di criptovalute conservino l’80% degli asset crittografici dei clienti in archiviazione a freddo per ridurre gli incidenti di hacking. Tuttavia, il paese mira anche a garantire che il settore delle criptovalute in Corea rimanga vivace e innovativo utilizzando una regolamentazione a favore delle criptovalute.</p>
<h2 id="h2-La20Corea20del20Sud20mira20a20cattive20incidenti20criptovaluta76422"><a name="La Corea del Sud mira a cattive incidenti criptovaluta" class="reference-link"></a><span class="header-link octicon octicon-link"></span>La Corea del Sud mira a cattive incidenti criptovaluta</h2><p>Nel corso degli ultimi due anni, la Corea del Sud ha vissuto diversi incidenti crittografici negativi che hanno costretto il governo a istituire misure regolamentari per proteggere i cittadini.</p>
<p>Ad esempio, nel maggio 2022, TerraUST, la stablecoin algoritmica e LUNA, il suo token gemello, sono imploderti causando la perdita di oltre 40 miliardi di dollari di fondi degli investitori in un solo giorno. In modo significativo, queste due criptovalute <a href="https://www.gate.io/blog_detail/1191/the-current-investigations-on-terraform-labs-and-founder-do-kwon-following-luna-ust-crash" target="_blank">appartenuto a Terraform Labs</a>, una società con sede in Corea del Sud.</p>
<p>Qualche mese dopo ci fu un altro disastro criptografico quando Wemade, con sede in Corea del Sud, ha ampliato la distribuzione di Wemix, un token di utilità nel gioco blockchain Mir 4.</p>
<p>In risposta, diverse borse locali hanno formato l’Alleanza degli Scambi di Asset Digitali (DAXA) per rimuovere Wemix. Tuttavia, Wemade ha intentato una causa per concorrenza sleale. Ma Bithumb, membro di DAXA, ha vinto la causa.</p>
<p>Questi due importanti incidenti negativi che sono accaduti in Corea del Sud e altri che si sono verificati in altre regioni del mondo <a href="https://www.gate.io/blog_detail/1806/el-colapso-de-ftx-afect%C3%B3-a-una-amplia-secci%C3%B3n-del-cripto-ecosistema" target="_blank">come il crollo di FTX</a> Hanno costretto il governo coreano a riportare la sanità nel settore delle criptovalute. Ad esempio, il governo mira a trovare modi per gli investitori di acquistare criptovalute in modo sicuro. Tuttavia, non ha intenzione di vietare gli asset digitali criptati.<br>Vietando l’acquisto di criptovaluta con carte di credito, il governo ha limitato le persone nell’uso di scambi di criptovalute straniere. Ciò gli consente di monitorare il comportamento di trading dei suoi cittadini, le prestazioni degli scambi di criptovalute locali e controllare i flussi di denaro.</p>
<p>Leggi anche: <a href="https://www.gate.io/blog_detail/1359/south-korea-increases-crypto-investigations-and-regulations" target="_blank">La Corea del Sud aumenta le indagini sulle criptovalute e le regolamentazioni</a></p>
<p>Inoltre, il governo ha invitato i suoi residenti a segnalare gli scambi non autorizzati che operano nel paese. Tuttavia, poiché le criptovalute sono senza confini, gli investitori e trader di criptovalute coreani potrebbero trovare un modo per affrontare la situazione emergente.</p>
<p>È improbabile che le criptovalute in Corea saranno significativamente influenzate dal divieto delle carte di credito. Questo perché ci sono molti scambi in Corea come Korbit, Hanbitco, Coinone e GOPAX per l’acquisto di criptovalute.</p>
<h2 id="h2-Altre20proposte20di20regolamentazione20delle20criptovalute20in20Corea20del20Sud421439"><a name="Altre proposte di regolamentazione delle criptovalute in Corea del Sud" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Altre proposte di regolamentazione delle criptovalute in Corea del Sud</h2><p>Il suddetto pezzo di legislazione criptata in Corea non è esaustivo. Tuttavia, il governo sta lavorando ad altre misure per regolare il settore.</p>
<p>In effetti, il governo ha già introdotto diverse leggi pertinenti. In primo luogo, nel 2018 il governo ha introdotto regolamenti che richiedono agli investitori di criptovalute coreani di utilizzare i propri nomi reali durante la registrazione presso gli scambi locali. Inoltre, questi dettagli dovrebbero essere verificati dalle banche sudcoreane.</p>
<p>Ancora una volta, si propone che gli scambi separino i propri fondi da quelli dei clienti. Inoltre, dovrebbero depositare i fondi dei clienti presso istituti finanziari affidabili.</p>
<p>Anche i VASPs dovrebbero essere responsabili per eventi negativi come hacking o guasti informatici. Alcune di queste disposizioni diventeranno efficaci dopo aver ricevuto feedback dai cittadini e dopo una valutazione completa dei dettagli da parte di vari settori della società.</p>
<h2 id="h2-Vantaggi20dellutilizzo20della20carta20Gate842900"><a name="Vantaggi dell’utilizzo della carta Gate" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Vantaggi dell’utilizzo della carta Gate</h2><p>Recentemente, Gate.io ha lanciato la sua carta di debito criptata che consente ai suoi titolari di effettuare varie transazioni in modo conveniente. Ad esempio, consente ai titolari di effettuare transazioni su oltre 70 milioni di commercianti in tutto il mondo. Quella carta supporta le principali criptovalute, tra cui USDT, <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> ed Ether (ETH).</p>
<p>Un altro fatto interessante <a href="https://www.gate.io/card" target="_blank">sulla carta Gate</a> è che gli utenti possono ricaricare le proprie carte con valuta fiat che viene poi convertita in criptovalute. Come hai notato, la carta Gate funziona come le tradizionali carte di debito che utilizziamo per acquistare beni e servizi.</p>
<h2 id="h2-Come20acquistare20criptovalute20con20una20carta20di20credito20su20Gateio922418"><a name="Come acquistare criptovalute con una carta di credito su Gate.io" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Come acquistare criptovalute con una carta di credito su Gate.io</h2><p>Poiché è ancora permesso ai sudcoreani di <a href="https://www.gate.io/buy_crypto" target="_blank">acquista criptovaluta usando carte di credito</a>, spieghiamo come possono farlo su Gate.io exchange. Se desideri acquistare criptovalute utilizzando una carta di credito, devi aprire e verificare un account sulla piattaforma.</p>
<p>Una volta fatto ciò, fai clic su <a href="https://www.gate.io/crypto/buy?fiat=USD&amp;crypto=USDT" target="_blank">Acquista Crypto - Carta di Credito</a>“ sulla homepage di Gate.io. Successivamente, selezioni la valuta fiat che desideri utilizzare per acquistare la criptovaluta e indicare l’importo esatto da utilizzare. Da lì, scegli un canale di pagamento come Banxa.</p>
<p>Dopo aver letto l’avviso legale e cliccato su “Continua”, verrai indirizzato al terzo fornitore per completare il pagamento. Sul sito del terzo fornitore creerai l’ordine, invierai la verifica e compilerai i dettagli della carta. Con questo hai finito, poiché l’ordine è completato.</p>
<h2 id="h2-Conclusione161017"><a name="Conclusione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusione</h2><p>La Corea del Sud ha proposto un divieto di criptovalute sull’uso delle carte di credito per acquistare attività digitali come criptovalute. Facendo ciò, il governo mira a frenare l’esternalizzazione dei fondi e il riciclaggio di denaro. Tuttavia, prima che la legge proposta entri in vigore, i coreani possono acquistare criptovalute usando carte di credito.</p>
<h2 id="h2-Domande20frequenti20sulle20criptovalute20in20Corea20del20Sud616831"><a name="Domande frequenti sulle criptovalute in Corea del Sud" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Domande frequenti sulle criptovalute in Corea del Sud</h2><h3 id="h3-Gateio2020legale20in20Corea20del20Sud809675"><a name="Gate.io è legale in Corea del Sud?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Gate.io è legale in Corea del Sud?</h3><p>Gate.io è legale in Corea del Sud in quanto i suoi cittadini possono liberamente comprare, detenere e vendere criptovalute sulla sua piattaforma. I residenti sudcoreani possono acquistare criptovalute su Gate.io utilizzando carte di debito/credito.</p>
<h3 id="h3-Le20criptovalute20sono20legali20in20Corea20del20Sud529706"><a name="Le criptovalute sono legali in Corea del Sud?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Le criptovalute sono legali in Corea del Sud?</h3><p>Le criptovalute sono legali in Corea del Sud in quanto i cittadini possono acquistarle, tenerle, scambiarle e venderle. Tuttavia, il governo coreano sta elaborando regolamenti criptografici per proteggere gli investitori e promuovere l’innovazione nel settore.</p>
<h3 id="h3-Quali20criptovalute20sono20popolari20in20Corea244454"><a name="Quali criptovalute sono popolari in Corea?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Quali criptovalute sono popolari in Corea?</h3><p>Bitcoin è la criptovaluta più popolare in Corea del Sud. A livello globale, la Corea del Sud è il secondo paese con il maggior <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> volume di trading. Gli Stati Uniti sono il primo paese in termini di trading di bitcoin.</p>
<h3 id="h3-La20Corea20del20Sud2020esente20da20tasse20sulle20criptovalute48501"><a name="La Corea del Sud è esente da tasse sulle criptovalute?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>La Corea del Sud è esente da tasse sulle criptovalute?</h3><p>Attualmente, non ci sono tasse sulle entrate criptate in Corea del Sud. Tuttavia, il governo prevede di introdurre una tassa del 20% sulle entrate criptate pari a $187 o più a partire dal 2025.</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 si faccia riferimento a Gate.io. In tutti i casi, verranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div>