VGV0aGVyIENUTyByZWFnZWVydCBhbHMgVVNEVCBoYW5kZWx0IG9uZGVyICQxLDAw

2023-07-03, 01:10

<p><img src="https://gimg2.gateimg.com/image/article/1688345904RDZZ.jpeg" alt=""></p>
<h2 id="h2-Te20lang20niet20gelezen757103"><a name="Te lang; niet gelezen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Te lang; niet gelezen</h2><p>Op 15 juni <a href="/price/tether-usdt" rel="nofollow noopener noreferrer" target="_blank">Tether</a> USD ontkoppeld om te handelen op $0,9558, wat paniek op de markt veroorzaakt.</p>
<p>De CTO van <a href="/price/tether-usdt" target="_blank" class="blog_inner_link">Tether</a> verzekerde zijn investeerders dat USDT op dat moment voldoende reserves en liquiditeit had.</p>
<p>Stablecoin depegging treedt op wanneer de waarde van de munt daalt of stijgt vanuit zijn vastgestelde positie.</p>
<h2 id="h2-Introductie549990"><a name="Introductie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introductie</h2><p>Hoewel het loskoppelen van Stablecoins zelden voorkomt, kan dit een verwoestend effect hebben op de cryptomarkt, omdat dit kan leiden tot paniekverkoop. De grootste angst die de verschillende marktdeelnemers kunnen hebben, is de mogelijkheid van prijsmanipulatie door bepaalde individuen of groepen. Bijvoorbeeld, er zijn tijden wanneer walvissen de prijzen van bepaalde cryptocurrencies kunnen manipuleren.<br>In dit artikel bespreken we de recente depegging van Tether USDT.<br>Waarom USDT Handelt onder $1,00?</p>
<p>Tether USDT, de grootste Stablecoin qua marktkapitalisatie, werd op 15 juni verhandeld onder de $1.00 als gevolg van een onevenwichtigheid in de liquiditeitspool van Curve. Hierdoor raakte de markt in paniek, omdat dit crypto-investeerders herinnerde aan de turbulente gebeurtenissen, waaronder de implosie van LUNA en UST en de ineenstorting van FTX in 2022.</p>
<p>De USDT, vastgezet op 1,1 tegen de Amerikaanse dollar, werd verhandeld voor zo laag als $0,9958, ongeveer 0,4% daling van de prijs binnen korte tijd. Desalniettemin staat de Tether USDT al geruime tijd onder toezicht, aangezien een deel van de markt van mening is dat het niet voldoende reserves heeft.</p>
<p>Desalniettemin heeft Tether van tijd tot tijd volgehouden dat het voldoende reserves heeft. In het verleden heeft het audit- en assurance-rapporten verstrekt om zijn bewering te ondersteunen dat het voldoende reserves heeft voor USDT. Sterker nog, het blijft volhouden dat zijn reserves in de vorm van contanten en contante equivalenten zijn, waarvan de meeste zijn “belegd in Amerikaanse schatkistbiljetten.” <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> vormt slechts 1,8% van de reserves.</p>
<p>De huidige harde aanpak van de SEC tegen altcoins heeft ertoe geleid dat handelaren en andere investeerders sommige transacties hebben gesloten. Daarom, Tether USDT en <a href="https://www.gate.io/learn/articles/what-is-stablecoin/40" target="_blank">andere stablecoins</a> speelt een cruciale rol bij het vergemakkelijken van deze transacties. Om de waarde van hun investering te behouden, converteren sommige beleggers hun altcoins naar Stablecoins, met name USDT.</p>
<h2 id="h2-Onevenwicht20in20de203pools20van20de20Curve956775"><a name="Onevenwicht in de 3pools van de Curve" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Onevenwicht in de 3pools van de Curve</h2><p>Het onevenwicht in de DeFi-liquiditeitspools op Curve Finance veroorzaakte het loskoppelen van Tether USDT. De 3pool van Curve Finance bestaat uit drie Stablecoins, namelijk Tether USDT, Maker’s gedecentraliseerde DAI en Circle’s USDC. Al deze drie Stablecoins zijn gekoppeld aan de Amerikaanse dollar in een verhouding van 1.1.</p>
<p>Lees ook: <a href="https://www.gate.io/ru/blog_detail/2432/depegging-bank-runs-and-unstablecoins" target="_blank">Depegging, Bank Runs en 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">Fxprofitsignals</a></p>
<p>Curve Finance biedt ook arbitragemogelijkheden voor de drie Stablecoins als een van hen waarde wint of verliest. Dit komt doordat Curve Finance een gedecentraliseerde exchange is waar investeerders vergelijkbare activa kunnen omwisselen.</p>
<p>Eigenlijk is de echte oorzaak van de <a href="https://www.gate.io/blog_detail/1302/the-impact-of-usdt-depegging-on-the-crypto-market" target="_blank">recente USDT-ontkoppeling</a> is de actie van enkele grote portefeuille-investeerders die Tether USDT hebben laten vallen ten gunste van de alternatieve Stablecoins, DAI en USDC. Als gevolg hiervan had de Curve 3pool meer dan 50% USDT, wat een verschuiving in het marktsentiment van de Curve Finance liquiditeitspoolgebruikers en USDT-houders signaleerde.</p>
<p>Er was eigenlijk op een bepaald moment $300 miljoen aan USDT en ongeveer $55 miljoen aan zowel USDC als DAI. Ook vond de samenstelling van het zwembad plaats in 2022, waarbij USDT 73% uitmaakte, toen FTX faillissement aanvroeg.</p>
<p>Tom Wan, een onderzoeksanalist bij 21Shares, informeerde Decrypt wat er aan de hand was. Hij zei: ‘Door on-chain te kijken, kunnen we zien dat de verkoop voornamelijk speculatief is en wordt veroorzaakt door arbitrage en short selling van Tether op gedecentraliseerde beurzen en uitleenmarktplaatsen’.</p>
<p>Bovendien was hij van mening: ‘Op dit moment is er geen duidelijke oorzaak. De liquiditeit van USDT in Curve 3Pool lijkt gestabiliseerd te zijn rond 70% sinds de CTO van Tether vermeldde dat ze klaar zijn om elk bedrag in te wisselen.’</p>
<h2 id="h2-Tether20CTO20verdedigt20de20solvabiliteit20van20de20stablecoinTether20CTO20verdedigt20de20solvabiliteit20van20de20stablecoin970026"><a name="Tether CTO verdedigt de solvabiliteit van de stablecoinTether CTO verdedigt de solvabiliteit van de stablecoin" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Tether CTO verdedigt de solvabiliteit van de stablecoinTether CTO verdedigt de solvabiliteit van de stablecoin</h2><p>Paolo Ardoino, Chief Technology Officer van Tether, verzekerde de USDT-houders dat de Stablecoin voldoende liquiditeit heeft en dat ze deze te allen tijde kunnen omzetten in Amerikaanse dollars. Ondanks het verhoogde verkoopdruk zei Ardoino dat de Stablecoin voldoende reserves heeft.</p>
<p>Via Twitter Ardoino ( <a href="https://twitter.com/paoloardoino/status/1669223742831042562?ref_src=twsrc%5Etfw" rel="nofollow noopener noreferrer" target="_blank">@@paoloardoino</a>) zei: ‘De markten zijn momenteel nerveus, dus het is gemakkelijk voor aanvallers om van deze algemene stemming te profiteren. Maar bij Tether zijn we zoals altijd klaar. Laat ze maar komen. We zijn klaar om elk bedrag in te wisselen.’</p>
<p>Overigens zijn sommige leden van de cryptogemeenschap van mening dat deze verkoopdruk van USDT slechts tijdelijk is. Bijvoorbeeld, <a href="https://twitter.com/scottmelker/status/1669280904873639938" rel="nofollow noopener noreferrer" target="_blank">Scott Melker, een crypto-investeerder, reageerde</a>, ‘Een Stablecoin-dekoppeling wordt niet bepaald door de prijs op een beurs, maar eerder door of u 1.1 kunt inwisselen van de bron.’</p>
<h2 id="h2-Wat20betekent20depegging774319"><a name="Wat betekent depegging?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wat betekent depegging?</h2><p>Aangezien we de recente daling van de USDT-prijs naar $0,9958 hebben besproken, laten we dieper ingaan op wat Stablecoin-ontkoppeling betekent, de oorzaken en implicaties ervan.</p>
<p>Stablecoins zijn cryptocurrencies die zijn ontworpen om prijsstabiliteit te behouden over een langere periode. Meestal zijn ze gekoppeld aan grote fiatvaluta’s zoals de Amerikaanse dollar. Sommige DeFi-protocollen koppelen hun Stablecoins echter aan activa zoals goud of cryptocurrencies zoals <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> en ETH.</p>
<p>De prijsstabiliteit van Stablecoins maakt ze erg aantrekkelijk voor handelaren en investeerders. Met name is het belangrijkste doel van Stablecoins om op te treden als medium van uitwisseling. Mensen gebruiken ze voornamelijk om de waarde van hun investeringen te behouden of voor grensoverschrijdende overmakingen. Desalniettemin kunnen Stablecoins hun koppelingen verliezen als gevolg van verschillende factoren, waaronder prijsmanipulatie door hebzuchtige investeerders.</p>
<h2 id="h2-Oorzaken20van20het20loskoppelen20en20de20bijbehorende20voorbeelden848227"><a name="Oorzaken van het loskoppelen en de bijbehorende voorbeelden" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Oorzaken van het loskoppelen en de bijbehorende voorbeelden</h2><p>Er zijn verschillende oorzaken voor de daling van de marktwaarde van Stablecoins, zoals een gebrek aan marktliquiditeit en gebreken in hun ontwerpen.</p>
<p><strong>Marktmanipulatie</strong>: Grote houders van een specifieke Stablecoin kunnen de prijs manipuleren door in één keer een aanzienlijke hoeveelheid te verkopen. Het wordt erger als veel beleggers de munt, zoals Tether USDT, binnen een korte periode verkopen. Deze massale verkoop van een Stablecoin kan leiden tot het loskoppelen ervan. Sterker nog, prijsmanipulatie verwijst naar elke activiteit die de prijs van een activum verstoort.</p>
<p><strong>Gebrek aan marktvloeibaarheid</strong>: De stabiliteit van de meeste Stablecoins hangt af van hun liquiditeit. In eenvoudige bewoordingen betekent liquiditeit hoe gemakkelijk een cryptocurrency kan worden omgezet naar fiat-valuta. Als een Stablecoin niet veel kopers en verkopers heeft, kan het gemakkelijk van zijn vastgekoppelde waarde afwijken.</p>
<p>Op 11 maart 2023 verloor de USDC, die wordt gesteund door Amerikaanse dollars en schatkistpapier, zijn koppeling toen de waarde daalde tot $0.88. Dit volgde op het instorten van Silicon Valley Bank (SVB), dat de custodian was van een deel van zijn reserves. Op dat moment was het niet duidelijk hoeveel van de reserves Circle, de uitgever van USDC, zou herstellen.</p>
<p>Het nieuws van de ineenstorting van SVB veroorzaakte paniek op de cryptomarkt, wat leidde tot veel verkopen. Omdat dit in het weekend gebeurde, was het moeilijk voor Circle om de grote verkopen aan te pakken, wat resulteerde in het verlies van de peg van USDC en een handelswaarde van $0,88.</p>
<p><strong>Ontwerpfouten</strong>: Als het ontwerp van een Stablecoin inherente fouten heeft, kan het afwijken van zijn peg. Bijvoorbeeld, een Stablecoin die overgecollateraliseerd is, kan enkele inefficiënties hebben die leiden tot ont-pegging. Sommige ontwerp-fouten voor algoritmische Stablecoins kunnen er ook toe leiden dat ze hun peg verliezen.</p>
<p>Soms kan een Stablecoin geen rekening houden met enkele externe factoren die de waarde ervan beïnvloeden. In mei 2022 <a href="/price/terra-luna" rel="nofollow noopener noreferrer" target="_blank">Terra</a> USD (UST) werd beïnvloed door een bankrun. Het ontwerp ervan zorgde ervoor dat het afweek van zijn koppeling aan de Amerikaanse dollar, waardoor het naar een paar centen daalde. Als gevolg daarvan verloor de markt meer dan $60 miljard als gevolg van het verlies van de koppeling.</p>
<p>Dit zijn niet de enige munten die in de geschiedenis van Stablecoins hun peg verloren. Begin dit jaar depegde DAI ook naar zo laag als $0,897.</p>
<h2 id="h2-Hoe20USDT20te20kopen20op20Gateio310991"><a name="Hoe USDT te kopen op Gate.io" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Hoe USDT te kopen op Gate.io</h2><p>De recente daling in <a href="/price/tether-usdt" rel="nofollow noopener noreferrer" target="_blank">Tether prijs</a> was slechts tijdelijk omdat het alweer zijn waarde heeft teruggekregen. Op het moment van schrijven is de USDT-prijs $1,00. Daarom, <a href="https://www.gate.io/how-to-buy/tether-usdt" target="_blank">je kunt het kopen bij Gate.io</a>. Om USDT te kopen bij Gate.io maakt u uw account aan en verifieert u deze. Zodra je dat doet, ga je naar de <a href="https://www.gate.io/buy_crypto?method=card&amp;fiat=USD&amp;type=buy" target="_blank">Koop Crypto sectie</a> waar u kiest hoe u uw betaling wilt doen. U kunt betalen met creditcards, P2P-handel en bankoverschrijving.</p>
<h2 id="h2-Conclusie424292"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>Op 15 juni van dit jaar verloor Tether USDT zijn waarde tot slechts $ 0,9958. Het heeft echter zijn koppeling al herwonnen, aangezien het wordt verhandeld tegen $ 1,00. Er zijn ook alternatieve stablecoins zoals USDC en UST die in het verleden afweken van hun pegs. Helaas stortte de UST in mei 2022 volledig in. Marktmanipulatie, gebrek aan liquiditeit en fouten in het ontwerp kunnen leiden tot waardeverlies van Stablecoins.</p>
<div class="blog-details-info"><br><div>Auteur: <strong> Mashell C. </strong>, Gate.io-onderzoeker<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de opvattingen van de onderzoeker en vormt geen beleggingsaanbevelingen.<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 zullen juridische stappen worden ondernomen wegens auteursrechtinbreuk.<br></div><p></p><br></div></div></div>