T3ZlcnRyZWZ0IEV0aGVuYSAoRU5BKSBUZXRoZXIgYWxzIGRlIGdyb290c3RlIHN0YWJsZWNvaW4/IEFsbGVzIHdhdCB1IG1vZXQgd2V0ZW4=

2024-04-08, 04:24

<p><img src="https://gimg2.gateimg.com/image/article/1692587501guide.jpeg" alt=""><br>Stablecoin is het belangrijkste handelsmedium in de cryptocurrency-industrie. Sinds 2013 is in alle veranderingen in stieren en beren het verhaal van Stablecoins onmisbaar geweest. Er zijn momenteel verschillende richtingen voor Stablecoins, afhankelijk van hun aard:</p>
<ol>
<li>Gecentraliseerde Stablecoins, zoals USDT en USDC, worden het meest besproken Stablecoins;</li><li>Over-gestabiliseerde Stablecoins, zoals DAI;</li><li>Algoritmische Stablecoins, zoals UST;</li><li>Zero-risk synthetische Amerikaanse dollars in de vroege fase, zoals USDe, waarover in dit artikel zal worden gesproken;</li></ol>
<h2 id="h2-De20huidige20problemen20met20stablecoins195587"><a name="De huidige problemen met stablecoins" class="reference-link"></a><span class="header-link octicon octicon-link"></span>De huidige problemen met stablecoins</h2><p>Het probleem met USDC en USDT ligt in hun centralisatie, wat voornamelijk risico’s met zich meebrengt zoals regelgevende beoordeling, hoge afhankelijkheid van bestaande banken en ontkoppeling van geïnternaliseerde rendementen.</p>
<p>Het probleem met MakerDAO’s DAI is dat het noch gedecentraliseerd, noch stabiel is. Bovendien is de kapitaalefficiëntie niet hoog. DAI is slechts 50 basispunten verwijderd van zijn $1 verankering gedurende 62% van zijn levensduur. Bovendien is het niet gedecentraliseerd, aangezien meer dan 65% van het ondersteunende onderpand bestaat uit gecentraliseerde Stablecoins en WBTC (dit aandeel neemt toe en kan blijven groeien). Om DAI uit te breiden, moest MakerDAO decentralisatie opofferen. Tegenwoordig speelt DAI de rol van wUSDC, en naarmate er meer gecentraliseerde Stablecoins als onderpand worden gebruikt, wordt dit steeds duidelijker.</p>
<p>Het probleem met Basis en andere algoritmische Stablecoins die ofwel niet-gecollateraliseerd of ondergecollateraliseerd zijn, zoals Empty Set Dollar of Ampleforth, is dat deze en reflexief en fragiel zijn. Deze algoritmische Stablecoins kunnen hun verankering niet goed behouden.</p>
<p>Als mensen niet geloven dat algorithmische Stablecoins zullen werken, zullen ze instorten. Bijvoorbeeld, de bekende Luna algorithmische Stablecoin UST.</p>
<p>Luna heeft een Stablecoin genaamd UST gemaakt, met een marktwaarde van ongeveer $2,5 miljard. Gebruikers kunnen een UST creëren door $1 aan LUNA te verbranden tegen de huidige marktprijs, terwijl gebruikers $1 aan LUNA tegen de huidige marktprijs kunnen inwisselen voor een waarde van $1. Dit is een zeer reflexief Stablecoin-systeem.</p>
<p>De ontwerp van UST is schaalbaar en gedecentraliseerd, maar het brengt overlevingsrisico’s met zich mee. Als de prijs van LUNA daalt, kan dit een ‘run’ veroorzaken - gebruikers zullen snel hun UST inwisselen om $1 aan LUNA te krijgen en verkopen. Naarmate de verkoopdruk de prijzen omlaag drijft, is het noodzakelijk om meer LUNA in te zetten voor elke ingewisselde UST, en het aanbod van LUNA kan buitensporig opgeblazen raken. Dus in mei 2022, met de loskoppeling van UST, vond er een grote ineenstorting plaats op de cryptocurrency markt. LUNA daalde van tientallen dollars naar nul binnen drie dagen, en de algehele cryptocurrency markt kende ook een scherpe daling.</p>
<h2 id="h2-Welk20probleem20probeert20Ethena20op20te20lossen56724"><a name="Welk probleem probeert Ethena op te lossen?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Welk probleem probeert Ethena op te lossen?</h2><p>Ethena is een synthetisch dollarprotocol gebaseerd op <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a>, die crypto-native oplossingen zal bieden voor valuta’s die niet vertrouwen op de traditionele bankinfrastructuur, evenals een wereldwijd toegankelijk spaarmiddel in Amerikaanse dollars - de ‘internetbond’. Ethena’s synthetische Amerikaanse dollar USDe zal de eerste anti-censuur, schaalbare en stabiele cryptocurrency native oplossing bieden voor fondsen gerealiseerd via Delta hedging tegen Ethereum-onderpand.</p>
<p>Het mechanisme van Ethena lijkt op een wip, en de Stablecoin wordt USDe genoemd. Als de prijs van ETH $1 is bij het slaan van 1 USDe, vertrouwt het systeem 1 ETH toe aan de derivatenbeurs om 1 ETH short te gaan;<br><img src="https://gimg2.gateimg.com/image/article/17125501311.jpg" alt=""></p>
<p>Als de prijs van ETH daalt van $1 naar $0.1, is de waarde van het shortcontract van 10 ETH * $0.1 nog steeds $1;<br><img src="https://gimg2.gateimg.com/image/article/17125501532.jpg" alt=""></p>
<p>Als de ETH-prijs stijgt van $1 naar $100, zal de waarde van het short-contract van 0,01 ETH * $100 nog steeds $1 zijn, en het saldo van het Ethena-systeem zal worden bereikt via contracthedges, wat uiteindelijk resulteert in een synthetische USD Stablecoin USDe met een inheemse gedecentraliseerde gelijke onderpand.</p>
<h2 id="h2-Wat20is20het20verschil20tussen20USDe20en20andere20stablecoins430891"><a name="Wat is het verschil tussen USDe en andere stablecoins?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wat is het verschil tussen USDe en andere stablecoins?</h2><p>Stablecoins in het cryptocurrency-veld vereisen onderpand, dat de waarde van Stablecoins ondersteunt. Of het nu gaat om MakerDAO’s DAI, Curve’s crvUSD, of <a href="/price/aave-aave" rel="nofollow noopener noreferrer" target="_blank">Aave</a> Ongeacht het mechanisme, is het doel van GHO’s om activa te collateraliseren om koopkracht vrij te maken, en het belangrijkste is om te hefboomwerken.</p>
<p>Ethena heeft een Stablecoin genaamd USDe gemaakt die altijd een wisselkoers van 1:1 met de Amerikaanse dollar behoudt. USDe zal een anti-censuur, schaalbaar onderliggend actief worden dat wordt gebruikt in DeFi-toepassingen. Omdat het het gestaakte inkomen van <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> en het inkomen van de futuresmarkt combineert, kan iedereen er een rendement in dollars mee behalen, en het kan ook een ‘Internet obligatie’ worden zoals de Amerikaanse schatkistobligaties op internet. Het wordt veel gebruikt als onderliggend actief in DeFi. U kunt ook verschillende obligaties maken op basis van verschillende afdekkingsstrategieën, zoals het gebruik van eeuwigdurende contracten voor afdekking en het creëren van obligaties met variabele rente. Door leveringscontracten te gebruiken voor afdekking kunnen vastrentende obligaties worden gecreëerd.<br><img src="https://gimg2.gateimg.com/image/article/17125502263.jpg" alt=""><br>Gebruikers die ETH staken om USDe in Ethena te ontvangen, zijn winstgevend. Dankzij de upgrade van Ethereum Shanghai is ETH een crypto-schatkistobligatie geworden, en obligaties die voornamelijk door Ethereum worden uitgegeven, zijn equivalent aan schatkistobligaties.</p>
<p>Gebruikers die USDe hebben ingezet, kunnen profiteren van de dubbele voordelen van de onderpande activa:</p>
<ol>
<li><p>De eerste is stabiele opbrengsten van spot-long staking. Ethena Labs ondersteunt het staken van spot ETH via vloeibare onderpand afgeleide protocollen zoals Lido om jaarrendementen van 3% tot 5% te verdienen.</p>
</li><li><p>Het tweede punt zijn de instabiele rendementen van de rente op korte termijnfondsen in futures. Gebruikers die bekend zijn met contracten zijn vertrouwd met het concept van fondsrentes. Hoewel fondsrentes instabiel zijn, wordt er op de lange termijn meestal een positieve fondsrente behaald bij shortposities, wat ook betekent dat het totale rendement positief zal zijn.</p>
</li></ol>
<p>De combinatie van de twee voordelen heeft een aanzienlijk rendement opgeleverd voor USDe. Officiële gegevens tonen aan dat de Ethena Labs protocol-opbrengst en sUSDe (USDe staking voucher token) opbrengst opmerkelijk goed hebben gepresteerd in de afgelopen twee maanden, waarbij de hoogste protocol-opbrengst 58,9% bereikte en de laagste 10,99% bereikte. De hoogste sUSDe bereikte 87,55% en de laagste was 17,43%.</p>
<div class="blog-details-info"><br><div>Auteur:<strong>Icing</strong>, Gate.io Onderzoeker<br><div>Vertaler: Joy Z.<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de standpunten van de onderzoeker en vormt geen enkele beleggingsaanbeveling.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het opnieuw plaatsen van het artikel is toegestaan mits Gate.io wordt vermeld. In alle glen zal er juridische actie worden ondernomen vanwege schending van het auteursrecht.<br></div><p></p><br></div></div></div></div>