U3RhYmxlY29pbiBzVVNEIERlY2VudHJhbGlzYXRpZSBDcmlzaXM6IEVlbiB1aXRnZWJyZWlkZSBhbmFseXNlIHZhbiBvb3J6YWtlbiwgZ2V2b2xnZW4gZW4gdG9la29tc3RwZXJzcGVjdGlldmVu

2025-04-21, 06:24

<p><img src="https://gimg2.gateimg.com/image/article/1745216277knowledge.png" alt=""><br>In april 2025 werd de gedecentraliseerde synthetische stablecoin sUSD die werd uitgegeven door het Synthetix-protocol geconfronteerd met een ernstige crisis van de-pegging, waarbij de prijs daalde naar $0.7732, ongeveer 23% lager dan zijn theoretische 1:1 USD-peg. Dit evenement zorgde niet alleen voor wijdverbreide discussies in de cryptogemeenschap, maar werd ook door sommige gebruikers in verband gebracht met gebeurtenissen in 2022. <a href="/price/terra-luna" rel="nofollow noopener noreferrer" target="_blank">Terra</a> De ineenstorting van UST wordt in één adem genoemd.</p>
<p>Als de kernactiva van het Synthetix-ecosysteem heeft de afscheiding van sUSD meerdere uitdagingen blootgelegd in het mechanismeontwerp van het protocol, marktvertrouwen en liquiditeitsbeheer. In dit artikel worden gedetailleerd de achtergrond, redenen, huidige situatie, responsmaatregelen van het Synthetix-team, evenals de kansen en risico’s waarmee investeerders worden geconfronteerd, geanalyseerd, waarbij lezers uitgebreide inzichten worden geboden.</p>
<h2 id="h2-Overzicht20van20de20achtergrond20en20het20mechanisme20van20sUSD20ontkoppeling203759"><a name="Overzicht van de achtergrond en het mechanisme van sUSD ontkoppeling" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Overzicht van de achtergrond en het mechanisme van sUSD ontkoppeling</h2><h3 id="h3-120De20kernmechanisme20van20sUSD866143"><a name="1. De kernmechanisme van sUSD" class="reference-link"></a><span class="header-link octicon octicon-link"></span>1. De kernmechanisme van sUSD</h3><p>sUSD is de gedecentraliseerde synthetische stablecoin van het Synthetix-protocol, gemunt door over-collateralizing SNX ( <a href="/price/synthetix-network-snx" rel="nofollow noopener noreferrer" target="_blank">Synthetix Netwerk</a> Token), met als doel een 1:1 koppeling met de Amerikaanse dollar te behouden. De kernmechanismen omvatten:</p>
<p>Overcollateralisatie: Gebruikers maken sUSD aan door SNX te staken, met een overwaarderingsratio meestal op 500% of hoger om de systeembeveiliging te waarborgen.</p>
<p>Schuldzwembad: Alle pleiters delen een wereldwijd schuldzwembad, en het slaan en verbranden van sUSD heeft direct invloed op de schulddistributie.</p>
<p>Prijsstabiliteitsprikkels: Wanneer de sUSD-prijs afwijkt van de ankerwaarde, kunnen plechters schulden aflossen door met korting sUSD te kopen of winst maken door sUSD te vernietigen, waardoor de prijs weer wordt gestuurd.</p>
<p>Dit mechanisme heeft sUSD geholpen om relatieve stabiliteit te behouden in volatiele markten in de afgelopen jaren, maar sinds 2024 heeft sUSD verschillende keren lichte afwijkingen ervaren, waarbij het SIP-420 voorstel in maart 2025 de kwestie naar een hoogtepunt duwde.</p>
<h3 id="h3-220Trigger20Point20for20Unpegging95144"><a name="2. Trigger Point for Unpegging" class="reference-link"></a><span class="header-link octicon octicon-link"></span>2. Trigger Point for Unpegging</h3><p>Vanaf 21 april 2025 is de prijs van sUSD ongeveer $0.7732, een daling van 4.25% in de afgelopen 24 uur, met een marktkapitalisatie die is gekrompen tot ongeveer $22.96 miljoen en een handelsvolume dat met 320% is gestegen tot $794,000. Deze drastische prijsschommeling en marktreactie zijn te wijten aan een combinatie van meerdere factoren, vooral de implementatie van het SIP-420 voorstel.</p>
<h2 id="h2-De20diepe20redenen20voor20de20verankering20van20sUSD778560"><a name="De diepe redenen voor de verankering van sUSD" class="reference-link"></a><span class="header-link octicon octicon-link"></span>De diepe redenen voor de verankering van sUSD</h2><h3 id="h3-120De20ontwrichtende20impact20van20het20SIP42020voorstel958588"><a name="1. De ontwrichtende impact van het SIP-420 voorstel" class="reference-link"></a><span class="header-link octicon octicon-link"></span>1. De ontwrichtende impact van het SIP-420 voorstel</h3><p>In maart 2025 heeft de Synthetix-gemeenschap het SIP-420-voorstel aangenomen en geïmplementeerd, waarbij het ‘420 Pool’-mechanisme werd geïntroduceerd, dat fundamenteel de manier van bijmaken en inzetten van sUSD heeft veranderd. De belangrijkste veranderingen zijn onder andere:</p>
<p>Verlaging van de collateralisatieverhouding: verlaging van de SNX collateralisatieverhouding van 500% naar 200%, waardoor de drempel voor het slaan van sUSD aanzienlijk wordt verlaagd en een sterke stijging van het aanbod van sUSD wordt gestimuleerd.</p>
<p>Gedeelde poolmodus: Hiermee kunnen stakers SNX delegeren aan de gedeelde ‘420 pool’, waardoor de operaties worden vereenvoudigd maar het oorspronkelijke individuele schuldbeheermechanisme verzwakt wordt.</p>
<p>Schuldenaflossingsprikkel mislukt: Onder het oude mechanisme hadden pandhouders de prikkel om sUSD te kopen tegen een gereduceerde prijs om hun schulden af te lossen, ter ondersteuning van prijsstabiliteit. Echter, SIP-420 heeft deze prikkel verwijderd, wat heeft geleid tot onvoldoende koopvraag op de markt.</p>
<p>Als gevolg hiervan is het aanbod van sUSD snel toegenomen, maar de vraag is niet gelijke tred gehouden, wat heeft geleid tot een directe prijsdaling als gevolg van een onevenwicht tussen vraag en aanbod. In de Curve-liquiditeitspool vertegenwoordigt sUSD maar liefst 90%, wat de neerwaartse prijsdruk verder verergert.</p>
<h3 id="h3-220Marktgedrag20en20Liquiditeitscrisis500888"><a name="2. Marktgedrag en Liquiditeitscrisis" class="reference-link"></a><span class="header-link octicon octicon-link"></span>2. Marktgedrag en Liquiditeitscrisis</h3><p>Het gedrag van marktdeelnemers versterkt het verankerings effect, voornamelijk tot uiting komend in de volgende aspecten:</p>
<p>Centralized Exchange: Een groot aantal gebruikers wisselt sUSD voor USDT of USDC uit op gedecentraliseerde beurzen zoals Curve en <a href="/price/uniswap-uni" rel="nofollow noopener noreferrer" target="_blank">Uniswap</a>, waardoor er een onevenwicht ontstaat in de liquiditeitspool en voortdurende druk op de sUSD-prijs.</p>
<p>Impact van de Infinex-campagne: Infinex, het gedecentraliseerde front-end platform van Synthetix, lanceerde sUSD-houd- en stortingsincentiveactiviteiten voorafgaand aan het loskoppelen van de anker, wat een groot aantal gebruikers aantrok om deel te nemen. Hoewel de campagne de liquiditeit van sUSD binnen het systeem verhoogde, slaagde ze er niet in om overeenkomende externe vraag aan te trekken, wat indirect bijdroeg aan de overmatige aanbodoverschot.</p>
<p>Speculatief gedrag: Sommige speculanten maken gebruik van de afgeprijsde prijs van sUSD voor arbitrage, wat de verkoopdruk verder verhoogt.</p>
<h3 id="h3-320De20Pijnen20van20Mechanism20Overgangsperiode930712"><a name="3. De Pijnen van Mechanism Overgangsperiode" class="reference-link"></a><span class="header-link octicon octicon-link"></span>3. De Pijnen van Mechanism Overgangsperiode</h3><p>Synthetix oprichter Kain Warwick gaf toe in de X-platform en community AMA dat de sUSD detachering een ‘overgangsperiode van pijn’ is voor de SIP-420 oude en nieuwe mechanisme afwisseling. Specifieke problemen zijn onder andere:</p>
<p>Het oude mechanisme is niet langer effectief: de oorspronkelijke schuldaflossingsprikkels zijn niet langer van toepassing onder de ‘420 pool’-modus, en de markt heeft het mechanisme van automatische prijsaanpassing verloren.</p>
<p>Het nieuwe mechanisme is nog niet volwassen: Het staken en minten mechanisme geïntroduceerd door SIP-420 vereenvoudigt gebruikershandelingen, maar mist een stabiel mechanisme, wat leidt tot versterkte prijsschommelingen.</p>
<p>Asset allocatie aanpassing: Om het nieuwe mechanisme te ondersteunen, heeft het Synthetix-protocol 90% van zijn ETH-positie verkocht en zijn SNX-holdings verhoogd om interne ondersteuning te versterken. Deze operatie kan echter de liquiditeit van het systeem verzwakken en het externe marktvertrouwen ondermijnen.</p>
<h2 id="h2-Vergelijking20met20historische20glen995672"><a name="Vergelijking met historische glen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Vergelijking met historische glen</h2><p>Het loskoppelen van sUSD is geen geïsoleerd incident. Historische glen van stablecoin-loskoppeling bieden referentie voor analyse:</p>
<p>USDC Depeg (2023): Als gevolg van de ineenstorting van Silicon Valley Bank daalde USDC naar 0.87 USD, maar het sterke inwisselingsmechanisme van Circle en de transparante communicatie herstelden de koppeling binnen drie dagen.</p>
<p>UST Crash (2022): Algorithmische stablecoin UST kelderde naar $0,022 als gevolg van onvoldoende onderpand en een vertrouwenscrisis, en stortte uiteindelijk in. Daarentegen biedt de overcollateralisatie en schuldpoolmechanisme van sUSD hogere beveiliging, maar huidige prikkels zijn nog steeds ontoereikend en moeten worden aangepakt.</p>
<p>DAI lichte de-pegging (2020): DAI van MakerDAO daalde naar $0.95 op ‘Zwarte Donderdag,’ maar herstelde snel door stabiliteitskosten aan te passen en onderpandactiva te verhogen.</p>
<p>De situatie van sUSD lijkt meer op die van USDC en DAI, maar door zijn gedecentraliseerde aard en complexe schuldzwembadmechanisme is het herstel ervan moeilijker dan bij gecentraliseerde stablecoins.</p>
<h2 id="h2-Vergelijking20met20andere20stablecoins9955"><a name="Vergelijking met andere stablecoins" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Vergelijking met andere stablecoins</h2><p>De crisis van het loskoppelen van sUSD is niet uniek voor gedecentraliseerde stablecoins, hier is een vergelijking met belangrijke stablecoins:</p>
<p>USDT/USDC: Gecentraliseerde stablecoins vertrouwen op fiatreserves en sterke inwisselingsmechanismen, met een uiterst laag risico op ontkoppeling, maar hun flexibiliteit in gedecentraliseerde financiën (DeFi) is niet zo goed als sUSD.</p>
<p>DAI: MakerDAO’s DAI maakt ook gebruik van een mechanisme van overgekapitaliseerd, dat kortstondig uit de peg viel in 2020, maar snel herstelde door stabiele tariefaanpassingen en diversificatie van onderpandactiva. Het schuldenpoolmechanisme van sUSD is complexer, met een hogere herstelmoeilijkheid.</p>
<p>UST: <a href="/price/terra-luna" rel="nofollow noopener noreferrer" target="_blank">Terra</a> UST is volledig ingestort als gevolg van het algoritmische stabiliteitsmechanisme en het vertrouwenscrisis. De overcollateralisatie van sUSD en SNX-staking bieden een sterkere veiligheidsmarge, maar onvoldoende prikkels blijven de huidige bottleneck.</p>
<h2 id="h2-Conclusie678365"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>De de-pegging crisis van sUSD is een grote uitdaging die Synthetix tegenkwam tijdens de overgang van zijn mechanisme, waarbij de complexiteit van gedecentraliseerde stablecoins in balans tussen vraag en aanbod, marktvertrouwen en liquiditeitsbeheer aan het licht kwam. De implementatie van SIP-420 voorstel, terwijl het verlagen van de drempel voor deelname van gebruikers, verzwakte onverwacht het prijsstabilisatiemechanisme, wat leidde tot overaanbod en afnemend marktvertrouwen. Desalniettemin vermindert het overmatige onderpandmodel van sUSD aanzienlijk het systeemrisico in vergelijking met <a href="/price/terra-luna" rel="nofollow noopener noreferrer" target="_blank">Terra</a> UST, terwijl het proactieve antwoord van het Synthetix-team ook hoop biedt op het herstellen van verankering.</p>
<p>Voor investeerders kan de lage prijs van sUSD mogelijkheden bieden voor een hoog rendement, maar de risico’s van korte-termijnvolatiliteit en vertrouwenscrisis moeten worden afgewogen. In de snel veranderende <a href="/price" rel="nofollow noopener noreferrer" target="_blank">crypto markt</a>, waakzaam blijven en het teamverloop nauwlettend in de gaten houden is een verstandige zet. In de toekomst, of Synthetix kan via <a href="/price/aave-aave" rel="nofollow noopener noreferrer" target="_blank">Aave</a> De integratie van Ethena en de lancering en mechanisme-optimalisatie van Snaxchain hervormen de stabiliteit en marktpositie van sUSD, en bepalen daarmee de lange-termijn concurrentiepositie in het gedecentraliseerde financiële veld.</p>
<div class="blog-details-info"><br><div>Auteur: Rooick Z., Gate-onderzoeker<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen het standpunt van de auteur en vormt geen enkel handelsadvies. Beleggen is riskant, dus beslissingen moeten zorgvuldig worden genomen.<br></em><div><em></em>Dit artikel is origineel, het auteursrecht behoort toe aan Gate.io, geef de auteur en bron aan als u wilt herdrukken, anders zullen juridische verantwoordelijkheden worden nagestreefd.<br></div><p></p><br></div></div></div>