R2xhc3Nub2RlIEluc2lnaHRzOiBSb3VuZC1Ucmlw

2023-12-13, 06:48
<p><img src="https://gimg2.gateimg.com/image/article/1702448874SDFX 1.jpeg" alt=""></p>
<h2 id="h2-utive20Samenvatting869920"><a name="utive Samenvatting" class="reference-link"></a><span class="header-link octicon octicon-link"></span>utive Samenvatting</h2><p>De sterke <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> De opwaartse trend vond deze week weerstand, brak door naar een nieuw jaarlijks hoogtepunt van $44.5k voordat het de op twee na scherpste verkoop van 2023 ervoer.</p>
<p>Verschillende on-chain prijsmodellen suggereren dat de ‘eerlijke waarde’ gebaseerd op de kostenbasis van de investeerder en de netwerkdoorvoer achterblijven, schommelend tussen $30k en $36k.</p>
<p>Als reactie op sterke prijsstijgingen in de afgelopen maanden hebben houders van <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> op korte termijn winst genomen in een statistisch betekenisvolle omvang, waardoor de stijging werd onderbroken.</p>
<p><img src="https://gimg2.gateimg.com/image/article/170244891500_cover-1.png" alt=""></p>
<p>De Bitcoin-markt heeft deze week een round-trip gemaakt, met een opening van $40,2k, een rally naar een nieuw jaarlijks hoogtepunt van $44,6k, voordat hij scherp verkocht tot $40,2k laat op zondagavond. De opwaartse beweging naar het jaarlijkse hoogtepunt bestond uit twee rallies van meer dan +5,0%/dag (+1 standaardafwijkingen). De verkoop was even krachtig en daalde met meer dan $2,5k (-5,75%), waardoor het de op twee na grootste daling van één dag was voor 2023.</p>
<p>Zoals we vorige week hebben besproken (WoC 49), heeft Bitcoin een opvallend jaar gehad, met een stijging van meer dan 150% YTD op het hoogtepunt, en presteert beter dan de meeste andere activa. Met dit in gedachten is het belangrijk om in de gaten te houden hoe investeerders reageren op hun nieuwe papieren winsten naarmate het jaar ten einde loopt.</p>
<p><img src="https://gimg2.gateimg.com/image/article/170244892701_price-1.png" alt=""></p>
<h2 id="h2-Navigeren20door20cycli20via20onchain20prijsmodellen893174"><a name="Navigeren door cycli via on-chain prijsmodellen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Navigeren door cycli via on-chain prijsmodellen</h2><p>Een nuttige gereedschapsset voor het navigeren door marktcycli zijn de kostenbasis van beleggers, gemeten aan de hand van de on-chain transacties voor verschillende cohorten. Het eerste kostenbasismodel dat we zullen overwegen is de Actieve Investeerder Gerealiseerde Prijs 🟠, die een reële waarde van Bitcoin berekent op basis van ons Cointime Economics-framework.</p>
<p>Dit model past een wegingsfactor toe op de gerealiseerde prijs in lijn met de mate van aanbodstrakheid (HODLing) over het netwerk. Grootschalig HODLing werkt als beperking van het aanbod, waardoor de geschatte ‘eerlijke waarde’ wordt verhoogd, en vice versa. De onderstaande grafiek belicht perioden waarin de spotprijs boven de klassieke gerealiseerde prijs 🔵 (een bodemmodel) handelt, maar onder de cyclische all-time-high. Hieruit hebben we een paar observaties:</p>
<p>De tijd tussen een succesvolle doorbraak van de Realized Price en het maken van een nieuwe ATH is historisch gezien 14 tot 20 maanden geweest (tot nu toe 11 maanden in 2023).</p>
<p>De weg naar een nieuwe ATH heeft altijd grote schommelingen van ±50% rond de Active Investor Realized Price 🟠 (weergegeven in oscillatoren voor elke cyclus) met zich meegebracht.</p>
<p>Als de geschiedenis ons iets leert, zou het een routekaart van enkele maanden van hobbelige omstandigheden rond dit ‘eerlijke waarde’ model (momenteel ongeveer $36k) schetsen.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1702449312woc-50-01.png" alt=""></p>
<p>De Mayer Multiple is een ander populair technisch prijsmodel voor Bitcoin, dat eenvoudigweg de verhouding tussen prijs en 200-daags voortschrijdend gemiddelde beschrijft. De 200-daags MA is een breed erkende indicator voor het vaststellen van macro-stier of -beer-bias, waardoor het een nuttig referentiepunt is voor het beoordelen van overgekochte en oververkochte omstandigheden.</p>
<p>Historisch gezien vallen overkochte en oververkochte omstandigheden samen met Mayer Multiple-waarden die respectievelijk hoger zijn dan 2,4 of lager dan 0,8.</p>
<p>De huidige waarde van de Mayer Multiple-indicator is 1,47, dicht bij het niveau van ~1,5 dat vaak een weerstandsniveau vormt in eerdere cycli, inclusief de Nov 2021 ATH. Misschien als indicator voor de ernst van de bear market 2021-22, zijn er 33,5 maanden verstreken sinds dit niveau werd doorbroken, de langste periode sinds de bear market van 2013-16.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1702449348woc-50-02-1.png" alt=""></p>
<p>Een andere lens om ‘eerlijke waarde’ voor Bitcoin te beoordelen, is om on-chain activiteit te vertalen naar het prijsdomein via het NVT-prijsmodel. De NVT-prijs streeft naar een fundamentele waardering van het netwerk op basis van de bruikbaarheid als afwikkelingslaag voor waarde uitgedrukt in Amerikaanse dollars.</p>
<p>Hier beschouwen we een 28-daagse 🟢 en een 90-daagse 🔴 variant, die respectievelijk een paar snelle en langzame signalen leveren. Een typische fase van overgang van beren naar stieren ziet de snellere 28-daagse variant handelen boven het 90-daagse model, een voorwaarde die sinds oktober van kracht is geweest.</p>
<p>De NVT Premium 🟠 kan ook worden gebruikt om de spotprijs te beoordelen ten opzichte van de langzamere 90-daagse NVT-prijs. De recente rally drukte een van de scherpste pieken af in de NTV-premie-indicator sinds de markttop in nov 2021. Dit suggereert een potentieel near-term ‘overwaardering’ signaal in verhouding tot netwerkdoorvoer.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1702449398woc-50-03.png" alt=""></p>
<h2 id="h2-De20marginale20belegger700982"><a name="De marginale belegger" class="reference-link"></a><span class="header-link octicon octicon-link"></span>De marginale belegger</h2><p>In eerdere edities van deze nieuwsbrief (WoC 38) hebben we de buitenproportionele invloed onderzocht die nieuwe investeerders (ook wel Short-Term Holders genoemd) hebben op het vormgeven van de prijsactie op korte termijn, zoals lokale toppen en bodems. Daarentegen heeft de activiteit van Long-Term Holders doorgaans meer invloed wanneer de markt macro-extremen bereikt, zoals het breken naar nieuwe ATHs of tijdens pijnlijke capitulatiegebeurtenissen en bodemvorming (zie Following the Smart Money en Buying High and Selling Low).</p>
<p>Om het effect van STH-gedrag te versterken, benadrukt de onderstaande grafiek de relatie tussen prijsbewegingen (trends en volatiliteit) en veranderingen in de winstgevendheid van deze groep investeerders.</p>
<ul>
<li><p><strong>STH Aanbod In Winst</strong> 🟢: Het aantal munten dat door STHs ‘in winst’ wordt gehouden, met een kostprijs die lager is dan de huidige spotprijs.</p>
</li><li><p><strong>30D-Vloer</strong> 🟨: Het minimale ‘in-winst’ STH-muntenaanbod van de afgelopen 30 dagen.</p>
</li><li><p><strong>90D-Vloer</strong> 🟥: De minimale ‘in-profit’ STH-muntenvoorraad gedurende de afgelopen 90 dagen.</p>
</li></ul>
<p>Deze 30D en 90D indicatoren stellen ons in staat om het percentage van STH-kapitaal te meten dat ‘in winst’ is over verschillende tijdsvensters. Met andere woorden, we kunnen deze sporen vergelijken om te meten hoeveel STH-munten minder dan 30 dagen, tussen 30 en 90 dagen en meer dan 90 dagen ‘in winst’ zijn gehouden.</p>
<p>Historisch gezien vallen rally’s naar nieuwe ATH’s samen met de 90-daagse statistiek die boven de 2M BTC uitkomt, wat wijst op een gematigde lange houdtijd door deze groep (een sterke investeerdersbasis). De rally sinds oktober heeft voornamelijk de variant van 30 dagen opgetild, wat erop wijst dat er nog geen solide STH-fundering is gelegd sinds de handel boven het $30k mid-cycle niveau (zie WoC 43).</p>
<p>We merken ook op dat de sporen van 2023 relatief laag zijn in vergelijking met voorgaande cycli, wat de relatieve schaarste aanbod bevestigt die we hebben behandeld in WoC 46.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1702449479woc-50-04.png" alt=""></p>
<h2 id="h2-Korte20termijn20angst20en20hebzucht487089"><a name="Korte termijn angst en hebzucht" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Korte termijn angst en hebzucht</h2><p>De volgende stap is het bouwen van een tool die periodes van verhoogde angst en hebzucht bij deze nieuwe investeerders identificeert, met de nadruk op overkopen (toppen) of oververkopen (bodems) signalen. We hebben de STH-Supply Profit / Loss Ratio geïntroduceerd in WoC 18, die een evenredige blik biedt op ongerealiseerde winst ten opzichte van verlies. Zoals weergegeven in de onderstaande grafiek:</p>
<ul>
<li><p><strong>Winst / Verlies Ratio’s &gt; 20</strong> historisch gezien in lijn liggen met oververhittingsomstandigheden.</p>
</li><li><p><strong>Winst/Verliesverhoudingen &lt; 0.05</strong> historisch gezien in lijn met oververkochte omstandigheden.</p>
</li><li><p><strong>Winst/Verlies Verhoudingen ~ 1.0</strong> betekent break-even en neigt zich te aligneren met ondersteunings-/weerstandsniveaus binnen de heersende markttrend.</p>
</li></ul>
<p>Sinds januari heeft deze metriek boven ~1 gehandeld, met verschillende hertesten en ondersteuning op dit niveau. Deze omstandigheden zijn historisch geassocieerd met het gedrag van investeerders die ‘buy-the-dip’ patronen volgen die vaak voorkomen tijdens stijgende trends.</p>
<p>We merken ook op dat de rally in oktober deze metriek ruimschoots boven het oververhitte niveau van 20 heeft gestuwd, wat wijst op een hoger risiconiveau en een vergelijkbare ‘oververhitte’ toestand als de NTV-Premium indicator.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1702449536woc-50-06.png" alt=""></p>
<p>De bovenstaande oscillator houdt rekening met de ongerealiseerde winst/verlies die wordt vastgehouden door STHs, wat hun ‘prikkels om te besteden’ kan worden genoemd. De volgende stap is om te beoordelen of deze nieuwe investeerders actie hebben ondernomen en winsten (of verliezen) hebben gerealiseerd, waardoor aanbod weer op de markt komt en verkoopweerstand ontstaat.</p>
<p>De onderstaande grafiek toont vier verschillende maatregelen van gerealiseerde winst/verlies door STH’s (alle genormaliseerd naar marktkapitalisatie):</p>
<ul>
<li><p>🟢<br> <strong>STH Volume in Winst naar Exchanges en</strong> 🔵<br> <strong>STH Gerealiseerde Winst</strong></p>
</li><li><p>🟠<br> <strong>STH-volume verlies aan beurzen en</strong> 🔴<br> <strong>STH Realized Verlies</strong></p>
</li></ul>
<p>Het belangrijkste inzicht uit deze studie is het identificeren van periodes waarin er een lezing is over zowel de gerealiseerde winst/verlies als het volume in winst/verlies naar uitwisselingsparen. Met andere woorden, STHs sturen veel munten naar beurzen en het gemiddelde verschil tussen aankoopprijzen en verkoopprijzen is groot.</p>
<p>Met dit in gedachten veroorzaakte de rally van deze week naar $44,2k een hoog niveau van winstnemingen door STH, wat erop wijst dat deze groep handelde op basis van hun papieren winsten en profiteerde van de liquiditeit van de vraag.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1702449689woc-50-06-1.png" alt=""></p>
<p>We kunnen deze observatie verder destilleren door dagen te benadrukken waarop STH-gerealiseerde winst met meer dan één standaarddeviatie is toegenomen ten opzichte van het gemiddelde van 90 dagen 🟥. We kunnen zien dat deze indicator lokale pieken heeft aangegeven gedurende de afgelopen drie jaar.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1702449975woc-50-07.png" alt=""></p>
<p>Met hetzelfde werkproces bereiken periodes van hoge verliesneming door STH’s meestal het niveau van één standaardafwijking tijdens grote verkoopgebeurtenissen. Dit signaleert wanneer beleggers in paniek raken en onlangs verworven munten terugsturen naar beurzen om deze met verlies te verkopen.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1702450001woc-50-08.png" alt=""></p>
<p>We kunnen natuurlijk beide indicatoren in één grafiek brengen, waardoor een instrument wordt gecreëerd om op basis van het uitgavenpatroon van de STH-groep de oververhitte/oververkochte omstandigheden op korte termijn te identificeren.</p>
<p>Zoals we kunnen zien, werd de recente rally naar $44.2k vergezeld door een statistisch betekenisvolle mate van winstneming door STHs. Naast de NTV-premie en de uitgebreide Realized Profit/Loss Ratio, kunnen we een samenvloeiing van factoren zien die wijzen op een mogelijke verzadiging van vraag (uitputting) die in het spel kan zijn.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1702450028woc-50-09.png" alt=""></p>
<h2 id="h2-Conclusie901383"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>Bitcoin maakte deze week een rondreis, steeg naar nieuwe jaarlijkse hoogtepunten voordat het weer terugviel naar de wekelijkse openingskoers. Na zo’n krachtig 2023 tot nu toe lijkt deze rally in het bijzonder weerstand te hebben ontmoet, waarbij on-chain data aangeeft dat STH’s een belangrijke drijfveer zijn.</p>
<p>We presenteren een reeks indicatoren en kaders die de lokale over- en onderwaardering voor Bitcoin benadrukken. Deze metingen zijn gebaseerd op zowel de kostenbasis van investeerders, technische gemiddelden, als on-chain fundamentals zoals transactievolumes. Vervolgens kunnen we confluente zoeken binnen (on)gerealiseerde winst/verlies-metingen, die aangeven wanneer investeerders beginnen met het opnemen van hun winst.</p>
<p><strong>Disclaimer: Deze rapportage geeft geen beleggingsadvies. Alle gegevens worden uitsluitend verstrekt ter informatie en educatieve doeleinden. Geen enkele beleggingsbeslissing mag worden gebaseerd op de verstrekte informatie en u bent volledig 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 enkel de standpunten van de onderzoeker en vormt geen enkele beleggingssuggestie.gate<p></p><br></div></div></div></div>
Share
Content
gate logo
Gate
Trade Now
Join Gate to Win Rewards