R2xhc3Nub2RlIEluc2lnaHRzOiBCaXRjb2luIHNjaGFrZWx0IGVlbiB2ZXJzbmVsbGluZyBob2dlcg==

2023-03-22, 02:12
<p><img src="https://gimg2.gateimg.com/image/article/1679450167SDFX.jpeg" alt=""></p>
<p><a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> heeft een van de best presterende weken in de geschiedenis meegemaakt, met een stijging van 35,8% op weekbasis. Slechts 124 handelsdagen in de geschiedenis hebben een grotere stijging van 7 dagen gezien, met slechts 16 dagen sinds 2015. Bijna alle glen deden zich voor binnen stierenmarkttrends, zij het meestal in de latere stadia van de run.</p>
<p>De sterke out-performance van BTC komt samen met uitdagende omstandigheden voor het traditionele financiële en bankwezen. Zorgen blijven hoog over de kwetsbaarheid van kleinere banken in een tijdperk van digitale bank runs, en nieuwe liquiditeitsfinancieringsfaciliteiten worden opgezet tussen de Amerikaanse Federal Reserve, Amerikaanse banken en swaplijnen met andere centrale banken.</p>
<p>Met dit als achtergrond zullen we onderzoeken hoe investeerders on-chain reageren en via verschillende methoden aantonen hoe de <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> de markt lijkt van koers te veranderen, weg van diep berenmarktgebied, en richting een structuur die lijkt op vroegere stierenmarkten. We zullen analyseren <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> vanuit de volgende invalshoeken:</p>
<p><img src="https://gimg2.gateimg.com/image/article/167945021000_cover-8.png" alt=""></p>
<p>On-chain Momentum, aangezien verschillende statistieken aangeven dat er een gezonde uitbreiding van het netwerkgebruik aan de gang is.</p>
<p>Een versnelling hoger schakelen als <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> verlaat omstandigheden die synoniem zijn met cyclische dieptepunten en betreedt het ‘middenterrein’ dat kenmerkend is voor het begin van stierenmarktcycli.</p>
<p>Het Cold Money volgen door te beoordelen of er aanzienlijke winsten worden genomen door houders op langere termijn en of het risico van een overaanbod op korte termijn toeneemt.</p>
<p><img src="https://gimg2.gateimg.com/image/article/167945023801_price-1.png" alt=""></p>
<h2 id="h2-20Momentum20Onchain381667"><a name="💨 Momentum On-chain" class="reference-link"></a><span class="header-link octicon octicon-link"></span>💨 Momentum On-chain</h2><p>We beginnen met het observeren van de on-chain activiteitenruimte, waar over het algemeen het eenvoudige concept van ‘meer is beter’ van toepassing is. Naarmate er meer mensen interactie hebben en transacties uitvoeren binnen de <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> In de economie wordt het doorgaans geassocieerd met periodes van toenemende adoptie, netwerkeffecten en investeerdersactiviteit.</p>
<p>Het maandelijkse gemiddelde van transactieaantallen heeft deze week 309,5k/dag bereikt, wat het hoogste niveau is sinds april 2021, en een significante doorbraak boven het jaarlijkse gemiddelde.<br><strong>Minder dan 12,2% van alle dagen heeft meer transactieactiviteit gezien voor <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a>, een gezond teken.</strong></p>
<p><img src="https://gimg2.gateimg.com/image/article/167945031302_tx_mom.png" alt=""></p>
<p>Met behulp van onze geavanceerde clustering-algoritmen kunnen we het aantal unieke nieuwe entiteiten dat on-chain actief is, schatten als een beste schatting voor unieke nieuwe gebruikers. Deze statistiek heeft 122k nieuwe entiteiten per dag bereikt, waarbij slechts 10,2% van de dagen een hogere acceptatiegraad van nieuwe gebruikers ziet, namelijk op de piek van 2017 en tijdens de bull run van 2020-21.</p>
<p><img src="https://gimg2.gateimg.com/image/article/167945037703_ent_mom.png" alt=""></p>
<p>Als gevolg hiervan neemt netwerkcongestie toe, wat opwaartse druk uitoefent op transactiekosten. Versterkt door een nieuwe vraag van Ordinals en Inions, is de 2-jarige Z-Score voor mijnbouwopbrengsten uit kosten positief geworden.</p>
<p>Verhoogde druk op de kosten is een veelvoorkomende voorloper van meer constructieve markten, samenhangend met nieuwere <a href="/price/waves-waves" rel="nofollow noopener noreferrer" target="_blank">Golven</a> van adoptie, uitgedrukt via toenemende vraag naar blockspace.</p>
<p><img src="https://gimg2.gateimg.com/image/article/167945039804_fee_mom.png" alt=""></p>
<p>Miners zijn natuurlijk de belangrijkste begunstigden van deze toestroom, aangezien hun totale inkomsten zien stijgen tot $ 22,6 miljoen per dag. Deze week zijn de inkomsten van miners gestegen naar het hoogste niveau sinds juni 2022 en zijn ze overtuigend boven het jaargemiddelde uitgekomen.</p>
<p>Vergelijkbaar met de bovenstaande activiteitsmodellen, wordt dit meestal waargenomen bij overgangspunten naar een meer constructieve markt.</p>
<p><img src="https://gimg2.gateimg.com/image/article/167945044305_miner_rev.png" alt=""></p>
<h2 id="h2-20Nieuw20Onderzoek20Shrimp20Supply20Sink784824"><a name="📖 Nieuw Onderzoek: Shrimp Supply Sink" class="reference-link"></a><span class="header-link octicon octicon-link"></span>📖 Nieuw Onderzoek: Shrimp Supply Sink</h2><p>De aanbodverdeling van <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> blijft een onderwerp van groot belang, voor de analyse van kapitaalstromen en ook voor het observeren van het gedrag van beleggerscohorten. In dit stuk splitsen we het BTC-aanbod op per portemonneegrootte, onderzoeken we hoe munten zich in de loop van de tijd verspreiden en laten we zien hoe kleinere houders hun aandeel in de <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> taart.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1679450565image-16.png" alt=""></p>
<h2 id="h2-20Een20versnelling20hoger20schakelen510786"><a name="⚙️ Een versnelling hoger schakelen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>⚙️ Een versnelling hoger schakelen</h2><p>Zoals we begin februari (WoC 6) hebben onderzocht, zijn verschillende on-chain indicatoren overgegaan van omstandigheden die typisch zijn voor diepe bearmarkten naar meer neutraal en constructief terrein. MVRV is zo’n metriek, die de niet-gerealiseerde winstveelvoud modelleert die binnen de muntvoorraad wordt aangehouden.</p>
<p>De grafiek hieronder toont aan dat MVRV is gestegen tot 1.36, wat zich tussen het altijd gemiddelde van 1.82 en het ‘oversold’ -1 standaardafwijkingniveau bevindt. Historisch gezien, <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> heeft binnen deze middenband 54% van alle handelsdagen verhandeld, zowel tijdens late berenfasen als tijdens vroege bullmarkt-herstels.</p>
<p><img src="https://gimg2.gateimg.com/image/article/167945062806_mvrv_bands.png" alt=""></p>
<p>Gegeven MVRV is een verhouding afgeleid van de Gerealiseerde Prijs, kunnen we een prijsniveau terugberekenen dat overeenkomt met deze belangrijke MVRV-niveaus. Met BTC-prijzen die deze week boven de $27k uitkomen, handelt de markt nu binnen de neutrale zone van ±0.5 standaardafwijkingen van het langetermijngemiddelde.</p>
<p>Dit geeft aan dat BTC-prijzen niet langer sterk zijn afgeprijsd in verhouding tot het gemiddelde kostenbasis op de on-chain markt.</p>
<p><img src="https://gimg2.gateimg.com/image/article/167945064707_mvrv_pricing.png" alt=""></p>
<p>De MVRV Momentum Oscillator is een krachtig instrument om deze macrofaseverschuivingen te identificeren, en het is momenteel bezig met het doorbreken van 0. Deze indicator reageert zeer snel op gebeurtenissen waarbij grote delen van de muntvoorraad worden verworven boven of onder de spotprijs, en snel weer overgaan tot het vasthouden van een ongerealiseerd verlies of winst, respectievelijk (d.w.z. bijna cyclusomkeerpunten).</p>
<p>MVRV Momentum is zojuist positief omgeslagen, wat aangeeft dat een groot deel van de muntvoorraad onder de huidige prijs is verworven en nu weer winstgevend is. Net als bij de hierboven genoemde statistieken, blijken eerdere glen van positieve omkeringen ook samen te hangen met stijgingen in netwerkadoptie en on-chain activiteit.</p>
<p><img src="https://gimg2.gateimg.com/image/article/167945072208_mvrv_mom.png" alt=""></p>
<h2 id="h2-20Gerelateerde20analyse20Het20beheersen20van20MVRV563734"><a name="📖 Gerelateerde analyse: Het beheersen van MVRV" class="reference-link"></a><span class="header-link octicon octicon-link"></span>📖 Gerelateerde analyse: Het beheersen van MVRV</h2><p>De MVRV-metingen hierboven zijn gebaseerd op een methodologie voor het identificeren van extreme afwijkingen van het langetermijngemiddelde, met live dashboards en grafieken beschikbaar voor beide<br><strong><a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> MVRV</strong> en<br><strong><a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> MVRV</strong>.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1679450820image-15.png" alt=""></p>
<h2 id="h2-20Volgend20het20Koude20Geld716092"><a name="🧊 Volgend het Koude Geld" class="reference-link"></a><span class="header-link octicon octicon-link"></span>🧊 Volgend het Koude Geld</h2><p>Een van de krachtigere tools binnen on-chain analyse is onze mogelijkheid om de houdtijd van munten te monitoren, genaamd Levensduur. Dit stelt ons in staat om te identificeren wanneer oudere munten, meestal in bezit van langere termijn, sterke overtuiging HODLers, in beweging zijn.</p>
<p>De grafiek hieronder toont het aandeel van het USD-vermogen dat wordt aangehouden in ‘hot coins’, gedefinieerd als munten die de afgelopen 7 dagen zijn verhandeld. Deze maatstaf neemt voornamelijk toe wanneer oude munten worden uitgegeven en winst wordt genomen, goedkope en oude munten worden overgedragen aan nieuwe kopers tegen hoge prijzen.</p>
<p>Hoewel er een lichte stijging is geweest in het aandeel ‘hete munten’, blijft dit dicht bij cyclische dieptepunten, opnieuw vergelijkbaar met overgangsperiodes na significante bearish trends. Dit geeft aan dat ondanks de sterke prijsprestaties, het nog steeds onvoldoende is om de meeste eigenaren van oudere munten te motiveren om winst te nemen.</p>
<p><img src="https://gimg2.gateimg.com/image/article/167945085209_hotcoins.png" alt=""></p>
<p>We kunnen dit zien in Long-Term Holder SOPR, die bezig is om terug te keren naar neutraal terrein. Long-Term Holders (LTH’s) zijn grotendeels kopers uit de cyclus van 2020-22, en ze hebben bijna 12 opeenvolgende maanden verliezen vastgelegd.</p>
<p>Het maandelijkse gemiddelde van LTH-SOPR breekt momenteel boven het jaarlijkse gemiddelde uit, wat wijst op een terugkeer van zowel vertrouwen als een terugkeer van positieve momentum in hun uitgavenpatronen.</p>
<p><img src="https://gimg2.gateimg.com/image/article/167945091111_lth_soprmultiple.png" alt=""></p>
<p>Eindelijk, een overzicht van de hele markt nemend, herzien we verschillende SOPR-varianten, een metriek die we ook hebben behandeld in de editie van vorige week (WoC 11). SOPR is een metriek voor alle weersomstandigheden die kan worden gebruikt om het niveau van winst en verlies te volgen die door marktcohorten worden gerealiseerd.</p>
<p>Hier hebben we vier varianten van SOPR over elkaar gelegd:</p>
<p>🟢<br><strong>SOPR</strong> - dekkend uitgavegedrag van het hele netwerk.<br>🔵<br><strong>Aangepaste SOPR</strong>- het filteren van niet-economische relaytransacties (&lt; 1 uur levensduur).<br>🟠<br><strong>Entiteit-Aangepaste SOPR</strong>- onze schoonste filtering voor de meest economisch zinvolle uitgavenactiviteit over het hele netwerk.<br>🔴<br><strong>Korte termijn houder SOPR</strong> - filtering alleen voor munten die in de afgelopen 155 dagen zijn verworven.<br>We zien momenteel een vergelijkbare herstelstructuur als de cyclus van 2018-19. Vorige week vond er een gezond ‘wash-out’-evenement plaats, waarbij alle SOPR-varianten onder een niveau van 1.0 kwamen te liggen. Dit duidt op een wijdverbreid gerealiseerd verlies tijdens de verkoop van de $19.8k.</p>
<p>Deze week heeft echter het hoogste SOPR-cijfer sinds de ATH van november 2021 opgevolgd, wat suggereert dat hoewel er ongetwijfeld winsten worden genomen, dit nog geen rem heeft gezet op de heersende stijgende trend.</p>
<p><img src="https://gimg2.gateimg.com/image/article/167945091111_lth_soprmultiple.png" alt=""></p>
<h2 id="h2-Samenvatting20en20conclusies434902"><a name="Samenvatting en conclusies" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Samenvatting en conclusies</h2><p><a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> beleggers hebben een van de sterkste wekelijkse winsten ooit ervaren, te midden van stress, consolidatie en liquiditeitsinjecties in het wereldwijde banksysteem. Verschillende on-chain indicatoren suggereren dat de <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> De markt maakt de overgang door van omstandigheden die historisch geassocieerd worden met diepe berenmarkten, en terug naar groenere weiden.</p>
<p>De adoptie op de blockchain versnelt en de meerderheid van de munthouders die volatiliteit al meer dan 5 maanden hebben doorstaan, blijven grotendeels standvastig. Slechts weinig langetermijnbeleggers lijken gemotiveerd om winst te nemen tijdens deze rally, wat duidt op opmerkelijke kracht en een weerspiegeling is van de overtuigingen die men heeft over <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> belangrijke rol in de toekomst van het wereldwijde financiële systeem.</p>
<hr>
<p>Disclaimer: Dit rapport geeft geen beleggingsadvies. Alle gegevens worden uitsluitend verstrekt voor informatieve en educatieve doeleinden. Geen enkele beleggingsbeslissing mag worden gebaseerd op de hier verstrekte informatie en u bent zelf verantwoordelijk voor uw eigen beleggingsbeslissingen.</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 investeringssuggesties.<br></div><p></p><br></div></div></div>
Share
Content
gate logo
Gate
Trade Now
Join Gate to Win Rewards