UHJvZ2V0dGFyZSBpbCBmdXR1cm86IHVuYSBzdHJhdGVnaWEgcGVyIHJlZ29sYW1lbnRhcmUgZ2xpIHN0YWJsZWNvaW4gbmVnbGkgU3RhdGkgVW5pdGk=

2024-05-22, 02:32

<p><img src="https://gimg2.gateimg.com/image/article/1692587449analysis.jpeg" alt=""></p>
<h2 id="h2-TL20DR933597"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p>Hilary Allen, un professore di legge presso l’Università Americana, sta chiedendo il divieto delle stablecoin mentre Marcelo M. Prates, un esperto di politica finanziaria e regolamentare, sta promuovendo l’introduzione di una adeguata legge federale sulla criptovaluta.</p>
<p>I tre pilastri di una legge federale sulla stablecoin sono la protezione del fallimento degli asset di backup, l’emissione di licenze non bancarie e l’accesso diretto ai conti delle banche centrali.</p>
<p>Le stablecoin dovrebbero integrare i servizi finanziari tradizionali anziché competere con le banche.</p>
<h2 id="h2-Introduzione467672"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>Diversi analisti di spicco, tra cui Jeremy Allaire, CEO di Circle, ritengono che gli Stati Uniti possano approvare la regolamentazione delle criptovalute stabili quest’anno, nel 2024, il che potrebbe determinare il futuro dei pagamenti digitali. Già è in fase di valutazione una proposta di legge per le criptovalute stabili, il Clarity for Payment Stablecoins Act del 2023.</p>
<p>Tuttavia, ciò che potrebbe bloccare la valutazione e l’approvazione della regolamentazione delle stablecoin potrebbe essere il Presidente degli Stati Uniti. <a href="https://www.gate.io/blog_detail/4135/as-the-us-presidential-election-approaches-is-trump-meme-becoming-a-best-loved-meme" target="_blank">elezioni previste per il 5 novembre</a> Lo scopo di questo articolo è esplorare i progressi compiuti dagli Stati Uniti verso il lancio di un quadro giuridico per le stablecoin.</p>
<h2 id="h2-Dibattito20sulla20regolamentazione20delle20stablecoin20negli20Stati20Uniti20Marcelo20Prates20vs20Hilary20Allen453099"><a name="Dibattito sulla regolamentazione delle stablecoin negli Stati Uniti: Marcelo Prates vs. Hilary Allen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Dibattito sulla regolamentazione delle stablecoin negli Stati Uniti: Marcelo Prates vs. Hilary Allen</h2><p>I punti di vista di Hilary Allen, professore di diritto presso l’Università Americana, e Marcelo M. Prates, esperto di politiche finanziarie e regolamentari, riguardo alle normative criptate mostrano la divisione all’interno della nostra società globale riguardante gli asset digitali.</p>
<p>Ad esempio, <a href="https://go.skimresources.com/?id=100652X1574425&amp;isjs=1&amp;jv=15.5.0&amp;sref=https%3A%2F%2Fwww.coindesk.com%2Fopinion%2F2024%2F05%2F09%2Fhow-the-us-should-regulate-stablecoins%2F&amp;url=https%3A%2F%2Fpodcasts.apple.com%2Fus%2Fpodcast%2Fbanking-with-interest%2Fid1506774121%3Fi%3D1000654155074&amp;xs=1&amp;xtz=-120&amp;xuuid=c2b55452016114d2809ff4aae8fbc6b2&amp;xjsf=other_click__auxclick%20%5B2%5D" rel="nofollow noopener noreferrer" target="_blank">Hilary Allen ritiene che le stablecoin rappresentino una minaccia per il settore bancario</a> e quindi dovrebbe essere vietato. Allen ritiene che una maggiore adozione di stablecoin probabilmente porterà alla destabilizzazione delle banche al punto che avranno bisogno di un salvataggio governativo.</p>
<p>I commenti di Allen sono arrivati in seguito a un nuovo tentativo del Congresso degli Stati Uniti di introdurre leggi sulle stablecoin a livello federale che determineranno il futuro dei pagamenti digitali. Anche se potrebbe richiedere più tempo al Congresso per approvare il nuovo disegno di legge, Allen ritiene che tale posizione dia al pubblico il tempo di sostenere la proposta regolamentazione delle criptovalute. In sostanza, ritiene che “le stablecoin non servano a uno scopo importante e francamente dovrebbero essere semplicemente vietate.”</p>
<p>D’altra parte, Marcelo M. Prates ritiene che le stablecoin siano importanti nell’economia poiché promuovono l’inclusione finanziaria, sono convenienti e migliorano la competitività nel sistema economico finanziario globale.</p>
<p>Per rendere chiara la sua opinione, ha usato come esempio lo sviluppo di <a href="https://www.gate.io/price/e-money-eur-eeur" target="_blank">e-money nell’Unione Europea</a>. Secondo Prates, il denaro elettronico (e-money) è stata una delle più grandi innovazioni negli ultimi 25 anni. Fondamentalmente, l’e-money è la versione di denaro emessa da istituzioni non bancarie <a href="https://www.gate.io/hot_news/detail/88/what-you-need-to-know-when-buying-bitcoin-with-paypal" target="_blank">come PayPal</a>. Ora, gli esperti classificano le criptovalute come denaro elettronico in quanto non sono emessi dalle banche. Tuttavia, affinché possano funzionare correttamente, potrebbero richiedere una regolamentazione chiara.</p>
<p>Un buon esempio è quello dell’Unione europea che ha ideato l’uso del denaro elettronico dal 2000. L’UE ha ritenuto essenziale avere del denaro elettronico in quanto facilita pagamenti più economici e un facile accesso. Inoltre, rende i pagamenti più veloci in tutto il mondo. Con quella visione, l’UE ha sviluppato una regolamentazione finanziaria per il denaro elettronico. Di conseguenza, sono nate le società FinTech che forniscono strumenti di pagamento sicuri e regolamentati.</p>
<p>La ragione per cui l’UE ha permesso l’uso delle e-money era quella di aumentare l’inclusione finanziaria attraverso mezzi semplificati di invio e ricezione di denaro. Ciò perché questi trasmettitori di e-money non richiedono ai loro clienti di sottoporsi a procedure complesse quando inviano o ricevono denaro. Inoltre, i servizi di e-money presentano meno rischi e complicazioni rispetto alle banche. Ad esempio, aprire un conto bancario per effettuare trasferimenti di denaro elettronico richiede molto tempo e il processo è complicato.</p>
<p>Al contrario, ci vuole poco tempo e sforzo per inviare denaro utilizzando servizi finanziari non bancari come PayPal. Con l’e-money, le istituzioni responsabili semplicemente ricevono denaro fiat dai clienti e lo convertono in denaro digitale che possono utilizzare per effettuare pagamenti virtuali utilizzando carte di credito o debito, tra gli altri metodi. Alla fine, l’e-money può essere facilmente convertito in contanti.</p>
<p>Pertanto, Prates ritiene che <a href="https://www.gate.io/learn/articles/what-is-stablecoin/40" target="_blank">le stablecoin funzionano</a> come moneta elettronica che esiste da decenni ed è stata utilizzata in modo sicuro per promuovere un vivace sistema di pagamento globale. In termini semplici, quindi, la maggior parte, se non tutti quelli esistenti <a href="https://www.gate.io/learn/articles/what-are-the-main-stablecoins/99" target="_blank">stablecoin supportata da valuta fiat</a> come USDT e <a href="https://www.gate.io/learn/articles/what-is-usdc/113" target="_blank">USDC</a> sono una forma di denaro elettronico.</p>
<p>Pertanto, il principale argomento a favore delle stablecoin supportate da valute fiat è che sono “e-money 2.0” che può agevolmente facilitare le transazioni finanziarie proprio come l’e-money finanziario tradizionale. Tuttavia, Prates suggerisce che il governo federale degli Stati Uniti dovrebbe stabilire tre pilastri di regolamentazione delle stablecoin, ovvero la protezione della bancarotta degli asset di backup, l’emissione di licenze non bancarie e l’accesso diretto ai conti della banca centrale che dovrebbero promuovere l’inclusione finanziaria e i sistemi di pagamento delle stablecoin. Un tale quadro normativo consentirà ai fornitori di stablecoin di operare in un ambiente finanziario regolamentato a basso rischio.</p>
<p>Leggi anche: <a href="https://www.gate.io/learn/articles/lst-backed-stablecoins-a-new-frontier-in-defi-innovation-and-opportunity/2200" target="_blank">Stablecoin supportate da LST: una nuova frontiera in DeFi</a></p>
<h2 id="h2-Pilastri20di20una20regolamentazione20efficace20delle20stablecoin957669"><a name="Pilastri di una regolamentazione efficace delle stablecoin" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Pilastri di una regolamentazione efficace delle stablecoin</h2><p>Come suggerito in precedenza, i tre pilastri di una regolamentazione efficace delle stablecoin sono la protezione da fallimento degli asset di backup, l’emissione di licenze non bancarie e l’accesso diretto ai conti della banca centrale. Tuttavia, Prates sostiene che sia necessaria una regolamentazione federale della blockchain anziché leggi sul trasferimento di denaro a livello statale che non sono uniformemente concepite ed applicate.</p>
<p>Concessione di una licenza non bancaria: il governo dovrebbe concedere licenze agli emittenti di stablecoin che devono mantenere riserve liquide sufficienti per le loro stablecoin. Il ruolo degli emittenti di stablecoin è quello di ottenere denaro dai loro clienti, trattenerlo e emettere asset digitali che sono commisurati all’importo di denaro ricevuto e detenuto. Poiché non concedono prestiti, c’è la necessità di sicurezza delle valute digitali attraverso il possesso di riserve al 100%.</p>
<p>Una volta che i fornitori di stablecoin mantengono sempre le riserve, possono svolgere altre funzioni. Ad esempio, possono promuovere i pagamenti transfrontalieri e l’emissione di stablecoin mentre la domanda delle monete aumenta. Rispettando la legislazione federale sulle stablecoin e proteggendo gli utenti delle stablecoin, manterranno una reputazione elevata che crea fiducia nel mercato delle criptovalute. In primo luogo, la regolamentazione delle criptovalute dovrebbe migliorare la stabilità del mercato delle stablecoin.</p>
<p>È anche importante notare che le e-monete e gli asset digitali non sono destinati a competere con le banche nella fornitura di trasferimenti finanziari internazionali. Pertanto, le banche centrali e le stablecoin dovrebbero integrarsi a vicenda. Di conseguenza, agli emittenti di stablecoin negli Stati Uniti dovrebbero essere rilasciate licenze non bancarie simili a quanto è stato fatto nell’UE, nel Regno Unito e in Brasile per i fornitori di e-monete nelle rispettive giurisdizioni.</p>
<p>Conti della Banca Centrale per gli Asset di Garanzia: Per aumentare la trasparenza e ridurre il profilo di rischio degli emittenti di stablecoin, dovrebbero mantenere le loro riserve presso la banca centrale. In questo modo, trasferiranno il loro denaro contante ai conti della banca centrale o investiranno in strumenti a basso rischio a breve termine come le opzioni. Pertanto, il modo più sicuro per ridurre i rischi associati agli asset di riserva è mantenerli presso la Federal Reserve.</p>
<p>Separazione e protezione dei fondi dei clienti: Una cosa essenziale che gli emittenti di stablecoin devono fare per proteggere gli utenti di stablecoin è quella di segregare i fondi dei clienti dai fondi dell’azienda. Ciò significa che se la stablecoin fallisce, l’azienda non dovrà dichiarare fallimento. Inoltre, in caso di liquidazione, i clienti possono rapidamente ottenere i loro fondi. Ciò perché i creditori dell’emittente fallito non saranno in grado di sequestrare i soldi dei clienti.</p>
<p>Leggi anche: <a href="https://www.gate.io/learn/articles/an-overview-of-the-global-regulatory-landscape-for-virtual-assets/1043" target="_blank">Una panoramica del panorama regolamentare globale</a></p>
<h2 id="h2-Regolamentazione20dellemoneta20nellUE20e20negli20USA928258"><a name="Regolamentazione dell’e-moneta nell’UE e negli USA" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Regolamentazione dell’e-moneta nell’UE e negli USA</h2><p>Sia l’Unione Europea che gli Stati Uniti stanno ultimando le loro regolamentazioni sulle stablecoin. L’UE ha MiCA, parte del pacchetto di finanza digitale mirato a promuovere l’uso di tecnologie innovative come la blockchain e le stablecoin. MiCA fornisce un quadro normativo chiaro che contiene dettagli sulla natura delle stablecoin e sulle responsabilità degli emittenti di moneta elettronica.</p>
<p>D’altra parte, gli Stati Uniti hanno una proposta di legge denominata Clarity for Payment stablecoins Act. Se approvata dal Congresso, la legislazione fornirà linee guida più chiare sulle operazioni degli stablecoin. Ad esempio, tutti i emittenti di stablecoin saranno tenuti a registrarsi presso le autorità competenti. Inoltre, saranno soggetti a regolamentazione simile a quella bancaria che richiede loro di mantenere riserve sufficienti. In modo simile, i regolatori statali come il Federal Reserve Board (FRB) faranno rispettare la legge e li supervisioneranno.</p>
<h2 id="h2-Conclusion363096"><a name="Conclusion" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusion</h2><p>Gli Stati Uniti e l’UE stanno ultimando le loro leggi sulle stablecoin. Mentre l’UE ha MiCA, gli Stati Uniti hanno un disegno di legge che il Congresso deve ancora approvare, il Clarity for Payment stablecoins Act. Marcelo M. Prates, esperto di politiche finanziarie e regolamentari, ha stabilito che la migliore legge federale sulle stablecoin dovrebbe avere tre pilastri: protezione del fallimento degli asset di backup, rilascio di licenze non bancarie e accesso diretto ai conti della banca centrale.</p>
<div class="blog-details-info"><br><div>Autore:<em> Mashell C.</em>, 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 ripostare l'articolo a condizione che si faccia riferimento a Gate.io. In tutti i casi, saranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div>