SWwgQ1RPIGRpIFRldGhlciByaXNwb25kZSBtZW50cmUgVVNEVCBzY2FtYmlhIGFsIGRpIHNvdHRvIGRpICQxLDAw

2023-07-03, 01:10

<p><img src="https://gimg2.gateimg.com/image/article/1688345904RDZZ.jpeg" alt=""></p>
<h2 id="h2-TL20DR18370"><a name="TL; DR" class="reference-link"></a><span class="header-link octicon octicon-link"></span>TL; DR</h2><p>Il 15 giugno <a href="/price/tether-usdt" rel="nofollow noopener noreferrer" target="_blank">Tether</a> USD scollegato per scambiare a $0.9558, suscitando panico sul mercato.</p>
<p>Il CTO di <a href="/price/tether-usdt" target="_blank" class="blog_inner_link">Tether</a> ha assicurato ai suoi investitori che USDT aveva abbastanza riserve e liquidità in quel momento.</p>
<p>La depeging della stablecoin si verifica quando il valore della moneta scende o sale dalla sua posizione stabilita.</p>
<h2 id="h2-Introduzione396458"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>Anche se lo stacco degli Stablecoin avviene raramente, potrebbe avere un effetto devastante sul mercato crittografico in quanto potrebbe portare a vendite di panico. La più grande paura che i vari partecipanti al mercato possono avere è la possibilità di manipolazione dei prezzi da parte di certi individui o gruppi. Ad esempio, ci sono momenti in cui le balene possono manipolare i prezzi di alcune criptovalute. In questo articolo, discutiamo del recente stacco di Tether USDT. Perché USDT scambia al di sotto di $1,00?</p>
<p>Tether USDT, la Stablecoin più grande per capitalizzazione di mercato, è scambiato al di sotto di $1,00 il 15 giugno a causa di un disequilibrio nel pool di liquidità di Curve. Di conseguenza, il mercato è entrato in panico in quanto ciò ha ricordato agli investitori cripto gli eventi turbolenti che includono l’implosione di LUNA e UST oltre al crollo di FTX nel 2022.</p>
<p>La USDT, ancorata a 1,1 contro il dollaro statunitense, è stata scambiata al minimo a $0,9958, circa un calo del 0,4% nel suo prezzo in un breve periodo. Tuttavia, da molto tempo, la Tether USDT è stata sotto scrutinio poiché una parte del mercato ritiene che non abbia abbastanza riserve.</p>
<p>Tuttavia, di tanto in tanto, Tether ha mantenuto la sua posizione che ha abbastanza riserve. In passato, ha fornito rapporti di audit e garanzia per sostenere la sua affermazione che ha abbastanza riserve per USDT. In effetti, sostiene che le sue riserve sono sotto forma di contanti e equivalenti in contanti, con la maggior parte di esse “investite in titoli del Tesoro degli Stati Uniti.” Tuttavia, <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> costituisce solo l’1,8% delle riserve.</p>
<p>La recente repressione della SEC sugli altcoin ha portato i trader e altri investitori a chiudere alcune operazioni. Pertanto, Tether USDT e <a href="https://www.gate.io/learn/articles/what-is-stablecoin/40" target="_blank">Altre stablecoin</a> stanno svolgendo un ruolo cruciale nel facilitare queste transazioni. Nel tentativo di mantenere il valore del loro investimento, alcuni investitori stanno convertendo le loro altcoin in Stablecoin, specialmente USDT.</p>
<h2 id="h2-Squilibrio20nei203pools20della20Curva487206"><a name="Squilibrio nei 3pools della Curva" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Squilibrio nei 3pools della Curva</h2><p>Lo squilibrio nei pool di liquidità DeFi su Curve Finance ha causato il distacco di Tether USDT. Il 3pool di Curve Finance è composto da tre Stablecoin, ovvero Tether USDT, DAI decentralizzato di Maker e USDC di Circle. Tutti e tre questi Stablecoin sono ancorati al dollaro statunitense con un rapporto di 1,1.</p>
<p>Leggi anche: <a href="https://www.gate.io/ru/blog_detail/2432/depegging-bank-runs-and-unstablecoins" target="_blank">Depegging, Bank Runs and Unstablecoins</a></p>
<p><img src="https://gimg2.gateimg.com/image/article/1688346559unnamed.png" alt=""><br>Curve Finance - <a href="https://th.bing.com/th/id/OIP.KXkha4nP7GoLhCXDXw56TwHaEK?pid=ImgDet&amp;rs=1" rel="nofollow noopener noreferrer" target="_blank">Segnali Fxprofit</a></p>
<p>Curve Finance offre anche opportunità di arbitraggio per le tre Stablecoin se una di esse guadagna o perde valore. Ciò perché Curve Finance è uno scambio decentralizzato in cui gli investitori possono scambiare asset simili.</p>
<p>Fondamentalmente, la vera causa del <a href="https://www.gate.io/blog_detail/1302/the-impact-of-usdt-depegging-on-the-crypto-market" target="_blank">disancoraggio recente USDT</a> è l’azione di alcuni grandi investitori di portafogli che hanno abbandonato Tether USDT a favore delle alternative Stablecoins, DAI e USDC. Di conseguenza, il Curve 3pool si è ritrovato con più del 50% di USDT, segnalando un cambiamento nel sentiment del mercato degli utenti del pool di liquidità di Curve Finance e dei detentori di USDT.</p>
<p>In effetti, ad un certo punto, c’erano $300 milioni di USDT e circa $55 milioni ciascuno di USDC e DAI. Inoltre, la composizione del pool in cui USDT costituiva il 73% è avvenuta recentemente nel 2022 quando FTX ha presentato istanza di fallimento.</p>
<p>Tom Wan, un analista di ricerca presso 21Shares ha informato Decrypt di ciò che stava accadendo. Ha detto: “Guardando l’on-chain, possiamo vedere che il sell-off è principalmente speculativo e scatenato dall’arbitraggio e dalla vendita allo scoperto di Tether su scambi decentralizzati e mercati di prestito.”</p>
<p>Inoltre, ha opinato: “Al momento non c’è una causa apparente. La liquidità di USDT in Curve 3Pool sembra essersi stabilizzata intorno al 70% da quando il CTO di Tether ha dichiarato che sono pronti a rimborsare qualsiasi importo.”</p>
<h2 id="h2-Il20CTO20di20Tether20difende20la20solvibilit20della20stablecoinIl20CTO20di20Tether20difende20la20solvibilit20della20stablecoin943227"><a name="Il CTO di Tether difende la solvibilità della stablecoinIl CTO di Tether difende la solvibilità della stablecoin" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Il CTO di Tether difende la solvibilità della stablecoinIl CTO di Tether difende la solvibilità della stablecoin</h2><p>Paolo Ardoino, Chief Technology Officer di Tether, ha assicurato ai detentori di USDT che la Stablecoin ha abbastanza liquidità e che possono convertirla in dollari americani in qualsiasi momento. Nonostante il livello aumentato di pressione venditrice, Ardoino ha affermato che la Stablecoin ha abbastanza riserve.</p>
<p>Attraverso Twitter Ardoino ( <a href="https://twitter.com/paoloardoino/status/1669223742831042562?ref_src=twsrc%5Etfw" rel="nofollow noopener noreferrer" target="_blank">@@paoloardoino</a>) ha detto: “I mercati sono tesi in questi giorni, quindi è facile per gli attaccanti sfruttare questo sentimento generale. Ma da Tether siamo pronti come sempre. Che vengano. Siamo pronti a rimborsare qualsiasi importo.”</p>
<p>In un altro ordine di idee, alcuni membri della comunità crittografica ritengono che questa pressione venditrice di USDT sia solo temporanea. Ad esempio, <a href="https://twitter.com/scottmelker/status/1669280904873639938" rel="nofollow noopener noreferrer" target="_blank">Scott Melker, un investitore di criptovalute, ha commentato</a>, “Un depeg di Stablecoin non è determinato dal suo prezzo su un exchange, ma piuttosto dal fatto che puoi riscattare 1.1 dalla fonte.”</p>
<h2 id="h2-Cosa20significa20depegging980653"><a name="Cosa significa depegging?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Cosa significa depegging?</h2><p>Dato che abbiamo discusso della recente caduta del prezzo di USDT a $0.9958, approfondiamo cosa significa la depeggatura di una stablecoin, le sue cause e implicazioni.</p>
<p>Le stablecoin sono criptovalute progettate per mantenere la stabilità del prezzo nel tempo. Di solito, sono ancorate alle principali valute fiat come il dollaro statunitense. Tuttavia, alcuni protocolli DeFi ancorano i loro stablecoin ad asset come l’oro o criptovalute come <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> ed ETH.</p>
<p>La stabilità del prezzo delle Stablecoin le rende molto attraenti per trader e investitori. In particolare, lo scopo principale delle Stablecoin è agire come mezzo di scambio. Le persone le utilizzano principalmente per mantenere il valore dei loro investimenti o per i trasferimenti transfrontalieri. Tuttavia, le Stablecoin potrebbero perdere il loro ancoraggio a causa di diversi fattori, tra cui la manipolazione del prezzo da parte di investitori avidi.</p>
<h2 id="h2-Cause20di20depegging20e20relativi20esempi917899"><a name="Cause di de-pegging e relativi esempi" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Cause di de-pegging e relativi esempi</h2><p>Ci sono diverse cause della diminuzione del valore di mercato delle Stablecoins come la mancanza di liquidità di mercato e difetti nei loro design.</p>
<p><strong>Manipolazione di mercato</strong>: I grandi detentori di una specifica Stablecoin possono manipolarne il prezzo vendendo una quantità significativa in una volta sola. La situazione peggiora se molti investitori vendono la moneta come Tether USDT in un breve periodo. Tale massiccio sell-off di una Stablecoin potrebbe portare alla sua de-ancoratura. In effetti, la manipolazione dei prezzi si riferisce a qualsiasi attività che distorce il prezzo di un’attività.</p>
<p><strong>Mancanza di liquidità di mercato</strong> La stabilità della maggior parte degli Stablecoin dipende dalla loro liquidità. In termini semplici, liquidità significa quanto facilmente una criptovaluta può essere convertita in valuta fiat. Se uno Stablecoin non ha molti acquirenti e venditori può facilmente staccarsi.</p>
<p>L’11 marzo 2023, il USDC, supportato da dollari statunitensi e titoli di stato, ha perso il suo ancoraggio poiché il suo valore è sceso a $0,88. Ciò è seguito dal crollo di Silicon Valley Bank (SVB), che era il custode di alcune delle sue riserve. A quel tempo, non era chiaro quanto delle riserve Circle, l’emittente di USDC, avrebbe recuperato.</p>
<p>La notizia del crollo di SVB ha creato panico nel mercato crittografico, portando a molte vendite. Poiché ciò è avvenuto durante il fine settimana, è stato difficile per Circle gestire l’alto numero di vendite, il che ha comportato la perdita del tethering di USDC e il suo scambio a $0.88.</p>
<p><strong>Difetti di design</strong>: Se il design di una Stablecoin ha difetti intrinseci, potrebbe deviare dal suo ancoraggio. Ad esempio, una Stablecoin che è sovra-collateralizzata potrebbe avere delle inefficienze che portano alla disancoraggio. Alcuni difetti di design per le Stablecoins algoritmiche possono portarle a perdere anche il loro ancoraggio.</p>
<p>A volte, un Stablecoin potrebbe non tener conto di alcuni fattori esterni che ne influenzano il valore. A maggio 2022, <a href="/price/terra-luna" rel="nofollow noopener noreferrer" target="_blank">Terra</a> USD (UST) è stato influenzato a causa di una corsa alle banche. Il suo design lo ha portato a deviare dal suo ancoraggio al dollaro statunitense mentre scendeva a pochi centesimi. Di conseguenza, il mercato ha perso oltre 60 miliardi di dollari a causa di questa perdita di ancoraggio.</p>
<p>Queste non sono le uniche monete che hanno perso peso nella storia delle stablecoin. All’inizio di quest’anno, oltre all’USDC, anche DAI è sceso a un minimo di 0,897$</p>
<h2 id="h2-Come20acquistare20USDT20su20Gateio219828"><a name="Come acquistare USDT su Gate.io" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Come acquistare USDT su Gate.io</h2><p>La recente caduta in <a href="/price/tether-usdt" rel="nofollow noopener noreferrer" target="_blank">Prezzo Tether</a> era solo temporaneo in quanto ha già riacquistato il suo valore. Al momento della stesura, il prezzo di USDT è di $1,00. Pertanto, <a href="https://www.gate.io/how-to-buy/tether-usdt" target="_blank">puoi comprarlo su Gate.io</a> Per acquistare USDT su Gate.io, crea e verifica il tuo account. Una volta fatto ciò, vai alla <a href="https://www.gate.io/buy_crypto?method=card&amp;fiat=USD&amp;type=buy" target="_blank">Sezione Acquista Crypto</a> dove scegli come effettuare il pagamento. Puoi pagare utilizzando carte di credito, trading P2P e bonifico bancario.</p>
<h2 id="h2-Conclusione264863"><a name="Conclusione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusione</h2><p>Il 15 giugno di quest’anno, Tether USDT ha perso il suo valore fino a raggiungere $0,9958. Tuttavia, ha già riacquistato la sua parità di valore poiché è scambiato a $1,00. Ci sono anche Stablecoin alternative come USDC e UST che si sono discostate dalla loro parità in passato. Purtroppo, l’UST è completamente collassato nel maggio 2022. La manipolazione di mercato, la mancanza di liquidità e i difetti di progettazione possono causare la perdita di valore delle Stablecoin.</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 a condizione che venga citato Gate.io. In tutti i casi, verranno intraprese azioni legali a causa di violazione del copyright.<br></div><p></p><br></div></div></div>