V2F0IHppam4gZGUgbmlldXdlIGthbnNlbiB2b29yIE1ha2VyREFPIG9tIHRlIHVwZ3JhZGVuIG5hYXIgU2t5Pw==

2024-08-30, 04:51

<p><img src="https://gimg2.gateimg.com/image/article/17249932461692587449analysis.jpeg" alt=""></p>
<h2 id="h2-TLDR554010"><a name="[TL;DR]:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL;DR]:</h2><p>MakerDAO heeft onlangs zijn naam veranderd in Sky Protocol en heeft een nieuwe stablecoin, USDS, en governance token, SKY, gelanceerd. Deze upgrade heeft als doel om groei en doorbraken te realiseren in het DeFi-veld.</p>
<p>De lancering van het Sky Protocol heeft een breed debat veroorzaakt over decentralisatie, naleving en merkhernoeming, vooral de mogelijke bevriezingsfunctie die de nieuwe stablecoin USDS kan introduceren, wat over het algemeen zorgen en kritiek in de gemeenschap heeft opgeleverd.</p>
<p>In de toekomst zal het vermogen van Sky Protocol om zijn oorspronkelijke concurrentievoordelen in het DeFi-ecosysteem te erven en te versterken, afhangen van zijn vermogen om te reageren op regelgevende vereisten, aan de behoeften van de gemeenschap te voldoen en technologische innovatie te bevorderen.</p>
<h2 id="h2-Introductie481254"><a name="Introductie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introductie</h2><p>Na twee jaar van zorgvuldige voorbereiding heeft MakerDAO deze week eindelijk aangekondigd dat het volgens het Endgame-plan een nieuwe fase is ingegaan, officieel hernoemd tot Sky Protocol, en de USDS-stablecoin en governance-token SKY heeft gelanceerd.</p>
<p>Hoewel deze transformatie de aandacht heeft getrokken, heeft het ook diverse discussies over decentralisatie, naleving en merktransformatie op gang gebracht. In dit artikel zullen de nieuwe mogelijkheden en uitdagingen die deze upgrade voor de lezers met zich meebrengt worden geanalyseerd.</p>
<h2 id="h2-MakerDAO20Upgrades20naar20SKY20en20zal20nieuwe20stablecoins20en20governance20tokens20lanceren387529"><a name="MakerDAO Upgrades naar SKY en zal nieuwe stablecoins en governance tokens lanceren" class="reference-link"></a><span class="header-link octicon octicon-link"></span>MakerDAO Upgrades naar SKY en zal nieuwe stablecoins en governance tokens lanceren</h2><p>Deze week kondigde MakerDAO, een al lang bestaand DeFi Leningen protocol dat al twee jaar in ontwikkeling is, officieel aan dat het zichzelf hernoemt naar Sky Protocol, met als doel de popularisering van DeFi (gedecentraliseerde financiën) te bevorderen en de gebruikerservaring te vereenvoudigen.</p>
<p>Het meest opvallende kenmerk van deze merkupgrade is de lancering van de nieuwe stablecoin USDS en het governance token SKY. Volgens de regels worden USDS en DAI in een verhouding van 1:1 uitgewisseld, terwijl MKR en SKY in een verhouding van 1:24000 worden uitgewisseld. De bestaande DAI stablecoin en MKR governance token zullen blijven circuleren en gebruikers kunnen er vrijwillig voor kiezen om te upgraden.<br><img src="https://gimg2.gateimg.com/image/article/17249933221.jpg" alt=""><br>Bron: sky.money</p>
<p>Ondertussen zal MakerDAO’s SubDAO worden hernoemd naar Sky Stars, en elke Sky Star sub-DAO zal in staat zijn om onafhankelijk governance tokens uit te geven en zijn financiën en gemeenschap te beheren. Het eerste project, subDAO Spark, is een DeFi-uitleningsplatform op basis van Sky. Het totale waarde van uitgeleende activa (TVL) heeft $2,42 miljard bereikt en staat op de derde plaats onder DeFi-uitleenprotocollen.<img src="https://gimg2.gateimg.com/image/article/17249933412.jpg" alt=""><br>Bron: DefiLlama</p>
<p>Bovendien zal het projectteam op 18 september een nieuw product Sky.money lanceren en een nieuwe DeFi-toepassing om de belangrijkste functies van het Sky Protocol uit te voeren, en een multi-chain-oplossing Skylink lanceren om de migratie van nieuwe tokens zoals USDS en SKY naar belangrijke L2-netwerken te ondersteunen.</p>
<p>Het projectteam heeft ook relevante beloningsactiviteiten uitgevoerd om samen te werken met deze upgrade. Gebruikers die deelnemen aan USDS-holdings ontvangen SKY-tokenbeloningen, met een jaarlijkse distributie van 600 miljoen tokens. Sky heeft ook een dubbele ‘early bird’-beloningscampagne gelanceerd, en tot 18 september kunnen gebruikers dubbele beloningen ontvangen door USDS te verstrekken aan het Sky Token Reward-module op Sky.money.</p>
<p>Naast de bovengenoemde maatregelen zal MakerDAO slimme contracten optimaliseren, bestuursmechanismen verbeteren en systeemschaalbaarheid verbeteren, die hier niet verder zullen worden toegelicht.</p>
<h2 id="h2-De20gemeenschap20heeft20gemengde20beoordelingen20en20de20muntkoersprestaties20zijn20gemiddeld472397"><a name="De gemeenschap heeft gemengde beoordelingen en de muntkoersprestaties zijn gemiddeld" class="reference-link"></a><span class="header-link octicon octicon-link"></span>De gemeenschap heeft gemengde beoordelingen en de muntkoersprestaties zijn gemiddeld</h2><p>Hoewel de merkupgrade de aandacht van de markt heeft getrokken, kreeg de prijs van de MKR-token geen koopgekte vóór de upgrade, maar volgde in plaats daarvan de algemene neerwaartse trend van de markt na de upgrade, en de prijs-prestatieverhouding was niet bevredigend.<img src="https://gimg2.gateimg.com/image/article/17249933793.jpg" alt=""><br>Bron: Gate.io</p>
<p>Dit is volledig het tegenovergestelde van vorig jaar, toen MakerdaoDAO zeer gewild was toen het de RWA-track betrad, wat aangeeft dat de markt niet geloofde in deze upgrade.</p>
<p>De belangrijkste kritiek in de gemeenschap op dit moment is dat de nieuwe stablecoin USDS een bevriezingsfunctie zal introduceren. In de ogen van de meeste gebruikers zal deze stap USDS dichter bij gecentraliseerde stablecoins zoals USDT en USDC brengen, waardoor de censuurbestendigheid en licentievrije kenmerken worden verzwakt en rechtstreeks in strijd komen met het kernprincipe van decentralisatie van DeFi.</p>
<p>MakerDAO medeoprichter Rune verduidelijkte dit. Hij wees erop dat USDS in de beginfase van de lancering geen bevriezingsfunctie heeft en benadrukte dat de implementatie van deze functie zal worden gebaseerd op toekomstige governancebeslissingen gericht op het voorkomen van risico’s en het voldoen aan wettelijke vereisten van rechtsgebieden. Tegelijkertijd herhaalde hij de stabiliteit en onveranderlijkheid van DAI en het bestaan van USDS als een optionele upgrade.<img src="https://gimg2.gateimg.com/image/article/17249934014.jpg" alt=""><br>Bron: @RuneKek</p>
<p>Bovendien legt de officiële website van Sky toegangsbeperkingen en VPN-gebruiksverboden op aan sommige regio’s, en de erkenning van USDS is verre van inferieur aan DAI. Problemen zoals onjuiste behandeling van het oorspronkelijke officiële Twitter-account hebben de zorgen in de gemeenschap verder verergerd, wat heeft geleid tot een lage gebruikersenthusiasme voor de nieuwe muntmigratie.</p>
<p>Kortom, de negatieve beoordeling van de gemeenschap van deze upgrade is positiever dan de positieve erkenning ervan, en of MKR de prestaties zal verbeteren, moet mogelijk verder worden waargenomen nadat Sky.money medio september is gelanceerd.</p>
<h2 id="h2-Kan20Sky20doorbreken20door20de20zwakke20groei20van20MakerDAO259737"><a name="Kan Sky doorbreken door de zwakke groei van MakerDAO?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Kan Sky doorbreken door de zwakke groei van MakerDAO?</h2><p>Naar mijn mening is deze upgrade meer te wijten aan de poging van MakerDAO om door de bottleneck in het decentrale stablecoin-veld te breken. Haar verkenning van het voldoen aan de regelgevingsvereisten raakt ook de concept van gemeenschapsdecentralisatie, wat leidt tot meer kritiek dan lof voor deze upgrade.</p>
<p>In feite, hoewel DAI een belangrijke positie inneemt in het DeFi-veld, zijn de toepassingsscenario’s niet wijdverbreid en wordt het al lang ingeperkt door het marktaandeel van gecentraliseerde stablecoins zoals USDT.</p>
<p>Volgens de gegevens van DefiLlama staat DAI op de derde plaats in de stablecoin-marktwaarde op de schrijfdatum, maar de marktaandelen van USDT en USDC bedragen respectievelijk 69,5% en 20,24%, terwijl het marktaandeel van DAI slechts 3,1% is.<img src="https://gimg2.gateimg.com/image/article/17249934335.jpg" alt=""><br>Bron: DefiLlama</p>
<p>De daling van het aandeel DAI is voornamelijk te wijten aan de voortdurende uitgifte van USDT, wat heeft geleid tot schommelingen, maar ook de stagnerende marktwaarde van DAI in het afgelopen jaar is een belangrijke reden. Sinds het bereiken van de hoogste marktwaarde van $7,1B in augustus 2022, is DAI blijven dalen naar het laagste punt van $3,9B, wat gedurende een jaar rond $5,3B is gebleven. Dit onderstreept ongetwijfeld het dilemma van MakerDAO’s onvermogen om de adoptie van DAI uit te breiden tegen de achtergrond van dalende rendementen als gevolg van institutionele fondsen die ETF’s betreden en renteverlagingen.<br><img src="https://gimg2.gateimg.com/image/article/17249934496.jpg" alt=""><br>Bron: THEBLOCK</p>
<p>Het is niet moeilijk te zien dat de upgrade van MakerDAO tot doel heeft om USDS te gebruiken ter ondersteuning van het gebruik van RWA, waardoor concurrentie ontstaat met <a href="/price/tether-usdt" rel="nofollow noopener noreferrer" target="_blank">Tether</a> en Circle. Het behoudt DAI om zijn voordeel in de DeFi gedecentraliseerde stabielecoin track niet te verzwakken, waardoor het zowel aanvallend als verdedigend is.</p>
<p>Over het algemeen is de overgang van MakerDAO naar Sky een uitgebreide merk- en productupgrade, maar de ontworpen USDS-freezefunctie, het blokkeren van toegang tot bepaalde regio’s en andere acties die te veel tegemoetkomen aan regelgevende vereisten, hebben de problemen blootgelegd in de communicatie met de gemeenschap en onvolledige upgradeplanning. Of SKY zijn bestaande marktvoordelen kan versterken en meer groei, innovatie en participatie in het hele DeFi-ecosysteem kan bevorderen, zal afhangen van zijn vermogen om geleidelijk te reageren op regelgevende vereisten, te voldoen aan de behoeften van de gemeenschap en technologische innovatie te stimuleren.</p>
<div class="blog-details-info"><br><div>Auteur:<strong>Carl Y.</strong>, Gate.io onderzoeker<br><div>Vertaler: Joy Z.<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de mening 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 zal worden toegestaan mits Gate.io wordt vermeld. In alle glen zal er juridische stappen worden ondernomen vanwege schending van het auteursrecht.<br></div><p></p><br></div></div></div></div>