R2xhc3Nub2RlIEluemljaHRlbjogRGUgVG9lbmFtZSBpbiBWbG9laWJhYXIgU3Rha2Vu

2023-07-05, 08:52

<p><img src="https://gimg2.gateimg.com/image/article/1688546613SDFX.jpeg" alt=""></p>
<h2 id="h2-Samenvatting397032"><a name="Samenvatting" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Samenvatting</h2><p>De introductie van <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Het intrekken van de stakingsfunctionaliteit van ‘s in medio april heeft een golf van interesse in liquide stakingstokens teweeggebracht.<br>Onder de aanbieders van liquide staking heeft Lido overweldigende dominantie gevestigd, met de hoogste aanvoer, liquiditeit en integratienetwerkeffecten, die allemaal zijn positie op de markt consolideren.</p>
<p>Een nieuwe trend heeft zich ontwikkeld met betrekking tot de DeFi-integratie van vloeibare stakingstokens. Liquiditeitspools die verband houden met vloeibaar staken zien een afname van de vergrendelde waarde, omdat kapitaal zich verplaatst naar gebruik als onderpand in uitleenprotocollen.</p>
<p><img src="https://gimg2.gateimg.com/image/article/168854666500_cover-1.png" alt=""></p>
<h2 id="h2-Relatieve20Prestatie401785"><a name="Relatieve Prestatie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Relatieve Prestatie</h2><p>De markt voor digitale activa verwerkt de reeks spot BTC ETF-aanvragen de afgelopen weken, met opmerkelijke BTC out-performance ten opzichte van de rest van de markt. Hoewel de ETF-indiening door BlackRock aanvankelijk de ETH-prijs met 11,2% heeft doen stijgen, is het Q2 verrassend rustig afgesloten met 6,4% boven zijn openingskoers in april.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1688546693ETHUSD-1.png" alt=""></p>
<p>Op relatieve basis hebben veel digitale activa terrein verloren tegenover <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> in 2023, met de ETH/BTC ratio die daalde naar een 50-weeks dieptepunt van 0.060. Deze ratio is echter weer gestegen naar 0.063, wat enige kracht laat zien bij het begin van juli.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1688546715ETHBTC.png" alt=""></p>
<p>Tot nu toe in 2023 hebben de stijgende ETH-prijzen nog niet geleid tot een significante toename van de netwerkactiviteit. Gas prijzen, die worden beschouwd als een proxy voor de vraag naar blockspace, zijn relatief laag gebleven, vooral in de week na de aankondigingen van de ETF-indiening. Ter vergelijking, tijdens de Shanghai-upgrade in april, die voorafging aan een vergelijkbare rally op de ETH-markten, stegen de gasprijzen met 78%, vergeleken met de 28% deze week.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1688546754Group-3191-2-.png" alt=""></p>
<h2 id="h2-Golven20van20nieuwe20staking20depositos426156"><a name="Golven van nieuwe staking deposito’s" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Golven van nieuwe staking deposito’s</h2><p>De Shanghai hardfork maakte het mogelijk om ETH die gestaked is uit het <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> consensusmechanisme te halen. In plaats van een golf van opnames te zien, heeft de upgrade juist een nieuwe golf van stortingen gemotiveerd, omdat stakers vertrouwen vinden in deze nieuwe flexibiliteit.</p>
<p>Het aantal stortingsactiviteiten (transacties) bereikte op 2 juni een piek, met meer dan 13.595 nieuwe stortingen (ter waarde van meer dan 408k ETH). Ter vergelijking kunnen we dit vergelijken met ETH-uitwisselingsstortings transacties, die gedurende deze periode op ongeveer 30k stortings transacties zijn blijven liggen.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1688546786deposits.png" alt=""></p>
<p>De explosie van nieuwe geïnvesteerde ETH is nog duidelijker als we ETH-volume met investeringen (blauw) vergelijken met het volume van instromen op de beurs (rood). Sinds Shanghai live ging, is het aantal nieuw geïnvesteerde ETH hoger geweest dan of gelijk aan het volume van instromen op de beurs.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1688546827exch_vs_stake.png" alt=""></p>
<p>Bij nadere beschouwing kunnen we dagelijkse stortingen per aanbieder isoleren, waarbij een zeer duidelijke trend in het voordeel van vloeibare stakingaanbieders duidelijk wordt, met Lido die deze trend leidt.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1688546843Group-3207-2.png" alt=""></p>
<h2 id="h2-Lido20Dominantie562855"><a name="Lido Dominantie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Lido Dominantie</h2><p>De bovenstaande observaties weerspiegelen een marktvraag naar vloeibare stakingsmunten (LST’s). Deze munten zijn effectief een omhulsel voor ETH die in de stakingspool is gestort, waarbij de stakingsoperaties worden geabstraheerd van de eindgebruiker door het platform.</p>
<p>Lido heeft op 15 mei zijn V2-update uitgebracht waarmee node-operators gestaakte ETH konden opnemen, waardoor houders van Lido’s stETH-token het konden omwisselen voor ETH. Na de release was er een inwisseling van 400k stETH ($721M), wat resulteerde in een inkrimping van de stETH-voorraad. De enorme golf van nieuwe ETH-stortingen heeft de daling echter meer dan gecompenseerd, waardoor er een nieuwe ATH van 7,49M stETH is bereikt.</p>
<p>Bij vergelijking met andere concurrenten op het gebied van liquid staking, steekt Lido eruit als de duidelijke leider in de sector, met een aanbod dat 16 keer hoger ligt dan dat van zijn naaste concurrent. Dat gezegd hebbende, groeit de aanvoer van rETH, de liquid staking token van Rocketpool, sinds het begin van dit jaar drie keer sneller dan die van Lido.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1688546872Group-3202.png" alt=""></p>
<p>Interessant genoeg wordt de toenemende vraag naar Lido’s stETH niet weerspiegeld in een toenemend aantal nieuwe tokenhouders. Terwijl we een toename in gebruikers van de staking tokens van Rocketpool en <a href="/price/frax-frax" target="_blank" class="blog_inner_link">FRAX</a> waarnemen na de Shanghai upgrade, heeft Lido geen significante groei geregistreerd in nieuwe gebruikers.</p>
<p>Het aantal nieuwe adressen dat stETH vasthoudt, schommelt tussen de 230-590 per dag, wat min of meer onveranderd is sinds het begin van het jaar. Dit leidt ons tot de conclusie dat veel nieuwe stortingen via Lido worden gestimuleerd door bestaande stETH-tokenhouders die hun blootstelling vergroten.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1688546896Group-3193-1-.png" alt=""></p>
<p>Bij het bekijken van het gemiddelde saldo van tokenhouders kunnen we schatten hoe de nieuw uitgegeven stETH-tokens zijn verdeeld. Nadat opnames werden ingeschakeld voor Lido, daalde het gemiddelde saldo van tokenhouders naar 46,1 stETH ($83k).</p>
<p>Het gemiddelde stETH-saldo is gestegen naar 51,0 stETH ($100k) sinds Shanghai, wat aangeeft dat bestaande tokenhouders inderdaad hun aandeel in ETH dat gestaked is in de vorm van stETH verhogen. Het suggereert ook dat we nog geen aanzienlijke toestroom van nieuwe houders zien die de markt betreden via deze stakingsmechanismen.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1688546921Group-3195-1-.png" alt=""></p>
<h2 id="h2-Verschuiving20van20LSTgebruik20in20DeFi809736"><a name="Verschuiving van LST-gebruik in DeFi" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Verschuiving van LST-gebruik in DeFi</h2><p>Een belangrijk verkoopargument van LST’s is hun integratie in DeFi-protocollen. LST-tokenhouders kunnen LST’s eenvoudig verhandelen op gedecentraliseerde beurzen, ze als onderpand gebruiken, of profiteren van opbrengstmogelijkheden via uitleenprotocollen.</p>
<p>Sinds hun oprichting hebben LST’s een toegenomen activiteit gezien binnen verschillende DeFi-protocollen, waarbij stETH van Lido de belangrijkste is. De netwerkeffecten en integraties van stETH zijn een andere factor die leidt tot Lido-dominantie in de sector. Onder de reeks DeFi-protocollen die LST’s accepteren, ontwikkelen zich echter verschillende interessante trends.</p>
<p>Sinds de Shanghai Upgrade heeft de stETH-ETH Curve Pool, de grootste liquiditeitspool voor Lido’s staking derivative, 39% van zijn totale waarde verloren. Het nadert nu de niveaus die te zien waren na de grote deleveraging na de <a href="/price/terra-luna" rel="nofollow noopener noreferrer" target="_blank">Terra</a>-Luna instorting in mei 2022.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1688546955Group-3196-1-.png" alt=""></p>
<p>Het onderzoeken van het wstETH-ETH Pool op <a href="/price/balancer-bal" rel="nofollow noopener noreferrer" target="_blank">Balancer</a>, we kunnen waarnemen dat deze trend nog meer uitgesproken is. Sinds 15 april is de TVL van deze pool met 71% afgenomen, waardoor de waarde van de pool is gedaald van $351,2 miljoen naar $101,4 miljoen.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1688546979Group-3197-1-.png" alt=""></p>
<p>Door de jaarlijkse opbrengst (APR) van beide pools te onderzoeken, kunnen we zien dat er in 2023 een consistente neerwaartse trend is vastgesteld. Voor onze analyse nemen we 15 april als referentiepunt, omdat rond die tijd de golf van nieuwe stakingsdeposito’s begon, evenals de afname van liquiditeit op de relevante DEXs.</p>
<p>De APR voor het Curve stETH-ETH pool is gedaald van 3,47% op 15 april naar 2,27% vandaag. Aan de andere kant heeft het <a href="/price/balancer-bal" target="_blank" class="blog_inner_link">Balancer</a> pool zijn laagste punt van 1,69% in april bereikt en is sindsdien licht gestegen naar 2,10%.</p>
<p>Houd er rekening mee dat APR’s voor liquiditeitspools bestaan uit verschillende beloningsstructuren die worden uitbetaald in verschillende tokens. Het Lido-project beloont Curve-liquiditeitsproviders bovendien met LDO-tokens, waarbij dit stimuleringsprogramma op 1 juni afloopt. Gezien de tegenstrijdige APR-trends op beide platforms, biedt alleen deze veranderende beloningsstructuur geen afdoende verklaring voor de afnemende liquiditeit.</p>
<p>Het kan zijn dat APR’s enigszins irrelevant zijn geworden voor LST-pools sinds de opening van opnames. Vóór Shanghai functioneerden liquiditeitspools als de enige bron van liquiditeit voor stakers, maar nu de vereiste om tussen stETH en ETH op DEXs te handelen is afgenomen, kunnen gebruikers direct bij het platform munt of inwisselen.</p>
<p>Dit kan wijzen op marktmakers die verminderde rendementsmogelijkheden zien als DeFi-liquiditeitsverschaffers. Bovendien kan deze trend versterkt zijn door de terugtrekking van verschillende grote marktmakers als gevolg van verhoogd toezicht door toezichthouders in de VS.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1688547011Group-3198-1-.png" alt=""></p>
<p>Aangezien we geen plotselinge liquiditeitsopnames zien als gevolg van het vertrek van een paar spelers, maar eerder een voortdurende trend, gaan we ervan uit dat deze afnames in liquiditeit waarschijnlijk te wijten zijn aan meer structurele verschuivingen.</p>
<p>Een andere verklaring zou kunnen zijn de toename van mogelijke opportunity kosten voor liquiditeitsverschaffers als gevolg van nieuwe inkomstenstromen over andere DeFi-protocollen. Uitleenpools zoals <a href="/price/aave-aave" rel="nofollow noopener noreferrer" target="_blank">Aave</a> of <a href="/price/compound-comp" rel="nofollow noopener noreferrer" target="_blank">Compound</a> waarmee LST’s als onderpand kunnen worden gebruikt en ze kunnen worden gekoppeld aan ETH. Deze gehefboomde stakingpositie wordt geschat op een versterking van de opbrengst met 3x.</p>
<p>Aave heeft een aanzienlijke toename gezien in TVL, vooral voor wstETH binnen de V3-leningenpool. Sinds de lancering eind januari 2023 is de wstETH-pool gegroeid tot meer dan S734,9M in waarde, terwijl de stETH-pool rond de $1,79B zweeft.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1688547042Group-3199-1-.png" alt=""></p>
<p>Ook het <a href="/price/compound-comp" target="_blank" class="blog_inner_link">Compound</a> V3 wstETH-zwembad heeft sinds de lancering eerder dit jaar aanzienlijke groei gezien, en heeft nu meer dan $42,2 miljoen aan stETH. Dit is een stijging van 817% sinds alleen al 9 mei. Het lijkt erop dat opbrengstdragende stakingderivaten steeds aantrekkelijker worden als onderpand in vergelijking met ETH en zelfs stabiele munten.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1688547065Group-3200-1-.png" alt=""></p>
<h2 id="h2-Samenvatting20en20conclusie343948"><a name="Samenvatting en conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Samenvatting en conclusie</h2><p>De Ethereum Shanghai-upgrade werd halverwege april voltooid, waardoor beleggers de opnamefase van de stakingsopbrengsthandel konden voltooien. In plaats van een golf van opnames te zien, versnelde de storting, waarbij een zeer duidelijke marktvoorkeur voor liquide stakingstokens naar voren kwam.</p>
<p>Van deze heeft Lido veruit het grootste marktaandeel veroverd, goed voor 7,5M aan gestoken ETH. Lido’s stETH heeft ook netwerkeffecten binnen de DeFi-sector, doordat het geïntegreerd en aangenomen wordt als een voorkeursbron van onderpand. Sinds Shanghai is er een opmerkelijke verschuiving geweest in de toewijzing van stETH-kapitaal binnen de DeFi-sector, waarbij DEX-liquiditeitspools krimpen en het gebruik van onderpand binnen uitleenprotocollen toeneemt.</p>
<p>Dit suggereert dat beleggers mogelijk een strategie voor het maximaliseren van het stakingsrendement spelen, waarbij ze stETH-belangen opbouwen via geleende hefboomwerking om rendementen te versterken.</p>
<p><strong>Disclaimer: Dit rapport geeft geen beleggingsadvies. Alle gegevens worden uitsluitend verstrekt ter informatie en educatieve doeleinden. Er mag geen beleggingsbeslissing worden genomen op basis van de hier verstrekte informatie en u bent volledig verantwoordelijk voor uw eigen beleggingsbeslissingen.</strong></p>
<div class="blog-details-info"><br><div>Auteur: Glassnode Insights<br><div>Redacteur: Gate.io Blog Team<br><div class="info-tips">*Dit artikel vertegenwoordigt alleen de standpunten van de onderzoeker en vormt geen enkele beleggingssuggestie.<p></p><br></div></div></div></div>