R2xhc3Nub2RlIEluc2lnaHRzOiBFZW4gVm9sYXRpZWxlIFdlZyBuYWFyIE5lcmdlbnM=

2023-06-20, 04:39

<p><img src="https://gimg2.gateimg.com/image/article/1687229585SDFX.jpeg" alt=""></p>
<h2 id="h2-Samenvatting505368"><a name="Samenvatting" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Samenvatting</h2><p>Volatiliteit, volume en gerealiseerde waarde zijn op meerjarige dieptepunten, wat erop wijst dat de liquiditeit steeds dunner wordt en investeerders onverschilligheid nu stevig aanwezig is.</p>
<p>De onderstroom van BTC-aanbod blijft doorgaan <a href="/price/flow-flow" rel="nofollow noopener noreferrer" target="_blank">Stroom</a> uitwisselingen, mijnwerkers en en walviswallets, en richting HODLer-entiteiten van alle groottes tegen een gezond tempo.</p>
<p>Vergelijkingen met eerdere cycli suggereren dat de markt zich waarschijnlijk binnen een overgangsperiode bevindt, gekenmerkt door apathie en verveling bij beleggers. De halvering komt echter steeds dichterbij, nu nog maar 305 dagen verwijderd.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1687229625Group-3179.png" alt=""></p>
<h2 id="h2-De20Weg20naar20Nergens459188"><a name="De Weg naar Nergens" class="reference-link"></a><span class="header-link octicon octicon-link"></span>De Weg naar Nergens</h2><p>Deze week, <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> De markt maakte prijsschommelingen in beide richtingen, maar maakte over het geheel genomen weinig vooruitgang. De markt handelde aan het begin van de week op $24,8k, steeg naar $26,7k op nieuws van de ETF-aanvraag door Blackrock, voordat deze bijna terugkeerde naar de openingskoers van $26,3k. Hoewel de prijzen intra-week volatiel waren, blijft de markt op een weg naar nergens.</p>
<p>Als we de prijsklasse van 30 dagen vergelijken, kunnen we zien dat stille periodes zoals deze zeldzaam zijn. De meerderheid lijkt zich voor te doen tijdens de apathische katerperiode die volgt op een berenmarkt, in lijn met onze observaties van marktapathie vorige week (WoC 25)</p>
<p><img src="https://gimg2.gateimg.com/image/article/1687235342Group-3161.png" alt=""></p>
<p>Dit wordt natuurlijk ook weerspiegeld in de Realized Volatility van 1 maand, die is teruggezet naar 39,6%, een van de laagste opnames sinds de stierenmarkt van 2021. We kunnen zien dat dergelijke gebeurtenissen typisch zijn tijdens de lange, zijwaartse grind terwijl de markt zijn voeten vindt na een langdurige bearish trend.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1687235351Group-3160-2.png" alt=""></p>
<p>Geïmpliceerde volatiliteit over optiecontracten van 1 week tot 6 maanden is ook op een cyclus laagtepunt gekomen. De geïmpliceerde volatiliteit op korte termijn van 1 week staat op de op één na laagste waarde (36%) ooit, terwijl contracten van 3 en 6 maanden op respectievelijk historische dieptepunten van 42% en 46% staan.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1687235379Group-3162.png" alt=""></p>
<p>De handelsvolumes op futuresmarkten zijn ook gedaald tot $20,9 miljard per dag, aangezien de liquiditeit op digitale activamarkten blijft afnemen.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1687235400Group-3177--2-.png" alt=""></p>
<p>Dit fenomeen wordt ook waargenomen in de <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Futuresmarkten suggereren dat deze afname in liquiditeit een sectorbrede krimp is. De enige periode in de afgelopen 30 maanden met een lagere totale handelsvolume was tijdens de eindejaarsdip van 2022.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1687235548Group-3164.png" alt=""></p>
<p>Een vergelijkbaar verhaal geldt on-chain, we kunnen zien dat de absolute waarde van winst en verlies bij evenementen is gedaald naar cyclische dieptepunten van $268M. Dit keert terug naar niveaus van oktober 2020 (BTC-prijzen waren ~$10k), waaruit blijkt hoe rustig de kapitaalstromen zowel binnen als buiten de activaklasse zijn geweest tot nu toe.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1687235574Group-3165.png" alt=""></p>
<h2 id="h2-HODLers20houden20vast119652"><a name="HODLers houden vast" class="reference-link"></a><span class="header-link octicon octicon-link"></span>HODLers houden vast</h2><p>We hebben vastgesteld dat de liquiditeit van digitale activa zeer beperkt is, zowel on-chain als off-chain. In het volgende gedeelte zullen we onderzoeken hoe dit zich vertaalt naar het gedrag van bestaande marktdeelnemers.</p>
<p>Liveliness biedt een breed overzicht van de neiging van Bitcoin-houders om hun munten uit te geven of vast te houden. Momenteel bevindt Liveliness zich in een meerjarige macro neerwaartse trend, nadat het in mei 2021 een piek bereikte toen de bearmarkt voor het eerst begon. We zien een vergelijkbare structuur die is gevormd in de cyclus van 2018-20, aangezien munten langzaam maar zeker migreren naar koude opslag en worden verwijderd van de markt door de HODLer-cohort.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1687235600Group-3166.png" alt=""></p>
<p>Deze HODLers zijn momenteel munten aan het verzamelen met een snelheid van ongeveer 42,2K BTC/maand, wat suggereert dat de prijs ongevoelige klasse een niet onbelangrijk deel van het momenteel beschikbare aanbod opneemt.</p>
<p>Als we dit gedrag vergelijken met eerdere cycli, kunnen we zien dat dit regime van gestage en geleidelijke accumulatie iets meer dan 2 jaar geleden begon, en suggereert dat er nog eens 6 tot 12 maanden voor ons liggen.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1687235621Group-3167.png" alt=""></p>
<p>Deze observatie wordt verder ondersteund door de divergentie tussen uitwisselingsbalansen en het volume van munten dat wordt aangehouden in niet-liquide portefeuilles, die weinig tot geen geschiedenis hebben van uitgaven. De niet-liquide voorraad bereikte deze week een nieuw ATH van 15,2 miljoen BTC, terwijl de uitwisselingsbalansen zijn gedaald tot de laagste niveaus sinds januari 2018, namelijk 2,3 miljoen BTC.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1687235656Group-3170.png" alt=""></p>
<p>Momenteel stroomt er ongeveer 146K BTC per maand naar deze illiquide wallets, wat het bewijs ondersteunt voor een geleidelijke en gestage accumulatie die plaatsvindt.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1687235682Group-3178--3-.png" alt=""></p>
<p>Om een idee te krijgen van de schaal, kunnen we de balansverandering van verschillende portemonneegroepen vergelijken met het volume van nieuwe munten die aan miners zijn uitgegeven.</p>
<p>Met deze relatieve maatstaf kunnen we zien dat entiteiten met een balans onder de 100 BTC hun bezittingen aanzienlijk verhogen, wat overeenkomt met 254% van de gemijnde voorraad in de afgelopen maand absorberen (2,54 x ~900 BTC/dag = 2.286 BTC/dag).</p>
<p><img src="https://gimg2.gateimg.com/image/article/1687235705Group-3171--1-.png" alt=""></p>
<p>Haaientiteiten (100 tot 1k BTC) zien ook een positieve verandering in het saldo en absorberen volumes die gelijk staan aan 36% van de gedolven voorraad. Walvistiteiten daarentegen (&gt; 1k BTC) voegen zich bij Miners als netto-distributeurs en laten een volume vrij dat gelijk staat aan 70% van de gedolven voorraad uit hun bezit.</p>
<p>Over het algemeen lijkt de markt zich in een periode van stille accumulatie te bevinden, wat wijst op een onderliggende vraag, ondanks de recente regelgevingswinden.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1687235755Group-3172.png" alt=""></p>
<h2 id="h2-Een20Zware20Weg20Vooruit532710"><a name="Een Zware Weg Vooruit" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Een Zware Weg Vooruit</h2><p>In een poging om een maatstaf te vinden voor wat er in de toekomst kan gebeuren, kunnen we voorgaande marktfasen beoordelen op basis van de duur ervan. De onderstaande grafiek toont het aantal dagen dat is besteed in de volgende fasen:</p>
<p>🔵 Bull Market gemeten vanaf de cycluslaag tot de cycluspiek.<br>🔴 Bear Market gemeten vanaf de cycluspiek tot de cycluslaag.<br>⚫ Overgang gemeten vanaf de cyclus ATL tot het instellen van een nieuwe ATH.</p>
<p>Als we aannemen dat de dieptepunten die in november 2022 zijn vastgesteld standhouden, kunnen we stellen dat de markt zich al 221 dagen in een overgangsperiode bevindt. Vorige overgangsperioden duurden tussen de 459 en 770 dagen, wat suggereert dat het geduld van investeerders mogelijk op de proef wordt gesteld, gedurende 8 tot 18 maanden, tot een nieuwe ATH van de markt, als de geschiedenis een leidraad is.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1687235809Group-3174--1-.png" alt=""></p>
<p>Deze overgangsperiodes hebben de neiging om prijzen te zien die zich tussen de Gerealiseerde Prijs 🟠 en de Gerealiseerde Prijs + 0,5 standaardafwijking band 🔵 bevinden. Sinds het instellen van elk cyclisch dieptepunt, is het volgende deel van de handelsdagen tussen deze grenzen geweest:</p>
<p>2012-13 Cyclus = 79%<br>2015-17 Cyclus = 64%<br>2019-21 Cyclus = 78%</p>
<p>Dit kader zou een prijsklasse suggereren tussen $20.1k (-23%) aan de onderkant en $45.0k (+71%) aan de bovenkant gedurende deze periode.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1687235825Group-3175--1-.png" alt=""></p>
<p>Met de Bitcoin-halvering slechts 305 dagen verwijderd, kunnen we ook de relatie zien tussen deze overgangsperiodes en halveringsevenementen, die meestal ongeveer twee derde van de reis plaatsvinden.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1687235850Group-3176--1-.png" alt=""></p>
<p>Hieruit kunnen we de prijsprestaties van eerdere periodes indexeren, te beginnen bij 305 dagen na de halvering. Het bereik van eerdere marktprestaties op de datum van de halvering is als volgt:</p>
<p>🟠 Epoch 1 = +126% met een maximale drawdown van -44,8%<br>🔴 Epoch 2 = +179% met een maximale drawdown van -23,3%<br>🔵 Epoch 3 = -6,4% met een maximale drawdown van -53% in maart 2020</p>
<p>De eerste twee tijdperken kenden beide een zeer positieve prijsstijging, terwijl het derde tijdperk veel uitdagender was voor beleggers om te navigeren, niet in de laatste plaats met de exogene schok van maart 2020.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1687235874Group-3173--1-.png" alt=""></p>
<p>Tot slot sluiten we onze analyse af met een beoordeling van de prijsprestaties gedurende het jaar dat volgt op elk halveringsevenement.</p>
<p>🔴 Prijsprestaties van Epoch 2: +7358% met een maximale drawdown van -69,4%<br>🔵 Prijsprestaties van Epoch 3: +393% met een maximale drawdown van -29,6%<br>🟢 Prijsprestaties van Epoch 4: +366% met een maximale drawdown van -45,6%</p>
<p>Er wordt duidelijk een afnemend rendementseffect waargenomen over de Epochs, een natuurlijke verwachting naarmate de marktomvang en kapitaalstromen in de loop van de tijd toenemen in omvang.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1687235909Group-3180.png" alt=""></p>
<h2 id="h2-Samenvatting20en20conclusies713232"><a name="Samenvatting en conclusies" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Samenvatting en conclusies</h2><p>Op de meeste maatstaven van marktenergie tonen digitale activamarkten weinig opwinding. Volatiliteit, volumes en gerealiseerde waarde bevinden zich allemaal op het laagste niveau in jaren, terwijl liquiditeit en opwinding plaatsmaken voor beleggersapathie.</p>
<p>Maar onder de oppervlakte blijft het klassieke patroon van vermogensoverdracht naar de prijsongevoelige HODLer-cohort ononderbroken. Als vorige cycli enige leidraad zijn, suggereert het dat een periode van apathische zijwaartse verveling de weg vooruit kan bepalen, mogelijk tussen de 8 en 18 maanden durend.</p>
<p><strong>Disclaimer: Dit rapport geeft geen beleggingsadvies. Alle gegevens worden uitsluitend verstrekt voor informatie- en educatieve doeleinden. Er mag geen beleggingsbeslissing worden genomen op basis van de hier verstrekte informatie en u bent zelf 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 opvattingen van de onderzoeker en vormt geen enkele beleggingsaanbeveling.<br></div><p></p><br></div></div></div>