U3VwZXJhcmUgVGV0aGVyIGNvbWUgbGEgcGnDuSBncmFuZGUgc3RhYmxlY29pbj8gVHV0dG8gY2nDsiBjaGUgZGV2aSBzYXBlcmUgc3UgY29zYSBzaWEgRXRoZW5hIChFTkEp

2024-04-08, 04:24

<p><img src="https://gimg2.gateimg.com/image/article/1692587501guide.jpeg" alt=""><br>Stablecoin è il mezzo di scambio più importante nell’industria delle criptovalute. Dal 2013, in tutte le fluttuazioni dei tori e degli orsi, la narrazione degli Stablecoin è stata indispensabile. Secondo la loro natura, attualmente ci sono diverse direzioni per gli Stablecoin:</p>
<ol>
<li>Stablecoin centralizzate, come USDT e USDC, sono le Stablecoin più ampiamente coperte;</li><li>Stablecoin sovrastato, come DAI;</li><li>Stablecoin algoritmici, come UST;</li><li>Dollari sintetici a rischio zero nella fase iniziale, come USDe, che saranno discussi in questo articolo;</li></ol>
<h2 id="h2-I20problemi20attuali20con20le20stablecoin386211"><a name="I problemi attuali con le stablecoin" class="reference-link"></a><span class="header-link octicon octicon-link"></span>I problemi attuali con le stablecoin</h2><p>Il problema di USDC e USDT risiede nella loro centralizzazione, che comporta principalmente rischi come la revisione normativa, l’alto affidamento sui sistemi bancari esistenti e lo sganciamento dei rendimenti internalizzati.</p>
<p>Il problema con DAI di MakerDAO è che non è né decentralizzato né stabile. Inoltre, la sua efficienza di capitale non è alta. DAI è solo a 50 punti base dal suo ancoraggio a $1 durante il 62% del suo ciclo di vita. Inoltre, non è decentralizzato, poiché oltre il 65% del collaterale che lo supporta è costituito da Stablecoin fiat-centralizzate e WBTC (questa proporzione è aumentata e potrebbe continuare a crescere). Per espandere DAI, MakerDAO è stato costretto a sacrificare la decentralizzazione. Oggi, DAI svolge il ruolo di wUSDC, e man mano che sempre più collaterali sono Stablecoin fiat-centralizzate, ciò diventa sempre più evidente.</p>
<p>Il problema di Basis e di altri Stablecoin algoritmici che sono o non collaterali o sottocollaterali, come Empty Set Dollar o Ampleforth, è che questi sistemi sono riflessivi e fragili. Questi Stablecoin algoritmici non riescono a mantenere bene il loro ancoraggio.</p>
<p>Se le persone non credono che gli Stablecoin algoritmici funzioneranno, crolleranno. Ad esempio, il ben noto Stablecoin algoritmico Luna UST.</p>
<p>Luna ha creato una Stablecoin chiamata UST, con un valore di mercato di circa $2.5 miliardi. Gli utenti possono creare un UST bruciando $1 di LUNA al prezzo di mercato attuale, mentre gli utenti possono riscattare $1 di LUNA al prezzo di mercato attuale per ottenere un valore di $1. Questo è un sistema di Stablecoin altamente riflessivo.</p>
<p>Il design di UST è scalabile e decentralizzato, ma presenta rischi di sopravvivenza. Se il prezzo di LUNA scende, potrebbe scatenare una “corsa” - gli utenti riscatteranno rapidamente il loro UST per ottenere 1 dollaro di LUNA e venderlo. Poiché la pressione delle vendite fa scendere i prezzi, diventa necessario emettere più LUNA per ogni UST riscattato, e l’offerta di LUNA potrebbe diventare eccessivamente inflazionata. Quindi, nel maggio 2022, con il distacco di UST, si è verificato un crollo importante del mercato delle criptovalute. LUNA è scesa da decine di dollari a zero in tre giorni, e anche l’intero mercato delle criptovalute ha subito una forte diminuzione.</p>
<h2 id="h2-Quale20problema20sta20cercando20di20risolvere20Ethena908724"><a name="Quale problema sta cercando di risolvere Ethena?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Quale problema sta cercando di risolvere Ethena?</h2><p>Ethena è un protocollo di dollaro sintetico basato su <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a>, che fornirà soluzioni cripto-native per le valute che non si basano sull’infrastruttura tradizionale del sistema bancario, oltre a uno strumento di risparmio denominato dollaro USA accessibile a livello globale - “Internet bond”. Il dollaro sintetico di Ethena, USDe, fornirà la prima soluzione criptovalutaria anti-censura, scalabile e stabile per i fondi ottenuti tramite copertura Delta contro il collaterale Ethereum.</p>
<p>Il meccanismo di Ethena è simile a un altalena e il suo Stablecoin si chiama USDe. Se il prezzo di ETH è di $1 quando si emette 1 USDe, il sistema affida 1 ETH al mercato dei derivati per vendere allo scoperto 1 ETH;<br><img src="https://gimg2.gateimg.com/image/article/17125501311.jpg" alt=""></p>
<p>Se il prezzo di ETH scende da $1 a $0.1, il valore del contratto breve di 10 ETH*$0.1 rimane comunque $1;<br><img src="https://gimg2.gateimg.com/image/article/17125501532.jpg" alt=""></p>
<p>Se il prezzo dell’ETH aumenta da $1 a $100, il valore del contratto short di 0,01 ETH*$100 sarà comunque $1, e l’equilibrio del sistema Ethena sarà raggiunto attraverso l’hedging del contratto, creando in definitiva un Synthetic USD Stablecoin USDe con collaterale equivalente decentralizzato nativo.</p>
<h2 id="h2-Qual2020la20differenza20tra20USDe20e20altri20stablecoin801841"><a name="Qual è la differenza tra USDe e altri stablecoin?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Qual è la differenza tra USDe e altri stablecoin?</h2><p>Le stablecoin nel campo delle criptovalute richiedono un collaterale, il quale supporta il valore dei stablecoin. Sia che si tratti del DAI di MakerDAO, del crvUSD di Curve o <a href="/price/aave-aave" rel="nofollow noopener noreferrer" target="_blank">Aave</a> Il GHO, indipendentemente dal meccanismo, ha lo scopo di collaterizzare asset per rilasciare potere d’acquisto, e la cosa più essenziale è sfruttare.</p>
<p>Ethena ha creato una Stablecoin chiamata USDe che mantiene sempre un tasso di cambio pari a 1:1 con il dollaro statunitense. USDe diventerà un asset sottostante scalabile anti-censura utilizzato nelle applicazioni DeFi. Poiché combina i redditi con scommesse di <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> e i redditi del mercato dei futures, chiunque può ottenere un rendimento in dollari attraverso di esso, e può diventare anche un “bond Internet” come i bond del tesoro degli Stati Uniti su Internet. Viene ampiamente utilizzato come asset sottostante in DeFi. È anche possibile creare diversi bond basati su diverse strategie di copertura, ad esempio utilizzando contratti perpetui per la copertura e creando bond a tasso variabile. Utilizzando contratti di consegna per la copertura è possibile creare bond a tasso fisso.<br><img src="https://gimg2.gateimg.com/image/article/17125502263.jpg" alt=""><br>Gli utenti che scommettono ETH per ricevere USDe in Ethena sono redditizi. Grazie all’aggiornamento di Ethereum Shanghai, ETH è diventato un bond del tesoro crittografico, e i bond principalmente emessi da Ethereum sono equivalenti ai treasury bonds.</p>
<p>Gli utenti che hanno staked USDe possono condividere i benefici duali degli asset collaterali:</p>
<ol>
<li><p>Il primo sono rendimenti stabili da spot-long staking. Ethena Labs supporta lo staking spot ETH attraverso protocolli derivati di collaterale liquido come Lido per guadagnare rendimenti annualizzati del 3% al 5%.</p>
</li><li><p>Il secondo sono i rendimenti instabili del tasso dei fondi a breve termine nei futures. Gli utenti familiarità con i contratti sono familiari con il concetto di tassi di fondi. Anche se i tassi di fondi sono instabili, per le posizioni corte, la maggior parte del tempo viene trascorso con un tasso di fondi positivo nel lungo periodo, il che significa anche che i rendimenti complessivi saranno positivi.</p>
</li></ol>
<p>La combinazione dei due benefici ha ottenuto un tasso di rendimento considerevole per USDe. I dati ufficiali mostrano che il rendimento del protocollo di Ethena Labs e il rendimento di sUSDe (token voucher di staking USDe) hanno avuto un ottimo rendimento nei ultimi due mesi, con il rendimento del protocollo più alto che ha raggiunto il 58,9% e il più basso che ha raggiunto il 10,99%. Il sUSDe più alto ha raggiunto l’87,55% e il più basso è stato del 17,43%.</p>
<div class="blog-details-info"><div>Autore:<strong>Icing</strong>, Ricercatore di Gate.io<br><div>Traduttore: Joy Z.<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. La ripubblicazione dell'articolo sarà consentita a condizione che venga fatto riferimento a Gate.io. In tutti i casi, verranno intraprese azioni legali a causa di violazioni del copyright.<br></div><p></p><br></div></div></div></div>