R2xhc3Nub2RlIEluc2lnaHRzOiBTdGlsIG1hYXIgemVsZnZlcnpla2VyZA==

2023-05-24, 01:46
<p><img src="https://gimg2.gateimg.com/image/article/1684892707SDFX.jpeg" alt=""></p>
<p>De <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Tegen Bitcoin</a> De markt heeft deze week geconsolideerd en handelt binnen een relatief smal prijsbereik van 3,4%, met een dieptepunt van $26,6k en een hoogtepunt van $27,5k. In feite is dit een van de meest beperkte handelsbereiken van de afgelopen jaren, met als laatste voorbeelden de jaarlijkse openingskoers van 2023 en juli 2020 na het herstel van de COVID-verkoop.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1684892756Group-3100--3-.png" alt=""></p>
<p>Dit gaat gepaard met extreem lage volumes op de chain, waarbij geaggregeerde, entiteits-aangepaste en aan de exchange gerelateerde stromen op cyclische dieptepunten blijven. Ondertussen blijft een groot deel van de muntvoorraad inactief in investeerdersportefeuilles, waarbij verschillende belangrijke leeftijdsgroepen recordhoogtes bereiken.</p>
<p>In deze editie zullen we deze interessante stand van zaken onderzoeken, en wat het ons vertelt over het vertrouwen van investeerders, prikkels en perspectief op de markt van 2023.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1684892335Group-3098.png" alt=""></p>
<h2 id="h2-Volume20Omlaag219908"><a name="Volume Omlaag" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Volume Omlaag</h2><p>In de editie van vorige week hebben we laten zien hoe on-chain activiteit voor <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Heeft historische hoogtepunten bereikt voor statistieken zoals transactieaantallen, grotendeels gerelateerd aan ordinals, inies en BRC-20-tokens. Deze soorten transacties vertegenwoordigen echter meestal relatief kleine BTC-volumes, waarbij ordinals vaak worden overgedragen samen met een klein volume BTC (meestal rond 10k sats = 0,0001 BTC).</p>
<p>Beoordelen van het overdrachtsvolume afgehandeld door de <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Netwerk over de afgelopen drie jaar, merken we een grote daling in de algehele economische doorvoer sinds begin 2021, die is gedaald van een hoogtepunt van $13,1B tot een dieptepunt van $1,9B, een daling van 85,5%. De overdrachtsvolumes hebben een marginale stijging meegemaakt in 2023, maar blijven echter dichtbij de dieptepunten tussen $1,9B en $4,4B.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1684892392Group-3091--1-.png" alt=""></p>
<p>Beurzen blijven een centraal punt voor BTC-handel, en het bestuderen van de in- en uitstroom biedt een robuuste proxy voor handelsvolume, bewustzijn, speculatieve vraag en investeerdersvertrouwen. We zien een vergelijkbare structurele afname in het volume van stortingen op beurzen, dat is gedaald van een hoogtepunt van $4,2 miljard in mei 2021 tot een dieptepunt van $343,4 miljoen vandaag (-91,8%).</p>
<p><img src="https://gimg2.gateimg.com/image/article/1684892413Group-3078--1-.png" alt=""></p>
<p>Een andere nuttige proxy voor het beoordelen van het gebruik van het netwerk is de absolute waarde van Realized Profit and Loss-gebeurtenissen. Dit geeft inzicht in de kapitaalstromen naar binnen of buiten het activum, aangezien munten hoger of lager worden hergewaardeerd. De gecombineerde Realized Profit and Loss wordt verhandeld op het laagste niveau dat de afgelopen 3 jaar is gezien.</p>
<p>Dit suggereert dat de meerderheid van de houders met grote winsten of verliezen niet bereid is om te spenderen.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1684892444Group-3101.png" alt=""></p>
<h2 id="h2-Onbenut20potentieel157965"><a name="Onbenut potentieel" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Onbenut potentieel</h2><p>We hebben vastgesteld dat zowel de nominale als de gerealiseerde netwerkdoorvoer cyclisch laag blijft. Dit kan te wijten zijn aan het feit dat veel marktdeelnemers een kostprijs hebben die heel dicht bij de huidige prijs ligt, wat aangeeft dat er op dit moment minimale prikkels zijn om uit te geven. Deelnemers hebben mogelijk meer volatiliteit nodig, in welke richting dan ook, om uitgaven te stimuleren.</p>
<p>De aangepaste gerealiseerde prijs biedt een verbeterd model om de totale marktkostenbasis te schatten. Het werkt door de enorme ongerealiseerde winsten van lang slapende (en waarschijnlijk verloren) munten (&gt; 7 jaar) te verwijderen, waardoor de economisch actieve en meer prijsgevoelige groep van houders geïsoleerd wordt.</p>
<p>Spotprijzen worden momenteel verhandeld net boven de Aangepaste Realized Prijs ($25.2k), wat waarschijnlijk een psychologisch interessegebied is in het g van een terugval. Dit bevestigt ook de these dat er eenvoudigweg niet veel winst (of verlies) beschikbaar is voor de actieve deelnemers op de markt.</p>
<p>⚠️Waarschuwingsidee: Een prijsdaling onder $25.2k zou aangeven dat er een hertest van de kostprijs voor de economisch actieve voorraad gaande is, waarbij het een belangrijk psychologisch prijsniveau is om in de gaten te houden.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1684892481Group-3097.png" alt=""></p>
<p>De recente rally boven $30k zag de aangepaste MVRV-ratio stijgen naar een waarde van 1,21, wat suggereert dat er een redelijk bescheiden niveau van 21% ongerealiseerde winst werd bereikt.</p>
<p>Op dit moment wordt de aMVRV opgenomen met een waarde van 1,09, wat suggereert dat er slechts 9% ongerealiseerde winst binnen de markt blijft. Dit valt samen met historisch oversold niveaus in zowel de 2018, 2019 en maart 2020 cyclische dieptepunten.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1684892491Group-3095.png" alt=""></p>
<h2 id="h2-Aanbod20blijft20stil269696"><a name="Aanbod blijft stil" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Aanbod blijft stil</h2><p>Ondanks het vlammende begin van het jaar in het digitale activum landschap, blijft de BTC voorraad die langer dan 1 jaar+ wordt vastgehouden nieuwe hoogtepunten bereiken. De onderstaande grafiek toont vier subsets van deze slapende voorraad als een proportie van de totale circulerende voorraad:</p>
<p>🔴 Aanbod voor het laatst actief 1+ jaar geleden: 68,1%<br>🟡 Aanbod voor het laatst actief 2+ jaar geleden: 55,2%<br>🟢 Aanbod voor het laatst actief 3+ jaar geleden: 40,0%<br>🔵 Aanbod voor het laatst actief 5+ jaar geleden: 28,9%</p>
<p>Het opmerkelijke niveau van HODLing over de voorraad blijft aanhouden, met zulke hoge muntinactiviteit die de extreme lage niveaus van on-chain volume doorvoer ondersteunt.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1684892518Group-3079--1-.png" alt=""></p>
<p>Dit fenomeen wordt ook weerspiegeld in de aanvoer van Long-Term Holder (munten die langer dan 155 dagen worden vastgehouden), die op een nieuw hoogtepunt van 14,46 miljoen BTC staat. Dit weerspiegelt munten die direct na het falen van FTX zijn verworven en tot LTH-status zijn gerijpt.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1684892541Group-3080--1-.png" alt=""></p>
<p>Confluence is te vinden in de metriek Levendigheid, die de relatieve balans tussen HODLing en bestedingsgedrag vergelijkt. Momenteel daalt de levendigheid van het netwerk naar de laagste waarde sinds de uitbraak van december 2020 boven $ 20K. Aanhoudende neerwaartse trends in levendigheid bevestigen opnieuw dat HODLing zeker de huidige primaire marktdynamiek is voor het grootste deel van het aanbod.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1684892567Group-3083--1-.png" alt=""></p>
<p>Als we kijken naar de Short-Term Holder (STH) cohort, kunnen we de hoeveelheid ‘houdtijd’ beoordelen die door deze groep wordt besteed (gemeten als coinday-vernietiging in de afgelopen 90 dagen). Volgens deze maatstaf is STH coinday-vernietiging extreem laag en significant lager dan de twee grote paniek-capsuleerevenementen die plaatsvonden in juni en november 2022.</p>
<p>Dit suggereert dat STH’s over het algemeen terughoudend zijn om te spenderen binnen het huidige prijsbereik en meer volatiliteit vereisen, en waarschijnlijk hogere prijzen (winst realiseren) als een stimulans.</p>
<p>Over het algemeen geven deze statistieken een relatief constructief beeld van <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Tegen Bitcoin</a> Houder overtuiging, waar de meesten gewoon nog niet geïnteresseerd zijn in het uitgeven van hun munten.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1684892590Group-3090--1-.png" alt=""></p>
<h2 id="h2-Houders20van20de20laatste20cyclus20zijn20vervalst426040"><a name="Houders van de laatste cyclus zijn vervalst" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Houders van de laatste cyclus zijn vervalst</h2><p>Na het dieptepunt in november is het in USD uitgedrukte vermogen dat in munten van 2-3 jaar oud wordt aangehouden, gegroeid van 3,1% naar 27,7%, aangezien er grote hoeveelheden aanbod volwassen worden bij de grens van 2 jaar. Dit weerspiegelt aanbod dat is verkregen na de verkoop in mei 2021, van $56k naar $29k.</p>
<p>De onderstaande grafiek toont het veranderende aandeel van het vermogen in USD dat in deze leeftijdsgroepen wordt aangehouden:</p>
<p>🟢 Rijkdom in bezit van 2-3 jaar: 3,1% tot 27,7% (stijging van +24,6%)<br>🟡 Rijkdom in bezit van 1-2 jaar: 43,5% tot 28,3% (daling van -15,2%)<br>🟠 Rijkdom in bezit van 6 maanden tot 1 jaar: 25,5% tot 10,6% (daling van -14,9%)</p>
<p><img src="https://gimg2.gateimg.com/image/article/1684892627Group-3102--1-.png" alt=""></p>
<p>We kunnen ook een nieuwe variant van de RHODL Ratio gebruiken, waarbij de rijkdom die wordt vastgehouden in 2y+ wordt vergeleken met die in de leeftijdsgroep 6m-2y. Dit helpt ons de balans te beoordelen tussen ervaren (2jr+) en enkelvoudige cyclus Lange-Termijn Houders (6m-2y).</p>
<p>Momenteel klimt deze RHODL-variant exponentieel, wat suggereert dat een aanzienlijk deel van de houders uit de cyclus 2021-22 uitgroeit tot de ervaren HODLers. Gezien de buitengewone, en meestal neerwaartse volatiliteit die zich in deze periode heeft voorgedaan, toont dit aan dat de <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> De houderbasis blijft ongelooflijk standvastig, wat een opmerkelijke en waarschijnlijk constructieve waarneming is.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1684892638Group-3088.png" alt=""></p>
<h2 id="h2-Samenvatting20en20conclusies250860"><a name="Samenvatting en conclusies" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Samenvatting en conclusies</h2><p>Een van de grote voordelen van on-chain analyse is onze mogelijkheid om beide kanten van het houdergedrag te observeren; hun bereidheid om vast te houden en hun bereidheid om uit te geven. Wat we blijven waarnemen, is de overtuiging van bestaande <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Het aantal houders blijft opmerkelijk hoog, ondanks de extreme volatiliteit en immense deleveraging van de afgelopen 2 jaar.</p>
<p>Het is belangrijk om te benadrukken dat het volume aan doorvoer op dit moment zeer laag is, wat wijst op een mogelijk gebrek aan nieuwe vraag, evenals een groeiende dominantie door transacties met lage volumes. Dit wordt echter gecompenseerd door een bestaande houderbasis die naar verluidt steeds prijsongevoeliger wordt.</p>
<p>Gezien 2022 geen tekort aan redenen bood om in paniek te raken, te capituleren en anderszins de markt te verlaten, is het ouder worden van munten in meerdere jaren opmerkelijk. Dit suggereert een situatie waarin degenen die 2022 hebben overleefd, mogelijk hogere prijzen nodig hebben voordat ze hun cold storage wallets openen.</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 standpunten van de onderzoeker en vormt geen beleggingsadvies.<br></div><p></p><br></div></div></div>
Share
Content
gate logo
Gate
Trade Now
Join Gate to Win Rewards