UmVnb2xhdG9yaSBzdGF0dW5pdGVuc2kgaW5mbHVlbnphbm8gVGV0aGVyLCBsYSBzdGFiaWxpdMOgIGRlbGxlIG1vbmV0ZSBkaW1pbnVpc2NlIGEgY2F1c2EgZGkgdW4gY3Jlc2NlbnRlIGNvbnRyb2xsbyByZWdvbGFtZW50YXJl

2024-03-06, 03:12

<p><img src="https://gimg2.gateimg.com/image/article/1692587449analysis.jpeg" alt=""></p>
<h2 id="h2-TL20DR928976"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p>Gli Stati Uniti hanno la capacità di monitorare e controllare <a href="/price/tether-usdt" rel="nofollow noopener noreferrer" target="_blank">Tether</a> uso offshore di ‘s.</p>
<p>Tether dovrebbe conformarsi a The Clarity for Payment Stablecoins Act negli Stati Uniti e a MiCA nell’Unione Europea una volta che saranno operativi.</p>
<p>Se <a href="/price/tether-usdt" target="_blank" class="blog_inner_link">Tether</a> migliora la sua conformità legale, sarà in grado di mantenere la sua predominanza nel mercato Stablecoin.</p>
<h2 id="h2-Introduzione175887"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>Il settore delle criptovalute sta affrontando diverse normative in diversi paesi, il che crea incertezza per gli emittenti e gli utenti. Le stablecoin sono sotto la lente regolamentare a causa della loro ampia adozione e domanda. Sebbene molte persone in tutto il mondo abbiano accesso a diverse criptovalute, coloro che mirano a mantenere i valori dei loro investimenti preferiscono le stablecoin rispetto ad altri asset criptografici.</p>
<p>Tuttavia, il <a href="https://www.gate.io/blog_detail/2026/brace-for-impact-a-guide-to-navigating-a-cryptocurrency-crash-in-2023" target="_blank">collasso di alcuni stablecoin come TerraUSD</a> ha costretto diversi governi ad adottare regolamenti più severi. Inoltre, ci sono altre regioni in tutto il mondo come l’Unione Europea dove i paesi stanno coordinando i loro sforzi per implementare e far rispettare la legislazione cripto.</p>
<p>Oggi vediamo come l’Unione Europea e gli Stati Uniti stanno lavorando per introdurre misure regolamentari più rigorose rispetto in passato. In particolare valuteremo le sfide regolamentari che la Stablecoin Tether sta affrontando.</p>
<h2 id="h2-Controllo20regolamentare20degli20Stati20Uniti20sulluso20offshore20della20stablecoin20Tether776277"><a name="Controllo regolamentare degli Stati Uniti sull’uso offshore della stablecoin Tether" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Controllo regolamentare degli Stati Uniti sull’uso offshore della stablecoin Tether</h2><p>Gli Stati Uniti possono controllare e monitorare <a href="https://www.gate.io/learn/articles/what-is-tether-usdt/205" target="_blank">stablecoin Tether</a> nelle sue operazioni offshore attraverso l’Ufficio per il Controllo degli Attivi Esterni (OFAC), l’agenzia responsabile dell’attuazione delle sanzioni finanziarie.</p>
<p>Dlnews, attraverso la sua pubblicazione online, <a href="https://www.gate.io/learn/articles/what-is-tether-usdt/205" target="_blank">cita un team di analisti di JPMorgan</a>, guidati da Nikolaos Panigirtzoglou, afferma che i regolatori statunitensi possono esercitare un certo controllo sull’uso offshore di Tether tramite l’OFAC.</p>
<p>Recentemente, JPMorgan ha lanciato l’allarme riguardo alla conformità regolatoria di Tether Stablecoin, specialmente in confronto ai suoi rivali come USDC. Nel corso degli anni, gli analisti di criptovalute e altri portatori di interesse hanno esercitato pressioni su Tether per migliorare la trasparenza sulle sue riserve.</p>
<p>Tuttavia, anche dopo che Tether ha reso note le sue attestazioni finanziarie, JPMorgan sostiene che l’emittente Stablecoin manchi ancora di piena trasparenza. Già nel 2021, la Commodity Futures Trading Commission (CFTC) degli Stati Uniti ha inflitto a Tether una multa di 41 milioni di dollari per aver rappresentato in modo errato le proprie riserve e per aver fatto una falsa affermazione secondo cui la sua Stablecoin era completamente garantita dal dollaro statunitense.</p>
<p>Ciò che rende Tether coin più vulnerabile rispetto ad altre Stablecoin è la sua eccessiva dipendenza dal mercato criptato degli Stati Uniti. Questo perché il panorama normativo in evoluzione nel paese minaccia le Stablecoin e altri asset criptati. In particolare, l’Ufficio dei controlli degli attivi esteri del Dipartimento del Tesoro degli Stati Uniti può monitorare le performance dei progetti criptati in tutto il mondo purché consentano ai cittadini statunitensi di investire con loro.</p>
<p>JPMorgan spiega come OFAC possa influenzare le performance di Tether. Ha detto: “Sebbene le azioni legali dirette contro entità offshore e aziende decentralizzate siano complesse, misure indirette e la cooperazione internazionale potrebbero potenzialmente ostacolare l’uso di Tether.” È importante capire che le sfide regolamentari possono influenzare il prezzo crittografico di un’attività digitale.</p>
<h2 id="h2-La20relazione20di20Tether20con20Tornado20Cash263450"><a name="La relazione di Tether con Tornado Cash" class="reference-link"></a><span class="header-link octicon octicon-link"></span>La relazione di Tether con Tornado Cash</h2><p>Ciò che ha permesso agli Stati Uniti di mettere Tether nel loro radar è la sua relazione con Tornado Cash, il crypto-mixer, che l’OFAC ha inserito nella lista nera e sanzionato. Gli Stati Uniti accusano Tornado Cash di facilitare attività di riciclaggio di denaro.</p>
<p>In passato, Tornado Cash ha facilitato gli spostamenti di cripto asset in modo difficile da tracciare. Ad esempio, il gruppo Lazarus, un gruppo di hacker affiliato alla Repubblica Democratica Popolare di Corea (DPRK), ha utilizzato Tornado Cash per accedere ad alcuni cripto asset acquisiti in modo illecito, come l’hacking.</p>
<p>Nella maggior parte dei casi, il gruppo Lazarus usava convertire gli asset crittografici che aveva saccheggiato in Tether Stablecoin, motivo per cui gli Stati Uniti stanno monitorando USDT.</p>
<p>È importante notare che quando gli Stati Uniti hanno sanzionato Tornado Cash, Tether ha rifiutato di bloccare gli indirizzi del portafoglio sanzionati nonostante la richiesta delle autorità statunitensi. Tuttavia, nel dicembre 2023 Tether ha congelato tutti i portafogli sanzionati dagli Stati Uniti, descrivendo la sua azione come una misura di sicurezza proattiva.</p>
<h2 id="h2-Laumento20della20dominanza20di20Tether227598"><a name="L’aumento della dominanza di Tether" class="reference-link"></a><span class="header-link octicon octicon-link"></span>L’aumento della dominanza di Tether</h2><p>Negli ultimi anni <a href="/price/tether-usdt" rel="nofollow noopener noreferrer" target="_blank">Crypto Tether</a> La stablecoin ha registrato una crescita poiché la sua capitalizzazione di mercato e la sua quota di mercato sono aumentate grazie all’adozione da parte di molte piattaforme centralizzate e decentralizzate, nonché da altre piattaforme DeFi, nel corso degli anni.</p>
<p>A seguito della sua crescita e delle prestazioni impressionanti, Tether ha registrato un profitto di 2,85 miliardi di dollari durante il quarto trimestre del 2023. Ancora più interessante, Tether ha generato un profitto di 6,2 miliardi di dollari nel 2023.</p>
<p>Nella sua attestazione di fine anno, Tether ha dichiarato di essere impegnata a garantire la trasparenza finanziaria. A tal proposito, <a href="https://tether.to/en/tethers-2023-q4-attestation/" rel="nofollow noopener noreferrer" target="_blank">Paolo Ardoino, CEO di Tether, ha detto</a>“La verifica del Q4 di Tether sottolinea il nostro impegno per la trasparenza, la stabilità e la gestione finanziaria responsabile.”</p>
<p>Un altro fattore che ha contribuito a <a href="https://www.gate.io/how-to-buy/tether-usdt" target="_blank">La crescente dominanza della moneta Tether</a> sono state le sfide normative e la crisi finanziaria bancaria del 2023 che hanno colpito i suoi rivali, in particolare USDC. Ad esempio, il crollo di Silicon Valley Bank (SVB) nel primo trimestre del 2023 <a href="https://www.gate.io/blog_detail/2303/svb-crash-caused-the-butterfly-effect-in-the-crypto-market-what-should-investors-do" target="_blank">ha portato al distacco di USDC</a> con conseguente diminuzione della sua quota di mercato dei Stablecoin. Pertanto, molti utenti di criptovalute che hanno perso fiducia in USDC, con una riserva di $3 miliardi in SVB a quel tempo, hanno scelto di utilizzare Tether USDT.</p>
<p>Leggi anche: <a href="https://www.gate.io/blog_detail/2399/usdc-stablecoin-issuer-befriends-cross-river-bank" target="_blank">Emittente di stablecoin USDC fa amicizia con Cross River Bank</a></p>
<h2 id="h2-Regolamentazione20delle20stablecoin20in20Europa20e20Stati20Uniti461633"><a name="Regolamentazione delle stablecoin in Europa e Stati Uniti" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Regolamentazione delle stablecoin in Europa e Stati Uniti</h2><p>Le normative sulle Stablecoin che i diversi paesi emanano influiscono sulle performance delle criptovalute come Tether USDT. Di conseguenza, le Stablecoin che si posizionano in basso in termini di conformità alle leggi sulle criptovalute perdono attrattività nel mercato.</p>
<p>A meno che Tether non aumenti la sua trasparenza finanziaria e la conformità alle norme KYC/AML e ad altre regole criptate, la sua predominanza di mercato probabilmente diminuirà in futuro.</p>
<p>Leggi anche: <a href="https://www.gate.io/learn/articles/behind-the-new-high-of-usdt-supply-the-average-transfer-amount-is-us7000-becoming-the-first-choice-for-daily-payments-and-remittances/1687" target="_blank">L’importo medio di trasferimento è di 7.000 dollari statunitensi, diventando la prima scelta per i pagamenti giornalieri e le rimesse</a></p>
<p>Attualmente, il mondo delle criptovalute sta aspettando l’introduzione di nuove normative in materia di criptovalute come la Markets in Crypto-Assets Act (MiCA) in Europa e la Clarity for Payment Stablecoins Act negli Stati Uniti. Entrambe le normative stabiliscono vari standard che gli emettitori di Stablecoin dovrebbero seguire.</p>
<p>Riguardo la legge sulla chiarezza per gli Stablecoin di pagamento, il rapporto CRS afferma che tutti gli emittenti di Stablecoin saranno tenuti a “detenere un dollaro di riserve consentite per ogni dollaro di valore dello Stablecoin” e “proibiti dall’usare riserve tranne che per lo scopo di creare liquidità per i rimborsi”.</p>
<p>In modo simile, MiCA richiederà agli emittenti di Stablecoin di mantenere riserve adeguate. Di conseguenza, gli emittenti di Stablecoin dovrebbero pubblicizzare le loro riserve ai propri clienti. Tale regolamentazione di Stablecoin richiede agli emittenti di essere trasparenti e di conformarsi ad essa.</p>
<h2 id="h2-Conclusione4311"><a name="Conclusione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusione</h2><p>A causa dell’evoluzione dell’ambiente normativo, Tether dovrebbe conformarsi alle normative esistenti per mantenere il suo predominio sul mercato delle stablecoin. Già, l’Ufficio del Controllo dei Beni Esterni può monitorare Tether nel suo utilizzo offshore e intraprendere azioni appropriate come presentare cause appropriate. In futuro, Tether deve conformarsi al Clarity for Payment Stablecoins Act negli Stati Uniti e a MiCA nell’Unione Europea.</p>
<h2 id="h2-Domande20frequenti20sullo20Stablecoin20Tether790265"><a name="Domande frequenti sullo Stablecoin Tether" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Domande frequenti sullo Stablecoin Tether</h2><h3 id="h3-Quale20azienda20possiede20Tether357246"><a name="Quale azienda possiede Tether?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Quale azienda possiede Tether?</h3><p>Tether Limited, fondata da iFinex Inc. - una società con sede a Hong Kong - possiede Tether Stablecoin. Questo Stablecoin è ancorato al dollaro degli Stati Uniti.</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 repostaggio dell'articolo a condizione che venga citato Gate.io. In tutti i casi, verranno intraprese azioni legali a causa di violazioni del copyright.<br></div><p></p><br></div></div></div>