R2xhc3Nub2RlIEluc2lnaHRzOiBFZW4gRnJpc3NlIFdpbmQ=

2023-10-26, 01:58

<p><img src="https://gimg2.gateimg.com/image/article/1698285277SDFX 1.jpeg" alt=""></p>
<h2 id="h2-Samenvatting889905"><a name="Samenvatting" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Samenvatting</h2><p><a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Stieren zijn erin geslaagd om de BTC-prijzen weer naar $35k te duwen, waarbij verschillende belangrijke technische en on-chain prijsniveaus werden doorbroken die rond $28k waren gelegen, een opmerkelijk teken van kracht.</p>
<p>De derivatenmarkten droegen bij aan de beweging met een paar short-squeezes, het afsluiten van 60k BTC aan futureposities en een stijging van $4,3 miljard in de openstaande optieposities van calls.</p>
<p>Lange termijn beleggers zijn onaangedaan door de prijsbeweging van deze week, met de voorraad van lange termijn houders die nieuwe ATH’s bereikt en de herstelde voorraadvolumes blijven onbeduidend.</p>
<p><img src="https://gimg2.gateimg.com/image/article/169828345200_cover-6.png" alt=""></p>
<p>Bitcoin-investeerders hebben deze week een aanzienlijke waardestijging van hun bezittingen gezien, waarbij BTC steeg van een dieptepunt van $27,1k naar een hoogtepunt van $35,1k. Deze beweging begon met een overtuigende doorbraak van verschillende belangrijke technische en on-chain prijsniveaus, wat wijst op een opmerkelijke kracht.</p>
<p>Een cluster van langetermijn eenvoudige voortschrijdende gemiddelden van de prijs bevindt zich rond $ 28k en heeft in september en oktober marktweerstand geboden. Na een maand van marktstijging vonden de stieren deze week voldoende kracht om overtuigend door de 111-daagse, 200-daagse en 200-weken gemiddelden heen te breken.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1698283622Frame-137691266-1.png" alt=""></p>
<h2 id="h2-Zijn20derivaten20de20drijvende20kracht39449"><a name="Zijn derivaten de drijvende kracht?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Zijn derivaten de drijvende kracht?</h2><p>Wanneer er belangrijke marktbewegingen plaatsvinden, raadplegen analisten vaak derivatengegevens om vast te stellen of de beweging werd gedreven door een leverage wash-out. Eerst zullen we kijken naar openstaande posities in eeuwigdurende swapmarkten, die we in BTC-termen beschouwen om de effecten van de muntprijsbeweging te filteren.</p>
<p>Het openstaande interesse daalde met ongeveer 25k BTC op 17 oktober, wat neerkomt op een vermindering van ongeveer 8,3%. Dit werd gevolgd door een tweede grote hefboomuitval van 35k BTC op 23 oktober toen de markt steeg naar nieuwe jaarlijkse hoogtepunten van $35k. Deze hefboom squeeze is nu van een vergelijkbare omvang als de short-squeeze in januari en de long-squeeze in augustus.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1698283673Frame-137691267-1.png" alt=""></p>
<p>Ongeveer $56M aan shortposities werden geliquideerd toen de rally begon op 17 oktober, gevolgd door nog eens $125M op 23 oktober. Dit is een aanzienlijk volume aan shortliquidaties binnen de context van 2023. Het is opnieuw vergelijkbaar met de $155M aan shortliquidaties in januari en de $220M aan gesloten longposities in augustus.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1698283747Frame-137691268-1.png" alt=""></p>
<p>We kunnen op een andere manier de volumes van liquidering van futures inspecteren door de 30-daagse som van geliquideerde longs, shorts te nemen en het nettobedrag te berekenen. We kunnen zien dat het grootste deel van 2023 (en inderdaad het grootste deel van de geschiedenis) wordt gedomineerd door grotere volumes van geliquideerde longposities in vergelijking met shorts.</p>
<p>Op het net heeft de markt nu meer korte volumes gezien die de afgelopen 30 dagen gedwongen zijn gesloten. De onderstaande grafiek benadrukt deze punten van zulke ‘korte dominantie’, die historisch gezien samenvielen met lokale marktextremen.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1698283797Frame-137691269-2.png" alt=""></p>
<p>Het is opmerkelijk dat de financieringsrentes en de cash-and-carry-basis op termijnmarkten alles bij elkaar genomen relatief kalm zijn gebleven. In 2023 hebben termijnmarkten over het algemeen geannualiseerde rentes opgeleverd van meer dan 6%, die hoger zijn dan de Amerikaanse schatkistrentes.</p>
<p>De verkoopgolf in augustus heeft deze lange bias aanzienlijk afgekoeld, met doorlopende financieringspercentages die zijn gedaald van 7,5%+ naar +2,5%. Hoewel de financieringspercentages tijdens de short squeezes deze week zijn gestegen, zijn ze relatief laag gebleven, wat erop wijst dat de rally mogelijk slechts gedeeltelijk wordt aangedreven door gehefde speculatie.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1698283878Frame-137691270-1.png" alt=""></p>
<p>De optiemarkten blijven echter een bestemming voor speculatief kapitaal. De open interest in call-opties is gestegen met $ 4,3 miljard, met 80% uitgebreid tot meer dan $ 9,7 miljard in totaal. Dit suggereert dat handelaren en investeerders optiemarkten blijven gebruiken als een voorkeursinstrument voor langdurige blootstelling. Dit is een relatief nieuwe ontwikkeling in de Bitcoin-marktstructuur, waar optiemarkten nu van vergelijkbare omvang zijn als futures (zie WoC 32).</p>
<p><img src="https://gimg2.gateimg.com/image/article/1698284027Frame-137691271-1.png" alt=""></p>
<h2 id="h2-Het20halen20van20sleutelkostenniveaus853192"><a name="Het halen van sleutelkostenniveaus" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Het halen van sleutelkostenniveaus</h2><p>Deze week heeft de rally niet alleen verschillende langetermijntechnische analyseprijsniveaus doorbroken, maar heeft ook steun gevonden boven twee belangrijke on-chain kostbasismodellen. Analisten kunnen deze ‘kostbasis’-modellen beschouwen in een vergelijkbaar licht als technische niveaus, aangezien ze zones van psychologisch belang weerspiegelen, en dus een gebied waar het investeerdersgedrag kan verschuiven.</p>
<p>In ons recente Cointime Economics-onderzoek ontwikkeld samen met ARK-Invest, hebben we de True Market Mean Price vastgesteld als een ideaal kandidaat voor een gemiddeld investeerderskostenbasismodel. Dit model wordt momenteel verhandeld op $29.78k en heeft historisch gezien de Bitcoin-markt zien handelen de helft van de tijd erboven en de helft eronder.</p>
<p>Met de markt die het midden van de cyclus 2020-22 heeft doorgegeven (zie WoC 28), evenals de handel boven de True Market Mean Price, zet dit de gemiddelde actieve BTC-belegger terug in een ongerealiseerde winst.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1698284150Frame-137691272-1.png" alt=""></p>
<p>De kostprijs van de korte termijn houder (STH) is nu ook in het verleden met $28k, waardoor de gemiddelde recente belegger een gemiddelde winst van +20% heeft. De onderstaande grafiek toont de STH-MVRV Ratio, waar rood perioden aangeeft waarin de markt onder de kostprijs van STH handelde en groen erboven.</p>
<p>We kunnen glen zien in 2021-22 waar STH-MVRV relatief diepe correcties van -20% of meer bereikte. Hoewel de verkoop van augustus een dieptepunt van -10% bereikte, is het opmerkelijk hoe ondiep deze MVRV-daling is in vergelijking, wat suggereert dat de recente correctie opmerkelijke steun vond, als voorbode van de rally van deze week.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1698284167Frame-137691273-1.png" alt=""></p>
<p>Terwijl MVRV de winstgevendheid beschrijft van munten die worden vastgehouden door Short-Term Holders (niet-uitgegeven aanbod), heeft het een verwante indicator genaamd SOPR die de winstgevendheid beschrijft van munten die zijn uitgegeven door STHs (uitgegeven aanbod).</p>
<p>We kunnen op dezelfde manier een ‘geïnvesteerde kostprijs’ berekenen om de gemiddelde aankoopprijs te bepalen voor de munten die zijn overgedragen door de STH-cohort. Met andere woorden, we beoordelen de prijs waaruit de uitgegeven munten afkomstig zijn.</p>
<p>We zien een soortgelijk patroon als MVRV, met een relatief ondiepe SOPR-drawdown in vergelijking met 2021-22, en een terugkeer naar positief terrein deze week. Dit suggereert dat beleggers niet dezelfde mate van paniek en angst uitten als in de eigenlijke bearmarkt van 2022, een ander teken van veerkracht van beleggers.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1698284198Frame-137691274-1.png" alt=""></p>
<p>Als we deze twee kostprijsmodellen samenvoegen, kunnen we een oscillator opzetten die de trend van het vertrouwen van korte termijn houders volgt (verder verkend in WoC 38).</p>
<p>Wat we kunnen zien is dat na het bereiken van de meest negatieve waarde sinds januari (toen de prijzen ongeveer $16k waren), het vertrouwen van investeerders is hersteld tot neutraal niveau, wat betekent dat STHs die uitgeven een vergelijkbare kostprijsbasis hebben als degenen die HODLing zijn. We staan ook op het punt om een positieve kruising van deze kostprijsmodellen te bereiken.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1698284026Frame-137691275-1.png" alt=""></p>
<h2 id="h2-Hoe20hebben20langetermijnbeleggers20gereageerd272353"><a name="Hoe hebben langetermijnbeleggers gereageerd?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Hoe hebben langetermijnbeleggers gereageerd?</h2><p>De laatste vraag die we zullen behandelen, is hoe langere termijn beleggers hebben gereageerd op deze rally, en hoe hun gezamenlijke positie is veranderd.</p>
<p>Met de markt die de YTD-hoogtepunten nadert, is een aanzienlijk deel van het aanbod nu hersteld van ‘in verlies’ naar ‘in winst’. Het percentage aanbod in winst steeg met maar liefst 4,7 miljoen BTC, wat overeenkomt met 24% van het totale circulerende aanbod. Dit geeft inzicht in het volume van munten die van eigenaar zijn veranderd en een kostprijs hebben tussen $27k en $35k.</p>
<p>Met 81% van de voorraad die nu winst maakt, is de markt nu terug in positieve versnelling, waarbij deze maatstaf nu boven het langetermijngemiddelde voor deze maatstaf ligt (getoond in groen).</p>
<p><img src="https://gimg2.gateimg.com/image/article/1698284231Frame-137691276-1.png" alt=""></p>
<p>Voor de cohort van lange-termijn houders lijken ze indrukwekkend onaangetast door de rally van deze week, gezien hun totale holdings stijgen naar een nieuw all-time-high van 14.899M BTC. De voortdurende stijging van deze metric geeft aan dat een groter volume van aanbod volwassen wordt over de 155-daagse drempel dan dat er wordt uitgegeven.</p>
<p>Ongeveer 29,6% van de LTH-voorraad wordt met verlies vastgehouden, wat historisch gezien hoog is voor deze maatstaf gezien de sterke marktuptrend sinds de dieptepunten van 2022. Dit is vergelijkbaar met eind 2015 en begin 2019, en de bodem van maart 2020.</p>
<p>Dit suggereert dat de LTH-cohort mogelijk een meer geharde en vastberaden cohort is in vergelijking met eerdere cycli.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1698284429Frame-137691277-1.png" alt=""></p>
<p>Ten slotte zullen we kijken naar een Z-Score (2-jaar periode) transformatie van de Revived Supply metric. We zijn op zoek naar periodes waarin munten die langer dan 1 jaar worden vastgehouden, worden uitgegeven tegen een statistisch significante snelheid in vergelijking met de voorgaande 2 jaar (half een halveringscyclus).</p>
<p>Perioden van hoge uitgaven (groen) komen vaak overeen met maximale winstnemingen (stijgende trends) of paniekverkopen (dalende trends). Echter, vandaag suggereert deze metriek dat we ons nog steeds binnen een regime van muntstilte bevinden, met een negatieve z-score lezing, wat duidt op minimale volumes van herleefde aanbod als reactie op de gebeurtenissen van deze week.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1698284388Frame-137691278.png" alt=""></p>
<h2 id="h2-Samenvatting20en20Conclusies67584"><a name="Samenvatting en Conclusies" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Samenvatting en Conclusies</h2><p>Bitcoinprijzen hebben nieuwe jaarlijkse hoogtepunten bereikt, zijn weer boven het prijsniveau van $30k uitgekomen en versneld naar $35k. De markt vond voldoende kracht om boven verschillende belangrijke prijsniveaus te breken, waaronder het 200-daags gemiddelde, het 200-weken gemiddelde (beide technisch), de Ware Marktmiddenprijs en de kostenbasis van de korte termijn houder (beide on-chain).</p>
<p>Een betekenisvol deel van het aanbod en investeerders bevindt zich nu boven de gemiddelde break-even prijs, die rond de $28k ligt. Dit legt de basis voor een hervatting van de opwaartse trend van 2023. Op zijn minst heeft de markt enkele belangrijke niveaus overschreden waarop de aggregate psychologie van investeerders waarschijnlijk verankerd is, waardoor de komende weken belangrijk zijn om in de gaten te houden.</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 zelf volledig 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 mening van de onderzoeker en vormt geen beleggingsadvies.<p></p><br></div></div></div></div>