TGEgR3JhbiBCcmV0YWduYSBzaSBwcmVwYXJhIGEgcmVnb2xhbWVudGFyZSBsYSBjcmlwdG92YWx1dGEgZG9wbyBpbCBjcm9sbG8gZGkgRlRY

2023-03-08, 08:54

<p><img src="https://gimg2.gateimg.com/image/article/1678265333热点.jpg" alt=""></p>
<h2 id="h2-TL20DR271214"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p>La Gran Bretagna ha annunciato la sua intenzione di introdurre una regolamentazione completa delle criptovalute.</p>
<p>Il crollo di FTX è la principale ragione per cui il Regno Unito intende creare una legislazione criptovalutaria.</p>
<p>La Gran Bretagna potrebbe introdurre una legislazione favorevole alle criptovalute, dato che il suo Primo Ministro Rishi Sunak ritiene che le criptovalute e altri asset digitali abbiano un ruolo chiave nello sviluppo del paese.</p>
<p>La regolamentazione delle criptovalute nel Regno Unito probabilmente coprirà aspetti come prestiti, pubblicità, stablecoin, luoghi di scambio e divulgazione di documenti idonei.</p>
<h2 id="h2-Introduzione185960"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>Ci sono molti paesi che mirano a utilizzare la tecnologia blockchain e i prodotti per sostenere le loro economie in crescita. Questo perché le criptovalute hanno il potenziale per supportare il sistema globale di rimessa dei pagamenti finanziari. Nonostante la loro alta volatilità dei prezzi, le criptovalute fanno parte di una classe di asset emergente che è popolare tra la generazione più giovane.</p>
<p>Tuttavia, la mancanza di regolamentazione ha portato a pratiche scorrette nel settore. A tal fine, molti paesi, tra cui la Gran Bretagna, sono pronti a introdurre leggi che regolano tali asset digitali. Il Regno Unito ha già ufficialmente creato un piano per regolamentare l’industria delle criptovalute per frenare alcune pratiche commerciali sconsiderate emerse nel corso del 2022 che hanno contribuito alla scomparsa di FTX.</p>
<p><img src="https://gimg2.gateimg.com/image/article/167826539410901678265158_.pic.jpg" alt=""><br>Il Regno Unito introdurrà regolamentazioni sulle criptovalute - Coinpedia</p>
<h2 id="h2-Perch20il20Regno20Unito20mira20a20regolamentare20lindustria20delle20criptovalute573785"><a name="Perché il Regno Unito mira a regolamentare l’industria delle criptovalute?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Perché il Regno Unito mira a regolamentare l’industria delle criptovalute?</h2><p>La Gran Bretagna ha elaborato un piano <a href="https://www.gate.io/hot_news/detail/141/united-kingdom-crypto-regulation-and-adoption" target="_blank">introdurre la regolamentazione criptata nel Regno Unito con l’intenzione principale</a> di proteggere i consumatori dalle pratiche scorrette che si verificano nel settore. L’introduzione della regolamentazione delle criptovalute in Gran Bretagna e in altri paesi, incluso gli Stati Uniti, fornirà chiarezza agli utenti di criptovalute in questi paesi. Ciò probabilmente aumenterà l’adozione delle criptovalute da parte degli investitori avversi al rischio.</p>
<p>Il paese intende creare un’agenzia che autorizzerà le organizzazioni cripto che operano nel Regno Unito o che vogliono servire i suoi cittadini. L’approccio della Gran Bretagna alla regolamentazione cripto deriva dall’alto livello di volatilità delle criptovalute, da alcune vulnerabilità strutturali di alcuni modelli di business cripto e dai recenti fallimenti come il crollo di FTX.</p>
<p>Risposta del Regno Unito <a href="https://www.gate.io/blog_detail/1806/FTX-s-collapse--Affected-a-Wide-Cross-section-of-the-Crypto-Eco-" target="_blank">il crollo di FTX è ragionevole</a> e si allinea alla sua responsabilità giudiziaria dal momento che milioni di persone, tra cui i suoi residenti, hanno perso miliardi di dollari a causa di quell’incidente criptato. In particolare, l’implosione di FTX è stata un chiaro monito per molti governi affinché introducano una legislazione adeguata che regoli il settore.</p>
<p>La triste realtà del settore delle criptovalute è che il crollo di un’importante impresa criptata ha effetti a catena sull’intera industria, influenzando gli investitori individuali e le istituzioni. Ad esempio, l’implosione di FTX ha portato al crollo di altre organizzazioni criptate come BlockFi e la piattaforma di prestiti Genesis.</p>
<p>Detto questo, possiamo riassumere il focus della regolamentazione delle criptovalute in Gran Bretagna utilizzando le parole di Andrew Griffith, Segretario Economico del Tesoro. Lui <a href="https://www.gov.uk/government/news/uk-sets-out-plans-to-regulate-crypto-and-protect-consumers" rel="nofollow noopener noreferrer" target="_blank">detto</a>, “Restiamo fermamente impegnati nel nostro impegno di far crescere l’economia e di consentire il cambiamento tecnologico e l’innovazione - e ciò include la tecnologia delle criptoasset.”</p>
<p>“Ma dobbiamo anche proteggere i consumatori che stanno abbracciando questa nuova tecnologia - garantendo standard robusti, trasparenti e equi.”</p>
<p><img src="https://gimg2.gateimg.com/image/article/167826549410911678265168_.pic.jpg" alt=""><br>Il crollo di FTX ha agito come catalizzatore per l’introduzione delle leggi criptate in Gran Bretagna - Theguardian</p>
<h2 id="h2-Il20quadro20proposto20della20regolamentazione20delle20criptovalute20in20Gran20Bretagna777728"><a name="Il quadro proposto della regolamentazione delle criptovalute in Gran Bretagna" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Il quadro proposto della regolamentazione delle criptovalute in Gran Bretagna</h2><p>In senso generale, la vigilanza dell’industria cripto nel Regno Unito si concentrerà su varie aree chiave come il prestito, la pubblicità, la divulgazione dei documenti chiave e il ruolo degli intermediari nel settore.</p>
<p>Intermediari: Parte della regolamentazione mira agli intermediari e ad altri custodi che conservano asset digitali.</p>
<p>Prestiti: Il governo del Regno Unito intende elaborare una legislazione chiara che regoli le istituzioni e i servizi di prestito di criptovalute. Attualmente, ci sono molte piattaforme che offrono prestiti rischiosi al pubblico. Per ridurre i rischi che esistono nel settore del prestito decentralizzato, la Gran Bretagna adotterà rigorose normative per proteggere i consumatori e rafforzare la resilienza operativa delle società di prestito.</p>
<p>Inoltre, tutte le istituzioni di credito saranno tenute a disporre di sufficienti risorse finanziarie e di termini contrattuali chiari che garantiranno che non crolleranno come BlockFi, <a href="/price/celsius-network-cel" rel="nofollow noopener noreferrer" target="_blank">Celsius Network</a> e Voyager Digital lo ha fatto.</p>
<p>Divulgazione dei documenti: L’altro obiettivo della legislazione è migliorare la trasparenza da parte degli scambi e <a href="https://www.gate.io/blog_detail/1038/everything-you-need-to-know-about-defi" target="_blank">altri giocatori DeFi</a>. Ad esempio, le borse criptovalute saranno tenute a divulgare alcuni documenti importanti che aiuteranno il pubblico a prendere decisioni di investimento informate. Il governo stabilirà anche termini rigorosi e chiari per il trading di asset digitali.</p>
<p>Pubblicità: un’area in cui il governo del Regno Unito introdurrà un atto legislativo è la promozione delle criptovalute e delle attività correlate. Nel gennaio 2022, la Gran Bretagna ha promesso di reprimere le pubblicità ingannevoli sulle criptovalute con l’obiettivo di proteggere i consumatori.</p>
<p>Tuttavia, nella sua recente comunicazione, il governo del Regno Unito ha permesso alle società cripto, registrate presso la FCA per scopi di antiriciclaggio, di diffondere le loro pubblicità cripto fino all’approvazione e all’implementazione delle normative proposte.</p>
<p>Leggi anche: <a href="https://www.gate.io/es/blog_detail/1689/the-sec-took-action-against-kim-kardashian-for-endorsing-ethereum-max-emax.?lang=en" target="_blank">La SEC ha preso provvedimenti contro Kim Kardashian per aver sponsorizzato Ethereum max EMAX</a></p>
<p>Registrazione delle società cripto: Inoltre, il governo richiederà a tutte le società cripto che desiderano operare nel paese di registrarsi e seguire le normative stabilite dall’Autorità di condotta finanziaria. Dovrebbero inoltre rispettare le norme anti-criminalità finanziaria del paese.</p>
<p>Altre normative: Non abbiamo coperto tutti gli aspetti che la Gran Bretagna intende includere nella sua regolamentazione. Ad esempio, la regolamentazione coprirà anche il trading di asset digitali e stablecoin, tra gli altri.</p>
<h2 id="h2-Il20motivo20per20cui20il20Regno20Unito20creer20una20legislazione20favorevole20alle20criptovalute880055"><a name="Il motivo per cui il Regno Unito creerà una legislazione favorevole alle criptovalute" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Il motivo per cui il Regno Unito creerà una legislazione favorevole alle criptovalute</h2><p>Dall’inizio di <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> nel 2009 e la successiva diffusione degli asset digitali molte persone hanno temuto l’introduzione di una legislazione crittografica ostile. Tuttavia, questo non dovrebbe preoccupare i cittadini britannici perché il loro Primo Ministro, Rishi Sunak, è un <a href="https://www.gate.io/es/blog_detail/1699/daily-news-bitcoin-and-ether-may-be-rising-now-but-be-wary-of-volatility-once-wall-street-wakes-up?lang=en" target="_blank">leader amichevole alle criptovalute</a>.</p>
<p>Sunak ha mostrato il suo interesse per le criptovalute quando era ancora Ministro delle Finanze nel 2022. Ad esempio, nell’aprile di quell’anno il governo ha annunciato l’intenzione di fare del Regno Unito un centro delle criptovalute. Inoltre, Sunak ha fatto pressioni per l’introduzione di regole appropriate sulle criptovalute e altri beni digitali. Ciò perché credeva che una regolamentazione amichevole delle criptovalute avrebbe attirato investitori nel paese.</p>
<p><img src="https://gimg2.gateimg.com/image/article/167826561310921678265179_.pic.jpg" alt=""><br>Rishi Sunak, primo ministro del Regno Unito- Independentcouk</p>
<p>Prima di ciò, nel 2021 Sunak ha chiesto al governo di introdurre una valuta digitale della banca centrale <a href="https://www.gate.io/learn/articles/what-are-central-bank-digital-currencies/363" target="_blank">CBDC</a>), che sarebbe chiamata Britcoin. Pertanto, l’esperienza di Sunak nel settore finanziario, degli investimenti e delle criptovalute ci dà un’indicazione sulla posizione della Gran Bretagna nei confronti della regolamentazione dell’industria delle criptovalute.</p>
<h2 id="h2-Conclusion104944"><a name="Conclusion" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusion</h2><p>L’incidente FTX e la regolamentazione criptata del Regno Unito sono strettamente collegati. Ciò perché l’implosione di FTX ha agito come catalizzatore per la proposta di legislazione criptata nel Regno Unito. In generale, l’obiettivo principale della regolamentazione criptata britannica è proteggere i consumatori e attrarre investimenti sostenibili nel settore.</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 venga citato Gate.io. In tutti i casi, saranno adottate azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div>