R2xhc3Nub2RlIEluc2lnaHRzOiBEZSBQcmlqcyB2YW4gVGlqZA==

2023-03-28, 02:39
<p><img src="https://gimg2.gateimg.com/image/article/1679970228Industry Analysis.jpeg" alt=""></p>
<p>De markt heeft deze week een pauze genomen, waarbij de BTC-prijzen consolideren binnen een nauwe marge tussen $26,7k en $28,7k. Na de historisch significante out-performance die we vorige week hebben behandeld, neemt de markt even een adempauze.</p>
<p>Terwijl deze consolidatie plaatsvindt, zullen we ons richten op een betere classificatie van het gedrag van beleggers die winst nemen door gebruik te maken van verschillende on-chain tools:</p>
<p><strong>Inkomsten van de beurs</strong>, inclusief een uitsplitsing in langetermijn- en kortetermijnhouders.</p>
<p><strong>Gerealiseerde winsten</strong> vastgehouden door investeerders die munten verzamelen in de buurt van de recente dieptepunten.</p>
<p><strong>Levensduurstatistieken</strong> beschrijft de hoeveelheid vernietiging van de vasthoudtijd, om het vertrouwen van beleggers in de heersende opwaartse trend beter te kunnen beoordelen.</p>
<p><img src="https://gimg2.gateimg.com/image/article/167997024200_cover-11.png" alt=""></p>
<h2 id="h2-Chips20van20tafel20halen762466"><a name="Chips van tafel halen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Chips van tafel halen</h2><p>Als reactie op de sterke prijsstijging van de afgelopen weken hebben investeerders het volume aan munten dat naar beurzen is gestort verhoogd. De nettostroom naar beurzen steeg deze week met ongeveer 4,18k BTC, de grootste nettostijging sinds LUNA instortte in mei 2022.</p>
<p><img src="https://gimg2.gateimg.com/image/article/167997036101_price-2.png" alt=""></p>
<p>Dit suggereert dat er enige winstneming gaande is, omdat beleggers hun chips van tafel halen. Eerdere glen met vergelijkbare of grotere nettostromen gedurende de laatste cyclus kwamen allemaal overeen met belangrijke marktvolatiliteitsgebeurtenissen, meestal aan de onderkant.</p>
<p><img src="https://gimg2.gateimg.com/image/article/167997037401_exchange_netflow.png" alt=""></p>
<p>We kunnen ook de verdeling van munten die naar beurzen zijn gestuurd, beoordelen door zowel langetermijn- als kortetermijnhouders, waardoor we kunnen onderzoeken welke cohorten winst nemen. Beide groepen hebben een stijging gezien in de munten die naar beurzen zijn gestuurd, met een piek van in totaal 31k BTC deze week.</p>
<p><strong>Korte termijn houders domineren 92,5% van de totale instroomvolumes</strong>, waarvan 65% van het totaal STH-munten zijn in winst.</p>
<p><strong>Houders op lange termijn zijn slechts goed voor 7,5% van het totale stortingsvolume</strong>, echter 80% van hun volume is winst, de grootste stijging sinds medio 2021.</p>
<p><img src="https://gimg2.gateimg.com/image/article/167997043302_lthsth_toexchanges.png" alt=""></p>
<p>In totaal is er $320M/dag aan nettowinsten vastgelegd door de markt op uitgegeven munten. Dit is de grootste nettowinst sinds mei 2022, vlak voordat het LUNA-UST-project instortte. We merken op dat de omvang van gerealiseerde winsten nog steeds ruim onder het niveau van een typische bullmarkt ligt.</p>
<p>Het is ook duidelijk dat de ernst van het netto verlies ook is afgenomen sinds juli 2022. Dit bevestigt onze observaties van vorige week (WoC 12) dat de markt lijkt terug te zijn gegaan naar een meer neutrale versnelling en lijkt op een meer overgangsstructuur van de markt.</p>
<p><img src="https://gimg2.gateimg.com/image/article/167997047003_netrealpnl.png" alt=""></p>
<p>Het meten van gerealiseerde winst/verlies is een krachtige techniek in on-chain analyse, mogelijk gemaakt door Pricestamping munten wanneer ze on-chain bewegen. Hierdoor kunnen we de omvang van de winst die in de afgelopen maand is vastgelegd, vergelijken met het jaarlijkse gemiddelde. Hier zien we dat we de eerste positieve momentum cross-over hebben sinds de ATH van oktober-november 2021.</p>
<p>Deze tool geeft intuïtief periodes aan van zwaar of licht winst nemen in respectievelijk bullish of bearish markten. Let met name op de algehele vorm van het jaarlijkse voortschrijdend gemiddelde voor Gerealiseerde Winsten, dat stijgt bij stieren en daalt bij beren.</p>
<p>We zullen deze observatie meenemen naar ons volgende gerelateerde en even krachtige onderwerp van Levensduur.</p>
<p><img src="https://gimg2.gateimg.com/image/article/167997054204_realprofit_momentum.png" alt=""></p>
<h2 id="h2-Tijd20bijhouden196181"><a name="Tijd bijhouden" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Tijd bijhouden</h2><p>In het vorige gedeelte hebben we gezien hoe uitwisselingsstromen verband kunnen houden met de mate van winst die wordt gerealiseerd door verschillende on-chain cohorten. We kunnen dit ook aanvullen met een andere reeks tools onder de categorie Levensduur. In plaats van de verandering in waarde van een munt te meten om winst/verlies te verkrijgen, meten we in plaats daarvan hoeveel tijd er wordt besteed tussen het verkrijgen en afstoten van een munt.</p>
<p>Wanneer we een zware vernietiging van de levensduur waarnemen, betekent dit meestal dat er een grote hoeveelheid oudere munten in beweging zijn, waardoor we periodes kunnen identificeren waarin langere termijn en meer ervaren beleggers uitstappen.</p>
<p>Ons eerste aanspreekpunt is om het macro landschap te beoordelen via de Levendigheidsmetriek. Deze metriek definieert elegant de verhouding tussen de vernietiging en creatie van levensduur aller tijden.</p>
<p><strong>Liveliness zal dalen</strong> wanneer de markt de voorkeur geeft aan het accumuleren en vasthouden van munten, waardoor een reservoir van Levensduur wordt opgebouwd en<br><strong>het vertrouwen in het actief suggereren.</strong></p>
<p><strong>Levendigheid zal toenemen</strong> wanneer de markt de voorkeur geeft aan het verdelen van oude munten en het uitputten van de levensduurreservoir,<br><strong>waarbij het actief als duur wordt beschouwd.</strong></p>
<p><img src="https://gimg2.gateimg.com/image/article/167997056805_liveliness.png" alt=""></p>
<p>Als we de vorm van het jaarlijkse gemiddelde van gerealiseerde winsten in herinnering roepen, kunnen we zien dat er een zeer vergelijkbare vorm en relatie bestaat met Levendigheid, grotendeels omdat ze vergelijkbare marktgedragingen beschrijven:</p>
<p><strong>Tijdens stierenmarkten</strong> Langere termijn investeerders besteden lang slapende munten en behalen grote winsten. Dit leidt uiteindelijk tot een overschot en het vaststellen van een macro-markttop.</p>
<p><strong>Tijdens bear markets</strong>, langere termijn investeerders keren terug naar een langzame accumulatiestrategie en er worden minder winsten op dagelijkse basis genomen. Dit resulteert uiteindelijk in een cyclusvloer.</p>
<p>Op dit moment kunnen we zien dat beide statistieken zich nog steeds in een macro-downtrend bevinden, wat erop wijst dat het merendeel van de munten inactief blijft op de blockchain.</p>
<p><img src="https://gimg2.gateimg.com/image/article/167997075206_lioveliness_realProfit.png" alt=""></p>
<p>De belangrijkste maatstaf voor het meten van de levensduur is Coindays Destroyed (CDD), die het volume van de ‘beleggerstijd’ weergeeft die elke dag wordt doorgebracht. In de afgelopen cyclus kunnen we over het algemeen oplevingen in CDD in twee categorieën beschrijven:</p>
<p>Aanhoudende stijgingen tijdens stierenmarkten weerspiegelen een consistente druk op de distributie omdat langetermijnhouders winst nemen.<br>Scherpe pieken tijdens evenementen met hoge volatiliteit, die meestal worden waargenomen bij bear market sell-offs. Deze weerspiegelen periodes van wijdverbreide paniek, omdat beleggers munten uitgeven in het licht van hoge volatiliteit.</p>
<p>In de afgelopen weken is een bescheiden stijging van CDD waarneembaar, echter blijft de omvang van de destructie ruim onder typische bullmarkt niveaus. Dit geeft aan dat de gemiddeld bestede munt nog relatief jong is, wat overeenkomt met onze observatie dat Short-Term Holders momenteel de winst nemen domineren.</p>
<p><img src="https://gimg2.gateimg.com/image/article/167997077308_cdd.png" alt=""></p>
<p>Een handig hulpmiddel om dit te vergelijken tussen cycli is Binary CDD, dat de CDD-metriek omzet in een resultaat van één als de omvang het langetermijngemiddelde overschrijdt (geeft nul terug als dit niet het g is). Hier hebben we ook de trace gladgestreken met een 7-daags gemiddelde om een oscillator te creëren.</p>
<p>Vanuit dit perspectief wordt het nemen van winst door langetermijnhouders in bullmarkten uitermate duidelijk, aangeduid als langdurige periodes van rood en oranje. In onze huidige markt bevinden we ons echter stevig in een rustige fase, typisch voor bearish markten, vroege bulls en de overgangsperiode daartussenin.</p>
<p><img src="https://gimg2.gateimg.com/image/article/167997081809_binary_cdd.png" alt=""></p>
<p>De recente stijging van CDD is goed zichtbaar wanneer deze wordt opgesplitst over de LTH- en STH-cohorten. Ondanks dat Long-Term Holders het minst bijdragen aan de volume van uitgegeven munten, is hun houdtijd veel langer, en hebben ze daardoor een grote invloed op de levensduurmetingen.</p>
<p>Volgens deze maatregel is de recente winstneming ook vrij bescheiden en heeft nog geen duurzame stijgende trend in CDD vastgesteld.</p>
<p><img src="https://gimg2.gateimg.com/image/article/167997094907_cdd_cohorts-1.png" alt=""></p>
<p>Bij het inzoomen op Short-Term Holders is de gemiddelde leeftijd van een uitgegeven STH-munt ook toegenomen, effectief verdubbeld van ~10 dagen in de maanden voorafgaand aan het FTX-falen, tot 21 dagen vandaag. Dit voegt verder bewijs toe aan het argument dat de Short-Term Holder-cohort, die BTC verzamelde in de buurt van de cyclische dieptepunten, de belangrijkste deelnemers zijn achter recente winstnemingen.</p>
<p>Het suggereert ook dat STH’s steeds meer bereid zijn om langer te wachten, wat wijst op een zekere mate van vertrouwen in de heersende markttrend.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1679970999Group-2914.png" alt=""></p>
<h2 id="h2-De20waarde20van20tijd478230"><a name="De waarde van tijd" class="reference-link"></a><span class="header-link octicon octicon-link"></span>De waarde van tijd</h2><p>Eindelijk kunnen we Lifespan in het prijsdomein brengen, gebruikmakend van ons eerdere onderzoek naar de ontwikkeling van de Value Days Destroyed Multiple (VDDM). Deze metriek vergelijkt de maandelijkse dollarkoers van CDD met het jaarlijkse gemiddelde.</p>
<p>Op dit moment kunnen we zien dat de VDDM-waarde versnelt uit een lange periode van handelen rond cyclustekorten. Dit geeft aan dat de vernietiging van de CDD-waarde als reactie op recente prijsacties typisch berenmarktgebied verlaat en suggereert dat er voldoende vraag naar de markt stroomt om de behaalde winsten op te nemen.</p>
<p>Dit vertoont opnieuw veel overeenkomsten met de late periodes van 2015, 2019 en 2020, die uiteindelijk overgangspunten in de marktcyclus bleken te zijn.</p>
<p><img src="https://gimg2.gateimg.com/image/article/167997106410_vdd_multiple.png" alt=""></p>
<h2 id="h2-Samenvatting20en20Conclusies267151"><a name="Samenvatting en Conclusies" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Samenvatting en Conclusies</h2><p>Als de <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> De markt neemt even pauze, winst nemen door beleggers begint op te warmen. Kortetermijnhouders die in de buurt van de cyclische dieptepunten hebben opgebouwd, domineren het grootste deel van het uitgavenpatroon, hoewel hun bereidheid om munten voor langere perioden vast te houden duidelijk is.</p>
<p>Over het algemeen lijkt de meerderheid van BTC vrij inactief on-chain te zijn, wat erop wijst dat beleggers vertrouwen blijven hebben in de heersende stijgende trend. Net als in ons artikel van vorige week, door de lens van de levensduur van de munt, <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> lijkt opnieuw een overgangsperiode op de markt in te gaan.</p>
<hr>
<p>Disclaimer: Dit rapport geeft 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 als enige verantwoordelijk voor uw eigen beleggingsbeslissingen.</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>
Share
Content
gate logo
Gate
Trade Now
Join Gate to Win Rewards