T250a29wcGVsaW5nLCBCYW5rcnVucyBlbiBPbnN0YWJpZWxlIG11bnRlbg==

<p><img src="https://gimg2.gateimg.com/image/article/1681093810SDFX.jpeg" alt=""></p>
<h2 id="h2-TL20DR847992"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p>De bankrun van Silicon Valley Bank (SVB) heeft een reeks stablecoin depeggingen veroorzaakt.</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) zijn voorbeelden van stablecoins die na de ineenstorting van Silicon Valley Bank losgekoppeld zijn.</p>
<p>De vier soorten stablecoins zijn fiat-gebackede stablecoins, commodity-gebackede stablecoins, crypto-gebackede stablecoins en algorithmische stablecoins.</p>
<p>De risico’s waarmee elke stablecoin te maken heeft, zijn afhankelijk van de aard van de reserves.</p>
<h2 id="h2-Introductie680215"><a name="Introductie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introductie</h2><p>Het jaar 2023 kende een veelbelovend begin op het gebied van cryptocurrencies, aangezien ze het goed deden. De meeste belangrijke cryptocurrencies boekten aanzienlijke winsten gedurende de eerste twee maanden, met <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> doorgaan met zijn rally. Echter, de recente bankruns (Silvergate Bank, Signature Bank en Silicon Valley Bank) hebben ervoor gezorgd dat verschillende stablecoins losgekoppeld zijn.</p>
<h2 id="h2-Een20volatiel20maand20voor20stablecoins723024"><a name="Een volatiel maand voor stablecoins" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Een volatiel maand voor stablecoins</h2><p>Een aantal stablecoins werden losgekoppeld na de instorting van de Silicon Valley bank (SVB), wat wijst op de inherente risico’s ervan. Het loskoppelen van stablecoins gebeurt wanneer hun prijzen onder hun opgegeven waarden vallen. In feite moet een stablecoin een vaste waarde behouden, zoals $1,00.</p>
<p>De eerste stablecoin die werd losgekoppeld was de U.S. Dollar Coin (USDC), de op drie na best presterende stablecoin, wiens waarde daalde tot $0,87. Echter, het heeft sindsdien zijn 1,1 koppeling met de Amerikaanse dollar hersteld. USDC werd losgekoppeld nadat Silicon Valley Bank er niet in slaagde een overboeking van $40 miljoen te verwerken die Circle, de uitgever van USDC, had aangevraagd.</p>
<p>Tijdens de periode van de USDC-verkoop daalde DAI, een crypto-gebackede stablecoin, ook van zijn peg, de waarde ervan daalde met 2,0%. DAI, de stablecoin van het Maker Protocol, daalde van zijn peg omdat USDC een van de activa is die het ondersteunt. De andere cryptocurrencies die DAI ondersteunen zijn ETH en <a href="/price/pax-dollar-usdp" rel="nofollow noopener noreferrer" target="_blank">Pax Dollar</a>(USDP). Uiteindelijk daalde de waarde van DAI, met een marktkapitalisatie van $5,7 miljard op dat moment, naar $0,897. Desalniettemin herstelde het zijn koppeling binnen een korte periode.</p>
<p>De bovenstaande grafiek toont het punt waarop USDC zijn koppeling verbrak. Opmerkelijk is dat er een domino-effect was op verschillende stablecoins zoals. <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>), en <a href="/price/pax-dollar-usdp" rel="nofollow noopener noreferrer" target="_blank">Pax Dollar</a> (USDP), die allemaal hun ankers verloren. De waarde van de <a href="/price/usdd-usdd" rel="nofollow noopener noreferrer" target="_blank">USDD</a>, een stablecoin uitgegeven door <a href="/price/tron-trx" rel="nofollow noopener noreferrer" target="_blank">TRON</a>, daalde met 7,5% tot $0,925. Aan de andere kant steeg de prijs van <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>) - een fractionele-algoritmische stablecoin- verminderd tot $0.885.</p>
<p>Hoewel <a href="/price/tether-usdt" rel="nofollow noopener noreferrer" target="_blank">Tether</a> USDT is ook gedaald, maar dit gebeurde op een positieve manier doordat de waarde steeg naar $1.06 als gevolg van een stijging in de vraag. Dit komt doordat veel investeerders het tijdens die periode als een betere stablecoin beschouwden dan de anderen.</p>
<h2 id="h2-Bankruns660474"><a name="Bankruns" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Bankruns</h2><p>De recente bankruns van Silvergate Bank, Signature Bank en Silicon Valley Bank, en het daaropvolgende loskoppelen van verschillende stablecoins hebben de risico’s laten zien die deze cryptocurrencies met zich meebrengen. Het heeft ook de onderlinge verbondenheid aangetoond die bestaat tussen het traditionele banksysteem en fiat-ondersteunde stablecoins. De reden voor deze verbinding is dat banken de reserves aanhouden die de stablecoins ondersteunen.</p>
<p>Wat is precies een bankrun? Een bankrun doet zich voor als veel depositohouders grote bedragen opnemen uit angst dat de bank hen hun geld niet kan geven wanneer ze het nodig hebben. Dit creëert een groot probleem voor de bank omdat zij slechts een klein deel van het gestorte geld te allen tijde aanhouden, omdat zij veel van de gestorte fondsen uitlenen.</p>
<p>In de meeste glen gebruiken banken de gelden van depositohouders om rente dragende beleggingsinstrumenten zoals staatsobligaties te kopen. Daarom zijn banken gedwongen hun activa te verkopen wanneer veel depositohouders binnen een korte periode veel geld opnemen. Als ze de activa met verlies verkopen, kunnen ze insolvent worden.</p>
<p>Helaas, wanneer banken insolvent worden, worden ze door de wet gedwongen om te sluiten, waardoor meestal de fondsen die stablecoins ondersteunen worden geblokkeerd. Als de markt erachter komt dat de fondsen die een bepaalde stablecoin ondersteunen vastzitten in een bank, verkopen ze hun bezittingen, wat resulteert in de-pegging. Daarom bedreigen bankruns de stabiliteit van stablecoins zoals USDC en BUSD.</p>
<h2 id="h2-Recente20bedreigingen20van20depegging247383"><a name="Recente bedreigingen van depegging" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Recente bedreigingen van depegging</h2><p>De dreiging van stablecoin-depegging is er al sinds de ineenstorting van de <a href="/price/terra-luna" rel="nofollow noopener noreferrer" target="_blank">Terra</a> USD (UST) in mei 2022, een gebeurtenis die de cryptomarkt verder in een berenmarkt duwde.</p>
<p>Volgens Whale , een blockchain-analysebedrijf, werden in het laatste deel van 2022 grote bedragen aan stablecoins ingeleverd. Het inwisselen van stablecoins betekent het omwisselen van de cryptocurrency voor de onderliggende waarde, zoals Amerikaanse dollars. Dit resulteert in een afname van de marktkapitalisatie.</p>
<p>Tussen november 2022 en 10 februari 2023 vond er een totale inwisseling plaats van stablecoins ter waarde van $9,8 miljard, equivalent aan 7,23%. Tegen die tijd vertegenwoordigde de inwisseling van BUSD 31% van dat totale bedrag. Als gevolg hiervan was er een enorme afname van de dominantie van stablecoins op de markt. Specifiek is de waarde van de stablecoins in omloop in de afgelopen drie maanden met ongeveer 16,5% gedaald, wat neerkomt op ongeveer $10 miljard.</p>
<p>Een van de risico’s van USDC is het type effecten dat het ondersteunt. Over het algemeen bestaat ongeveer 80% van de onderpand van de stablecoin uit schatkistpapier met een vaste looptijd van 30 dagen. Dit betekent dat slechts 20% van het onderpand van de fiat-gecollateraliseerde stablecoins liquide geld is. Het is deze misvatting over fiat-gecollateraliseerde stablecoins die een extra bedreiging vormt.</p>
<h2 id="h2-Depegging20en20kasreserves766429"><a name="Depegging en kasreserves" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Depegging en kasreserves</h2><p>Zoals hierboven opgemerkt, bepaalt het type onderpand voor een vastgezette crypto zijn vermogen om crypto-ontkoppeling te weerstaan. Normaal gesproken kunnen de waarden van stablecoins licht schommelen ten opzichte van de peg, bijvoorbeeld met een paar cent. Niettemin leiden grote schommelingen van hun vastgestelde waarden tot ontkoppeling.</p>
<p>De waarderingen van de onderpanden die de stablecoins ondersteunen, zijn afhankelijk van veranderingen in hun prijzen en de kosten van het omzetten ervan in contanten. Enkele van de onderliggende activa zijn beveiligde leningen, bedrijfsobligaties en edele metalen, vooral goud.</p>
<p>Een rapport over <a href="/price/tether-usdt" rel="nofollow noopener noreferrer" target="_blank">Tether</a> Een stablecoin (USDT) van december 2022 geeft aan dat het 58,5% van zijn kasreserves in Treasury Bills heeft met een gemiddelde looptijd van 60 dagen. De reserves van USDC en BUSD zijn ook in obligaties en kasdeposito’s. De verschillen in de reserveverhoudingen van deze stablecoins bepalen hun risico’s.</p>
<h2 id="h2-Soorten20stablecoins356600"><a name="Soorten stablecoins" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Soorten stablecoins</h2><p>Het type stablecoins bepaalt de inherente risico’s ervan. We hebben vier soorten stablecoins, namelijk fiat-gebackede stablecoins, commodity-gebackede stablecoins, crypto-gebackede stablecoins en algoritmische stablecoins.</p>
<p><strong>Stabiele munten ondersteund door fiat</strong>: Dit zijn stablecoins die worden gedekt door een fiatvaluta zoals de Amerikaanse dollar. Elke stablecoin is gekoppeld aan een bepaalde valuta in een verhouding van 1 op 1,1. Bijvoorbeeld, <a href="/price/tether-usdt" rel="nofollow noopener noreferrer" target="_blank">Tether</a> USDT is gekoppeld aan de Amerikaanse dollar in een verhouding van 1,1. Dit betekent dat de waarde van elke USDT $1,00 is, tenzij deze is ontkoppeld. Bij crypto-ankering houdt de uitgever voldoende reserves aan voor alle munten in omloop.</p>
<p><strong>Stabiele munten ondersteund door goederen</strong>: Dit zijn stablecoins die worden gedekt door grondstoffen zoals edelmetalen of onroerend goed. De meeste bestaande stablecoins zoals Paxos Gold (PAXG) of <a href="/price/tether-gold-xaut" rel="nofollow noopener noreferrer" target="_blank">Tether Gold</a> (xAUT) zijn gedekt door goud. In dit g moet de stablecoin-uitgever een reserve van de onderliggende activa aanhouden.</p>
<p><strong>Crypto-ondersteunde stablecoin</strong>: Zoals de naam al doet vermoeden, zijn dit stablecoins die worden ondersteund door andere cryptocurrencies. Dai, ondersteund door USDC, ETH en <a href="/price/pax-dollar-usdp" rel="nofollow noopener noreferrer" target="_blank">Pax Dollar</a>(USDP) is een goed voorbeeld van zo’n stablecoin.</p>
<p><strong>Algorithmische stablecoins</strong>: Deze stablecoins, ook wel niet-onderpande stablecoins genoemd, worden niet gedekt door enig actief. De waarde van de stablecoin wordt onderhouden met behulp van een algoritme dat de vraag en het aanbod regelt.</p>
<p>Als de waarde van de stablecoin stijgt boven de vastgestelde prijs, maakt het protocol nieuwe munten aan. Dit verhoogt het aanbod en verlaagt de prijs. Daarentegen, als de waarde onder de vastgestelde prijs daalt, verbrandt het protocol een deel van de munt, waardoor het aanbod afneemt. Dit resulteert in een toename van de waarde ervan.</p>
<h2 id="h2-De20zaak20van20BUSD439043"><a name="De zaak van BUSD" class="reference-link"></a><span class="header-link octicon octicon-link"></span>De zaak van BUSD</h2><p>In februari 2023 heeft de Securities and Exchange Commission (SEC) een Wells Notice uitgegeven aan Paxos, waarin werd beweerd dat BUSD een niet-geregistreerde effect is. Deze Wells Notice, een brief die een bedrijf informeert over een geplande handhaving van de wet, toonde aan dat de SEC BUSD onderzocht.</p>
<p>Aanvankelijk was Paxos het er niet mee eens dat BUSD geen effect was onder de federale effectenwetgeving. Niettemin stemde het later in met het stoppen van het slaan van BUSD. Vanwege het onderzoek van de SEC en de Wells Notice heeft Paxos zijn samenwerking met Binance stopgezet. Hoewel de actie van de SEC niet leidde tot een ernstige marktreactie, laat het wel zien hoe handhaving van de wet tegen een stablecoin een bedreiging kan vormen.</p>
<h2 id="h2-Conclusie152322"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>Kortom, verschillende stablecoins verloren tot nu toe in 2023 hun pegging. Dit omvat de USDC die zijn pegging verloor, wat een domino-effect had op andere stablecoins zoals 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>), en <a href="/price/pax-dollar-usdp" rel="nofollow noopener noreferrer" target="_blank">Pax Dollar</a>(USDP). Die reeks van cryptodekoppeling was het gevolg van de ineenstorting van Silicon Valley Bank.</p>
<h2 id="h2-Veelgestelde20vragen20over20stablecoins545068"><a name="Veelgestelde vragen over stablecoins" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Veelgestelde vragen over stablecoins</h2><p><strong>Wat zijn de top tien stablecoins?</strong></p>
<p>De top tien stablecoins zijn <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) en <a href="/price/terraclassicusd-ustc" rel="nofollow noopener noreferrer" target="_blank">TerraClassicUSD</a>(USTC). Al deze cryptocurrencies zijn opgericht en genoteerd op verschillende crypto-beurzen.</p>
<p><strong>Wat zijn de twee belangrijkste soorten stablecoins? </strong><br>De twee belangrijkste soorten stablecoins zijn fiat-ondersteunde stablecoins en crypto-ondersteunde stablecoins. Fiat-ondersteunde stablecoins zijn cryptocurrencies waarvan de waarde gekoppeld is aan fiatvaluta zoals de Amerikaanse dollar. Crypto-ondersteunde stablecoins zijn stablecoins die worden ondersteund door andere cryptocurrencies zoals BTC.</p>
<p>Hoeveel stablecoins zijn er?<br>CoinMarketCap heeft een lijst van 139 stablecoins. Het totale aantal stablecoins kan echter hoger zijn omdat sommige nog niet op beurzen zijn vermeld.</p>
<div class="blog-details-info"><div>Auteur:<strong> Mashell C.</strong>, Gate.io onderzoeker<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 juridische actie worden ondernomen wegens auteursrechtinbreuk.<br></div><p></p><br></div></div></div>