R2xhc3Nub2RlIEluemljaHRlbjogVm9sYXRpbGl0ZWl0IENydXNo

<p><img src="https://gimg2.gateimg.com/image/article/1691466319SDFX.jpeg" alt=""></p>
<h2 id="h2-Samenvatting832473"><a name="Samenvatting" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Samenvatting</h2><p>Bitcoin-prijzen staan ​​berucht bekend om hun volatiliteit, maar de markt ervaart momenteel een extreme volatiliteitscompressie. Minder dan 5% van de handelsdagen heeft een nauwer handelsbereik.</p>
<p>De termijnmarkten zijn opvallend vlak, met handelsvolumes voor BTC en ETH die beide nieuwe dieptepunten bereiken, en cash-and-carry-opbrengsten van 5,3% net iets boven de risicovrije rente.</p>
<p>De geïmpliceerde volatiliteit op de optiemarkten ondergaat een aanzienlijke volatiliteitsdaling, waarbij volatiliteitspremies handelen op minder dan de helft van het baseliniveau 2021-22.</p>
<p>Zowel de put/call ratio als de 25-delta skew metingen staan op historisch lage niveaus, wat erop wijst dat de optiemarkten de voorkeur geven aan calls en put-opties zeer lage volatiliteit hebben ingeprijsd.</p>
<p><img src="https://gimg2.gateimg.com/image/article/169146636601_price.png" alt=""></p>
<h2 id="h2-Een20Stille20Patch203878"><a name="Een Stille Patch" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Een Stille Patch</h2><p><a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> markten maken een ongelooflijk rustige periode door, waarbij verschillende maatstaven voor volatiliteit richting historische dieptepunten dalen. In deze editie zullen we onderzoeken hoe opmerkelijk deze stille periode is vanuit historisch oogpunt, en vervolgens onderzoeken hoe dit wordt ingeprijsd in de derivatenmarkten.</p>
<p>Om de situatie te schetsen, merken we op dat de BTC-spotprijs hoger handelt dan een aantal lange termijn bewegende gemiddelden (111D, 200D, 365D en 200W) die veelvuldig worden waargenomen in de industrie. Deze gemiddelden variëren van een laag van $23.3k (200DMA) tot $28.5k (111DMA). Deze grafiek benadrukt ook vergelijkbare periodes gedurende de afgelopen twee cycli die neigen samen te vallen met macro-uptrends.</p>
<p><img src="https://gimg2.gateimg.com/image/article/169146640300_cover-2.png" alt=""></p>
<p>We kunnen een zeer vergelijkbare context zien door on-chain gerealiseerde prijzen te gebruiken die het kostenbasismodel vormen voor drie cohorten:</p>
<p>🟠 Gehele markt (de gerealiseerde prijs).<br>🔴 Korte termijn houders (munten jonger dan 155 dagen).<br>🔵 Lange termijn houders (munten ouder dan 155 dagen).</p>
<p>De spotprijs handelt opnieuw boven alle drie modellen en toont een sterke samenvloeiing met de klassieke technische analyse tools hierboven.</p>
<p><img src="https://gimg2.gateimg.com/image/article/169146646602_realprice.png" alt=""></p>
<p>Het is 842 dagen geleden dat de piek van de stierenmarkt werd bereikt in april 2021 (zie opmerking hieronder). Het herstel van 2023 doet het eigenlijk iets beter dan de laatste twee cycli, met een handel van -54% onder de ATH, vergeleken met historisch -64%.</p>
<p>We merken ook op dat zowel de cycli van 2015-16 als 2019-20 een periode van 6 maanden van zijwaartse verveling doormaakten voordat de markt versnelde boven het -54% drawdown niveau. Dit is misschien een indicatie van de verveling die mogelijk voor ons ligt.</p>
<p><img src="https://gimg2.gateimg.com/image/article/169146648203_cycleath.png" alt=""></p>
<p>Na een vurige start van 2023 is zowel de kwartaal- als de maandelijkse prijsprestatie afgekoeld. We kunnen opnieuw veel overeenkomsten zien met eerdere cycli waar de initiële rally vanaf de bodem krachtig is, maar leidt tot een langere periode van hobbelige consolidatie.</p>
<p>Deze periode wordt vaak aangeduid als de heraccumulatieperiode door Bitcoin-analisten.</p>
<p><img src="https://gimg2.gateimg.com/image/article/169146675104_quarterlyperformance.png" alt=""></p>
<h2 id="h2-Volatiliteit20stort20in552675"><a name="Volatiliteit stort in" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Volatiliteit stort in</h2><p>De gerealiseerde volatiliteit van <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> varieert van 1-maand tot 1-jaar observatieperiodes is dramatisch gedaald in 2023 en heeft multi-jaar dieptepunten bereikt. Het volatiliteitsvenster van 1 jaar bevindt zich nu op niveaus die sinds december 2016 niet meer zijn gezien. Dit is de vierde periode van extreme volatiliteitscompressie.</p>
<p>De late fase van de beer in 2015 gaat over in de her-accumulatieperiode van 2016.<br>De late fase van de beer in 2018 die voorafging aan een verkoop van 50% in november. Dit werd echter gevolgd door de herstelrally van april 2019, waarbij de prijs in drie maanden steeg van $4k naar $14k.</p>
<p>Na de consolidatie van maart 2020 terwijl de wereld zich aanpaste aan de uitbraak van COVID-19.</p>
<p>De eindejaarsvakantie van 2022 terwijl de markt de mislukking van FTX verwerkte, en onze huidige markt (zie WoC 2-23 voor onze analyse in januari 2023).</p>
<p><img src="https://gimg2.gateimg.com/image/article/169146679405_realizedvolatility.png" alt=""></p>
<p>Het prijsbereik dat de 7-daagse hoogste en laagste punten scheidt, is slechts 3,6%. Slechts 4,8% van alle handelsdagen heeft ooit een nauwere wekelijkse handelsrange ervaren.</p>
<p><img src="https://gimg2.gateimg.com/image/article/169146680506_7dayrange.png" alt=""></p>
<p>Het prijsbereik van 30 dagen is nog extremer, waarbij de prijs in de afgelopen maand beperkt blijft tot slechts een bandbreedte van 9,8%, en met slechts 2,8% van alle maanden die strakker zijn. Perioden van consolidatie en prijscompressie van deze omvang zijn uiterst zeldzame gebeurtenissen voor Bitcoin.</p>
<p><img src="https://gimg2.gateimg.com/image/article/169146689407_30dayrange.png" alt=""></p>
<h2 id="h2-Futures20vlakken20af796875"><a name="Futures vlakken af" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Futures vlakken af</h2><p>Deze stille periode is ook zichtbaar op de derivatenmarkten voor zowel BTC als ETH. Het gecombineerde handelsvolume van Futures en Opties voor de twee activa bevindt zich op, of nadert, een historisch dieptepunt voor <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> en respectievelijk Bitcoin.</p>
<p>BTC heeft momenteel een totaal handelsvolume van $19,0 miljard in afgeleide producten, terwijl ETH-markten slechts $9,2 miljard per dag hebben, wat de dieptepunten van januari 2023 overtreft.</p>
<p><img src="https://gimg2.gateimg.com/image/article/169146701112_derivvolume.png" alt=""></p>
<p>De markt handhaaft ook een relatief risico-avers standpunt, waarbij de dominantie van Bitcoin binnen futuresmarkten langzaam hoger wordt. Gedurende 2021-22 ervoeren Ethereum-futuresmarkten een gestage toename van zowel handelsvolume als open interest ten opzichte van Bitcoin, met een piek op een 60 BTC: 40 ETH-verhouding in H2-2022.</p>
<p>Dit jaar heeft gezien dat de balans weer in het voordeel van Bitcoin is gekanteld, wat suggereert dat lichter liquiditeit en een verminderde risicobereidheid een kracht blijft die kapitaal omhoog beweegt op de risicocurve.</p>
<p><img src="https://gimg2.gateimg.com/image/article/169146704609_futoidominance.png" alt=""></p>
<p>Het openstaande belang van Bitcoin op de futuresmarkten is de afgelopen maand ook relatief vlak gebleven op $12,1B. Dit zijn vergelijkbare niveaus als in de tweede helft van 2022 toen de prijzen ~30% goedkoper waren dan vandaag en de FTX-beurs nog actief was. Het is ook vergelijkbaar met de run-up van januari 2021 toen de prijzen 30% hoger waren, de markt minder volwassen was en de gehefboomde speculatie nog maar net op gang kwam.</p>
<p><img src="https://gimg2.gateimg.com/image/article/169146706908_futoi-1.png" alt=""></p>
<p>Op een vergelijkende basis hebben optiemarkten een aanzienlijke toename gezien in dominantie en groei, met een open interest die meer dan verdubbeld is in de afgelopen 12 maanden. Opties concurreren nu met futuresmarkten wat betreft de omvang van het open interest.</p>
<p>Futures open interest daarentegen is sinds eind 2022 gestaag afgenomen (toen FTX instortte) en heeft in 2023 slechts een lichte stijging gezien.</p>
<p><img src="https://gimg2.gateimg.com/image/article/169146709113_options_oi.png" alt=""></p>
<h2 id="h2-Implied20Volatility20Crush578868"><a name="Implied Volatility Crush" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Implied Volatility Crush</h2><p>Met zo weinig handelsvolume en gebrek aan activiteit in futures markten is het volgende doel om te identificeren welke kansen handelaren actief houden in de digitale activa derivatenruimte.</p>
<p>In de termijnmarkten geeft de termijnstructuur aan dat een geannualiseerd rendement tussen 5,8% en 6,6% beschikbaar is via een cash-and-carry strategie. Dit is echter slechts een zeer kleine premie ten opzichte van de opbrengsten die beschikbaar zijn in korte termijn Amerikaanse schatkistpapier, of geldmarktfondsen.</p>
<p><img src="https://gimg2.gateimg.com/image/article/169146711710_futtermstructure.png" alt=""></p>
<p>Perpetuele swapmarkten zijn veruit de meest liquide handelsplaats voor digitale activa, en handelaren en market makers kunnen een financieringstariefpremie vastzetten om de toekomstige en spotprijzen te arbitreren. Deze vorm van cash-and-carry is volatieler en dynamischer, maar levert momenteel een aantrekkelijker jaarlijks rendement van 8,13% op om rekening te houden met dit extra risico.</p>
<p>Opmerkelijk is de aanhoudende positieve stijging van de financieringstarieven sinds januari, wat wijst op een duidelijke verandering in sentiment sinds eind 2022.</p>
<p><img src="https://gimg2.gateimg.com/image/article/169146714711_futfundingrate.png" alt=""></p>
<p>Bij de overgang naar de optiemarkten kunnen we zien hoe ernstig de volatiliteitsdrukte is geweest, waarbij de geïmpliceerde volatiliteit bij alle contractvervaldata is ingestort tot recorddieptepunten.</p>
<p>Bitcoin-markten staan ​​berucht bekend om hun volatiliteit, met optiehandel die een geïmpliceerde volatiliteit heeft tussen 60% en meer dan 100% voor het grootste deel van 2021-22. Op dit moment echter, prijzen opties de kleinste volatiliteitspremie in de geschiedenis in, met een IV tussen 24% en 52%, minder dan de helft van de langetermijn-baseline.</p>
<p><img src="https://gimg2.gateimg.com/image/article/169146718413_impliedvolatility.png" alt=""></p>
<p>De termijnstructuur van de IV toont aan dat de volatiliteitspremies in de afgelopen twee weken zijn ingekrompen. Het contract van december heeft de impliciete volatiliteit alleen al in de afgelopen twee weken zien dalen van 46% naar 39%. Opties met een vervaldatum tot juni 2024 dragen een volatiliteitspremie van iets meer dan 50%, wat historisch gezien laag is.</p>
<p><img src="https://gimg2.gateimg.com/image/article/169146719514_optionsivtermstructure.png" alt=""></p>
<p>De Put/Call Ratio over zowel volume- als open interest-metingen staat op, of nabij het laagste niveau ooit, met een handel tussen 0,42 en 0,48. Dit suggereert dat er een nettobullish sentiment is binnen de markt, en de vraag naar callopties blijft domineren.</p>
<p><img src="https://gimg2.gateimg.com/image/article/169146722615_putcallratio.png" alt=""></p>
<p>Als gevolg hiervan zijn putopties steeds goedkoper in vergelijking met callopties, wat wordt weerspiegeld door een all-time-low in de 25-delta skew-metriek. Over het algemeen duidt dit erop dat de optiemarkten, die nu qua omvang wedijveren met de termijnmarkten, historisch lage volatiliteit in de toekomst inprijzen.</p>
<p>Aangezien echter minder dan 5% van alle handelsdagen een vergelijkbare prijsklassekrimp heeft gezien, suggereert dit dat Bitcoin niet langer berucht volatiel is… of de volatiliteit kan verkeerd worden ingeprijsd.</p>
<p><img src="https://gimg2.gateimg.com/image/article/169146724916_deltaskew.png" alt=""></p>
<h2 id="h2-Samenvatting20en20Conclusies913497"><a name="Samenvatting en Conclusies" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Samenvatting en Conclusies</h2><p>Slechts weinig nieuwskoppen verkondigen dat Bitcoin een prijsstabiel en niet-volatiel bezit is, waardoor maandelijkse handelsreeksen van minder dan 10% opvallen als een zere duim. De markt is naar verluidt het minst volatiel ooit geweest, wat de vraag oproept of er inderdaad sprake zal zijn van verhoogde volatiliteit.</p>
<p>De opbrengsten van futures cash-and-carry liggen tussen de 5,3% en 8,1%, wat marginaal boven de risicovrije rente van kortlopende Amerikaanse T-bills ligt. De optiemarkten hebben de laagste geïmpliceerde volatiliteitspremie ooit geprijsd, waarbij met name putopties de minste vraag zien.</p>
<p>Gezien de context van de beruchte volatiliteit van Bitcoin, staat er een nieuw tijdperk van stabiliteit in de prijs van BTC voor de deur, of is de volatiliteit verkeerd geprijsd?</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 opvattingen van de onderzoeker en vormt geen enkele beleggingssuggestie.<p></p><br></div></div></div></div>