RGVwZWdnaW5nLCBCYW5rIFJ1bnMgZSBVbnN0YWJsZWNvaW5z

2023-04-10, 02:35
<p><img src="https://gimg2.gateimg.com/image/article/1681093810SDFX.jpeg" alt=""></p>
<h2 id="h2-TL20DR94618"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p>La corsa alle banche di Silicon Valley Bank (SVB) ha scatenato una serie di depegging di stablecoin.</p>
<p>USDC, <a href="/price/trueusd-tusd" rel="nofollow noopener noreferrer" target="_blank">TrueUSD</a> (TUSD), <a href="/price/frax-frax" rel="nofollow noopener noreferrer" target="_blank">Frax</a>, <a href="/price/pax-dollar-usdp" rel="nofollow noopener noreferrer" target="_blank">Pax Dollar</a>(USDP) sono esempi di stablecoin che hanno staccato dopo il crollo della Silicon Valley Bank.</p>
<p>I quattro tipi di stablecoin sono le stablecoin fiat-backed, le stablecoin commodity-backed, le stablecoin crypto-backed e le stablecoin algoritmiche.</p>
<p>I rischi che ogni stablecoin affronta dipendono dalla natura delle sue riserve.</p>
<h2 id="h2-Introduzione664390"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>L’anno 2023 ha avuto un inizio promettente in termini di criptovalute poiché si sono comportate bene. La maggior parte delle principali criptovalute ha guadagnato significativamente durante i primi due mesi, con <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> continuando con la sua corsa. Tuttavia, le recenti corse alle banche (Silvergate Bank, Signature Bank e Silicon Valley Bank) hanno causato la svalutazione di diverse stablecoin.</p>
<h2 id="h2-Un20mese20volatile20per20le20stablecoin96911"><a name="Un mese volatile per le stablecoin" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Un mese volatile per le stablecoin</h2><p>Un certo numero di stablecoin si sono scollegati in seguito al crollo della banca Silicon Valley (SVB), il che indica i rischi intrinseci in essi. Lo scollamento di stablecoin avviene quando il loro prezzo scende al di sotto dei loro valori dichiarati. In sostanza, uno stablecoin dovrebbe mantenere un valore fisso come 1,00 dollari.</p>
<p>Il primo stablecoin a depeggare è stato il Dollaro Statunitense Coin (USDC), il terzo stablecoin per classifica, il cui valore è sceso a $0.87. Tuttavia, ha successivamente riacquistato il suo peg di 1.1 rispetto al dollaro statunitense. USDC si è depeggato dopo che la Silicon Valley Bank non è riuscita a elaborare un trasferimento di $40 milioni richiesto da Circle, l’emittente di USDC.</p>
<p>Durante il periodo di vendita di USDC, DAI, una stablecoin supportata da criptovalute, si è anche staccata dal valore, con una diminuzione del 2,0%. DAI, la stablecoin del protocollo Maker, si è staccata perché USDC è uno degli asset che la supportano. Le altre criptovalute che supportano DAI sono ETH e <a href="/price/pax-dollar-usdp" rel="nofollow noopener noreferrer" target="_blank">Pax Dollaro</a>(USDP). Alla fine, il valore di DAI, con una capitalizzazione di mercato di $5.7 miliardi in quel momento, è sceso a $0.897. Tuttavia, ha riconquistato il suo ancoraggio in un breve periodo.</p>
<p>Il grafico sopra mostra il punto in cui USDC si è staccato. Noto, c’è stato un effetto domino su diversi stablecoin come <a href="/price/trueusd-tusd" rel="nofollow noopener noreferrer" target="_blank">TrueUSD</a> (TUSD), <a href="/price/frax-frax" rel="nofollow noopener noreferrer" target="_blank">Frax</a> ( <a href="/price/frax-frax" rel="nofollow noopener noreferrer" target="_blank">Frax</a>) e <a href="/price/pax-dollar-usdp" rel="nofollow noopener noreferrer" target="_blank">Pax Dollaro</a> (USDP), che hanno tutti perso il loro ancoraggio. Il valore del <a href="/price/usdd-usdd" rel="nofollow noopener noreferrer" target="_blank">USDD</a>, una stablecoin emessa da <a href="/price/tron-trx" rel="nofollow noopener noreferrer" target="_blank">TRON</a>, è diminuito del 7,5% a $0,925. D’altra parte, il prezzo di <a href="/price/frax-frax" rel="nofollow noopener noreferrer" target="_blank">Frax</a> ( <a href="/price/frax-frax" rel="nofollow noopener noreferrer" target="_blank">Frax</a>) - una stablecoin algoritmica frazionaria - è scesa a $0.885.</p>
<p>Anche se <a href="/price/tether-usdt" rel="nofollow noopener noreferrer" target="_blank">Tether</a> USDT è anche aumentato, lo ha fatto in modo positivo poiché il suo valore è salito a $1.06 a causa di un aumento della domanda. Questo perché, durante quel periodo, molti investitori lo hanno considerato una migliore stablecoin rispetto alle altre.</p>
<h2 id="h2-Fuga20dalle20banche869760"><a name="Fuga dalle banche" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Fuga dalle banche</h2><p>Le recenti corse alle banche, Silvergate Bank, Signature Banks e Silicon Valley bank, e la successiva deancorazione di diverse stablecoin hanno mostrato i rischi che queste criptovalute hanno. Ha anche indicato l’interdipendenza che esiste tra il sistema bancario tradizionale e le stablecoin garantite dal fiat. Il motivo di questa connessione è che le banche detengono le riserve che supportano le stablecoin.</p>
<p>Ora, cos’è esattamente una corsa alle banche? Una corsa alle banche si verifica quando molti depositanti ritirano i loro fondi in grandi quantità, temendo che la banca non sarà in grado di restituire loro i soldi quando ne avranno bisogno. Ciò crea un grosso problema per la banca poiché detiene solo una piccola frazione dei soldi depositati in qualsiasi momento dato che gran parte dei fondi depositati viene prestata.</p>
<p>Nella maggior parte dei casi, le banche utilizzano i fondi dei depositanti per acquistare strumenti di investimento che fruttano interessi come i titoli di Stato. Pertanto, quando molti depositanti ritirano molte somme di denaro entro breve tempo, le banche sono costrette a vendere i loro asset. Se vendono gli asset in perdita, potrebbero diventare insolventi.</p>
<p>Purtroppo, quando le banche diventano insolventi, sono costrette dalla legge a chiudere, il che di solito blocca i fondi che supportano le stablecoin. Se il mercato apprende che i fondi che supportano una determinata stablecoin sono bloccati in una banca, vendono le loro partecipazioni, il che comporta il suo distacco. Pertanto, le corse alle banche minacciano la stabilità delle stablecoin come USDC e BUSD.</p>
<h2 id="h2-Minacce20recenti20di20depegging202858"><a name="Minacce recenti di depegging" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Minacce recenti di depegging</h2><p>Le minacce di depegging delle stablecoin sono state presenti fin dalla caduta del <a href="/price/terra-luna" rel="nofollow noopener noreferrer" target="_blank">Terra</a> USD (UST) a maggio 2022, un evento che ha spinto ulteriormente il mercato delle criptovalute in una fase ribassista.</p>
<p>Secondo Whale , una società di analisi blockchain, nell’ultima parte del 2022 si sono verificate grandi riscossioni di stablecoin. Il rimborso di stablecoin significa scambiare la criptovaluta con la sua garanzia come i dollari degli Stati Uniti. Ciò comporta una diminuzione della sua capitalizzazione di mercato.</p>
<p>Tra novembre 2022 e il 10 febbraio 2023 c’è stata un’intera riscossione di stablecoin del valore di 9,8 miliardi di dollari, equivalente al 7,23%. A quel tempo, il riscatto di BUSD rappresentava il 31% di quella cifra totale. Di conseguenza, c’è stato un enorme decremento della dominanza delle stablecoin sul mercato. Nello specifico, negli ultimi tre mesi il valore delle stablecoin in circolazione è diminuito di circa il 16,5%, equivalente a circa 10 miliardi di dollari.</p>
<p>Uno dei rischi di USDC è il tipo di titoli che lo supportano. Complessivamente, circa l’80% del collaterale stabilecoin è sotto forma di titoli del Tesoro a scadenza fissa di 30 giorni. Ciò significa che solo il 20% del collaterale fiat è in contanti liquido. È questa inesattezza con le stablecoin collaterizzate in fiat che crea una minaccia aggiuntiva.</p>
<h2 id="h2-Depegging20e20riserve20di20denaro394536"><a name="Depegging e riserve di denaro" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Depegging e riserve di denaro</h2><p>Come hai notato sopra, il tipo di garanzia per una criptovaluta agganciata determina la sua capacità di resistere al distacco dalla criptovaluta. Normalmente, i valori delle stablecoin possono oscillare leggermente dal peg, ad esempio di pochi centesimi. Tuttavia, grandi fluttuazioni dai valori stabiliti portano al distacco.</p>
<p>Le valutazioni dei collaterali che sostengono le stablecoin dipendono dai cambiamenti nei loro prezzi e dal costo di convertirli in contanti. Alcuni degli attivi sottostanti sono prestiti garantiti, obbligazioni societarie e minerali preziosi, specialmente l’oro.</p>
<p>Un rapporto su <a href="/price/tether-usdt" rel="nofollow noopener noreferrer" target="_blank">Tether</a> La stablecoin (USDT) datata dicembre 2022 indica che ha il 58,5% delle sue riserve in contanti in Titoli di Stato con un’età media di maturità di 60 giorni. Allo stesso modo, le riserve di USDC e BUSD sono in obbligazioni e depositi in contanti. Le differenze nei rapporti di riserva di queste stablecoin determinano i loro rischi.</p>
<h2 id="h2-Tipi20di20stablecoin307436"><a name="Tipi di stablecoin" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Tipi di stablecoin</h2><p>I tipi di stablecoin determinano i rischi ad essi associati. Abbiamo quattro tipi di stablecoin, ovvero stablecoin supportate da valute fiat, stablecoin supportate da beni di consumo, stablecoin supportate da criptovalute e stablecoin algoritmiche.</p>
<p><strong>Stablecoin supportate da Fiat</strong>: Queste sono stablecoin che sono garantite da una valuta fiat come il dollaro degli Stati Uniti. Ogni stablecoin è legata a una certa valuta in un rapporto di 1:1. Ad esempio, <a href="/price/tether-usdt" rel="nofollow noopener noreferrer" target="_blank">Tether</a> USDT è collegato al dollaro degli Stati Uniti con un rapporto di 1,1. Ciò significa che il valore di ogni USDT è di $1,00 a meno che non si scolleghi. Con il pegging delle criptovalute, l’emittente mantiene riserve sufficienti per tutte le monete in circolazione.</p>
<p><strong>Stablecoin supportate dalle materie prime</strong>: Queste sono stablecoin che sono garantite da beni come minerali preziosi o immobili. Tuttavia, la maggior parte delle stablecoin esistenti come Paxos Gold (PAXG) o <a href="/price/tether-gold-xaut" rel="nofollow noopener noreferrer" target="_blank">Tether Gold</a>(xAUT) sono garantiti dall’oro. In questo caso, l’emittente della stablecoin dovrebbe mantenere una riserva degli asset sottostanti.</p>
<p><strong>Stablecoin supportata da criptovaluta</strong>: Come suggerisce il nome, queste sono stablecoin che sono supportate da altre criptovalute. Dai, supportato da USDC, ETH e <a href="/price/pax-dollar-usdp" rel="nofollow noopener noreferrer" target="_blank">Pax Dollaro</a>(USDP) è un buon esempio di una stablecoin.</p>
<p><strong>Stablecoin algoritmiche</strong> Queste stablecoin, anche chiamate stablecoin non collaterali, non sono supportate da alcun asset. Il valore della stablecoin è mantenuto utilizzando un algoritmo che controlla la sua offerta e domanda.</p>
<p>Se il valore della stablecoin sale al di sopra del prezzo impostato, il protocollo emette nuove monete. Questo aumenta la sua offerta e riduce il suo prezzo. Al contrario, se il suo valore scende al di sotto del prezzo stabilito, il protocollo brucia alcune delle monete, riducendo così la sua offerta. Ciò comporta un aumento del suo valore</p>
<h2 id="h2-Il20caso20di20BUSD485999"><a name="Il caso di BUSD" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Il caso di BUSD</h2><p>Nel febbraio 2023, la Securities and Exchange Commission (SEC) ha emesso un avviso Wells a Paxos, affermando che BUSD è un titolo non registrato. Questo avviso Wells, una lettera che informa un’azienda di un’applicazione prevista dell’applicazione della legge, ha mostrato che la SEC stava indagando su BUSD.</p>
<p>Inizialmente, Paxos era in disaccordo sul fatto che BUSD non fosse un titolo ai sensi delle leggi federali sui titoli. Tuttavia, successivamente ha accettato di smettere di emettere BUSD. A causa dell’indagine della SEC e dell’avviso di Wells, Paxos ha interrotto la sua partnership con Binance. Sebbene l’azione della SEC non abbia portato a una reazione di mercato grave, mostra come l’applicazione della legge contro una stablecoin possa diventare una minaccia.</p>
<h2 id="h2-Conclusione970321"><a name="Conclusione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusione</h2><p>In sintesi, diversi stablecoin hanno perso la loro ancoraggio fino ad ora nel 2023. Ciò include il distacco di USDC che ha avuto un effetto domino sugli altri stablecoin come DAI, <a href="/price/trueusd-tusd" rel="nofollow noopener noreferrer" target="_blank">TrueUSD</a> (TUSD), <a href="/price/frax-frax" rel="nofollow noopener noreferrer" target="_blank">Frax</a> ( <a href="/price/frax-frax" rel="nofollow noopener noreferrer" target="_blank">Frax</a>), e <a href="/price/pax-dollar-usdp" rel="nofollow noopener noreferrer" target="_blank">Pax Dollar</a> (USDP). Quella serie di cripto depegging è stata il risultato del crollo di Silicon Valley Bank.</p>
<h2 id="h2-Domande20frequenti20sulle20stablecoin953181"><a name="Domande frequenti sulle stablecoin" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Domande frequenti sulle stablecoin</h2><p><strong>Quali sono le dieci stablecoin migliori?</strong></p>
<p>I primi dieci stablecoin sono <a href="/price/tether-usdt" rel="nofollow noopener noreferrer" target="_blank">Tether</a> USDT, <a href="/price/usd-coin-usdc" rel="nofollow noopener noreferrer" target="_blank">USD Coin</a> (USDC), <a href="/price/binance-usd-busd" rel="nofollow noopener noreferrer" target="_blank">Binance USD</a>(BUSD), Dai (DAI), <a href="/price/trueusd-tusd" rel="nofollow noopener noreferrer" target="_blank">TrueUSD</a>(TUSD), <a href="/price/pax-dollar-usdp" rel="nofollow noopener noreferrer" target="_blank">Pax Dollar</a> (USDP), <a href="/price/usdd-usdd" rel="nofollow noopener noreferrer" target="_blank">USDD</a>, <a href="/price/gemini-dollar-gusd" rel="nofollow noopener noreferrer" target="_blank">Gemini Dollar</a> (GUSD), Fei USD (FEI) and <a href="/price/terraclassicusd-ustc" rel="nofollow noopener noreferrer" target="_blank">TerraClassicUSD</a> (USTC). Tutte queste criptovalute sono state create e elencate su varie criptoborse.</p>
<p><strong>Quali sono i due principali tipi di stablecoin? </strong><br>I due principali tipi di stablecoin sono le stablecoin supportate da valute fiduciarie e le stablecoin supportate da criptovalute. Le stablecoin supportate da valute fiduciarie sono criptovalute il cui valore è ancorato a una valuta fiduciaria come il dollaro degli Stati Uniti. Le stablecoin supportate da criptovalute sono stablecoin garantite da altre criptovalute come BTC.</p>
<p><strong>Quanti stablecoin ci sono? </strong><br>CoinMarketCap ha una lista di 139 stablecoin. Tuttavia, il numero totale di stablecoin potrebbe essere maggiore poiché alcune di esse non sono ancora quotate sugli scambi.</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 ripubblicare l'articolo a condizione che venga citato Gate.io. In tutti i casi, saranno intraprese azioni legali a causa di violazioni del copyright.<br></div><p></p><br></div></div></div>
Share
Content
gate logo
Gate
Trade Now
Join Gate to Win Rewards