R2xhc3Nub2RlIEluc2lnaHRzOiBJcyBEZUZpIHRlcnVnIGluIGRlIGJ1c2luZXNzPw==

2023-08-01, 09:29

<p><img src="https://gimg2.gateimg.com/image/article/1690880674SDFX.jpeg" alt=""></p>
<h2 id="h2-Uitvoerige20samenvatting278844"><a name="Uitvoerige samenvatting" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Uitvoerige samenvatting</h2><p>Diverse positieve ontwikkelingen in de digitale activa-industrie, evenals ontwikkelingen binnen de DeFi-sector, hebben geleid tot hernieuwde interesse van investeerders in DeFi-tokens.</p>
<p>De toename van de interesse in DeFi-tokens heeft de interesse gewekt van marktmakers, die de liquiditeit in de betreffende pools hebben vergroot. Dit duidt op een positief vooruitzicht voor handel en prijsactiviteiten rondom deze tokens.</p>
<p>Verdere analyse van <a href="/price/uniswap-uni" rel="nofollow noopener noreferrer" target="_blank">Uniswap</a> De handelsvolumeverdeling van ‘s onthult dat een aanzienlijk deel van de handelsactiviteit kan worden toegeschreven aan bots, die zich voornamelijk richten op ETH-Stablecoin-paren.</p>
<p><img src="https://gimg2.gateimg.com/image/article/169088144700_cover-14.png" alt=""></p>
<h2 id="h2-Altcoins20weer20in20de20smaak452796"><a name="Altcoins weer in de smaak?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Altcoins weer in de smaak?</h2><p>In de afgelopen maanden hebben altcoinmarkten een strijd gezien tussen positief en negatief nieuws, gedreven door verschillende belangrijke ontwikkelingen:</p>
<p>Begin juni heeft de SEC 68 cryptocurrencies aangemerkt als niet-geregistreerde effecten, wat een demper heeft gezet op de marktinteresse in altcoins buiten… <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> en <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a>. Veel van deze tokens hadden al slechte prestaties gezien vóór dit nieuws, dat we bespraken in ons rapport ‘Omgaan met de DeFi Downtrend’.</p>
<p>De indiening van <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> spot ETF’s door financiële reuzen zoals BlackRock en Fidelity resulteerde in een opleving van marktsentiment, die zich uitstrekte tot voorbij Bitcoin en in de bredere digitale activaruimte.</p>
<p>Bovendien, het vonnis van de zaak Ripple Labs vs. SEC in medio juli, waarin werd geoordeeld dat het crypto bedrijf geen inbreuk heeft gemaakt op de federale effectenwetgeving door de verkoop van haar <a href="/price/xrp-xrp" rel="nofollow noopener noreferrer" target="_blank">XRP</a> De overwinning van <a href="/price/xrp-xrp" target="_blank" class="blog_inner_link">XRP</a> op openbare beurzen heeft een positief signaal afgegeven voor andere op in de VS gebaseerde cryptoprojecten en de sector in het algemeen. De overwinning van XRP heeft altcoin-investeerders enige hoop gegeven met betrekking tot robuustheid tegen verdere regelgevingsmaatregelen.</p>
<p>Met name tokens die verband houden met de DeFi sector hebben de sterkste prestaties laten zien, met onze DeFi indexprijs die met 56% is gestegen sinds het dieptepunt op 11 juni. Andere belangrijke marktsectoren zoals GameFi en Staking hebben daarentegen minder gepresteerd.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1690881458Group-137691265.png" alt=""></p>
<p>Onze DeFi-index bestaat uit de top 8 DeFi-tokens op basis van marktkapitalisatie en heeft een bijna twee maanden durende stijgende trend ten opzichte van ETH. Dit is de eerste overperformance sinds september 2022 en tot nu toe met een zeer vergelijkbare prestatie.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1690881467The-Metric-Factory-52-.png" alt=""></p>
<p>Als we echter afzonderlijk naar de acht belangrijkste DeFi-tokens kijken, vallen twee tokens op als belangrijkste drijfveer van deze trend: MKR en COMP. Bij nader onderzoek kunnen we zien dat de prestaties mogelijk nauw verband houden met nieuwe projectfundamenten, eerder dan bredere marktontwikkelingen.</p>
<p>Op 28 juni, <a href="/price/compound-comp" rel="nofollow noopener noreferrer" target="_blank">Compound</a> De oprichter en CEO, Robert Leshner, heeft zijn vertrek aangekondigd bij het uitleenprotocol, evenals de lancering van een nieuw project dat zich richt op het brengen van gereguleerde financiën naar blockchain-netwerken. Na deze aankondiging steeg de COMP-token met maximaal 83% in een week.</p>
<p>Rond dezelfde tijd activeerde MakerDAO zijn Smart Burn Engine, een terugkoopprogramma dat overtollige DAI van het protocol gebruikt om MKR uit een Uniswap-pool te kopen. Het vooruitzicht om in één maand ongeveer $7 miljoen aan MKR te verwijderen, deed de prijs van de token met maximaal 43% stijgen in de week.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1690881575Group-137691266-1-.png" alt=""></p>
<p>Door de DEX vs. CEX uitwisselingstransacties voor de top acht DeFi-tokens te onderzoeken, kunnen we zien dat er hernieuwde interesse is in DEX-activiteit. Het relatieve aandeel van het handelsvolume op DEXs is gestegen van 3,75% aan het begin van juni tot 29,2% vandaag, dicht bij de hoogtepunten die werden gezien tijdens de tweede helft van 2022.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1690881586Group-137691267-1-.png" alt=""></p>
<h2 id="h2-Gemengde20soorten20Uniswaphandel964243"><a name="Gemengde soorten Uniswap-handel" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Gemengde soorten Uniswap-handel</h2><p>Met deze toename in DEX-activiteit kunnen we onderzoeken hoe deze recente ontwikkelingen van invloed zijn geweest op DEX-activiteit en eventuele mogelijke implicaties voor belanghebbenden. Onze primaire focus zal liggen op Uniswap, de toonaangevende DEX, die ook de meest significante verbruiker van gas is geweest in de afgelopen week.</p>
<p>Wat betreft de handelsvolume van <a href="/price/uniswap-uni" target="_blank" class="blog_inner_link">Uniswap</a> op Ethereum, blijft het huidige niveau van $5,57 miljard per week aanzienlijk lager dan in voorgaande jaren. Er was een volume-uitbarsting gerelateerd aan de interesse rond Liquid Staking Tokens eerder in 2023, evenals een kortstondige opleving in ‘meme-token’, die sindsdien is vervaagd.</p>
<p>Vanuit dit perspectief kunnen we zien dat de recente opwinding rond de BTC ETF-aanvragen en het vonnis van Ripple vs. SEC geen merkbare toename in handelsactiviteit heeft veroorzaakt op Uniswap.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1690881656Group-137691269.png" alt=""></p>
<p>Door de verdeling van het handelsvolume van Uniswap over verschillende Layer 2’s te onderzoeken, krijgen we een duidelijker beeld. Het wordt duidelijk dat een aanzienlijk deel van de handel is verschoven van het Ethereum-mainnet naar Arbitrum, waarbij tot 32% van het volume in maart werd aangetrokken. Deze trend is in juni en juli hoog gebleven, wat enigszins verklaart waarom het handelsvolume op <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> lager is dan we hierboven hebben waargenomen.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1690881688Group-137691270.png" alt=""></p>
<h2 id="h2-Bots20vs20Mensen61433"><a name="Bots vs. Mensen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Bots vs. Mensen</h2><p>Een andere manier om Uniswap-handelsactiviteit in perspectief te plaatsen, is te kijken naar het type handelaar dat het uitvoert. Sinds 2019 hebben we de opkomst gezien van verschillende soorten MEV-bots, geautomatiseerde programma’s die de blockchain controleren om lucratieve transacties te detecteren en te exploiteren. Voor deze analyse zullen we ons alleen richten op twee soorten; Arbitrage- en Sandwich-bots.</p>
<p>Arbitrage bots streven ernaar winst te maken uit prijsverschillen tussen hetzelfde token-paar op verschillende DEXs en CEXs.</p>
<p>Sandwich-bots werken door hun transacties vóór de doelhandelaar (neem aan een koper) in te voegen, wat resulteert in een uitvoering tegen een bredere spread. Daarna zal de sandwich-bot het activum opnieuw verkopen om de spread te sluiten en de waarde aan beide zijden te maximaliseren.<br>De onderstaande grafiek toont het aandeel van de handelsvolumes op Uniswap (op Ethereum) dat afkomstig is van bot-handel in vergelijking met handel door mensen.</p>
<p>We merken op dat Sandwich-bots over het algemeen goed zijn voor meer dan 60% van het dagelijkse volume. Het volumeaandeel van Arbitrage-bots is sinds het begin van het jaar gedaald van ongeveer 20% naar 10%. Ondertussen is het aandeel van het volume gecreëerd door menselijke handelaren gestegen tot 30% sinds begin juli, in lijn met de periode van verhoogde interesse in DeFi-tokens.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1690881764Group-137691271-1-.png" alt=""></p>
<p>Aangezien het volume op verschillende manieren kan worden opgeblazen door verschillende soorten botaanvallen, biedt het dagelijkse aantal transacties per handelstype een ander perspectief op de vergelijking.</p>
<p>We kunnen zien dat menselijke handelaren zeer actief waren tijdens belangrijke gebeurtenissen zoals de USDC-depegging of de meme-token manie. Met grotere prijsvolatiliteit en een toestroom van ‘doelhandelaren’ volgen zowel Arbitrage- als Sandwich-bots, en worden tot drie keer zo actief tijdens deze pieken in menselijke handel.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1690881794Group-137691273.png" alt=""></p>
<p>De interactieve grafiek hieronder toont de voorkeurstoken en -pool voor elk type handelaar, waarbij alle drie typen handelaren duidelijk de voorkeur geven aan de grootste en meest liquide handelsparen ETH-USDC en ETH-USDT.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1690881941WX20230801-172521@2x.png" alt=""></p>
<h2 id="h2-Liquiditeitspools20als20informatiemarkten760256"><a name="Liquiditeitspools als informatiemarkten" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Liquiditeitspools als informatiemarkten</h2><p>Sinds de introductie van Uniswap V3 kunnen liquiditeitsverschaffers liquiditeit verdelen binnen specifieke prijsbereiken binnen het zwembad. In plaats van liquiditeit te verspreiden over een oneindig prijsbereik, kan liquiditeit efficiënter geconcentreerd worden rond prijsbereiken waar de investeerder de hoogste handelsvolumes verwacht (om kosten te innen).</p>
<p><img src="https://gimg2.gateimg.com/image/article/1690881978image-11.png" alt=""></p>
<p>Sinds de aankondiging van het Maker terugkoopprogramma was de meest succesvolle liquiditeitspool voor Maker op Uniswap V3 de MKR/WETH-pool, die een opmerkelijke toename in liquiditeit heeft ervaren.</p>
<p>Hoewel de pool traditioneel voornamelijk MKR-fondsen heeft vastgehouden, is de liquiditeitsdiepte van WETH met meer dan 700% gestegen. Dit suggereert dat liquiditeitsverschaffers een verwachting van hogere handelsvolumes voor het MKR-WETH-paar aangeven.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1690882014pool_liq-1.png" alt=""></p>
<p>Bij het onderzoeken van de samenstelling van het fonds kunnen we duidelijk zien dat het aandeel van WETH is toegenomen, wat nu 21,2% van het totaal vertegenwoordigt. Dit is het gevolg van handelaren die steeds meer MKR kopen met WETH, wat wijst op een duidelijke stijging in de vraag naar MKR sinds het begin van juni.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1690882039Group-137691275.png" alt=""></p>
<p>Als laatste willen we een idee voorstellen over hoe de liquiditeitspools van Uniswap kunnen functioneren als een vorm van informatiemarkt voor de verwachte prijsontwikkeling van tokens. Als we nauwkeuriger kijken naar de MKR-WETH-liquiditeit die buiten bereik is geplaatst, kunnen we duidelijk zien dat de liquiditeit verhoogd is bij prijsniveaus die veel hoger liggen dan de MKR/ETH-wisselkoers.</p>
<p>Naarmate liquiditeitsverschaffers hun kapitaal verplaatsen naar hogere prijsniveaus, drukken ze op een bepaalde manier een vorm van out-of-the-money optie uit op de vergoedingeninkomsten op hogere prijspunten. Onder de veronderstelling dat liquiditeitsverschaffers rationele winstzoekende actoren zijn, kan de beweging van hun liquiditeit inzicht geven in de verwachte volatiliteit en verwachte reikwijdte voor de token van interesse, vergelijkbaar met de optiemarkt.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1690882064Group-137691276.png" alt=""></p>
<h2 id="h2-Samenvatting20en20Conclusies234684"><a name="Samenvatting en Conclusies" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Samenvatting en Conclusies</h2><p>De regelgevingsomgeving rond digitale activa is in 2023 heen en weer gegaan, met een gevarieerde mix van positief en negatief nieuws. DeFi-tokens hebben met name de afgelopen weken een bovengemiddelde prestatie geleverd, geleid door MKR en COMP. Echter, na het onderzoeken van handelsactiviteiten op Uniswap, blijkt dat deze prijsstijgingen niet zijn weerspiegeld in een stijging van de handelsactiviteiten op DEX.</p>
<p>Een verklaring hiervoor is zowel een groter aandeel van de handelsvolume dat plaatsvindt op L2’s zoals Arbitrum, maar ook door een minder aanwezigheid van menselijke handelaren. Met minder menselijke transacties is er een even lichte mate van arbitrage en sandwichbot-activiteit.</p>
<p>In het g van MKR is er een opmerkelijke toename geweest van market makers die liquiditeit verschaffen in Uniswap-pools, wat wijst op een zekere mate van anticipatie op een toename van de handelsvolumes. Van hieruit stellen we een concept voor waarbij de verdeling van liquiditeit mogelijk informatie kan verschaffen over de verwachte handelsbereiken voor de betreffende token.</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 uitsluitend 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 beleggingsaanbevelingen.<p></p><br></div></div></div></div>