TCdhbmFsaXNpIGRpIERldXRzY2hlIEJhbmsgc3VzY2l0YSB1biBkaWJhdHRpdG8gc3VsbGEgc3RhYmlsaXTDoCBlIGxlIG9wZXJhemlvbmkgZGkgVGV0aGVy

2024-05-22, 03:01

<p><img src="https://gimg2.gateimg.com/image/article/1692587449analysis.jpeg" alt=""></p>
<h2 id="h2-TL20DR765789"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p><a href="/price/tether-usdt" rel="nofollow noopener noreferrer" target="_blank">Tether</a> USDT dovrebbe migliorare la sua trasparenza per aumentare la sua fattibilità.</p>
<p>Deutsche Bank e JPMorgan concordano sul fatto che <a href="/price/tether-usdt" target="_blank" class="blog_inner_link">Tether</a> USDT affronta rischi operativi che minacciano la sua futura sostenibilità.</p>
<p>L’UE implementerà i regolamenti MICA durante la metà dell’anno, che influenzerà le stablecoin nella regione.</p>
<h2 id="h2-Introduzione725644"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>La Deutsche Bank, rilasciata il 7 maggio, ha suscitato molto dibattito nel settore delle criptovalute poiché prevede il fallimento di diversi stablecoin leader, tra cui Tether USDT. È importante sottolineare che il rapporto copre le performance di <a href="https://www.gate.io/learn/articles/what-is-pegging-in-crypto/802" target="_blank">diverse ancoraggi monetari dal 1800</a>. Nonostante tali speculazioni, alcuni analisti sostengono che se i governi nazionali istituiranno una regolamentazione adeguata, la maggior parte delle stablecoin sarà in grado di mantenere i loro ancoraggi.</p>
<p>I rischi più grandi che le stablecoin affrontano sono legati alla legislazione criptata e alla conformità delle riserve. Questo articolo copre l’analisi di Tether USDT di Deutsche Bank e il futuro delle stablecoin.</p>
<h2 id="h2-Lanalisi20di20Deutsche20Bank20Research20su20USDT20di20Tether25095"><a name="L’analisi di Deutsche Bank Research su USDT di Tether" class="reference-link"></a><span class="header-link octicon octicon-link"></span>L’analisi di Deutsche Bank Research su USDT di Tether</h2><p>Il rapporto di ricerca di Deutsche Bank che esplora 334 valute ancorate dal 1800 ha evidenziato i rischi che affrontano le stablecoin. Tuttavia, ha approfondito molto di più i rischi operativi che Tether potrebbe incontrare.</p>
<p>La ricerca ha concluso che su 334 ancoraggi valutari indagati da Deutsche solo il 14% è ancora sul mercato, dimostrando la vulnerabilità delle stablecoin. Le principali minacce per le stablecoin esistenti <a href="https://www.gate.io/blog_detail/2432/depegging-bank-runs-and-unstablecoins" target="_blank">include depegging</a> a causa delle tendenze speculative. La mancanza di trasparenza operativa da parte degli emittenti di stablecoin esaspera i loro rischi.</p>
<p>Innanzitutto, nel suo rapporto, Deutsche Bank ha messo in dubbio la stabilità di Tether USDT e la trasparenza delle pratiche di Tether riguardanti le riserve denominate in USD. Secondo un recente <a href="https://cointelegraph.com/news/tether-slams-deutsche-bank-over-suggestion-stablecoin-could-fail" rel="nofollow noopener noreferrer" target="_blank">Pubblicazione di Cointelegraph</a>, gli analisti della banca mettono in dubbio anche la solvibilità di Tether USDT.</p>
<p>Tuttavia, a causa della dominanza del mercato di Tether potrebbe non essere possibile notare le minacce che sta affrontando fino a un momento “peso” che probabilmente avrà un impatto sulla volatilità del mercato delle criptovalute. Secondo il rapporto di Deutsche Bank, il momento del peso potrebbe avere un impatto sull’intero mercato delle criptovalute.</p>
<p>Per illustrare il suo punto, il rapporto ha citato l’esempio del <a href="https://www.gate.io/blog_detail/2430/terra-luna-tokens-fall-steeply-on-do-kwons-arrest" target="_blank">crollo di TerraUSD (TUSD) che ha cancellato oltre 40 miliardi di dollari</a>: “Mentre alcuni potrebbero sopravvivere, la maggior parte probabilmente fallirà, soprattutto a causa della mancanza di trasparenza nelle operazioni delle stablecoin e della vulnerabilità al sentimento speculativo.”</p>
<p>Leggi anche: <a href="https://www.gate.io/explore/terra-luna" target="_blank">Il progetto Terra Luna si riprenderà mai?</a></p>
<p>Un punto che Deutsche Bank ha messo in evidenza per l’intero mercato crittografico è che c’è bisogno di trasparenza delle stablecoin. Ad esempio, tutte le valute criptate dovrebbero mantenere riserve abbondanti che vengono sottoposte a revisione e rese pubbliche per evitare il panico tra i suoi utenti se ci sono segni di depegging.</p>
<p>Nel quadro della sua ricerca, Deutsche Bank ha effettuato un sondaggio tra i consumatori in vari paesi, tra cui Spagna, Italia, Francia, Germania, Regno Unito e Stati Uniti. Dei 3.350 partecipanti, solo l’18% ha mostrato fiducia nella sostenibilità e <a href="https://www.gate.io/learn/articles/what-are-the-main-stablecoins/99" target="_blank">sostenibilità delle stablecoin</a>. Al contrario, il 42% credeva che le stablecoin potessero diminuire a causa dei vari rischi dell’ecosistema cripto.</p>
<h2 id="h2-Analisi20Tether20USDT20Preoccupazione20di20JPMorgan106150"><a name="Analisi Tether USDT: Preoccupazione di JPMorgan" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Analisi Tether USDT: Preoccupazione di JPMorgan</h2><p>L’analisi di mercato sullo stablecoin Tether della Deutsche Bank sembra risuonare con lo scetticismo di JPMorgan sulla longevità dell’USDT. A febbraio JPMorgan ha prodotto un altro rapporto che posiziona la dominanza di mercato di Tether come una minaccia per il mercato delle criptovalute poiché limita la concorrenza e l’innovazione. Come risultato della sua dominanza, se si trova ad affrontare problemi operativi gravi, questi potrebbero avere un effetto domino sull’intero mercato delle criptovalute.</p>
<p>Brad Garlinghouse, CEO di Ripple, ha sollevato anche preoccupazioni sulla fattibilità di Tether USDT. Tuttavia, la sua preoccupazione è diversa da quella di JPMorgan e Deutsche Bank. La paura di Garlinghouse è che le regolamentazioni sulle stablecoin negli Stati Uniti e nell’UE possano influire negativamente sulle prestazioni di Tether USDT. In effetti, il CEO di Ripple crede fermamente che il governo degli Stati Uniti stia prendendo di mira Tether USDT in un modo che potrebbe destabilizzare le sue operazioni senza intoppi.</p>
<h2 id="h2-Problemi20regolatori20e20multe20passate20di20Tether709126"><a name="Problemi regolatori e multe passate di Tether" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Problemi regolatori e multe passate di Tether</h2><p>Le paure di Garlinghouse potrebbero sembrare realistiche se consideriamo i precedenti problemi normativi di Tether. In effetti, nel 2021 la Commodity Futures Trading Commission degli Stati Uniti ha inflitto a Tether una multa di 41 milioni di dollari. Nello stesso anno Tether ha raggiunto un accordo di 18,5 milioni di dollari con il Procuratore Generale di New York. Entrambe le sanzioni sono derivate dalle accuse secondo cui Tether aveva reso dichiarazioni fuorvianti sulle sue riserve. Fondamentalmente, le autorità statunitensi nutrivano forti dubbi sulla conformità della stablecoin di Tether in termini di riserve. Sembra ovvio che in quel momento Tether non ha superato il test del carico della prova.</p>
<p>In futuro, è importante che Tether mantenga riserve sufficienti per la sua stablecoin USDT. Ancora più importante, dovrebbe essere trasparente al riguardo e essere in grado di dimostrare alle autorità la sufficienza delle sue riserve in qualsiasi momento. Potrebbe anche essere essenziale per Tether invitare revisori esterni. Al momento, sembra che Tether si stia affidando alla sua attestazione. Ad esempio, <a href="https://tether.io/news/tethers-2023-q4-attestation/" rel="nofollow noopener noreferrer" target="_blank">la sua attestazione Q4, 2023</a> mostra che ha generato $2.85 miliardi di profitto. Ha prodotto quanto segue come parte dell’attestazione.<br><img src="https://gimg2.gateimg.com/image/article/1716346764image.jpg" alt=""><br>2023 Riserve Tether - Tether</p>
<p>Sebbene ciò sembri impressionante, un rapporto di audit esterno potrebbe fare molto bene e migliorare l’immagine pubblica poiché aumenta la trasparenza e l’accountability. Un audit completo è più comprensibile poiché indica i rischi, la conformità e i dati attualmente sconosciuti dell’azienda.</p>
<p>Importante sapere: <a href="https://www.gate.io/learn/articles/commodities-vs-securities-key-differences/2478" target="_blank">Commodities vs. securities: Differenze chiave</a></p>
<h2 id="h2-Risposta20di20Tether186925"><a name="Risposta di Tether" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Risposta di Tether</h2><p>Alla luce delle suddette accuse e delle preoccupazioni del settore, Tether ha minimizzato le paure sollevate dalle parti citate. Ha respinto il rapporto di Deutsche Bank per mancanza di validità in quanto non contiene prove né chiarezza. D’altro canto, il gigante delle stablecoin ha dichiarato di avere meccanismi per mantenere la stabilità della stablecoin.</p>
<p>Ha anche dichiarato che è irrilevante per Deutsche Bank confrontare USDT, una stablecoin fiat-backed, con TerraUSD, una stablecoin algoritmica. Nei commenti condivisi con Cointelegraph, un <a href="https://cointelegraph.com/news/tether-slams-deutsche-bank-over-suggestion-stablecoin-could-fail" rel="nofollow noopener noreferrer" target="_blank">Il rappresentante di Tether ha detto</a>, Inoltre, il confronto con Terra, una stablecoin algoritmica, è fuorviante e non pertinente alla discussione sulle monete garantite dalle riserve. Il motivo è che il crollo del <a href="/price/terra-luna" target="_blank" class="blog_inner_link">Terra</a> USD non era direttamente collegato all’assenza di riserve.</p>
<p>Ha continuato: “Mettere in dubbio la credibilità di qualsiasi istituzione finanziaria, specialmente una con il record di Deutsche Bank, sembra ironico. La storia di Deutsche Bank di multe e penalità solleva dubbi sul suo stesso diritto di criticare gli altri nell’industria.”</p>
<h2 id="h2-Ruolo20di20USDT20e20crescita20della20capitalizzazione20di20mercato20nel20mercato20delle20criptovalute262839"><a name="Ruolo di USDT e crescita della capitalizzazione di mercato nel mercato delle criptovalute" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Ruolo di USDT e crescita della capitalizzazione di mercato nel mercato delle criptovalute</h2><p>Sulla base dell’attuale analisi del mercato delle stablecoin <a href="https://www.gate.io/learn/articles/what-is-tether-usdt/205" target="_blank">Tether USDT sta svolgendo un ruolo critico in tutto il mercato delle criptovalute</a>. Fondamentalmente, USDT consente ai trader di mantenere il valore dei loro asset crittografici. Ad esempio, durante un periodo di volatilità di mercato, molti investitori preferiscono convertire i loro asset crittografici in Tether USDT. È importante notare anche che la stabilità di USDT è evidente poiché non ha mai subito casi di forte depeggio.</p>
<p>Tether, con una capitalizzazione di mercato superiore a $100 miliardi, ha una quota di mercato delle stablecoin superiore al 69%. Nella maggior parte dei casi, i volumi di trading di USDT sono superiori a quelli di <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Tether USDT è la criptovaluta numero uno. La ragione principale è che USDT è accoppiato con molti asset criptati. Allo stesso modo, molte persone e istituzioni utilizzano Tether USDT come mezzo di scambio e per le rimesse internazionali. Inoltre, la stablecoin fornisce la liquidità tanto necessaria al mercato delle criptovalute e aumenta la popolarità degli asset digitali.</p>
<h2 id="h2-Regolamenti20imminenti20sulle20stablecoin20negli20Stati20Uniti20e20il20MiCA20dellUE258419"><a name="Regolamenti imminenti sulle stablecoin negli Stati Uniti e il MiCA dell’UE" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Regolamenti imminenti sulle stablecoin negli Stati Uniti e il MiCA dell’UE</h2><p>diversi paesi intendono introdurre leggi sulle criptovalute che regolamentino diverse classi di criptovalute, compresi gli stablecoin. Ad esempio, l’UE implementerà presto la regolamentazione dei mercati delle cripto-attività (MiCA) entro la metà dell’anno. D’altra parte, gli Stati Uniti sono <a href="https://www.gate.io/blog_detail/469/stablecoin-regulation-is-coming-part-responses-and-opportunities" target="_blank">lavorando sulla regolamentazione della sua stablecoin</a>, l’Atto di chiarezza per i pagamenti delle stablecoin. Queste legislazioni cripto hanno diverse somiglianze. Ad esempio, entrambe richiedono agli emittenti di ottenere licenze prima di emettere stablecoin. I fornitori di stablecoin dovrebbero inoltre segregare i fondi dei clienti e mantenere riserve sufficienti.</p>
<h2 id="h2-Conclusione666373"><a name="Conclusione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusione</h2><p>Una recente ricerca della Deutsche Bank ha indicato che le stablecoin affrontano sfide di sostenibilità, specialmente se mancano di trasparenza. Ha anche sottolineato che stablecoin come USDT possono incontrare rischi operativi a causa delle tendenze speculative delle criptovalute. Negli ultimi mesi, JPMorgan ha identificato la dominanza di USDT come una minaccia per il sistema bancario. La legislazione criptata che gli Stati Uniti e l’UE potrebbero implementare presto è probabile che crei rischi aggiuntivi per le stablecoin.</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à consentita la ripubblicazione dell'articolo a condizione che venga citato Gate.io. In tutti i casi, saranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div>