UHJlcGFyYXJlIGlsIHRlcnJlbm86IGlsIGRpc2Vnbm8gZGkgbGVnZ2UgZGkgVGFpd2FuIHJpZGVmaW5pc2NlIGdsaSBhc3NldCB2aXJ0dWFsaSBlIGxlIG9wZXJhemlvbmkgZGkgc2NhbWJpbw==

<p><img src="https://gimg2.gateimg.com/image/article/1690791857hotspot.jpeg" alt=""></p>
<h2 id="h2-TL20DR194178"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p>I legislatori a Taiwan hanno redatto il progetto di legge sulla gestione degli asset virtuali che ha superato la prima lettura nel Yuan legislativo.</p>
<p>Attualmente, Taiwan utilizza le disposizioni antiriciclaggio (AML) per regolamentare le attività cripto nel paese.</p>
<p>Il disegno di legge sugli asset digitali sarà sottoposto alla seconda lettura a gennaio 2024.</p>
<h2 id="h2-Introduzione580251"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>Ora è evidente che molti paesi si rendono conto del potere trasformativo delle criptovalute per le loro economie, qualcosa che li ha spinti a essere proattivi emanando regolamenti cripto-friendly.</p>
<p>Taiwan è una delle prime nazioni a compiere un passo audace nell’istituire una legislazione criptata. Per questo motivo, ci concentreremo sul nuovo disegno di legge criptico di Taiwan e sul suo effetto previsto sull’uso e l’adozione delle criptovalute nel paese.</p>
<h2 id="h2-Il20progetto20di20legge20di20Taiwan20sulle20risorse20digitali78854"><a name="Il progetto di legge di Taiwan sulle risorse digitali" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Il progetto di legge di Taiwan sulle risorse digitali</h2><p>Taiwan ha compiuto il suo primo audace passo verso la regolamentazione degli asset digitali, in particolare delle criptovalute, nel paese presentando un primo Progetto di Legge sulla Gestione degli Asset Virtuali presso il Legislative Yuan, l’organo eletto responsabile dell’analisi delle future leggi. Tuttavia, la proposta di regolamentazione delle criptovalute a Taiwan sarà sottoposta a ulteriori revisioni in futuro.</p>
<p>Secondo quanto <a href="https://ppg.ly.gov.tw/ppg/bills/202103224730000/details" rel="nofollow noopener noreferrer" target="_blank">Registri parlamentari taiwanesi</a>, il “Virtual Asset Management Ordinance Draft”, introdotto nel parlamento legislativo il 25 ottobre, mira a stabilire un quadro giuridico per gli asset digitali a Taiwan”.</p>
<p>Ci sono diversi obiettivi che la regolamentazione delle criptovalute a Taiwan raggiungerà. Fornirà una chiara definizione degli asset virtuali, stabilirà linee guida per la protezione dei clienti e fornirà standard per i fornitori di servizi di asset virtuali, nonché obbligherà i giocatori del settore ad aderire all’associazione industriale pertinente.</p>
<h2 id="h2-Principali20disposizioni20del20progetto20di20legge20sulla20gestione20degli20asset20virtuali27205"><a name="Principali disposizioni del progetto di legge sulla gestione degli asset virtuali" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Principali disposizioni del progetto di legge sulla gestione degli asset virtuali</h2><p>Il disegno di legge sugli asset digitali stabilirà varie linee guida operative per i fornitori di servizi di asset virtuali e le organizzazioni del settore finanziario.</p>
<p>Per molto tempo Taiwan ha adottato un approccio non interventista e permessivo nella supervisione delle attività criptate nel paese. Principalmente, il paese ha utilizzato il suo <a href="https://www.gate.io/learn/articles/what-is-anti-money-laundering/81" target="_blank">antiriciclaggio</a> (AML) e <a href="https://www.gate.io/learn/articles/what-is-kyc-2/103" target="_blank">conosci-il-tuo-cliente</a> leggi (KYC) per regolare le operazioni di cripto come la negoziazione di asset digitali.</p>
<p>Tuttavia, <a href="https://www.gate.io/blog_detail/1806/ftx-s-collapse-affected-a-wide-cross-section-of-the-crypto-eco" target="_blank">dopo il crollo dello scambio di criptovalute FTX nell’ottobre 2022</a>, c’era la necessità di regolamentare le criptovalute a Taiwan per proteggere i suoi cittadini da individui e organizzazioni fraudolente. Questo è <a href="https://www.gate.io/blog_detail/1804/key-lessons-from-the-collapse-of-ftx-and-the-implosion-of-ftt" target="_blank">perché la caduta di FTX ha influito</a> molti taiwanesi come usavano scambiare criptovalute sulla borsa.</p>
<p>La legge sugli asset digitali prevede che i fornitori di servizi di asset virtuali (VASP) devono ottenere una licenza prima di operare nel paese. Coloro che già offrono i loro servizi devono richiedere le licenze entro 6 mesi dalla promulgazione della legge sulle criptovalute. I VASP che operano senza autorizzazione pagheranno multe che vanno da TWD 2 milioni (circa $60.000) a TWD 20 milioni ($600.000).</p>
<p>A differenza delle leggi cripto di altri paesi <a href="https://www.gate.io/blog_detail/2191/%E9%A6%99%E6%B8%AF%E5%BC%95%E5%8F%91%E4%B8%9C%E6%96%B9%E5%8A%A0%E5%AF%86%E7%83%AD-%E4%B8%8B%E8%BD%AE%E7%89%9B%E5%B8%82%E7%94%B1%E4%B8%AD%E5%9B%BD%E5%BC%80%E5%90%AF" target="_blank">compresa la Città di Hong Kong</a>, il disegno di legge sulla gestione degli asset virtuali non stabilisce che gli emittenti di stablecoin debbano avere riserve 1.1 per le loro monete. Tuttavia, il regolatore competente ha il diritto di stabilire standard di ratio degli asset. Inoltre, il disegno di legge tace sugli stablecoin algoritmici.</p>
<p>Un’altra disposizione degna di nota della legislazione criptata, se approvata, è che i VASPs dovrebbero segregare le riserve aziendali e i fondi dei clienti per migliorare la trasparenza. Dovrebbero inoltre attuare misure di controllo interno e sistemi di revisione contabile per creare responsabilità che consentano una rendicontazione finanziaria trasparente. Tuttavia, il disegno di legge non prevede la custodia separata.</p>
<p>Inoltre, qualsiasi exchange di criptovalute di Taiwan dovrà presentare relazioni finanziarie periodiche all’agenzia di regolamentazione pertinente. Inoltre, sarà responsabilità della Commissione di Vigilanza Finanziaria (FSC) condurre ispezioni regolari delle loro procedure interne e dei sistemi di audit.</p>
<p>Una disposizione interessante della proposta di regolamentazione delle criptovalute è che tutti i VASP dovrebbero unirsi alle associazioni industriali pertinenti prima di operare nel paese. È importante notare che il consiglio legislativo di Taiwan si aspetta anche che la Commissione di vigilanza finanziaria crei la propria legislazione sulle criptovalute.</p>
<p>Inoltre, la legge non ha regole rigide e veloci sui derivati crittografici. Il motivo è che ciascuna classe di derivati ha caratteristiche uniche. È molto probabile che il paese creerà un quadro normativo specifico per i derivati.</p>
<p>Interessantemente, la proposta di regolamentazione delle criptovalute non impone restrizioni sul trading di asset virtuali. Questo lascia spazio a un gruppo diversificato di investitori per partecipare al mercato degli asset digitali.</p>
<p><a href="https://ppg.ly.gov.tw/ppg/bills/202103224730000/details" rel="nofollow noopener noreferrer" target="_blank">Secondo i documenti ufficiali</a>, il disegno di legge è ora in attesa della seconda lettura nel parlamento legislativo che potrebbe avere luogo all’inizio del 2024.</p>
<p>Attualmente, tuttavia, i VASP e gli investitori di criptovalute dovrebbero attenersi alle linee guida esistenti sulle criptovalute, come le leggi del conosci-il-tuo-cliente e anti-riciclaggio.</p>
<h2 id="h2-Regolamentazione20criptovalutaria20esistente20a20Taiwan62839"><a name="Regolamentazione criptovalutaria esistente a Taiwan" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Regolamentazione criptovalutaria esistente a Taiwan</h2><p>Sebbene abbiamo descritto la proposta di regolamentazione crittografica di Taiwan, il paese ha un quadro normativo esistente basato sulle sue leggi finanziarie. Attualmente, non esiste una legislazione specifica che regoli le criptovalute e altri asset digitali. Tuttavia, tutte le operazioni crittografiche dovrebbero essere conformi alle disposizioni antiriciclaggio (AML).</p>
<p>In passato la Financial Supervisory Commission (FSC) ha chiarito che <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> non era sotto la sua autorità poiché non ha un emittente. Attualmente, questa linea di ragionamento si applica alla maggior parte delle criptovalute. Nel 2013, la Banca Centrale e la FSC hanno dichiarato che gli asset digitali come il <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">bitcoin</a> non erano corso legale nel paese.</p>
<p>Tuttavia, con effetto dal 1 luglio 2021, il paese ha dichiarato che i Regolamenti che disciplinano il riciclaggio di denaro e il contrasto del finanziamento del terrorismo per le imprese che gestiscono piattaforme o transazioni di valute virtuali si applicano anche alle criptovalute e ad altri asset digitali. Ciò significa che tutte le società e le piattaforme che forniscono valute digitali devono attenersi a essi.</p>
<p>Nel 2014 la banca centrale e la FSC hanno fornito maggiori chiarimenti sulle criptovalute. Ad esempio, la FSC ha ordinato a tutte le banche locali di non accettare criptovalute come bitcoin o offrire servizi correlati. Ha inoltre proibito l’uso di carte di credito/debito per effettuare pagamenti per servizi criptati.</p>
<p>Tuttavia, la FSC consente a individui e aziende di comprare e vendere bitcoin che considera una merce virtuale, non una valuta. Secondo l’autorità di regolamentazione, le carte di credito/debito non sono progettate per la gestione del patrimonio e l’investimento di beni altamente leva e a rischio come le criptovalute.</p>
<h2 id="h2-Criptovalute20e20tassazione20a20Taiwan854914"><a name="Criptovalute e tassazione a Taiwan" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Criptovalute e tassazione a Taiwan</h2><p>È importante sottolineare che il paese considera il trading di criptovalute come una vendita di servizi soggetti a tassazione criptata di Taiwan. Pertanto, sia le imprese taiwanesi che gli altri venditori dovrebbero pagare l’IVA sulle entrate generate. Inoltre, le imprese criptate e i venditori criptati taiwanesi dovrebbero richiedere l’iscrizione fiscale.</p>
<p>Oltre all’imposta sul valore aggiunto (IVA), le aziende cripto nel paese devono pagare l’imposta sul reddito. Questo si applica ai trader di cripto. Dovrebbero dichiarare il reddito generato dal trading e versare l’importo corretto dell’imposta sul reddito dovuta.</p>
<p>Leggi anche: <a href="https://www.gate.io/blog_detail/2564/g7-sets-out-strengthen-crypto-regulation" target="_blank">Il G7 si impegna a rafforzare la regolamentazione delle criptovalute</a></p>
<h2 id="h2-Autoregolamentazione20nellindustria20cripto20di20Taiwan815357"><a name="Autoregolamentazione nell’industria cripto di Taiwan" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Autoregolamentazione nell’industria cripto di Taiwan</h2><p>Una pratica esistente importante è l’autoregolamentazione all’interno dell’industria cripto di Taiwan. Un gruppo di importanti scambi di criptovalute nel paese ha formato l’Associazione piattaforma di attività virtuali e business di transazione di Taiwan.</p>
<p>Lo scopo di questo consorzio, che comprende Hoya Bit, Bitgin, Rybit, Maicoin, BitstreetX, Xrex e Shangbito, è quello di lavorare duramente per sostenere l’intero settore crittografico. Collabora anche con le agenzie regolatorie per garantire che ci sia cooperazione e comprensione reciproca.</p>
<h2 id="h2-Come20la20Legge20Influenza20lIndustria20delle20Criptovalute46755"><a name="Come la Legge Influenza l’Industria delle Criptovalute" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Come la Legge Influenza l’Industria delle Criptovalute</h2><p>La principale ragione per cui i legislatori a Taiwan hanno elaborato la regolamentazione degli asset digitali è quella di proteggere i clienti, sostenere le attività cripto e promuovere l’innovazione nel settore della blockchain.</p>
<p>Nel frattempo, il paese vuole beneficiare dell’industria emergente. Pertanto, mira a allineare il suo quadro normativo con il resto del mondo. Facendo ciò, collaborerà con le principali società blockchain e aumenterà gli investimenti in asset digitali.</p>
<p>L’implementazione di <a href="https://www.gate.io/blog_detail/378/how-are-cryptocurrencies-currently-regulated-in-countries-around-the-world" target="_blank">regolamentazione delle criptovalute</a> A Taiwan verrà creato un clima di investimento affidabile che attirerà molti investitori nel settore. Gli investitori e le imprese di criptovalute non considereranno più gli asset digitali come rischiosi e una minaccia per la comunità.</p>
<p>Inoltre, la regolamentazione probabilmente stabilizzerà il mercato degli asset digitali poiché ridurrà i casi di manipolazione di mercato e attività fraudolente. In generale, la legge cripto comporterà l’espansione dell’industria. Inoltre, rafforzerà la fiducia negli scambi di criptovalute, nelle altre aziende blockchain e nel resto del settore.</p>
<p>Leggi anche: <a href="https://www.gate.io/uk/blog_detail/2856/us-crypto-crackdown" target="_blank">Vittoria dell’Asia: la repressione delle criptovalute degli Stati Uniti beneficia l’Asia</a></p>
<h2 id="h2-Possibili20modifiche20nella20regolamentazione20delle20criptovalute20a20Taiwan425687"><a name="Possibili modifiche nella regolamentazione delle criptovalute a Taiwan" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Possibili modifiche nella regolamentazione delle criptovalute a Taiwan</h2><p>Al momento, il quadro normativo delle criptovalute a Taiwan non è ancora completo. Ci sono altre aree che avranno bisogno di miglioramenti in futuro. Ad esempio, la Commissione di Vigilanza Finanziaria (FSC) probabilmente introdurrà le proprie proposte che riguardano aspetti come le criptovalute, le stablecoin e i derivati.</p>
<p>Il paese potrebbe anche incorporare altri aspetti che osserva da altri paesi come gli Stati Uniti e blocchi economici come l’Unione Europea.</p>
<h2 id="h2-Conclusione316636"><a name="Conclusione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusione</h2><p>I legislatori taiwanesi hanno redatto un quadro normativo per la criptovaluta per il paese che è passato alla prima lettura. La prossima lettura è probabile che si svolga nel gennaio 2024. Taiwan ha sempre adottato una posizione morbida sulle attività criptate nel paese, poiché è disposto a vedere l’espansione dell’industria. Se la legge sulla gestione degli asset virtuali viene approvata, molti paesi impareranno dall’approccio proattivo di Taiwan agli asset digitali.</p>
<h2 id="h2-FAQ20su20Crypto20a20Taiwan834397"><a name="FAQ su Crypto a Taiwan" class="reference-link"></a><span class="header-link octicon octicon-link"></span>FAQ su Crypto a Taiwan</h2><h3 id="h3-Il20bitcoin2020accettato20a20Taiwan603859"><a name="Il bitcoin è accettato a Taiwan?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Il bitcoin è accettato a Taiwan?</h3><p>Anche se Taiwan consente alle persone di scambiare bitcoin e altre criptovalute, non è una moneta legale nel paese. Il paese considera il bitcoin come una merce e non una sicurezza. Attualmente, Taiwan sta rivedendo la sua normativa sulle criptovalute dopo aver introdotto il disegno di legge sulla gestione degli asset virtuali nel Yuan legislativo.</p>
<h3 id="h3-Come20comprare20bitcoin20a20Taiwan618224"><a name="Come comprare bitcoin a Taiwan?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Come comprare bitcoin a Taiwan?</h3><p>Le persone possono <a href="/how-to-buy/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">acquista Bitcoin</a> in vari scambi di criptovalute come Bit2Me e Paxful. Possono utilizzare Perfect Money, Advcash, SEPA Skrill, Neteller, Payeer e Bonifico Bancario per pagare bitcoin e altre criptovalute.</p>
<h3 id="h3-Come20viene20tassata20la20criptovaluta20a20Taiwan284114"><a name="Come viene tassata la criptovaluta a Taiwan?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Come viene tassata la criptovaluta a Taiwan?</h3><p>Taiwan ha una tassa sul commercio di criptovalute poiché la considera come una vendita di servizi. Le aziende e i venditori di criptovalute dovrebbero pagare l’IVA e l’imposta sul reddito.</p>
<h3 id="h3-Ci20sono20regolamenti20nella20criptovaluta912991"><a name="Ci sono regolamenti nella criptovaluta?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Ci sono regolamenti nella criptovaluta?</h3><p>Attualmente, Taiwan utilizza le sue disposizioni anti-riciclaggio di denaro (AML) per regolare le attività criptate nel paese. Tuttavia, ha recentemente introdotto il Disegno di Legge sulla Gestione degli Asset Virtuali che il Yuan Legislativo esaminerà ulteriormente nel 2024.</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, si intraprenderanno azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div>