R2xhc3Nub2RlIEluemljaHRlbjogQml0Y29pbiBGbGFzaCBDcmFzaA==

<p><img src="https://gimg2.gateimg.com/image/article/1692694480SDFX 1.jpeg" alt=""></p>
<h2 id="h2-Samenvatting702766"><a name="Samenvatting" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Samenvatting</h2><p>De markt beleefde vorige week een gewelddadige uitverkoop, waardoor de BTC-prijzen onder de $ 25k kwamen en een einde kwam aan een periode van historisch lage volatiliteit.</p>
<p>De markt heeft verschillende belangrijke prijssteunmodellen doorgesneden, waardoor de stieren in het nadeel zijn.</p>
<p>Een belangrijke drijfveer lijkt een uitverkoop van leverage te zijn op de derivatenmarkt, waarbij in slechts een paar uur tijd meer dan $2,5 miljard aan openstaande rente wordt afgewikkeld.</p>
<p>De optiemarkten hebben de volatiliteitspremies scherp herprijsd van historisch lage niveaus, hoewel het open interest opmerkelijk stabiel blijft.</p>
<p>Spotmarkten zijn nog steeds relatief ‘topzwaar’, met meer dan 88,3% van de aanbod van korte termijn houders die nu worden aangehouden met een ongerealiseerd verlies.</p>
<p>We introduceren een responsieve experimentele indicator die helpt bij het identificeren van knooppunten in marktwinstgevendheid en trend.</p>
<p><img src="https://gimg2.gateimg.com/image/article/169269451500_cover-5.png" alt=""></p>
<h2 id="h2-Technische20Schade483385"><a name="Technische Schade" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Technische Schade</h2><p>De digitale activamarkt onderging vorige week een hevige verkoopgolf, wat een dramatisch einde markeerde aan het uitputtende gebrek aan volatiliteit dat sinds juli de overhand had. Zoals we hebben besproken in de laatste twee edities (WoC 32, WoC 33), had de prijsactie voor BTC enkele van de laagste volatiliteitsniveaus ooit bereikt, en met name de optiemarkten hadden de mogelijkheid van significante neerwaartse volatiliteit sterk ondergewaardeerd.</p>
<p>Na enkele weken te hebben gehandeld net boven de $29,3k, explodeerden de BTC-prijzen lager en sneden ze door verschillende langetermijn bewegende gemiddelden, waaronder de 111-daagse, 200-daagse en de 200-wekelijkse. Met de markt die de week rond de $26,1k afsloot, betekent dit een aanzienlijk verlies van marktondersteuning en hebben de stieren nu hun werk voor zich liggen.</p>
<p><img src="https://gimg2.gateimg.com/image/article/169269454701_price_tech.png" alt=""></p>
<p>De verkoop duwde de prijzen ook onder de kostenbasis van de korte termijn houder, een on-chain prijsmodel dat historisch gezien ondersteuning heeft geboden tijdens robuuste opwaartse trends. Met de gerealiseerde prijs en de kostenbasis van de lange termijn houder die enige afstand lager handelt ($20.3k), bevindt de markt zich vanuit een psychologisch oogpunt in een enigszins precaire positie.</p>
<p>Zoals we vorige week hebben opgemerkt (WoC 33), is de voorraad die in bezit is van de Short-Term Holder cohort nogal ‘topzwaar’, waarbij een aanzienlijke meerderheid een kostprijs heeft boven $29.0k. Dit is een onderwerp dat we later in deze editie zullen bespreken.</p>
<p><img src="https://gimg2.gateimg.com/image/article/169269455702_price_onchain.png" alt=""></p>
<p>De wekelijkse prijsactie daalde met -11,3%, wat een aanzienlijke daling is, maar niet de meest significante in recente jaren. Deze prestatie ligt iets onder de langetermijn-beweeglijkheid van één standaardafwijking van -12,6%, een niveau dat werd overschreden tijdens belangrijke capitulatiegebeurtenissen zoals de ineenstortingsgebeurtenissen van FTX, 3AC en LUNA.</p>
<p><img src="https://gimg2.gateimg.com/image/article/169269458103_weeklyperf.png" alt=""></p>
<p>Op dagelijkse basis is dit echter de grootste enkelvoudige verkoopdag tot nu toe, met een daling van -7,2% op 17 augustus. Dit overschreed een beweging van één standaardafwijking naar beneden, waardoor de stieren verrast werden.</p>
<p><img src="https://gimg2.gateimg.com/image/article/169269460404_dailyperf-1.png" alt=""></p>
<h2 id="h2-Opties20Herprijs20Volatiliteit747661"><a name="Opties Herprijs Volatiliteit" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Opties Herprijs Volatiliteit</h2><p>De impliciete volatiliteit in de optiemarkten had tegen het begin van de week het laagste niveau ooit bereikt, 50% lager dan de langetermijnbasis die gezien werd gedurende 2021-22. Natuurlijk werd de volatiliteit snel opnieuw geprijsd toen de verkoop deze week begon. De impliciete volatiliteit verdubbelde meer dan voor kortlopende contracten met een vervaldatum tot eind september.</p>
<p><img src="https://gimg2.gateimg.com/image/article/169269466105_impliedvol.png" alt=""></p>
<p>Put-opties ondergingen van nature de scherpste repricing, waarbij de 25-Delta Skew volledig omkeerde en van historische dieptepunten van -10% naar meer dan +10% steeg. Over het algemeen werden optiehandelaren hevig wakker geschud uit hun slaap en gedwongen om volatiliteitsverwachtingen vooruit te heroverwegen.</p>
<p><img src="https://gimg2.gateimg.com/image/article/169269467106_deltaskew.png" alt=""></p>
<p>Interessant genoeg bleef het openstaande belang voor zowel call- als put-opties verrassend stabiel, met zeer weinig nettoverandering gezien de explosieve prijsactie. Dit suggereert dat hoewel de volatiliteit waarschijnlijk verkeerd was geprijsd, er niet veel gedwongen deleveraging was op de optiemarkten.</p>
<p>Een ontwikkeling die we in WoC 32 hebben belicht, is dat de omvang van de open interesse in <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> De optiemarkten zijn nu vergelijkbaar met de futuremarkten, wat betekent dat analisten beide nauwlettend in de gaten moeten houden.</p>
<p><img src="https://gimg2.gateimg.com/image/article/169269469707_optionsoi.png" alt=""></p>
<p>De handelsvolumes van opties zijn aanzienlijk gestegen, met een stijging van meer dan 200% tot $620M per dag voor calls en $326M per dag voor puts. Het is nog afwachten of dit verhoogde volatiliteitsregime aanhoudt, of dat de heersende omgeving van lage liquiditeit terugkeert naar een markt met weinig enthousiasme.</p>
<p><img src="https://gimg2.gateimg.com/image/article/169269475408_optionsvolume.png" alt=""></p>
<h2 id="h2-Futures20Flushout583456"><a name="Futures Flush-out" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Futures Flush-out</h2><p>In tegenstelling tot de optiemarkten hebben futures-handelaren wel te maken gehad met een belangrijk deleveraging-evenement dat opmerkelijke overeenkomsten vertoont met de FTX-collaps. Hoewel kleiner van omvang, werden er op één dag meer dan $2,5 miljard aan eeuwigdurende futures-contracten afgesloten. Dit vertegenwoordigt een daling van -24,5%, en een volledige ontmanteling van alle opgebouwde leverage in juli-augustus.</p>
<p><img src="https://gimg2.gateimg.com/image/article/169269479109_futuresoi.png" alt=""></p>
<p>In slechts een paar uur tijd werd in totaal $230M aan longposities geliquideerd en gedwongen gesloten, wat resulteerde in het grootste liquidatie-evenement sinds de ineenstorting van LUNA in mei 2022. Dit liquidatie-evenement was groter van omvang dan de short squeeze die de rally van 2023 in januari in gang zette, wat suggereert dat het mogelijk potentieel heeft om de trend te veranderen.</p>
<p><img src="https://gimg2.gateimg.com/image/article/169269480310_longliq.png" alt=""></p>
<p>Futuresmarkten ondervonden ook een negatieve ontwrichting als gevolg van de gedwongen verkoop, waardoor de futuresprijzen ruim onder de index van de spotmarkt kwamen te liggen. Financieringspercentages werden negatief om een prikkel te creëren voor marktmakers om longposities te openen en prijsverschillen te arbitreren.</p>
<p>Dit is de diepste negatieve financieringsrente sinds de verkoop in maart tot $19,8k, hoewel de verstoring vorige week kleiner van omvang was. Over het algemeen suggereert dit dat de opbouw van hefboomwerking en de daaropvolgende deleveraging in futuresmarkten een belangrijke factor was die deze verkoop dreef.</p>
<p><img src="https://gimg2.gateimg.com/image/article/169269483411_fundingrate.png" alt=""></p>
<h2 id="h2-Top20Zware20Spotmarkten166761"><a name="Top Zware Spotmarkten" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Top Zware Spotmarkten</h2><p>Een concept dat we vorige week hebben herzien (WoC 33) was het idee van een ‘topzware markt’, waar aanzienlijke volumes van spotaanbod een kostprijs hebben die in de buurt van of boven de huidige prijs ligt. Wanneer de BTC-prijs plotseling beweegt, kunnen we de omvang van het aanbod dat verlies lijdt zien via veranderingen in de metric Percent Supply in Profit.</p>
<p>Hier zien we dat 12,8% (2,48M BTC) van de voorraad deze week in een niet-gerealiseerd verlies is terechtgekomen, waarmee een lagere laag op deze metriek wordt gezet. Dit suggereert dat ‘topzwaarte’ op de spotmarkten ook een rol kan spelen.</p>
<p><img src="https://gimg2.gateimg.com/image/article/169269486312_pctsupplyloss-1.png" alt=""></p>
<p>Als we kijken naar de reactie van de lange termijn houders (LTHs), kunnen we zien dat er bijna geen reactie is. De LTH-cohort heeft het volume dat naar beurzen is gestuurd niet wezenlijk verhoogd, en hun totale saldo is eigenlijk gestegen naar een nieuw ATH deze week.</p>
<p>Zo kunnen we concluderen dat Short-Term Holders (STHs) relevanter zijn om te beoordelen.</p>
<p><img src="https://gimg2.gateimg.com/image/article/169269488613_lthreaction.png" alt=""></p>
<p>Met de LTH-voorziening op ATH kunnen we ook zien dat de STH-voorziening op multi-jaar dieptepunten blijft. De onderstaande grafiek legt echter het percentage van de STH-voorziening vast dat wordt aangehouden met een ongerealiseerd verlies.</p>
<p>Let op hoe scherpe stijgingen in STH-aanbod bij verlies vaak volgen op ‘topzware markten’ zoals mei 2021, december 2021 en opnieuw deze week. Van de 2,56 miljoen BTC die in het bezit is van STH’s, is slechts 300k BTC (11,7%) nog steeds winstgevend.</p>
<p><img src="https://gimg2.gateimg.com/image/article/169269493114_sthsupplyinloss.png" alt=""></p>
<h2 id="h2-Meting20Diepgaande20Duik20Gerealiseerd20Verlies20Momentum695574"><a name="Meting Diepgaande Duik: Gerealiseerd Verlies Momentum" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Meting Diepgaande Duik: Gerealiseerd Verlies Momentum</h2><p>Tot slot sluiten we af met een van de meer geavanceerde en responsieve tools die momenteel in ontwikkeling zijn door het Glassnode-team. Het doel van deze tool is om significante marktomkeerpunten te identificeren, zoals ‘top- of bodemzware markten’. Het is als volgt ontworpen:</p>
<p>Tijdens macro opwaartse trends worden beleggers over het algemeen steeds winstgevender, waarbij verliezen minder vaak voorkomen (en vice versa in neerwaartse trends).</p>
<p>Dit resulteert in de verhouding tussen Realized Profit/Loss (P/L) die gedurende langere perioden van tijd tijdens marktstijgingen boven 1,0 blijft. Omgekeerd blijft de Loss/Profit (L/P) -verhouding tijdens neergangen boven 1,0.</p>
<p>Als we de P/L-verhouding vergelijken met het 1-jaars voortschrijdend gemiddelde, kunnen we een P/L-momentumindicator 🟢 vaststellen die hoger piekt wanneer de winstdominantie snel toeneemt. Dit gebeurt vaak na een regime van verliesdominantie (zoals bijna bodemzware keerpunten). Een vergelijkbaar L/P-momentum 🔴 kan worden berekend om topzware keerpunten te identificeren.</p>
<p>Een dominantie-oscillator (onderaan de grafiek) kan ook worden geconstrueerd om een ​​ander perspectief te bieden bij het identificeren van keerpunten.</p>
<p>De variant van deze metriek die hieronder wordt getoond, is specifiek voor Short-Term Holders die de meest reactieve cohort zijn voor marktvolatiliteit. We kunnen zien dat na enkele maanden van afnemende winstdominantie, het verliesmomentum en de dominantie aanzienlijk zijn toegenomen. Valse signalen doen zich voor, zoals tijdens de correctie van maart 2023, en deze zijn historisch gezien snel hersteld.</p>
<p>Echter, aanhoudende dalingen gingen ook vooraf aan meer gewelddadige neerwaartse trends zoals in mei en december 2021, waardoor deze weeks daling nauwlettend in de gaten gehouden moet worden.</p>
<p><img src="https://gimg2.gateimg.com/image/article/169269686816_sthrealizedmomentum.png" alt=""></p>
<h2 id="h2-Samenvatting20en20Conclusies655870"><a name="Samenvatting en Conclusies" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Samenvatting en Conclusies</h2><p>De Bitcoin-markt werd deze week hevig wakker geschud en verkocht -7,2% op 17 augustus, wat zorgde voor de grootste neerwaartse beweging op één dag YTD. Veel indicatoren wijzen op een toekomstige schuldafbouw van de markt als de meest waarschijnlijke drijfveer, waarbij optiehandelaren ook gedwongen worden om volatiliteitspremies te heroverwegen en opnieuw te prijzen.</p>
<p>Langdurige houders blijven grotendeels onaangedaan en onverschillig, wat een typisch gedragspatroon is van deze groep tijdens periodes van een kater op de berenmarkt. Kortetermijnhouders zijn daarentegen van groter belang, waarbij 88,3% van hun aangehouden aanbod (2,26M BTC) nu wordt aangehouden met een ongerealiseerd verlies. Dit wordt verergerd door een versnelling in gerealiseerde verliezen van KTH die naar beurzen worden gestuurd, evenals het verlies van belangrijke technische bewegende gemiddelde ondersteuning, waardoor de stieren op de achterste voet worden gezet.</p>
<p><strong>Disclaimer: Dit rapport biedt geen beleggingsadvies. Alle gegevens worden alleen 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 opvattingen van de onderzoeker en vormt geen beleggingsadvies.<p></p><br></div></div></div></div>