SlBNb3JnYW4gc29sbGV2YSBsJ2FsbGFybWUgc3VsbCdhdnZpY2luYXJzaSBkaSBUZXRoZXIgYWkgMTAwIG1pbGlhcmRpIGRpIGRvbGxhcmkgaW4gY2lyY29sYXppb25l

<p><img src="https://gimg2.gateimg.com/image/article/1700024128RDZZ 1.jpeg" alt=""></p>
<p><a href="/price/tether-usdt" rel="nofollow noopener noreferrer" target="_blank">Tether</a> La capitalizzazione di mercato di potrebbe presto superare i 100 miliardi di dollari.</p>
<p>JPMorgan ha espresso preoccupazione per la crescente dominanza di mercato di <a href="/price/tether-usdt" target="_blank" class="blog_inner_link">Tether</a> USDT.</p>
<p>L’UE potrebbe presto adottare MiCA mentre il congresso degli Stati Uniti potrebbe approvare la legge sulla chiarezza per le stablecoin di pagamento che regola le stablecoin.</p>
<p>Parole chiave: mercato delle stablecoin, USDT e Tether, ecosistema cripto, detenere cripto, detentori di cripto, acquistare cripto, <a href="/how-to-buy/tether-usdt" rel="nofollow noopener noreferrer" target="_blank">acquista Tether</a>, acquista USDT, token USDT</p>
<h2 id="h2-Introduzione886723"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p><a href="https://www.gate.io/price/view/stablecoins" target="_blank">Stablecoin sono una delle più ricercate</a> dopo le criptovalute sul mercato in quanto conservano il valore per un lungo periodo. Tether USD (USDT) è la principale criptovaluta con una capitalizzazione di mercato vicina ai 100 miliardi di dollari.</p>
<p>In questa analisi, esamineremo i possibili effetti negativi dell’aumento della crescita di Tether USDT. Valuteremo anche le opinioni di JPMorgan sull’espansione di Tether. <a href="https://www.gate.io/learn/course/stablecoin-fundamentals-video" target="_blank">e dominio nella stablecoin</a> e mercati DeFi.</p>
<h2 id="h2-JPMorgan20mette20in20evidenza20i20rischi20legati20alla20dominanza20di20Tether20e20alle20sfide20regolamentari362812"><a name="JPMorgan mette in evidenza i rischi legati alla dominanza di Tether e alle sfide regolamentari" class="reference-link"></a><span class="header-link octicon octicon-link"></span>JPMorgan mette in evidenza i rischi legati alla dominanza di Tether e alle sfide regolamentari</h2><p>Recentemente JPMorgan Chase &amp; Co ha lanciato l’allarme sull’aumento della crescita di Tether USDT mentre mira a raggiungere $100 miliardi in circolazione. È la prima volta che USDT, la principale stablecoin, è sull’orlo di superare i $100 miliardi di capitalizzazione di mercato.</p>
<p>La Stablecoin ha registrato una crescita astronomica negli ultimi due anni a causa della crescente domanda di Stablecoin. Ad esempio, nelle ultime due settimane di gennaio Tether ha emesso token USDT del valore di 1 miliardo di dollari. Complessivamente, ha aggiunto 13 miliardi di dollari alla sua capitalizzazione di mercato durante gli ultimi quattro mesi.</p>
<p><a href="https://www.gate.io/learn/articles/what-is-stablecoin/40" target="_blank">Gli stablecoin sono parte integrante dell’ecosistema delle criptovalute</a> poiché sono meno volatili rispetto agli altri asset cripto come <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> e ETH. Come tale, la maggior parte dei detentori di criptovalute che desiderano mantenere il valore degli asset digitali preferiscono possedere Stablecoin, incluso il token USDT.</p>
<p>Come la principale Stablecoin sul mercato, USDT ha diversi vantaggi competitivi. Individui che desiderano detenere criptovalute <a href="https://www.gate.io/how-to-buy/tether-usdt" target="_blank">può acquistare USDT su varie borse come Gate.io</a> e Binance. Di nuovo, poiché USDT esiste su diverse reti, è conveniente per gli investitori acquistare Tether e usarlo.</p>
<p>Leggi anche: <a href="https://www.gate.io/blog_detail/491/tether-losing-dominance-in-the-stablecoin-space" target="_blank">Tether Sta Perdendo Dominanza Nello Spazio Delle Stablecoin</a></p>
<p>Anche se la crescita di USDT e Tether è uno sviluppo positivo nella sfera DeFi che potrebbe comportare anche alcuni rischi. Nel suo <a href="https://www.bloomberg.com/news/articles/2024-02-01/stablecoin-tether-s-usdt-market-dominance-may-jeopardize-crypto-jpmorgan-says" rel="nofollow noopener noreferrer" target="_blank">pubblicazione</a>, Bloomberg evidenzia le preoccupazioni di JPMorgan sull’espansione di USDT.</p>
<p>la mancanza di conformità normativa e trasparenza di Tether crea rischi per gli utenti del token USDT. A tal proposito, <a href="https://www.theblock.co/post/275643/jpmorgan-tether-negative-crypto" rel="nofollow noopener noreferrer" target="_blank">Gli analisti di JPMorgan, guidati da Nikolaos Panigirtzoglou, hanno detto</a>“Tether è principalmente a rischio data la mancanza di conformità normativa e trasparenza. Pertanto, consideriamo la crescente concentrazione in Tether nell’ultimo anno come negativa per l’universo delle Stablecoin e l’ecosistema crittografico in generale.”</p>
<p>Gli analisti hanno anche affermato che non vi è certezza se Tether mantenga o meno la giusta quantità di riserve per soddisfare i requisiti di rimborso in qualsiasi momento. Al momento, Tether non ha pubblicato una revisione completa dei suoi attivi e passivi.</p>
<p>Leggi anche: <a href="https://www.gate.io/learn/articles/what-are-algorithmic-stablecoins/182" target="_blank">Cosa sono gli stablecoin algoritmici?</a></p>
<p>Invece, BDO Italia, uno studio di consulenza contabile, compila di volta in volta le sue attestazioni finanziarie. Sulla base dell’ultima attestazione, al 31 dicembre 2023 Tether ha attività per un valore di 97 miliardi di dollari e passività per un totale di 92 miliardi di dollari.</p>
<p>Tuttavia, Tether ha recentemente affermato che il suo token USDT crea molto valore per l’intero mercato delle criptovalute. In relazione a ciò, Coingape cita <a href="https://coingape.com/tether-paolo-ardoino-jpmorgan-usdt/" rel="nofollow noopener noreferrer" target="_blank">Paolo Ardoino, un dirigente di Tether, ha detto</a>, La dominazione del mercato di Tether potrebbe essere un ‘aspetto negativo’ per i concorrenti, inclusi quelli del settore bancario che desiderano un successo simile, ma non è mai stato un fattore negativo per i mercati che ci necessitano di più. Abbiamo sempre lavorato a stretto contatto con i regolatori globali per informarli sulla tecnologia e fornire indicazioni su come devono pensarla.</p>
<p>Vale la pena notare che l’attuale espansione di USDT e Tether è dovuta alla continua perdita di quota di mercato di USDC a causa di vari motivi, tra cui la repressione regolamentare degli Stati Uniti sulle criptovalute. Il grafico successivo confronta il mercato USDT e quello USDC.<br><img src="https://gimg2.gateimg.com/image/article/17083356221.png" alt=""><br>Dominio di mercato di Tether - JPMorgan su CoinMarketCap</p>
<p>Come mostra l’immagine, mentre la dominanza del mercato di Tether è aumentata, quella di USDC è diminuita.</p>
<p>Leggi anche: <a href="https://www.gate.io/blog_detail/2859/jpmorgans-jpm-coin-ushering-in-euro-denominated-payments" target="_blank">JPM Coin di JPMorgan: Introduzione dei Pagamenti in Euro</a></p>
<h2 id="h2-Il20CEO20di20Tether20difende20il20leadership20di20USDT20sul20mercato958727"><a name="Il CEO di Tether difende il leadership di USDT sul mercato" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Il CEO di Tether difende il leadership di USDT sul mercato</h2><p>Paolo Ardoino, CEO di Tether, è ottimista sul futuro dell’USDT, indipendentemente dall’ambiente normativo che cambia. Ha sostenuto che la crescente dominanza dell’USDT non comporta rischi nel mercato ma è essenziale per gli utenti che ne fanno affidamento.</p>
<p>A riguardo di questo, <a href="https://www.theblock.co/post/275388/tether-q4-attestation-report-excess-reserves?utm_source=rss&amp;utm_medium=rss" rel="nofollow noopener noreferrer" target="_blank">Ardoino ha detto a The Block</a> che Tether e USDT hanno le caratteristiche necessarie per sopravvivere nell’attuale ecosistema cripto. In particolare, ha detto: “Il successo di Tether USDT è guidato dalla sua affidabilità finanziaria, riserve solide e impegno verso i mercati emergenti e i paesi in via di sviluppo, in cui intere comunità utilizzano USDT come una salvezza per difendere le loro famiglie dall’alta inflazione e svalutazione della loro valuta nazionale.”</p>
<p>Ha aggiunto: “Sono felice di leggere che JPMorgan riconosce l’importanza di Tether e della tecnologia Stablecoin creata dalla nostra azienda. Ma mi sembra un po’ ipocrita parlare di concentrazione proveniente da JPMorgan, la banca più grande del mondo.”</p>
<h2 id="h2-Le20imminenti20regolamentazioni20criptate20degli20Stati20Uniti20e20dellUE20segnalano20importanti20cambiamenti20nel20panorama20delle20stablecoin950065"><a name="Le imminenti regolamentazioni criptate degli Stati Uniti e dell’UE segnalano importanti cambiamenti nel panorama delle stablecoin" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Le imminenti regolamentazioni criptate degli Stati Uniti e dell’UE segnalano importanti cambiamenti nel panorama delle stablecoin</h2><p>L’emergente ambiente regolamentare globale minaccia Stablecoin e altri asset crittografici. Ad esempio, il Clarity for Payment Stablecoins Act è in attesa dell’approvazione del Congresso degli Stati Uniti. Se approvato, stabilirà vari requisiti per Stablecoin come USDT.</p>
<p>Secondo il CRS <a href="https://crsreports.congress.gov/product/pdf/IN/IN12249#:~:text=The%20bill%20would%20establish%20rules,union%20supervisor%20could%20safeguard%20stablecoins" rel="nofollow noopener noreferrer" target="_blank">rapporto</a> Il Clarity for Payment Stablecoins Act richiederà a tutti i emitenti di Stablecoin di “tenere un dollaro di riserve consentite per ogni dollaro di Stablecoin,” e saranno “proibiti dall’utilizzare le riserve tranne che per creare liquidità per i rimborsi.”</p>
<p>Inoltre, i regolatori rilasceranno licenze per stable coin che soddisfino tre principi, enunciati come segue: “La capacità dell’applicante di soddisfare i requisiti di “base”; il “carattere generale e l’idoneità della gestione dell’applicante”; e i rischi e i benefici associati ai consumatori.”</p>
<p>In Europa, il regolamento sui mercati degli asset crittografici (MiCA), se approvato, disciplinerà l’accreditamento e le operazioni delle Stablecoin negli Stati membri. Ad esempio, MiCA bandirà le Stablecoin algoritmiche e richiederà che quelle garantite da fiat abbiano riserve di 1:1.</p>
<p>Inoltre, questo pezzo di regolamentazione cripto stabilisce determinate procedure che gli emittenti dovrebbero implementare. Ad esempio, gli emittenti di Stablecoin potrebbero dover segnalare le loro riserve alle persone che vogliono comprare cripto nella forma di Stablecoin.</p>
<p>MiCA è previsto diventi efficace in qualsiasi momento dopo giugno di quest’anno. Pertanto, gli emittenti di Stablecoin come Tether dovrebbero essere preparati per queste e altre normative criptate. Ciò perché, se non rispettano le nuove regolamentazioni, potrebbero trovarsi di fronte alla chiusura o a pesanti multe.</p>
<h2 id="h2-Conclusione237016"><a name="Conclusione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusione</h2><p>Negli ultimi quattro mesi, Tether ha aumentato la capitalizzazione di mercato di USDT di circa $13 miliardi, causando un notevole aumento della sua dominanza di mercato. A causa di ciò, gli analisti di JPMorgan hanno lanciato l’allarme sulla dominanza di mercato di Tether di fronte al mutevole panorama normativo. Nel frattempo, il Congresso degli Stati Uniti potrebbe approvare il Clarity for Payment Stablecoins Act mentre nella MiCA dell’Unione Europea potrebbe entrare in vigore verso metà 2024.</p>
<p>Notizie correlate: <a href="https://www.gate.io/uk/blog_detail/3537/jpmorgan-forecasts-2.7-b-outflows-from-gbtc-etf-conversion" target="_blank">JPMorgan stima deflussi di 2,7 miliardi di dollari dalla conversione dell’ETF GBTC</a> <a href="/how-to-buy/toncoin-ton" rel="nofollow noopener noreferrer" target="_blank">come comprare Toncoin</a></p>
<h3 id="h3-Cosa20sono20gli20stablecoin295373"><a name="Cosa sono gli stablecoin?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Cosa sono gli stablecoin?</h3><p>Un <a href="https://www.gate.io/blog_detail/1066/what-is-a-stable-coin" target="_blank">stablecoin è una criptovaluta</a> che è agganciata al valore di un bene o di una valuta fiat. USDT, la Stablecoin numero uno, è agganciata al dollaro degli Stati Uniti.</p>
<h3 id="h3-Cos20Tether191016"><a name="Cos’è Tether?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Cos’è Tether?</h3><p><a href="https://www.gate.io/learn/articles/what-is-tether-usdt/205" target="_blank">Tether è una piattaforma basata su blockchain</a> che facilita l’uso della valuta legale in maniera digitale. In generale, tuttavia, alcune persone definiscono Tether come un Stablecoin ancorato al valore del dollaro statunitense.</p>
<h3 id="h3-Tether20vs20USDT2020qual2020la20differenza495032"><a name="Tether vs. USDT - qual è la differenza?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Tether vs. USDT - qual è la differenza?</h3><p>Tether è una piattaforma basata su blockchain che facilita l’uso della valuta fiat in forma digitale. D’altra parte, USDT è una Stablecoin che è agganciata al dollaro statunitense.</p>
<h3 id="h3-Quali20sono20le20stablecoin20pi20popolari395972"><a name="Quali sono le stablecoin più popolari?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Quali sono le stablecoin più popolari?</h3><p>USDT, DAI, <a href="/price/binance-usd-busd" rel="nofollow noopener noreferrer" target="_blank">Binance USD</a>, USDC, <a href="https://www.gate.io/learn/articles/what-is-trueusd/429" target="_blank">TrueUSD</a> e <a href="https://www.gate.io/learn/articles/what-is-pax-dollar/469" target="_blank">Pax Dollar</a> sono le Stablecoin più popolari. Anche se la maggior parte di queste Stablecoin è ancorata alle valute fiat, alcune basano il loro valore su asset come l’oro. Leggi anche: <a href="https://www.gate.io/learn/articles/what-is-pegging-in-crypto/802" target="_blank">Cosa significa pegging in criptovaluta</a></p>
<h3 id="h3-Chi20possiede20USDT688130"><a name="Chi possiede USDT?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Chi possiede USDT?</h3><p>Tether Limited, fondata da iFinex - una società registrata a Hong Kong - possiede USDT, una stablecoin fiat-backed. Diversi imprenditori che includono Jean-Louis van Der Velde, Stuart Hoegner, Christopher Harborne, Chakrit Sakunkrit e Giancarlo Devasini hanno fondato Tether Limited e quindi possiedono USDT.</p>
<h3 id="h3-Il20USDT2020supportato20da20denaro20reale48013"><a name="Il USDT è supportato da denaro reale?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Il USDT è supportato da denaro reale?</h3><p>USDT è supportato dal dollaro degli Stati Uniti. Ciò significa che Tether Limited mantiene una riserva di dollari statunitensi equivalente al numero di token USDT che ha in qualsiasi momento.</p>
<h3 id="h3-20sicuro20detenere20USDT38104"><a name="È sicuro detenere USDT?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>È sicuro detenere USDT?</h3><p>È molto sicuro detenere USDT poiché mantiene il valore dei dollari degli Stati Uniti nella maggior parte dei casi. Tuttavia, potrebbe disancorarsi per un breve periodo se alcuni fattori esterni lo influenzano. È anche suscettibile ad altri rischi come l’hacking.</p>
<h3 id="h3-La20piattaforma20di20trading20USDT2020sicura762156"><a name="La piattaforma di trading USDT è sicura?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>La piattaforma di trading USDT è sicura?</h3><p>USDT viene scambiato su molte borse criptovalutarie che hanno standard di sicurezza diversi. Alcune borse come Gate.io, Coinbase e Binance sono conosciute per i loro elevati standard di sicurezza.</p>
<h3 id="h3-Dove2020il20posto20pi20sicuro20per20tenere20USDT448080"><a name="Dove è il posto più sicuro per tenere USDT?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Dove è il posto più sicuro per tenere USDT?</h3><p>Le persone possono tranquillamente conservare i loro token USDT in portafogli a freddo così come in sicure borse crittografiche. Gate.io è una principale cripto-borsa che mantiene elevati standard di sicurezza.</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 purché venga citato Gate.io. In tutti i casi, verranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div>