TnVvdm8gZGlzZWdubyBkaSBsZWdnZSBjcmlwdGF0bzogY29sbGFib3JhemlvbmUgQ0ZUQyAmIFNFQw==

2023-08-03, 09:52

<p><img src="https://gimg2.gateimg.com/image/article/1691056122RDZZ.jpeg" alt=""></p>
<h2 id="h2-TL20DR159212"><a name="TL; DR" class="reference-link"></a><span class="header-link octicon octicon-link"></span>TL; DR</h2><p>Gli enti regolatori degli Stati Uniti hanno introdotto un disegno di legge volto a migliorare la cooperazione tra la CFTC e la SEC.</p>
<p>Un obiettivo chiave del nuovo disegno di legge sugli cripto degli Stati Uniti è sostenere l’innovazione nel settore cripto.</p>
<p>Secondo la proposta di legge cripto degli Stati Uniti, tutte le blockchain si registreranno presso la SEC e la CFTC.</p>
<h2 id="h2-Introduzione929790"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>È chiaro che l’incertezza regolamentare e la mancanza di chiarezza possono soffocare l’innovazione nel settore tecnologico, come dimostrano gli sviluppi negli Stati Uniti. Sembra esserci incoerenza su come venga regolata la criptovaluta dalla SEC. Alla luce di una continua repressione del settore delle criptovalute, i regolatori degli Stati Uniti hanno avviato misure per creare sinergia tra le due principali autorità di regolamentazione, la Commodity Futures Trading Commission (CFTC) e la Securities and Exchange Commission (SEC).</p>
<p>Questa guida discute come i regolatori degli Stati Uniti stanno lavorando duramente per creare chiarezza nel settore delle criptovalute introducendo legislazioni che supportano l’innovazione e lo sviluppo del settore digitale.</p>
<p>Leggi anche: <a href="https://www.gate.io/blog_detail/1689/the-sec-took-action-against-kim-kardashian-for-endorsing-ethereum-max-emax." target="_blank">La SEC ha preso provvedimenti contro Kim Kardashian per aver sponsorizzato Ethereum max EMAX</a></p>
<h2 id="h2-Legge20sullinnovazione20finanziaria20e20tecnologica20per20il20XXI20secolo53369"><a name="Legge sull’innovazione finanziaria e tecnologica per il XXI secolo" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Legge sull’innovazione finanziaria e tecnologica per il XXI secolo</h2><p>I Senior House Republicans degli Stati Uniti hanno introdotto un quadro normativo criptografico che cerca di mappare un modo su come il settore cripto dovrebbe operare nel paese. Infatti, i membri repubblicani dei Comitati per l’agricoltura e i servizi finanziari della Camera dei rappresentanti degli Stati Uniti hanno introdotto il Financial Innovation and Technology for the 21st Century Act il 20 luglio 2023.</p>
<p>Glenn Thompson, presidente della commissione agricola della Camera, e French Hill, presidente della sottocommissione sugli asset digitali, hanno presentato congiuntamente il disegno di legge. Questa proposta di legge cripto arriva dopo anni e mesi di conflitti tra la SEC e i principali attori industriali che includono scambi, progetti cripto, tribunali e regolatori su cosa costituisce titoli e materie prime cripto.</p>
<p>Leggi anche: <a href="https://www.gate.io/blog_detail/2238/do-kwon-reaches-5-star-wanted-level-as-sec-brings-more-fraud-charges" target="_blank">Do Kwon raggiunge il livello di ricerca con 5 stelle mentre la SEC presenta ulteriori accuse di frode</a></p>
<p>Il principale obiettivo del disegno di legge è promuovere la cooperazione e la collaborazione tra i due principali regolatori federali, la Commodity Futures Trading Commission (CFTC) e la Securities and Exchange Commission (SEC), sulla regolamentazione del settore digitale negli Stati Uniti.</p>
<p>Con questo, il disegno di legge sulla regolamentazione delle criptovalute di 212 pagine mira a colmare le lacune regolamentari che esistono nell’industria digitale, in particolare nel settore delle criptovalute. Questo perché affronterà i vari rischi che influiscono sui consumatori e sulle aziende criptovalute. Soprattutto, il suo obiettivo principale è favorire l’innovazione nel settore delle criptovalute negli Stati Uniti.</p>
<p>Il disegno di legge modificherà le leggi esistenti che disciplinano gli asset digitali nel paese. Secondo i regolatori, quando si elaborano le leggi sui titoli valori degli Stati Uniti, la SEC dovrebbe considerare l’innovazione come un fattore critico.</p>
<p>Leggi anche: <a href="https://www.gate.io/blog_detail/2564/g7-sets-out-strengthen-crypto-regulation" target="_blank">Il G7 si propone di rafforzare la regolamentazione delle criptovalute</a></p>
<p>Se approvato, questo disegno di legge aiuterà a chiarire vari aspetti che governano l’industria digitale. Ad esempio, utilizzando il disegno di legge sarà facile classificare gli asset digitali come merci o titoli, creando così un confine chiaro su chi regola gli specifici asset cripto, la CFTC o la SEC.</p>
<p>In base alla legge attuale, la CFTC regola le cripto commodity e i derivati, mentre la SEC supervisiona i titoli di attività digitali. Pertanto, la SEC ha il controllo sulle criptovalute che ritiene essere titoli e sugli scambi su cui vengono negoziate. Tuttavia, la SEC non ha giurisdizione sulle commodity pure e sulle loro piattaforme di trading.</p>
<p>Leggi anche: <a href="https://www.gate.io/blog_detail/1396/the-pros-and-cons-of-crypto-and-blockchain-related-regulation" target="_blank">I pro e i contro della regolamentazione cripto e blockchain</a></p>
<p>La legge creerà anche chiarezza su come le criptovalute e altre piattaforme di trading opereranno. Di conseguenza, verrà specificato come le borse di criptovalute e altre società si registreranno presso la Securities and Exchange Commission degli Stati Uniti (SEC) e la Commodities Futures and Trading Commission (CFTC).</p>
<p>Un’altra cosa importante è che questo pezzo di legge criptata aiuterà i regolatori e altre parti interessate a capire come funziona il settore digitale poiché contiene definizioni di alcuni termini chiave e fornisce linee guida chiare su come i partecipanti al mercato dovrebbero comportarsi.</p>
<p>Ci sarà anche la necessità per le blockchain di registrarsi presso le autorità regolamentari come la SEC e la CFTC. Questo processo consentirà ai regolatori di comprendere come opera ogni progetto cripto e quali requisiti deve soddisfare. Di conseguenza, questi progetti si conformeranno molto probabilmente alle aspettative e agli standard del settore.</p>
<p>Ad esempio, i fornitori di token saranno in grado di conformarsi ai nuovi requisiti che includono la divulgazione delle roadmap, dei codici sorgente e della tokenomica, tra gli altri. Alla fine, varie attività criptovalutarie saranno sottoposte a un controllo regolamentare che riduce i rischi per i consumatori e gli investitori. L’aspetto sottostante è che qualsiasi attività criptovalutaria si registrerà presso le autorità come la CFTC e la SEC dopo aver soddisfatto i requisiti regolamentari.</p>
<p>Il disegno di legge significa anche che la SEC e la CFTC opereranno utilizzando un nuovo manuale che si concentra sull’innovazione e lo sviluppo del settore della blockchain. Leggi anche: <a href="https://www.gate.io/id/blog_detail/2723/sec-allegations-spark-sell-off-and-regulatory-worries-in-cryptocurrency-market" target="_blank">Le accuse della SEC scatenano vendite e preoccupazioni regolamentari nel mercato delle criptovalute</a></p>
<h2 id="h2-Collaborazione20CFTC20e20SEC967593"><a name="Collaborazione CFTC e SEC" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Collaborazione CFTC e SEC</h2><p>Il nuovo progetto di legge proposto dai Repubblicani della Camera punta ad aumentare la collaborazione tra la CFTC e la SEC per creare un settore digitale vibrante. A tal proposito, il rappresentante Dusty Johnson ha dichiarato: “L’industria della criptovaluta desidera chiarezza e il nostro progetto di legge collaborativo dà sia alla CFTC che alla SEC un posto al tavolo”.</p>
<p>Nel contempo, Patrick McHenry ha dichiarato: “Non solo gli asset digitali possono rivoluzionare il nostro sistema finanziario, ma la loro tecnologia blockchain sottostante promette di essere il fondamento per la prossima generazione di internet.”</p>
<h2 id="h2-Conclusione686336"><a name="Conclusione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusione</h2><p>Il disegno di legge proposto dai repubblicani della Camera è progettato per aumentare la cooperazione tra i regolatori finanziari, tra cui la CFTC e la SEC, nonché per promuovere l’innovazione nel settore delle criptovalute. Ciò sarà realizzato attraverso nuove definizioni chiare dei termini chiave e fornendo un manuale operativo per la SEC. Questo sviluppo aumenterà anche il dialogo tra i regolatori e altri portatori di interesse, tra cui gli investitori.</p>
<h2 id="h2-Domande20frequenti20sulla20regolamentazione20delle20criptovalute20negli20Stati20Uniti354243"><a name="Domande frequenti sulla regolamentazione delle criptovalute negli Stati Uniti" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Domande frequenti sulla regolamentazione delle criptovalute negli Stati Uniti</h2><p><strong>Qual è il disegno di legge statunitense sulla regolamentazione delle criptovalute?</strong></p>
<p>Il disegno di legge statunitense sulla regolamentazione delle criptovalute è un insieme di regole e procedure proposte che i regolatori degli Stati Uniti elaborano e presentano per la considerazione. Qualsiasi membro del Congresso degli Stati Uniti, sia della camera che del senato, può presentare un disegno di legge. Infine, il Presidente può approvare o respingere un disegno di legge che è stato approvato dal Congresso.</p>
<p><strong>Qual è il nuovo disegno di legge sulle criptovalute?</strong></p>
<p>Gli Stati Uniti hanno una nuova legge, la Financial Innovation and Technology for the 21st Century Act, presentata dai membri repubblicani dei Comitati per l’Agricoltura e i Servizi Finanziari. Lo scopo della legge è promuovere la collaborazione tra due importanti regolatori federali, la SEC e la CFTC.</p>
<p><strong>Cosa farà la regolamentazione alla criptovaluta?</strong></p>
<p><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> creerà chiarezza sui ruoli dei regolatori (SEC e CFTC) nonché stabilirà procedure per la registrazione dei progetti criptati e la segnalazione. Le normative aiuteranno anche a proteggere i consumatori, gli investitori e le imprese criptate degli Stati Uniti.</p>
<p><strong>Le criptovalute sono regolamentate dalla SEC?</strong></p>
<p>Non esistono pezzi completi di regolamenti che governano il settore delle criptovalute negli Stati Uniti. Tuttavia, i regolatori utilizzano la legislazione finanziaria esistente per governare le attività criptografiche nel paese.</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. La ripubblicazione dell'articolo sarà consentita a condizione che si faccia riferimento a Gate.io. In tutti i casi, verranno intraprese azioni legali a causa della violazione del copyright.<br></div><p></p><br></div></div></div>