RGUgd2FhcmhlaWQgYWNodGVyIGRlIGJpam5hIDQwMCUgc3RpamdpbmcgdmFuIFVTVEMgaW4gdHdlZSBkYWdlbg==

2023-11-28, 08:19

<p><img src="https://gimg2.gateimg.com/image/article/1692587449analysis.jpeg" alt=""></p>
<h2 id="h2-TLDR505695"><a name="[TL;DR]:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL;DR]:</h2><p>De tokens USTC, LUNA en LUNC in de <a href="/price/terra-luna" rel="nofollow noopener noreferrer" target="_blank">Terra</a> Het aantal faillissementen in de sector is de afgelopen twee dagen sterk gestegen, vooral bij USTC, dat in de afgelopen twee dagen met meer dan 400% is gestegen.</p>
<p>De marktinterpretatie van de stijging van USTC is te wijten aan plannen zoals de Mint Cash airdrop empowerment en de herstelling van de US dollar koppeling van USTC.</p>
<p>De aanzienlijke stijging van USTC-prijzen vertegenwoordigt een positief beeld op de markt, maar voorzichtigheid is nog steeds geboden bij investeringen die niet op tijd zijn binnengekomen.</p>
<h2 id="h2-Introductie999407"><a name="Introductie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introductie</h2><p>Naast een aanzienlijke stijging van FTT recentelijk hebben failliete sectoren zoals USTC, LUNA en LUNC allemaal een verbazingwekkende stijging ‘s nachts meegemaakt. De populariteit van de algorithmische stablecoin USTC is sterk teruggekeerd en de markt speculeert dat dit verband houdt met voorstellen zoals de Mint Cash airdrop empowerment en het herstel van de USTC-US dollar koppeling ontwikkeld door voormalige Terra-leden.</p>
<p>Wat zijn de nieuwe hoogtepunten achter de drukte, en of er nog steeds ruimte is voor arbitrage in USTC en anderen? Dit artikel zal u een gedetailleerde uitleg geven.</p>
<h2 id="h2-De20sterke20markttrend20van20USTC20die20in20twee20dagen20tijd20met20meer20dan2040020steeg203117"><a name="De sterke markttrend van USTC, die in twee dagen tijd met meer dan 400% steeg" class="reference-link"></a><span class="header-link octicon octicon-link"></span>De sterke markttrend van USTC, die in twee dagen tijd met meer dan 400% steeg</h2><p>Vanaf 23:00 uur op 26 november steeg de oorspronkelijke <a href="/price/terra-luna" target="_blank" class="blog_inner_link">Terra</a> Eco-stablecoin USTC (Terra Classic UST) plotseling in een rechte lijn en bereikte binnen een uur 0,05 USDT, een stijging van maar liefst 250% ten opzichte van 0,02 USDT.</p>
<p>Op het moment van schrijven heeft de hoogste muntprijs 0,075 USDT bereikt en wordt momenteel aangepast rond 0,041 USDT. De kortetermijnstijging heeft een nieuw hoogtepunt bereikt in een jaar tijd.<br><img src="https://gimg2.gateimg.com/image/article/170115936415461701159284_.pic.jpg" alt=""><br>Bron: Gate.io</p>
<p>Ondertussen zijn volgens de markt van Gate.io LUNC en LUNA, beide behorend tot de Terra faillissementssector, ook aangespoord om te herstellen, met een stijging in handelsvolume, en is de muntkoers respectievelijk met meer dan 60% en 40% gestegen in de afgelopen twee dagen.<img src="https://gimg2.gateimg.com/image/article/170115938215471701159295_.pic.jpg" alt=""><br>Bron: Gate.io</p>
<p>Veel nieuwe lezers zijn mogelijk nog niet bekend met het Terra-project, dus laten we hier een korte aanvulling maken.</p>
<p>Na de ineenstorting van het Terra-ecosysteem in mei vorig jaar bouwde het team de nieuwe openbare keten Terra 2.0 op, waarbij de token nog steeds zijn oorspronkelijke naam LUNA gebruikte. Het oorspronkelijke Terra-netwerk kreeg de naam Terra Classic en de bestuurstoken LUNA werd hernoemd naar LUNA Classic (dwz LUNC eerder genoemd). De overeenkomstige algoritme-stabiele munt UST werd hernoemd naar Terra Classic UST (dwz eerder USTC genoemd) volgens dezelfde regels.</p>
<h2 id="h2-Mint20Cash20Team20roept20op20tot20bestellingen20om20USTC20te20roeren426885"><a name="Mint Cash Team roept op tot bestellingen om USTC te roeren" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Mint Cash Team roept op tot bestellingen om USTC te roeren</h2><p>Wellicht geïnspireerd door de populaire gameplay van cryptocurrency exchange Backpack bound SOL airdrops gelanceerd door voormalige FTX utives, heeft het Mint Cash project van Terra’s ecosysteem nieuwe stablecoin de laatste tijd blijven verspreiden nieuws over de airdrop door USTC-houders, en heeft eindelijk de marktenthousiasme aangewakkerd in de nabije toekomst.</p>
<p>Volgens het witboek is Mint Cash een stablecoin-project ontwikkeld door het oorspronkelijke Anchor-team op basis van de Terra Classic oorspronkelijke code-opslagplaats, volledig ondersteund door <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> als onderpand, gericht op het bereiken van een volledig gedecentraliseerde betalings- en spaardoelstelling.</p>
<p>Het moet worden opgemerkt dat de officiële website van Mint Cash momenteel alleen whitepapers en sociale media-accounts heeft, en er zijn geen daadwerkelijke of zelfs testversies van producten beschikbaar.<img src="https://gimg2.gateimg.com/image/article/170115941315481701159307_.pic.jpg" alt=""><br>Bron: mintca.sh</p>
<p>Met andere woorden, Mint Cash bereikte het aantrekkende effect door bevelen te schreeuwen zonder sterke KOL-ondertekening.</p>
<p>Volgens teamleden zal Mint Cash op twee manieren een koude start uitvoeren, waaronder:</p>
<p>(1) Gebruikers die $UST of $LUNA bezitten vóór 10 mei 2022;</p>
<p>(2) Vergrendel en vernietig een bepaalde hoeveelheid $USTC via de airdrop van Mint Cash.</p>
<p>De projectleider Shin Hyojin heeft duidelijk verklaard in de tweet dat deelnemers USTC op de Terra Classic-keten moeten vergrendelen om deel te nemen aan airdrops, en de wisselkoers is 1 USTC voor 1 Amerikaanse dollar. Naarmate er meer gebruikers deelnemen aan airdrops, zal het projectteam alle verzamelde USTC vernietigen om de marktcirculatie te verminderen. Bovendien verklaarde Shin Hyojin ook dat zelfs USTC-houders die niet hebben deelgenomen aan de airdrop zullen profiteren van het plan.</p>
<p>Daarom kunnen USTC-houders, als dit plan echt wordt uitgevoerd, duidelijk enorme winsten behalen, omdat de USTC-prijs op de 26e van deze maand slechts 0,02 USDT was, wat bijna 50 keer meer ruimte voor arbitragegroei aangeeft.<img src="https://gimg2.gateimg.com/image/article/170115945215491701159319_.pic.jpg" alt=""><br>Bron: X@shinhyojin1031</p>
<p>Naast de officiële aankondiging van de verwachte airdrop van Mint Cash, zijn ook veel gemeenschapsvoorstellen voor het revitaliseren van USTC en LUNC opgevat als een optimistische achtergrond voor markt FOMO.</p>
<p>Onlangs is het 11885-voorstel voor het implementeren van Terrad-client v2.3.1 op de keten goedgekeurd door de gemeenschap. Het is vermeldenswaard dat deze update belangrijke problemen oplost met betrekking tot de dynamische ante-decorator en accountvolgorde. De stemming is nog aan de gang, maar het voorstel werd in slechts één dag aangenomen.</p>
<p>Op 21 november stelde Dfunk, beheerder van de Terra Classic-gemeenschap, op een forum voor om het Terra Marketplace-module te reactiveren en geleidelijk de USTC te koppelen aan $1, inclusief het instellen van de prijsverschiltoeslag op 98% (geleidelijk afnemend) om de USTC-prijs effectief te stabiliseren op $2 of zelfs te verhogen naar 3 of 4 cent, waarbij 100% van de prijsverschiltoeslag wordt verbrand in plaats van het naar het Oracle-pool te sturen, enz. Het voorstel is echter nog niet in de stemfase beland vanwege bijna 100% replicatie van LUNA.</p>
<p>Vooruitkijkend werd in september van dit jaar het voorstel van de Terra Classic-gemeenschap 11324 ‘Reanchoring LUNC en UST’ goedgekeurd. Kort daarna stemde de Terra Classic-gemeenschap opnieuw om alle uitgifte van Terra Classic USD (USTC) stop te zetten en werd dit goedgekeurd met 59% steun. Het voorstel heeft tot doel gemeenschappen en externe investeerders te beschermen die momenteel USTC vernietigen om de verankering te herstellen.</p>
<h2 id="h2-Is20USTC20een20nieuwe20fles20oude20wijn20of20is20het20de20terugkeer20van20de20koning481954"><a name="Is USTC een nieuwe fles oude wijn, of is het de terugkeer van de koning?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Is USTC een nieuwe fles oude wijn, of is het de terugkeer van de koning?</h2><p>Kort gezegd zal het Mint Cash-project een nieuwe keten uitgeven die bijna overlapt en verschillende buff-nestingpoppen bundelt, waaronder Celestia (modulaire blockchain gericht op de datatoegankelijkheidslaag), nieuwe Anchor (voorheen Luna’s UST-spaarrente-protocol) en Nomic DAO (nBTC-protocol, dat BTC naar het Cosmos-ecosysteem brengt), onder andere.</p>
<p>Voor gebruikers die de vorige golf van Terra lancering hebben meegemaakt, zijn ze erg bekend met dit nestingpatroon, vooral in bullmarkten waar ze zeer rijke rendementen kunnen behalen.</p>
<p>Tot op zekere hoogte heeft de stijging van de USTC-prijzen een positieve invloed gehad op de markt. Ten eerste geeft dit aan dat mensen vertrouwen hebben in het Terra ecosysteem. Ten tweede versterkt dit ook de status van USTC als een stablecoin.</p>
<p>Mint Cash heeft inderdaad een gunstige poging gedaan om USTC’s uitbreiding van het gebruiksscenario naar vernietiging en deflatie te bevorderen. Als de werking van Mint Cash echt kan worden geïmplementeerd, zal het ongetwijfeld een nieuw voorwaartse spiralen-nestproject voortbrengen.</p>
<p>Aan de andere kant hebben vroege projecten in de PPT-fase ook potentiële risico’s. Op basis van de momenteel bekendgemaakte informatie is er niet veel correlatie tussen USTC en de latere scenario’s en gebruiksmogelijkheden van CASH en de nieuwe Anchor. Het Mint Cash-projectteam heeft duidelijk niet de financiële reserves en nobele sentimenten om de enorme USTC in te wisselen, dus er moet nog veel werk worden verzet achter het grote plan.<img src="https://gimg2.gateimg.com/image/article/170115949515501701159333_.pic.jpg" alt=""><br>Bron: X@cmdefi</p>
<p>Als we voorspellen vanuit het perspectief van het kapitaalspel, wanneer de prijs van USTC te hoog is, zal dit leiden tot een toename van arbitragehandel, wat op zijn beurt een prijsdaling veroorzaakt. Bovendien, als er een algemene paniek op de markt is, kan de USTC-prijs ook aanzienlijk dalen.</p>
<p>Het laatste nieuws dat we ontvingen aan het einde van dit artikel is dat Shin Hyojin heeft verklaard dat de airdrop meerdere tokens zal bevatten en dat de specifieke details worden afgerond. Mint Cash zal investeringen zoeken van VC. Deze tegenstrijdige verklaring heeft de marktenthousiasme echt getemperd en de muntkoers is verlaagd. Verder observatie is nodig in de toekomst.</p>
<p>Samengevat is de aanzienlijke stijging van de USTC-prijzen het gevolg van de positieve reactie van de belangrijkste markt op de verwachtingen van de Mint Cash airdrop en nieuwe communityvoorstellen. De markt is echter nog steeds vol onzekerheid, en voor investeerders die niet vroeg zijn ingestapt, moet voorzichtigheid nog steeds worden betracht.</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 opvattingen van de onderzoeker en vormt geen enkele 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 schending van het auteursrecht.<br></div><p></p><br></div></div></div></div>