RGVjcml0dGFyZSBsYSBjcml0aWNhIGFsbGEgY3JpcHRvdmFsdXRhIGRpIEVsaXphYmV0aCBXYXJyZW4=

2023-12-25, 08:23

<p><img src="https://gimg2.gateimg.com/image/article/1692587449analysis.jpeg" alt=""></p>
<h2 id="h2-TL20DR875071"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p>La legislatrice Elizabeth Warren ha presentato un disegno di legge che potrebbe creare disposizioni rigorose per le attività legate alle criptovalute negli Stati Uniti.</p>
<p>La regolamentazione delle criptovalute aiuta a proteggere i clienti e le aziende cripto da varie pratiche criminali e fraudolente.</p>
<p>Jamie Dimon, CEO di JPMorgan, vuole che il governo bandisca le criptovalute.</p>
<h2 id="h2-Introduzione544736"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>I legislatori in molti paesi del mondo stanno lavorando giorno e notte per sviluppare una regolamentazione adeguata delle criptovalute. Alcune nazioni chiedono una legislazione rigorosa sugli asset digitali, mentre altre adottano posizioni progressive e soft nei loro confronti.</p>
<p>Sebbene gli Stati Uniti siano stati permissivi nei confronti delle criptovalute nel corso degli anni, dal 2023 hanno iniziato a reprimere le attività legate alle criptovalute.</p>
<p>Oggi analizziamo le posizioni di Elizabeth Warren, legislatrice, e Jamie Dimon, CEO di JPMorgan, sulle criptovalute. In generale, entrambi hanno un’opinione simile su come gli Stati Uniti dovrebbero gestire gli asset crittografici.</p>
<p>Leggi anche: ​​ <a href="https://www.gate.io/blog_detail/3215/jp-morgan-deposit-tokens" target="_blank">JP Morgan considera token di deposito basati su blockchain per transazioni più veloci e costi ridotti</a></p>
<h2 id="h2-La20prospettiva20di20Elizabeth20Warren20sulla20criptovaluta583786"><a name="La prospettiva di Elizabeth Warren sulla criptovaluta" class="reference-link"></a><span class="header-link octicon octicon-link"></span>La prospettiva di Elizabeth Warren sulla criptovaluta</h2><p>Elizabeth Warren, una senatrice anti-crypto degli Stati Uniti, ha recentemente affermato che le criptovalute minacciano gli Stati Uniti. Il suo attacco impenitente alle criptovalute segue un punto di vista simile sulle attività digitali di Jamie Dimon, CEO di JPMorgan. In effetti, Dimon ha dichiarato che il governo dovrebbe chiudere le criptovalute.</p>
<p>Secondo Warren, le criptovalute sono principalmente utilizzate per finanziare attività criminali come il terrorismo e il traffico di droga. <a href="https://twitter.com/i/status/1732813883130147195" rel="nofollow noopener noreferrer" target="_blank">Lei ha detto</a>, “C’è una nuova minaccia là fuori - è la criptovaluta ed è utilizzata per il finanziamento del terrorismo e per il traffico di droga. Non possiamo permettere che questo continui.”</p>
<p>Tuttavia, diversi analisti non sono d’accordo con Warren poiché sostengono che il dollaro degli Stati Uniti finanzia più attività illegali di <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Potrebbe significare che il governo degli Stati Uniti dovrebbe vietare la sua valuta?</p>
<p>Un utente X, <a href="https://twitter.com/natbrunell/status/1732874958894989567" rel="nofollow noopener noreferrer" target="_blank">Natalie Brunnel ha pubblicato</a>, “Diciamo onestamente i fatti: la valuta più utilizzata per la corruzione, l’estorsione, il traffico di droga, il traffico di esseri umani, e <a href="https://www.gate.io/learn/articles/what-is-anti-money-laundering/81" target="_blank">riciclaggio</a> è il dollaro statunitense. Non c’è un vero e proprio secondo classificato, tanto meno Bitcoin, dove ogni transazione è trasparente e registrata per sempre.</p>
<p>Un altro appassionato di criptovalute, <a href="https://twitter.com/diehardcubfan3/status/1732816130425655612" rel="nofollow noopener noreferrer" target="_blank">@diehardcubfan</a> ritiene che vietare <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">bitcoin</a> e altre criptovalute solo negli Stati Uniti non abbia alcuna importanza poiché altri paesi continueranno a utilizzarlo.</p>
<p><a href="https://twitter.com/diehardcubfan3/status/1732816130425655612" rel="nofollow noopener noreferrer" target="_blank">Ha detto</a>, “Forse sono ingenuo, ma come può una legge degli Stati Uniti influire sulla decisione della Corea del Nord di utilizzare o meno Bitcoin? Non possiedo BTC, ma penso che il suo argomento manchi di autenticità.”</p>
<p>È importante notare che Warren ha presentato un disegno di legge mirato a rispondere alle sue preoccupazioni. <a href="https://twitter.com/i/status/1732813883130147195" rel="nofollow noopener noreferrer" target="_blank">Warren ha aggiunto</a>, “Il Dipartimento del Tesoro sta chiarendo che abbiamo bisogno di nuove leggi per contrastare l’uso delle criptovalute nel permettere a gruppi terroristici, nazioni rogue, signori della droga, bande di ransomware e truffatori di riciclare miliardi di fondi rubati, eludere sanzioni, finanziare programmi di armi illegali e trarre profitto da devastanti attacchi informatici.”</p>
<p>Sono contento che cinque nuovi senatori si uniscano alla lotta per agire, tra cui tre membri del Comitato bancario: il nostro disegno di legge bipartizan è la proposta più rigorosa sul tavolo per contrastare l’uso illecito delle criptovalute e fornire ai regolatori più strumenti a disposizione.</p>
<p>La Major County Sheriffs of America, la Global Financial Integrity, la National District Attorneys Association, la Massachusetts Bankers Association, la Bank Policy Institute, la Transparency International U.S., la AARP, la National Consumer Law Center, la National Consumers League e la Massachusetts Sheriffs’ Association sono esempi di organizzazioni che sostengono il disegno di legge, indicando un’impostazione verso l’introduzione della regolamentazione delle criptovalute negli Stati Uniti e in altri paesi.</p>
<p>Il nuovo disegno di legge estenderà le disposizioni del Bank Secrecy Act (BSA) e i requisiti del Conosci-il-tuo-cliente (KYC). Questo sviluppo arriva in un momento in cui c’è stato un <a href="https://www.gate.io/blog_detail/2563" target="_blank">aumento dell’adozione di bitcoin e altre criptovalute</a>.</p>
<p>Nonostante la proposta di legge cripto degli Stati Uniti <a href="https://www.gate.io/blog_detail/3555/grayscale-pushes-spot-btc-etf &quot;Securities and Exchange Commission (SEC" rel="nofollow noopener noreferrer" target="_blank">Si prevede che la Securities and Exchange Commission (SEC) approverà diversi fondi negoziati sul posto di bitcoin (ETF) nel 2024</a> si prevede di approvare diversi fondi negoziati in borsa (ETF) di bitcoin spot nel 2024.</p>
<h2 id="h2-Collaborazione20di20Warren20e20Dimon978412"><a name="Collaborazione di Warren e Dimon" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Collaborazione di Warren e Dimon</h2><p>Da oltre un decennio, Dimon e il senatore statunitense Warren hanno spesso scontrato le loro opinioni su molte questioni. Tuttavia, di recente hanno ragionato in modo simile riguardo alle criptovalute negli Stati Uniti.</p>
<p>Entrambi vogliono che il governo sia rigoroso sull’uso delle criptovalute nel paese. La loro percezione comune è che le criptovalute siano utilizzate principalmente per scopi criminali.</p>
<p>La critica cripto di Dimon risuona con quella di <a href="https://twitter.com/SenWarren/status/1732591261431836794" rel="nofollow noopener noreferrer" target="_blank">Warren che ha detto</a>, “Quando si tratta di politiche bancarie, di solito non sono d’accordo con i CEO delle banche multibilionarie. Ma <a href="https://www.gate.io/article/30683" target="_blank">applicazione delle norme anti-riciclaggio per le criptovalute</a> proteggere la sicurezza nazionale è buon senso e fondamentale. È ora che il Congresso agisca.</p>
<p>Ciò che sorprende è che JPMorgan ha lanciato il suo token cripto JPM sul <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> La blockchain è diffusa, eppure il suo CEO, Dimon, le sta denunciando. Vietarle, con l’adozione così diffusa delle criptovalute, sarebbe come chiudere Internet.</p>
<h2 id="h2-Implicazioni20della20politica20cripto20e20della20conoscenza20dei20clienti20KYC762347"><a name="Implicazioni della politica cripto e della conoscenza dei clienti (KYC)" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Implicazioni della politica cripto e della conoscenza dei clienti (KYC)</h2><p>Sia la politica cripto più ampia che le disposizioni sul conoscersi cliente sono un requisito per il settore cripto in quanto salvaguardano sia gli investitori che le imprese di criptovaluta. <a href="https://www.gate.io/blog_detail/918/what-is-kyc-and-why-is-it-important" target="_blank">KYC è un obbligo legale</a> in molti paesi. Pertanto, violare le loro disposizioni potrebbe comportare azioni legali e pesanti sanzioni.</p>
<p>In generale, il KYC aiuta a prevenire diverse forme di frode che potrebbero danneggiare sia i clienti che le imprese criptate come gli scambi. Il KYC consente alle aziende criptate e al governo di monitorare il comportamento degli utenti e le transazioni.</p>
<p>In secondo luogo, l’utilizzo del KYC crea fiducia e fiducia nel settore in quanto i diversi soggetti interessati si sentono protetti. Ciò perché il governo può facilmente individuare segni di riciclaggio di denaro e finanziamento del terrorismo, tra altre attività fraudolente e criminali.</p>
<p>La legge sulle criptovalute è importante per proteggere le imprese criptografiche dall’insolvenza, dal fallimento e dall’implosione. Diverse garanzie legali come le comunicazioni obbligatorie e l’uso delle riserve assicurano che le imprese criptografiche non siano coinvolte in attività ad alto rischio che mettono a repentaglio la loro esistenza. Durante il 2022, pratiche di cattiva governance aziendale da parte di società criptografiche come l’exchange FTX hanno portato al loro collasso.</p>
<h2 id="h2-Conclusione236665"><a name="Conclusione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusione</h2><p>Sia la legislatrice Elizabeth Warren che Jamie Dimon, CEO di JPMorgan, stanno chiedendo regolamentazioni più severe sulle criptovalute per fermarne l’uso nel finanziamento di attività criminali come il terrorismo e il traffico di droga. Già, Warren ha presentato un disegno di legge sulle criptovalute mirato a espandere le disposizioni del Bank Secrecy Act (BSA) e il quadro Know-Your-Customer (KYC). Anche se la politica sulle criptovalute è necessaria, il paese dovrebbe lasciare spazio all’innovazione nel settore delle 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 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, saranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div>