R2xhc3Nub2RlIEluc2lnaHRzOiBIZXQgdm9sZ2VuIHZhbiBzZW50aW1lbnQgdmlhIGxpcXVpZGl0ZWl0c3Bvb2xz

2023-09-05, 07:32

<p><img src="https://gimg2.gateimg.com/image/article/1693898020SDFX 1.jpeg" alt=""></p>
<h2 id="h2-Samenvatting413061"><a name="Samenvatting" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Samenvatting</h2><p>De volatiliteit gedreven door evenementen is de afgelopen weken teruggekeerd in de digitale activamarkten, waarbij opvallende indicatoren van totale kapitaaluitstroom werden gemeld voordat dit gebeurde.</p>
<p>Derivatenmarkten laten voortdurend liquiditeitsverlies zien, met name bij ETH-futures, wat erop wijst dat kapitaal blijft bewegen naar hogere risiconiveaus voor relatieve veiligheid.</p>
<p>We duiken diep in hoe <a href="/price/uniswap-uni" rel="nofollow noopener noreferrer" target="_blank">Uniswap</a> Liquiditeitspools hebben veel overeenkomsten met optiemarkten, waarbij liquiditeitsverschaffers een mening geven over zowel volatiliteit als prijsniveaus.</p>
<p><img src="https://gimg2.gateimg.com/image/article/169389810000_cover.png" alt=""></p>
<h2 id="h2-Digitale20activamarkten20ontwaken695814"><a name="Digitale activamarkten ontwaken" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Digitale activamarkten ontwaken</h2><p>De afgelopen weken zijn digitale activamarkten wakker geschud uit een periode van historisch lage volatiliteit. Dit werd voornamelijk veroorzaakt door twee belangrijke gebeurtenissen:</p>
<ul>
<li><p><strong>De flash-crash op 17 aug</strong> waar BTC en ETH respectievelijk met -11% en -13% zijn verkocht.</p>
</li><li><p><strong>Nieuws over de juridische overwinning van Greyscale op de SEC brak op 29 augustus uit</strong>, het rijden van prijzen kortstondig hoger, maar al het gewonnen terrein ging verloren in de daaropvolgende drie dagen.</p>
</li></ul>
<p>Spotprijzen voor zowel BTC als ETH bevinden zich momenteel rond de dieptepunten van augustus.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1693898086Group-137691447-2.png" alt=""></p>
<p>Een belangrijke maatstaf voor het volgen van de totale kapitaalstromen naar de industrie is de maatstaf voor het gerealiseerde totaalbedrag. Deze tool combineert:</p>
<ul>
<li><p>De gerealiseerde marktkapitalisatie van de twee belangrijkste cryptocurrencies BTC en ETH</p>
</li><li><p>De levering van de vijf toonaangevende stablecoins USDT, USDC, BUSD, DAI en TUSD.</p>
</li></ul>
<p>Hieruit blijkt dat de markt begin augustus een regime van kapitaaluitstroom was ingegaan, ruim voor deze twee belangrijke gebeurtenissen. Ongeveer $55B aan kapitaal heeft de digitale activaruimte verlaten gedurende augustus.</p>
<p>Deze trend wordt gedreven door kapitaaluitstromen over alle drie de activa <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a>, Etheruem en stablecoins.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1693898311Group-137691448.png" alt=""></p>
<p>Binnen de <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> In het ecosysteem zijn er gemengde reacties geweest op indices voor de DeFi, GameFi en Staking sectoren. Elke index is samengesteld uit de gemiddelde aanbod-gewogen prijs van ‘Blue-Chip’ tokens in de sector.</p>
<p>We kunnen zien dat DeFi- en GameFi-tokens relatief slecht hebben gepresteerd (-17%) en (-20%) vergeleken met de belangrijkste, terwijl Liquid Staking-tokens er iets beter aan toe waren (-7,7%). Over de hele linie was de neerwaartse prijsactie echter vergelijkbaar of minder ernstig dan de neergangen die in maart, april en juni werden gezien.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1693898515Group-137691436-1-.png" alt=""></p>
<h2 id="h2-Risicobereidheid20neemt20af20in20derivatenmarkten726615"><a name="Risicobereidheid neemt af in derivatenmarkten" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Risicobereidheid neemt af in derivatenmarkten</h2><p>Een van de belangrijkste ontwikkelingen gedurende de cyclus van 2021-23 is de volwassenheid van de derivatenmarkten, vooral voor BTC en ETH. De manier waarop derivatenmarkten deze activa waarderen, kan informatie bieden over marktsentiment en positionering.</p>
<p>Algemene activiteit op de <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> futures- en optiemarkten in 2023 ligt opvallend lager dan de niveaus die in 2021 en 2022 zijn gezien. Het gemiddelde dagelijkse handelsvolume op beide markten is gedaald tot slechts $14.3B/dag, wat ongeveer de helft is van het gemiddelde volume van de afgelopen twee jaar. Deze week is het volume zelfs nog lager op $8.3B/dag, wat erop wijst dat de liquiditeit blijft weglekken uit de markt.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1693898768Group-137691437-1-.png" alt=""></p>
<p>Deze trend wordt weerspiegeld in Open Interest van derivaten. Na de marktdieptepunten die werden ingesteld in de nasleep van de ineenstorting van FTX, begon Open Interest begin 2023 te stijgen. Voor opties piekte de open interest tijdens de bankencrisis in maart toen USDC een dekoppeling van $1 ervoer. Open interest in Ethereum-futures piekte rond de Shanghai Upgrade, wat suggereert dat dit het laatste belangrijke speculatieve evenement voor het activum was.</p>
<p>Sindsdien is de nominale waarde van actieve contracten in beide markten behoorlijk stabiel gebleven. Net als onze observatie voor BTC-markten (WoC 32) zijn ETH-optiemarkten nu van vergelijkbare omvang ($5,3 miljard) als toekomstige markten ($4,2 miljard), en zijn ze momenteel zelfs groter in omvang.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1693898795Group-137691449.png" alt=""></p>
<p>Sinds het begin van het jaar is er een opmerkelijke stijging geweest in de Ethereum-optiemarkten, waarbij het volume met +256% is gestegen naar een dagelijkse handel van $326M/dag. Ondertussen hebben futurevolumes dit jaar een gestage daling meegemaakt, van $20B/dag begin januari tot slechts $8B/dag vandaag. De enige opmerkelijke uitzondering was een korte stijging naar ongeveer $30B/dag rond de Shanghai-upgrade.</p>
<p>Aangezien er in augustus geen significante verschuivingen zijn geweest in handelsvolumes voor beide markten, suggereert dit dat handelaren doorgaan met het verplaatsen van liquiditeit naar hogere risico’s.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1693898838Group-137691450.png" alt=""></p>
<p>Kijkend naar de Pull/Call-verhouding kunnen we een hoge mate van responsiviteit zien op belangrijke nieuwsgebeurtenissen. Na bijvoorbeeld de indiening van een <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> ETF door BlackRock werd het sentiment meer bullish, waardoor de Pull/Call-verhouding daalde van 0,72 naar 0,40.</p>
<p>Dit veranderde echter met de verkoop op 17 augustus, aangezien de Pull/Call-verhouding toenam tot 0,50, en met oproepvolumes die sterk daalden van $320M/dag tot $140M/dag.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1693898867Group-137691439.png" alt=""></p>
<h2 id="h2-Zijn20liquiditeitspools20optiemarkten648307"><a name="Zijn liquiditeitspools optiemarkten?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Zijn liquiditeitspools optiemarkten?</h2><p>Om onze analyse hierboven te versterken, zullen we nu de activiteiten onderzoeken over Automated Market Makers zoals de <a href="/price/uniswap-uni" target="_blank" class="blog_inner_link">Uniswap</a> ETH/USDC Pool. Sinds de introductie van geconcentreerde liquiditeit op Uniswap V3, circuleert er een these dat Uniswap Liquidity Positions op een vergelijkbare manier kunnen worden beschouwd als het prijzen van put- en callopties. Hoewel we niet geloven dat optieconcepten deze dynamiek volledig beschrijven, zijn er zeker veel parallellen die het waard zijn om verder te onderzoeken.</p>
<p>Onze analyse zal zich richten op de USDC/ETH 0.05% Pool, die de meest actieve Uniswap-pool is en daarom kan worden verwacht dat deze het sterkste signaal zal afgeven. Deze pool heeft een handelsvolume van 7 dagen van $1.51B en $260m aan Totale Waarde Geblokkeerd (TVL).</p>
<p>Uniswap V3 heeft een unieke eigenschap van geconcentreerde liquiditeit. Liquiditeitsverschaffers (LP’s) kunnen een prijsklasse selecteren waarin hun verstrekte liquiditeit zich zal concentreren. Vergoedingen worden alleen verdiend wanneer de markt in dit bereik handelt (analoog aan uitoefenprijzen), en hoe krapper het bereik, hoe groter de relatieve vergoedingsinkomsten. Dit leidt zowel tot een betere gebruikerservaring voor DEX-handelaren, aangezien de spreads doorgaans krapper zijn, als tot een verbeterde kapitaalefficiëntie voor LP’s.</p>
<p>Op deze manier kan worden betoogd dat de positionering van het kapitaal van LP’s rekening moet houden met een verwachting van volatiliteit (spreiding tussen boven- en ondergrens) en de verwachte prijsbereiken (strike-niveau boven en onder). De these is dat we vergelijkbare inzichten kunnen verkrijgen uit gegevens van de optiemarkt als we ervan uitgaan dat LP’s actief hun positie beheren.</p>
<p><img src="https://gimg2.gateimg.com/image/article/16938989020-VGxxFh0ovRn_xAQb-1.png" alt=""></p>
<p>We beginnen met het observeren van de algemene activiteit in het USDC/ETH 0.05% pool. Om verschillende redenen zullen we het gebruik van de TVL-metriek vermijden als maatstaf voor de activiteit in een pool of een respectief tokenpaar. In plaats daarvan zullen we activiteit uitdrukken in termen van twee metrieken:</p>
<ul>
<li><p>i.<br><strong>Munten per dag</strong> het aantal liquiditeitsposities geopend door LP’s, en</p>
</li><li><p>ii.<br> <strong>Brandwonden per dag</strong> vertegenwoordigt het aantal liquiditeitsposities dat is gesloten door LP’s.</p>
</li></ul>
<p>Volgens deze maatregelen kromp de activiteit na de bankencrisis in maart en de Shanghai-upgrade in april en bleef vervolgens relatief laag tot begin juni. We zien dan een piek in nieuwe Mints en Burns rond de aankondiging van BlackRock ETF en vervolgens opnieuw tijdens de verkoop op 17 augustus.</p>
<p>De grafiek hieronder toont ook de nettowijziging in het aantal LP-posities als maatstaf voor het evenwicht tussen het openen en sluiten van posities. We merken op dat deze metriek minder wordt beïnvloed door markttrends, maar des te meer door discrete gebeurtenissen die suggereren dat kortetermijnvolatiliteit een belangrijke drijfveer is.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1693898935Group-137691451.png" alt=""></p>
<p>Bij het onderzoeken van de verdeling van liquiditeit over verschillende prijsbereiken in de Uniswap-pool, kunnen we zien dat LP’s momenteel een meerderheid van de liquiditeit boven de huidige prijs tick leveren.</p>
<p>De meest geconcentreerde liquiditeit (ongeveer 30,4% van het kapitaal) bevindt zich binnen een prijsbereik van 11%, met een verwachte neerwaartse beweging van -2,7% en een opwaartse beweging van +8,6%. Een tweede laag liquiditeit is gepositioneerd met een neerwaartse buffer van -8,5% en een opwaartse buffer van +23,7%. Er kan betoogd worden dat Uniswap LP’s een verwachting uiten van <a href="/price/optimism-op" rel="nofollow noopener noreferrer" target="_blank">Optimisme</a> en marktpotentieel voor ETH in het algemeen.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1693899021Group-137691441-1-.png" alt=""></p>
<p>Als we dit vergelijken met de uitoefenprijzen van opties voor contracten die eind september aflopen, kunnen we een vergelijkbaar positief vooruitzicht zien. 70% van de calls hebben een uitoefenprijs tussen $1.7k en $2.3k, terwijl 75% van de puts een uitoefenprijs hebben tussen $1.3k en $1.9k. Deze prijsniveaus stemmen grotendeels overeen met de liquiditeitsverdeling van de Uniswap Liquiditeitspool.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1693899049Group-137691452.png" alt=""></p>
<p>Als we teruggaan naar de USDC/ETH Uniswap Pool, kunnen we analyseren hoe de concentratie van liquiditeit in de loop der tijd is aangepast. De onderstaande heatmap toont de dichtheid van liquiditeit, uitgedrukt in steeds koelere tot warmere kleuren.</p>
<p>Met de uitbreiding van geautomatiseerde LP-strategieën en -uitvoering zijn liquiditeitsverschaffers erin geslaagd om tijdens perioden van hogere volatiliteit liquiditeit zeer dicht bij de spotprijs te regelen. Op 1 juni werd een grote hoeveelheid liquiditeit uitgebreid net boven de prijs op dat moment (getoond in een diepere gele zone). Dit duidde mogelijk op een verwachting van hogere vergoedingsinkomsten in deze zone door market makers. Deze liquiditeit bleef bestaan tot de flashcrash in augustus, waarbij liquiditeitsconcentraties werden aangepast om steeds meer onder de $1,8k te liggen. Deze grafiek biedt een opmerkelijk inzicht in hoe responsief LP’s zijn ten opzichte van marktevenementen en volatiliteit.</p>
<p>Het is ook interessant om op te merken hoe hoge concentraties van liquiditeit, vertegenwoordigd door rode zones, samenvallen met sterke prijsbewegingen en vaak trendomkeringen. Door inspectie blijkt inderdaad dat Uniswap liquiditeitspools een waardevolle bron van informatie zouden kunnen zijn voor het peilen van marktsentiment en positionering.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1693899076Group-137691443.png" alt=""></p>
<h2 id="h2-Samenvatting20en20conclusie948250"><a name="Samenvatting en conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Samenvatting en conclusie</h2><p>Het aanvankelijke optimisme rond de overwinning van Grayscale op de SEC was van korte duur, waarbij de waarde van Ethereum binnen enkele dagen terugzakte naar de dieptepunten van augustus. Spotmarkten zien nog steeds een uitstroom van kapitaal en ook de derivatenmarkten zijn getuige van een aanhoudende daling van de liquiditeit. Over het algemeen lijken beleggers te aarzelen om terug te keren naar de markten en geven ze er de voorkeur aan kapitaal hoger op de risicocurve te plaatsen.</p>
<p>We hebben een onderzoek uitgevoerd naar Uniswap-liquiditeitspools, waarbij we hebben geprobeerd te achterhalen of vergelijkbare prijsinformatie als in de optiemarkten kon worden verkregen. Onze analyse toont aan dat liquiditeitskapitaal vrij responsief is op marktgebeurtenissen en dat waarschijnlijk inzichten kunnen worden verkregen met betrekking tot de volatiliteit en prijsverwachtingen van LP’s.</p>
<p><strong>Disclaimer: Dit rapport biedt geen beleggingsadvies. Alle gegevens worden alleen verstrekt voor informatie 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 beleggingsadvies.<p></p><br></div></div></div></div>