R2xhc3Nub2RlIEluc2lnaHRzOiBNYXJrdCB3aWpzdCBhZiB2YW4gZGUga29zdHByaWpz

2023-03-07, 10:30
<p><img src="https://gimg2.gateimg.com/blog/167117004537106004920221216-135350.jpeg" alt=""><br>De digitale activamarkt handelde deze week lager, met <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> komend van een hoogtepunt van $23.871 en dalend naar een wekelijks laagtepunt van $22.199. Zoals we zullen bespreken in deze editie, valt het wekelijkse hoogtepunt samen met verschillende psychologisch belangrijke gerealiseerde prijsniveaus die verband houden met zowel oudere houders uit de laatste cyclus als walvisentiteiten die actief zijn sinds de cyclus van 2018.<br><img src="https://gimg2.gateimg.com/image/article/167819915911.png" alt=""><br>In deze editie zullen we deze verschillende gerealiseerde prijzen verkennen, evenals indicatoren met betrekking tot kapitaalinstromen, overdrachtsvolumes en winstnemingen die opkomen terwijl de markt probeert over te gaan van het berenmarktgebied.<br><img src="https://gimg2.gateimg.com/image/article/1678199359woc-10-00.png" alt=""></p>
<h2 id="h2-Markt20wedstrijden20met20kostenbasis723242"><a name="Markt wedstrijden met kostenbasis" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markt wedstrijden met kostenbasis</h2><p>Naast traditionele technische indicatoren kunnen op on-chain principes gebaseerde prijsmodellen krachtige tools zijn om aanbod- en vraaggrenzen te schatten.</p>
<p>Onder verschillende on-chain waarderingsmodellen is de gemiddelde aankoopprijs van verschillende cohorten in de <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> De economie geeft een schatting van prijsbereiken die psychologisch belangrijk zijn. De onderstaande grafiek vergelijkt deze geschatte kostprijs (gerealiseerde prijs) in drie cohorten:</p>
<p>🔴 Jonge Levering Gerealiseerde Prijs ($21,0k), wat de gemiddelde prijs is van munten die in de laatste ~6 maanden van eigenaar zijn veranderd.</p>
<p>🟠 Markt Gerealiseerde Prijs ($19.8k), wat de gemiddelde prijs is van alle munthouders.</p>
<p>🔵 Oude Realisatieprijs van het aanbod ($23.5k), wat de gemiddelde verkrijgingskosten is van munten die minstens ~6 maanden worden aangehouden.</p>
<p>We kunnen zien dat deze week de spotprijzen werden afgewezen van niveaus die samenvielen met de Old Supply Realized Price. Veel van deze oudere munten worden vastgehouden door kopers van de cyclus 2021-22, die onder water staan ​​in hun positie.<br><img src="https://gimg2.gateimg.com/image/article/1678199429woc-10-01-1-.png" alt=""><br>Naast de tijdscohorten kan ook het investeerdersgedrag worden beoordeeld op basis van de portemonneegroottecohorten. Onder alle bekende entiteiten in de <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> In het ecosysteem zijn walvissen (met meer dan 1k BTC) vaak het middelpunt van speculanten’ aandacht.</p>
<p>De onderstaande grafiek geeft de gemiddelde aankoopprijzen weer voor de walviscohorte, waarbij alleen munten die in en uit beurzen stromen in overweging worden genomen. De sporen beginnen meten bij de volgende belangrijke marktbodems, met als doel de meest gunstige gemiddelde walvis-aankoopprijs te bieden voor elke cyclusperiode.</p>
<p>🟡 Sinds juli 2017, de lancering van Binance</p>
<p>🔴Sinds december 2018, op het laagste punt van de berenmarkt van 2018.</p>
<p>🔵 Maart 2020 op het dieptepunt van de COVID-verkoop.</p>
<p>Alle drie de subgroepen van de walvissen zagen hun bezittingen in een niet-gerealiseerd verlies terechtkomen toen de markt begin november 2022 onder de ~$18k dook. Opmerkelijk genoeg stokte het recente herstel bij de ongeveer kostprijs van de walvissen uit het tijdperk Dec-2018+ 🔴 ($23.8k), samenvallend met de Oude Gerealiseerde Prijs van de Voorraad.<br><img src="https://gimg2.gateimg.com/image/article/1678199468woc-10-02-1-.png" alt=""><br>De huidige staat van de markt kan redelijkerwijs worden omschreven als een overgangsfase, die meestal optreedt in de latere stadia van een bear markt. Deze bewering kan worden waargenomen in de Netto Ongerealiseerde Winst/Verlies-metriek (NUPL).</p>
<p>Sinds medio januari is het wekelijkse gemiddelde van NUPL verschoven van een staat van nettogerealiseerd verlies naar een positieve toestand. Dit duidt erop dat het gemiddelde <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> De houder heeft nu een nettowinst van ongeveer 15% van de marktkapitalisatie. Dit patroon lijkt op een marktstructuur die overeenkomt met overgangsfases in eerdere berenmarkten 🟧.</p>
<p>We kunnen ook rekening houden met verloren munten door de ongerealiseerde winst af te trekken die is vergrendeld in het 7+ jaar oude deel van het aanbod, waardoor een aangepaste variant van deze metriek (aNUPL) wordt verkregen 🔵. Volgens deze maatstaf bevindt de markt zich slechts iets onder het break-even punt en kan worden betoogd dat deze nog steeds binnen het berenmarktgebied valt.<br><img src="https://gimg2.gateimg.com/image/article/1678199540woc-10-03-1-.png" alt=""></p>
<h2 id="h2-Een20duwtje20in20de20goede20richting892587"><a name="Een duwtje in de goede richting" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Een duwtje in de goede richting</h2><p>Een klassiek teken van groeiende adoptie tijdens een constructieve overgangsfase is de aantrekking en instroom van nieuw kapitaal op de markt. We kunnen deze verandering in momentum verder onderzoeken vanuit het perspectief van Transfer Volume, die neigt te fluctueren met het totale niveau van kapitaal op de markt.</p>
<p>De onderstaande metriek vergelijkt het maandelijkse gemiddelde 🔴 overdrachtsvolume met het jaarlijkse gemiddelde 🔵 om relatieve verschuivingen in dominante sentimenten te benadrukken en te helpen identificeren wanneer de getijden zich keren voor netwerkactiviteit.</p>
<p>Sinds begin januari is het maandelijkse overdrachtsvolume met 79% gestegen tot $9,5 miljard per dag. Dit blijft echter aanzienlijk onder het jaarlijkse gemiddelde, hoewel dit langetermijngemiddelde sterk wordt beïnvloed door een helaas grote hoeveelheid FTX/Alameda-gerelateerde wasvolumes (zoals vermeld in WoC 3).<br><img src="https://gimg2.gateimg.com/image/article/1678199608woc-10-05-1-.png" alt=""><br>We kunnen deze waarneming aanvullen met een vergelijkbare momentumgrafiek die specifiek gerelateerd is aan on-chain uitwisselingsvolumes, aangezien investeerders en handelaren doorgaans actiever worden wanneer er kapitaal binnenkomt. Volgens deze maatstaf kunnen we een veel nauwere maandelijkse en jaarlijkse gemiddelde waarnemen, waarbij het momentum begint toe te nemen. Het maandelijkse gemiddelde voor de uitwisselingsstromen is sinds begin januari met 34% gestegen, maar het blijft onder het jaarlijkse gemiddelde van $1,64 miljard per dag.<br><img src="https://gimg2.gateimg.com/image/article/1678199655woc-10-04-1-.png" alt=""></p>
<h2 id="h2-Winst20nemen174163"><a name="Winst nemen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Winst nemen</h2><p>Naarmate er meer muntvolumes door het netwerk beginnen te bewegen, kunnen we de aSOPR-metriek raadplegen om de gemiddelde winst (of verlies) te beoordelen die door transactoren wordt gerealiseerd. Het 14-daags gemiddelde van aSOPR handelt nu al 40 dagen op een gestaag niveau boven een waarde van 1.0 🟩.</p>
<p>Dit patroon onderstreept de eerste aanhoudende golf van winstnemingen sinds maart 2022 en weerspiegelt een niet onbelangrijke terugkeer van binnenkomend kapitaal dat voldoende is om de genomen winsten te absorberen.</p>
<p>De terugkeer van aSOPR-handel boven 1.0 op een blijvende basis is een typisch kenmerk als de markt hersteld is van een periode van diepe en langdurige verliezen.<br><img src="https://gimg2.gateimg.com/image/article/1678199696woc-10-06-1-.png" alt=""><br>Door de verhouding tussen gerealiseerde winsten en verliezen te berekenen, kunnen we bevestigen dat winstgevendheid weer terug is verschoven naar een overgangsfase. Een winstgedomineerd regime begon in medio januari, waardoor de Realized P/L Ratio boven de 1 uitkwam.</p>
<p>Interessant genoeg is er een waarneembare bovengrens voor de gerealiseerde P/L-verhouding van ongeveer 2,0, die neigt te fungeren als een weerstandsniveau in bear-markten, aangezien winstnemingen zwakke vraag overweldigen. Het overschrijden van deze drempel kan een robuustere indicator bieden voor groeiende kapitaalinstroom.<br><img src="https://gimg2.gateimg.com/image/article/1678199734woc-10-07-1-.png" alt=""></p>
<h2 id="h2-Het20ontleden20van20de20verkopende20zijde846234"><a name="Het ontleden van de verkopende zijde" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Het ontleden van de verkopende zijde</h2><p>Als we inzoomen op de recente marktrally, zien we dat het aandeel van de voorraad in handen van nieuwe investeerders, dat nu winst maakt, is gestegen van ongeveer 2,5% (berenmarkt-basislijn) naar meer dan 15%. Dit patroon doet denken aan het vorige herstel van het laagste punt van de berenmarkt in 2018-19 🟦 en geeft een beeld van het volume aan munten dat de afgelopen maanden van eigenaar is veranderd.<br><img src="https://gimg2.gateimg.com/image/article/1678199774woc-10-07-2-.png" alt=""><br>We kunnen ook de invloed van deze nieuwe investeerders meten door het volume te observeren dat naar beurzen werd gestuurd en dat ofwel winstgevend ofwel verliesgevend was. Hier zien we het volgende:</p>
<p>1- De verhouding tussen het volume op korte termijn in winst versus verlies dat naar beurzen wordt gestuurd, piekte op 2,75x begin februari, wat gelijk staat aan het ATH van oktober 2022.</p>
<p>2- Het totale volume van STH-munten dat vandaag naar beurzen is gestuurd, bedraagt ongeveer 16k BTC per dag en is ongeveer 50:50 verdeeld in Winst: Verlies.</p>
<p>Relatief gezien blijft dit een relatief lage totale muntvolume dat naar beurzen is gestuurd in vergelijking met de cyclus 2020-23.<br><img src="https://gimg2.gateimg.com/image/article/1678199823woc-10-08-3-.png" alt=""><br>Tenslotte kunnen we de Short-Term Holder MVRV beoordelen om de relatieve ongerealiseerde winst van STHs te schatten. Zoals besproken in WoC 07, neigt de mogelijkheid dat STHs winst nemen toe tijdens periodes waarin de gemiddelde STH 20%+ in geld is, met een STH-MVRV boven 1.2.</p>
<p>De recente afwijzing op niveau $23,8k resoneert met deze structuur, aangezien de STH-MVRV een waarde van 1,2 bereikte voordat het tot stilstand kwam. Als de markt terugkeert naar $19,3k, zou dit de STH-MVRV terugbrengen naar de waarde van 1,0 en aangeven dat spotprijzen zijn teruggekeerd naar de kostprijs van deze groep nieuwe kopers.<br><img src="https://gimg2.gateimg.com/image/article/1678199890woc-10-09-1--1.png" alt=""></p>
<h2 id="h2-Conclusie598030"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>De <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Tegen Bitcoin</a> De economie reageert vaak niet alleen op niveaus die algemeen worden waargenomen in traditionele technische analyse, maar ook op de psychologische kostenbasisniveaus van verschillende beleggerscohorten die on-chain zijn afgedrukt. Dit gebeurt niet alleen met betrekking tot hun gerealiseerde prijs, maar ook met betrekking tot de mate van winst en verlies die binnen hun aanbod wordt gehouden.</p>
<p>Vanuit dit perspectief bevindt de markt zich momenteel in een overgangsfase, begrensd boven door de Gerealiseerde Prijs van Oudere Voorraad en ook door de gemiddelde Walvis die actief is geweest sinds het dieptepunt van de cyclus in 2018. We hebben een eerste golf van kapitaalinstroom in de ruimte gezien, waarneembaar door winstnemingen. Deze kapitaalstroom is echter nog steeds in de kinderschoenen en blijft historisch licht in totaal munthandelvolume.</p>
<div class="blog-details-info"><br><div>Auteur: <strong>Glassnode Insights</strong><br><div>Editor: Gate.io Blog Team<br><div class="info-tips">*Dit artikel vertegenwoordigt alleen de standpunten van de onderzoeker en vormt geen enkele beleggingssuggestie.<br></div><p></p><br></div></div></div>
Share
Content
gate logo
Gate
Trade Now
Join Gate to Win Rewards