R2xhc3Nub2RlIEluc2lnaHRzOiBSaXNpY28tdWl0IENhcGl0YWwgUm90YXRpZQ==

<p><img src="https://gimg2.gateimg.com/image/article/1686044173SDFX.jpeg" alt=""></p>
<p>De rust en kalmte blijven heersen op de digitale activamarkten, waarbij de prijs van ETH deze week beperkt blijft tot een bereik van $68 (3,6%), met handel tussen een dieptepunt van $1.861 en een hoogtepunt van $1.931. Afgezien van een kleine stijging in ETH-markten na de Shanghai-upgrade, zijn de ETH-prijzen min of meer vlak gebleven sinds medio maart.</p>
<p>Terwijl de markt zijwaarts beweegt, zijn er groeiende verschillen in marktvoorkeur die zich onder de oppervlakte voordoen, waarbij velen wijzen op een risico-avers klimaat. Handelsvolumes blijven laag, het gebruik van DeFi wordt steeds meer geautomatiseerd en er groeit een marktvoorkeur voor stablecoins, specifiek voor <a href="/price/tether-usdt" rel="nofollow noopener noreferrer" target="_blank">Tether</a> (USDT).</p>
<p><img src="https://gimg2.gateimg.com/image/article/168604420500_cover-5.png" alt=""></p>
<p>In deze editie zullen we deze zich ontwikkelende onderstromen verkennen, en hoe we ze kunnen waarnemen aan de hand van on- en off-chain gegevens.</p>
<p><img src="https://gimg2.gateimg.com/image/article/168604424501_price.png" alt=""></p>
<h2 id="h2-Geautomatiseerde20arbitrage749464"><a name="Geautomatiseerde arbitrage" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Geautomatiseerde arbitrage</h2><p>Terwijl ETH-prijzen sinds maart relatief vlak en gebonden aan een bereik zijn gebleven, hebben gasprijzen wel een aanzienlijke stijging doorgemaakt in de maand mei. Gasprijzen stegen naar een gemiddelde gasprijs van 76 Gwei, wat neerkomt op $1,14 voor een reguliere ETH-overdrachtstransactie. De gemiddelde gasprijs bereikte begin mei meer dan 155 Gwei ($6,53 per ETH-overdracht), wat bijna net zo hoog is als tijdens de bull-cyclus van 2021-22.</p>
<p><img src="https://gimg2.gateimg.com/image/article/16860443022.png" alt=""></p>
<p>Smart contractinteracties zijn intensiever op het gebied van gas en kunnen meervoudig kosten dan een eenvoudige overdracht. Het gasverbruik dat gepaard gaat met DeFi-protocollen steeg in april met 270%, waardoor het dagelijkse gasverbruik in de sector boven de 20B gas-eenheden uitkwam.</p>
<p><img src="https://gimg2.gateimg.com/image/article/16860460103.png" alt=""></p>
<p>Als we DeFi-gas per protocol ontleden, bepalen we snel dat de belangrijkste stijging in activiteit wordt gedreven door handelsactiviteit op gedecentraliseerde beurzen. <a href="/price/uniswap-uni" rel="nofollow noopener noreferrer" target="_blank">Uniswap</a> blijft de belangrijkste locatie, met een toename van 388% in gasverbruik sinds april, en vertegenwoordigt nu tussen 7,7% en 14,4% van het totaal <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> gasbehoefte.</p>
<p><img src="https://gimg2.gateimg.com/image/article/16860460634.png" alt=""></p>
<p>Wie het nieuws volgt, zou kunnen aannemen dat deze toename in activiteit te wijten is aan de recente Memecoin-hype, die draaide om tokens zoals PEPE en HEX. Echter, een meer gedetailleerde analyse van het handelsvolume op <a href="/price/uniswap-uni" target="_blank" class="blog_inner_link">Uniswap</a> geeft een gedetailleerder beeld.</p>
<p>De grafiek hieronder toont de top verhandelde pools op Uniswap en onthult dat de hoogste volumes in de afgelopen 30 dagen voornamelijk gerelateerd waren aan activa met een grotere marktkapitalisatie zoals ETH, stablecoins, WBTC en de stakingsderivaten cbETH van Coinbase.</p>
<p><img src="https://gimg2.gateimg.com/image/article/16860455455.png" alt=""></p>
<p>Na het vergelijken van de adressen van de top 10 handelaren met onze labels, hebben we ontdekt dat allemaal behalve één in verband stonden met MEV-bots. Met de beruchte MEV-bot jaredfromsubway.eth die meer dan 3 miljard dollar heeft verdiend in de afgelopen maand.</p>
<p>Hoewel er verder onderzoek nodig is om te bepalen hoeveel van de wereldwijde pool van handelaren bots zijn, geeft de omvang gegenereerd door de top tien ons al een idee van hoeveel van het volume van Uniswap in feite geautomatiseerde arbitrage kan zijn.</p>
<p>Een manier om dit te rationaliseren is om rekening te houden met het exponentiële bereik van arbitragemogelijkheden die beschikbaar zijn via <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> DEXs:</p>
<ul>
<li><p>Naarmate de prijs van elke token (+ slippage) verandert, zal uiteindelijk de gasvergoeding een arbitragetransactie rechtvaardigen.</p>
</li><li><p>Elke DEX pool die deze token host, biedt een locatie voor een arbitragetransactie.</p>
</li><li><p>Het aantal mogelijke arbitragetransactiekansen zal dus exponentieel groeien, gerelateerd aan zowel het aantal DEX-liquiditeitspools als het aantal beschikbare tokens om te verhandelen.</p>
</li></ul>
<p>Als we rekening houden met het feit dat veel bots zich bezighouden met arbitrage of sandwich-aanvallen, kan het niveau van ‘organisch’ handelsvolume op Uniswap wel eens meer dan tweederde van alle DEX-activiteit vertegenwoordigen.</p>
<p><img src="https://gimg2.gateimg.com/image/article/16860464136.png" alt=""></p>
<p>Hoewel de activiteiten van deze handelsrobots schadelijk kunnen zijn voor eindgebruikers van Ethereum, hebben ze voordelen voor Ethereum-validatoren. In de afgelopen maand hebben validators niet alleen hogere beloningen verdiend door verhoogde prioriteitskosten, maar ook geprofiteerd van MEV-boostbetalingen. Deze betalingen worden verzameld van handelaren en robots die betalen om hun transacties op de meest winstgevende manier in een blok te laten ordenen.</p>
<p>Dit benadrukt op veel manieren een steeds gunstiger trend voor ETH die gestaked is als een primaire activa binnen het Ethereum-ecosysteem. Dit stelt ook een inheemse drempelrente vast waarmee tokens moeten concurreren om kapitaalstromen aan te trekken.</p>
<p><img src="https://gimg2.gateimg.com/image/article/16860456517.png" alt=""></p>
<h2 id="h2-RiskOff20Rotatie399220"><a name="Risk-Off Rotatie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Risk-Off Rotatie</h2><p>Er zijn ook sterke aanwijzingen van kapitaalrotatie die lager op de risicocurve beweegt, verschuift naar stablecoins en BTC als liquiditeit afneemt. Als we beginnen met Ethereum Futures-markten, kunnen we inzicht krijgen in marktdeelnemers buiten de crypto-native handelaren die meestal te vinden zijn op gedecentraliseerde beurzen.</p>
<p>Na de ineenstorting van FTX daalde het handelsvolume van futures naar slechts ~ $ 7,5 miljard / dag. Het volume is echter teruggekomen in 2023, maar het 30-daagse gemiddelde ($ 12,0 miljard / dag) blijft ruim onder het jaargemiddelde ($ 21,5 miljard / dag).</p>
<p>In tegenstelling tot de stijging in Uniswap-handelsactiviteit, is de handel in futures in mei blijven krimpen, wat erop wijst dat institutionele handelsbelangstelling en liquiditeit nog steeds behoorlijk zwak zijn.</p>
<p><img src="https://gimg2.gateimg.com/image/article/16860456838.png" alt=""></p>
<p>We kunnen een ondersteunende trend zien in de relatieve volume dominantie tussen BTC en ETH in de eeuwigdurende swapmarkten. Terwijl de handelsvolumes tussen beide activa eind 2022 gelijk waren, is het relatieve aandeel van Ethereum in de futurevolumes in 2023 enorm afgenomen.</p>
<p>ETH vertegenwoordigt momenteel 34,5% van het handelsvolume tussen de twee belangrijkste valuta’s, wat erop wijst dat de liquiditeit naar beneden beweegt op de risicokromme en de voorkeur geeft aan concentratie op BTC-markten op een relatieve basis.</p>
<p><img src="https://gimg2.gateimg.com/image/article/16860457199.png" alt=""></p>
<p>On-chain data biedt een andere kijk op kapitaalstromen en rotatie binnen cryptomarkten. De onderstaande grafiek vergelijkt de totale in USD uitgedrukte waarde van ETH versus stablecoins die in en uit beurzen stromen. Tijdens de enorme deleveraging in 2022 ontwikkelde zich een opvallende verschuiving in de voorkeur van investeerders, waarbij de dominantie van ETH in kapitaalstromen daalde van ~35% naar 10%.</p>
<p>In 2023 zagen we een sterke ommekeer, waarbij het aandeel van ETH in de uitwisselingsstromen weer steeg naar 25%. Deze trend stagneerde echter begin mei, wat wijst op een mogelijke verandering in het risicoverlangen. Beleggers die hebben geprofiteerd van de sterke rendementen van het eerste kwartaal, kunnen beginnen met het overbrengen van kapitaal naar stablecoins.</p>
<p><img src="https://gimg2.gateimg.com/image/article/168604576610.png" alt=""></p>
<p>Een andere manier om deze conclusie te versterken is door de dagelijkse uitwisselingsinstroom van elk activum te vergelijken als een maatstaf voor koop- en verkoopdruk. Voor dit vereenvoudigde model gaan we ervan uit dat BTC+ETH-uitwisselingsinstroom de verkoopdruk vertegenwoordigt, terwijl stablecoin-instroom de koopdruk vertegenwoordigt.</p>
<p>Negatieve waarden suggereren dat we sinds het begin van april 2023 een nettoregime van verkopende partijen hebben gezien, waarbij de instroom van BTC+ETH begon te overtreffen die van stablecoins. Dit is een duidelijke breuk met de aanzienlijke koopdruk die in Q1 werd waargenomen, met een verzwakking van de koopzijde begin april, wat samenviel met het begin van de heersende marktcorrectie.</p>
<p><img src="https://gimg2.gateimg.com/image/article/168604579711.png" alt=""></p>
<p>Over het algemeen heeft kapitaal de neiging om <a href="/price/flow-flow" rel="nofollow noopener noreferrer" target="_blank">Stroom</a> in digitale activa via de twee belangrijkste, BTC en ETH, of via stablecoins. Daarom kunnen we de richting van de totale kapitaalstromen schatten door twee metrieken te aggregeren en te vergelijken:</p>
<ul>
<li><p>Gerealiseerde kapitalisatie voor BTC en ETH (zijnde de nettowijziging in waarde voor munten die on-chain worden verplaatst)</p>
</li><li><p>Circulerende voorraad voor stablecoins (rekening houdend met USDT, USDC, BUSD, TUSD en DAI)</p>
</li></ul>
<p>Hieruit kunnen we zien dat kapitaalstromen naar de cryptomarkten voornamelijk worden gedreven door een toename van kapitaalstromen naar BTC (+$4,47 miljard per maand), gevolgd door ETH (+$3,5 miljard per maand). Dit is echter deels gecompenseerd door ongeveer -$1,2 miljard aan kapitaaluitstroom uit stablecoins, omdat er aanzienlijke terugbetalingen plaatsvinden binnen de stablecoinsector.</p>
<p><img src="https://gimg2.gateimg.com/image/article/168604583412.png" alt=""></p>
<p>Recente uitstroom van kapitaal uit stablecoins wordt voornamelijk gedreven door de twee (USDC) en derde (BUSD) grootste activa, waarbij de voorraden respectievelijk in 2023 met -$15,7B en $-11,5B dalen. USDT heeft een aanzienlijk deel van deze stromen opgenomen, waardoor de voorraad naar een nieuw ATH-niveau van $83,1B is gestegen.</p>
<p>Waarschijnlijk weerspiegelt dit een geografische divergentie, waarbij Amerikaanse gereguleerde entiteiten historisch gezien de voorkeur hebben gegeven aan USDC boven USDT.</p>
<p><img src="https://gimg2.gateimg.com/image/article/168604586613.png" alt=""></p>
<p>We sluiten af ​​door op te merken dat een vergelijkbare divergentie zichtbaar is in de jaar-op-jaar BTC-aanbodverandering op basis van geografische regio’s. De extreme dominantie van Amerikaanse entiteiten in 2020-21 is duidelijk omgekeerd, met een daling van de Amerikaanse aanbod dominantie met 11% sinds medio 2022. Europese markten zijn het afgelopen jaar redelijk neutraal geweest, terwijl er een aanzienlijke toename van aanbod dominantie zichtbaar is tijdens de Aziatische handelsuren.</p>
<p><img src="https://gimg2.gateimg.com/image/article/168604589714.png" alt=""></p>
<h2 id="h2-Samenvatting20en20Conclusies564410"><a name="Samenvatting en Conclusies" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Samenvatting en Conclusies</h2><p>In de afgelopen maand is er een toename geweest van activiteit op gedecentraliseerde beurzen, met name op Uniswap. Hoewel men zou kunnen denken dat Memecoins deze activiteiten hebben veroorzaakt, blijkt uit nader onderzoek dat het grootste deel van het volume werd gegenereerd op grotere en diepere WETH-stablecoin pools. Opmerkelijk genoeg lijkt slechts een fractie van deze handelsactiviteiten organisch te zijn geweest, wat suggereert dat het voornamelijk arbitrage, MEV en algoritmische handel betreft.</p>
<p>Nu de Amerikaanse rentetarieven meer dan 5% bedragen, zijn niet-rentedragende stablecoins minder aantrekkelijk geworden, vooral voor beleggers met toegang tot Amerikaanse kapitaalmarkten. <a href="/price/tether-usdt" target="_blank" class="blog_inner_link">Tether</a> daarentegen heeft historisch gezien een bredere acceptatie gevonden in markten buiten de VS, waar nationale valuta vaak zwakker zijn en toegang tot USD minder gebruikelijk is. Op dezelfde manier lijkt er, te midden van een steeds vijandiger wordende regelgevende omgeving in de VS, kapitaal uit te stromen en oostwaarts te stromen in de digitale-activasector.</p>
<p>Veel hiervan wijst op een algemene risico-aversie, waarbij het resterende kapitaal zich concentreert in de meer liquide majors en een groeiende voorkeur heeft voor stablecoin-kapitaal.</p>
<p><strong>Disclaimer: Dit rapport biedt geen beleggingsadvies. Alle gegevens worden uitsluitend verstrekt voor informatieve en educatieve doeleinden. Er mag geen beleggingsbeslissing worden genomen op basis van de hier verstrekte informatie en u bent als enige verantwoordelijk voor uw eigen beleggingsbeslissingen.</strong></p>
<div class="blog-details-info"><br><div>Auteur: Glassnode Insights<br><div>Editor: Gate.io Blog Team<br><div class="info-tips">*Dit artikel vertegenwoordigt alleen de standpunten van de onderzoeker en vormt geen enkele beleggingsaanbeveling.<br></div><p></p><br></div></div></div>