SWwgRzcgc2kgaW1wZWduYSBhIHJhZmZvcnphcmUgbGUgcmVnb2xhbWVudGF6aW9uaSBjcmlwdGF0ZQ==

2023-05-06, 01:25

<p><img src="https://gimg2.gateimg.com/image/article/1682586049RDZZ.jpeg" alt=""><br>I paesi del G7 e l’Unione Europea stanno lavorando a una strategia cooperativa globale per gli asset digitali che sarà svelata nel maggio 2023.</p>
<p>Il Canada e il Giappone sono esempi di paesi che hanno regolamenti favorevoli alle criptovalute.</p>
<p>Il Regno Unito sta pianificando di introdurre una categoria fiscale per le criptovalute nei moduli di dichiarazione dei redditi per il periodo 2024-2025.</p>
<p>BIS, FSB e FMI sono organizzazioni internazionali che mirano a introdurre standard per gli asset digitali.</p>
<p><strong>Parole chiave</strong>: Tasse cripto, regolamentazione cripto, asset cripto, valuta digitale, asset digitali, legge sulla criptovaluta, FMI, FSB, BIS, MiCA</p>
<h2 id="h2-Introduzione372953"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>Le implosioni di diversi progetti cripto come <a href="/price/terra-luna" rel="nofollow noopener noreferrer" target="_blank">Terra</a> LUNA e FTX hanno allertato i governi nazionali sulla necessità di creare e applicare legislazioni che proteggano i loro cittadini da simili incidenti futuri nel settore. Oltre ai governi nazionali, ci sono organizzazioni internazionali come il Fondo Monetario Internazionale (FMI) che stanno guidando nella creazione di una legislazione crittografica standard che i loro Stati membri possono adottare. Oggi ci concentriamo su come il Gruppo dei Sette maggiori paesi industrializzati (G7) mira a regolamentare il settore crittografico.</p>
<h2 id="h2-Il20ruolo20del20G720nella20regolamentazione20delle20criptovalute45035"><a name="Il ruolo del G7 nella regolamentazione delle criptovalute" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Il ruolo del G7 nella regolamentazione delle criptovalute</h2><p>Il gruppo dei sette paesi industrializzati, composto da Gran Bretagna, Germania, Italia, Giappone, Canada, Francia e Stati Uniti, sta lavorando a un quadro di normative criptografiche con l’obiettivo di migliorare la protezione dei consumatori e la trasparenza.</p>
<p>Il suo obiettivo principale è quello di ridurre o prevenire i potenziali rischi che le criptovalute hanno sul sistema finanziario globale. In generale, le autorità di regolamentazione vogliono affrontare la scarsa governance che dilaga nel settore delle criptovalute. Questi paesi ritengono che il crollo dei giganti delle criptovalute FTX e <a href="/price/terra-luna" rel="nofollow noopener noreferrer" target="_blank">Terra</a> Luna sono il risultato di una cattiva governance.</p>
<p>La mossa di G7 e dell’Unione europea arriva alcuni mesi dopo il collasso delle tre banche degli Stati Uniti, Signature Bank, Silvergate Bank e Silicon Valley Bank, che offrivano servizi cripto a istituzioni e individui.</p>
<p>In particolare, alcuni membri del G7 come il Canada hanno regolamenti cripto esistenti. Tuttavia, il G7 e l’Unione europea stanno elaborando una strategia cooperativa globale per gli asset digitali che dovrebbe essere presentata a maggio 2023.<br><img src="https://gimg2.gateimg.com/image/article/16833362071.png" alt=""><br>Gli Stati membri dell’Unione europea - BBC</p>
<h2 id="h2-Regolamentazione20delle20criptovalute20in20Giappone218374"><a name="Regolamentazione delle criptovalute in Giappone" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Regolamentazione delle criptovalute in Giappone</h2><p>Dopo il crollo di Mt Gox, un exchange di criptovalute giapponese, il Giappone ha introdotto misure per proteggere i consumatori dai rischi legati alle criptovalute. Parte della legislazione giapponese consente a individui e organizzazioni di segnalare qualsiasi transazione criptata sospetta.</p>
<p>Inoltre, gli utenti di crittografia dovrebbero rispettare la legge sulle valute estere e sul commercio estero, che prevede che chiunque o qualsiasi organizzazione che voglia effettuare una transazione crittografica con un valore di 30 milioni di JPY o più deve notificare il Ministero delle Finanze.</p>
<p>Curiosamente, i regolatori permettono alle persone di comprare e vendere criptovalute su scambi di criptovalute. Il Giappone ha anche regole chiare sulle procedure di Antiriciclaggio (AML) e una politica fiscale che si applica a beni digitali come criptovalute.</p>
<p>In generale, l’Agenzia dei servizi finanziari giapponese (FSA) collabora con l’Associazione giapponese degli scambi di valuta virtuale (JVCEA) e l’Associazione giapponese per l’offerta di token di sicurezza (JSTOA) per regolare le criptovalute.</p>
<h2 id="h2-Regolamentazione20delle20criptovalute20in20Canada433034"><a name="Regolamentazione delle criptovalute in Canada" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Regolamentazione delle criptovalute in Canada</h2><p>Il Canada è un altro paese che ha una legislazione funzionale che si applica al settore delle criptovalute. In effetti, è uno dei paesi con regole cripto ben definite. Ad esempio, ha regole di divulgazione chiare per tutte le aziende o progetti che si occupano di criptovalute.</p>
<p>Inoltre, la Canadian Securities Administrators (CSA), un organo statutario, richiede che tutte le attività crypto si registrino presso di essa. È importante comprendere che il paese tratta le criptovalute come titoli. Pertanto, le autorità provinciali e regionali assicurano che le entità che gestiscono asset digitali rispettino queste leggi.</p>
<p>Anche se agli scambi di criptovalute è consentito operare nel paese, è richiesto che si registrino presso l’autorità di regolamentazione canadese competente. In modo significativo, le leggi fiscali canadesi trattano le criptovalute come materie prime come l’oro e il petrolio.</p>
<h2 id="h2-Sviluppi20normativi20sulla20crittografia20nel20Regno20Unito20e20nellUnione20Europea987343"><a name="Sviluppi normativi sulla crittografia nel Regno Unito e nell’Unione Europea" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Sviluppi normativi sulla crittografia nel Regno Unito e nell’Unione Europea</h2><p>Altri paesi e organizzazioni regionali come l’Unione Europea stanno elaborando anche loro regolamenti sulle criptovalute. Ad esempio, il Regno Unito sta introducendo una categoria separata di tasse sulle criptovalute nei moduli di dichiarazione dei redditi per il periodo 2024-2025. Ciò dimostra la sua preparazione a incorporare le criptovalute nei suoi requisiti di bilancio.<br><img src="https://gimg2.gateimg.com/image/article/16833362352.png" alt=""><br>Regolamentazione cripto nel Regno Unito - Coingpedia</p>
<p>Inoltre, un rapporto pubblicato dal Tesoro del Regno Unito <a href="https://www.gov.uk/government/publications/spring-budget-2023/spring-budget-2023-html#cost-of-living-and-public-services" rel="nofollow noopener noreferrer" target="_blank">annuncia</a> una modifica dei moduli di autovalutazione per gli asset crittografici. Pertanto, le criptovalute appariranno nella sezione delle spese e dei ricavi del bilancio nazionale per il periodo 2025-2026.</p>
<p>Il Chartered Institute of Taxation (CIOT) ha apprezzato le modifiche al sistema fiscale e al bilancio nazionale che tengono in considerazione gli asset digitali come le criptovalute. <a href="https://www.tax.org.uk/crypto-assets-changes-to-tax-return-welcomed" rel="nofollow noopener noreferrer" target="_blank">Si dice</a>“Sottolineare la necessità di dichiarare le transazioni di asset cripto nella dichiarazione dei redditi contribuirà a aumentare la consapevolezza degli obblighi delle persone in questo settore.”</p>
<p>In uno sviluppo correlato, l’Unione Europea <a href="https://www.gate.io/learn/articles/what-is-markets-in-crypto-assets/459 &quot;Markets in Crypto-Assets (MiCA" rel="nofollow noopener noreferrer" target="_blank">Mercati delle cripto-attività (MiCA)</a> La regolamentazione della criptovaluta entrerà in vigore nel 2024. In effetti, i legislatori dell’UE hanno elaborato e approvato un insieme di regolamenti sulla criptovaluta chiamato Markets in Crypto Act (MiCA) che mira a ridurre e mitigare i rischi della criptovaluta che possono influire sui consumatori e rendere i fornitori di servizi digitali responsabili della perdita di asset criptati degli investitori.</p>
<p>Il set di regole <a href="https://www.europarl.europa.eu/news/en/press-room/20230414IPR80133/crypto-assets-green-light-to-new-rules-for-tracing-transfers-in-the-eu" rel="nofollow noopener noreferrer" target="_blank">imporre requisiti su diverse entità</a> come gli emittenti di token e le piattaforme crypto. Sottolineano la necessità di “divulgazione, autorizzazione e supervisione delle transazioni.”</p>
<p>Altre organizzazioni che stanno lavorando per standardizzare le regole e i regolamenti sulle criptovalute sono il Financial Stability Board (FSB), il Fondo Monetario Internazionale (FMI) e la Banca dei Regolamenti Internazionali (BRI). Questi organismi presenteranno quadri regolatori ai paesi o ai blocchi regionali interessati.</p>
<p>I previsti quadri normativi copriranno le attività degli asset crittografici, i mercati e la supervisione delle varie entità e l’applicazione delle leggi. Ad esempio, il FMI sta spingendo gli Stati membri a respingere l’accettazione delle criptovalute come corso legale.</p>
<h2 id="h2-Previsioni20per20le20regolamentazioni20criptovalutarie20per20il2020232024776713"><a name="Previsioni per le regolamentazioni criptovalutarie per il 2023-2024" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Previsioni per le regolamentazioni criptovalutarie per il 2023-2024</h2><p>Prevediamo che diversi paesi e organismi internazionali introdurranno leggi sulle criptovalute nel 2023 e nel 2024. Ad esempio, le leggi sulle criptovalute diventeranno più rigorose a causa dell’effetto del crollo di FTX.</p>
<p>Diverse organizzazioni internazionali come il FMI e l’Organizzazione internazionale delle commissioni di valore (IOSCO) probabilmente stileranno le loro normative. Ancora una volta, molti paesi allineeranno le loro leggi finanziarie esistenti o creeranno nuovi quadri legali per governare le attività delle imprese criptovalutarie sotto la loro giurisdizione.</p>
<h2 id="h2-Conclusion413771"><a name="Conclusion" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusion</h2><p>Il G7 e l’Unione europea stanno lavorando su proposte di regolamentazione delle criptovalute che probabilmente saranno adottate tra il 2023 e il 2025. Già diversi paesi come il Canada e il Giappone hanno regole chiare che controllano le attività criptovalutarie. FSB, FMI e BIS sono altre organizzazioni internazionali che mirano a stabilire quadri legali standard per le criptovalute.</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. Sarà consentito il ripostaggio dell'articolo a condizione che Gate.io venga citato. In tutti i casi, saranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div>