R2xhc3Nub2RlIEluc2lnaHRzOiBEZSBLYXBpdGFhbCBXYXRlcnZhbA==

2023-11-02, 03:25
<p><img src="https://gimg2.gateimg.com/image/article/1698893221SDFX 1.jpeg" alt=""></p>
<h2 id="h2-Samenvatting991029"><a name="Samenvatting" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Samenvatting</h2><p>De markt voor digitale activa heeft in 2023 indrukwekkende rendementen behaald, waarbij zowel BTC als ETH traditionele activa zoals goud met respectievelijk 93% en 39% hebben overtroffen.</p>
<p>Marktcorrecties voor de twee belangrijkste valuta’s zijn aanzienlijk minder diep geweest dan in eerdere cycli, wat wijst op ondersteuning van investeerders en positieve kapitaalinstromen.</p>
<p>Onze Altseason-indicator heeft de eerste significante waardering tegenover de USD gesignaleerd sinds de piek van de cyclus. Het is echter belangrijk op te merken dat dit binnen de context van <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> dominantie blijft stijgen, met de BTC marktkapitalisatie die dit jaar met 110% is gestegen.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1698893249Group-137691595-1.png" alt=""></p>
<p>De prijzen van <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> zijn de afgelopen weken met meer dan 30% gestegen, mede dankzij positieve vooruitgang met betrekking tot de verschillende Bitcoin ETF-aanvragen die bij de SEC liggen ter goedkeuring. Ook opmerkelijk is de relatieve prestaties van BTC en digitale activa in vergelijking met traditionele activaklassen zoals grondstoffen, edele metalen, aandelen en obligaties.</p>
<p>In deze editie zullen we deze indrukwekkende relatieve prestaties van digitale activa tot 2023 verkennen. Tot nu toe hebben zowel BTC als ETH aanzienlijk beter gepresteerd dan traditionele activa, terwijl ze ook minder diepe dalingen hebben ervaren in vergelijking met eerdere cycli.</p>
<h2 id="h2-Relatieve20veerkracht263680"><a name="Relatieve veerkracht" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Relatieve veerkracht</h2><p>De onderstaande grafiek vergelijkt de BTC- en ETH-prijs in goudwaarde en laat de prestaties zien in vergelijking met de traditionele defensieve waardeopslag. BTC is met +93% gestegen ten opzichte van goud in 2023, terwijl ETH met 39% is gestegen in goudtermen. Deze sterke prestatie komt te midden van toenemende mondiale onzekerheid, wat waarschijnlijk de aandacht trekt van veel traditionele beleggers.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1698893302Group-137691584-1.png" alt=""></p>
<p>We kunnen zien dat op basis van een rollende periode van 30 dagen de rendementen van BTC 🟧 en ETH 🟦 sterk gecorreleerd zijn geweest gedurende heel 2023. Beide activa hebben vergelijkbare neerwaartse bewegingen ervaren, maar Bitcoin heeft een sterkere prestatie laten zien tijdens periodes van herstel.</p>
<p>We kunnen ook zien dat de relatieve volatiliteit van beide digitale activa groter is dan die van Goud (in het zwart), dat handelt met kleinere prijsbewegingen in beide richtingen.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1698897823Group-137691585-1.png" alt=""></p>
<p>De relatieve kracht van digitale activa kan ook worden waargenomen door de diepste correctie tijdens een macro-uptrend te beoordelen. Hier zullen we deze maatstaf beoordelen voor ETH, omdat het ons in staat stelt om prestaties te zien ten opzichte van USD (een externe benchmark), maar ook in vergelijking met de marktleider BTC (een interne benchmark).</p>
<p>We beschouwen de cyclische laag voor ETH/USD als gezet in juni 2022 na de ineenstorting van 3AC, Celcius en LUNA-UST. Sindsdien is de diepste correctie van ETH/USD (ten opzichte van de lokale hoogte) -44% geweest, ingesteld tijdens het falen van FTX. Vandaag wordt ETH verhandeld met een daling van -26% ten opzichte van zijn hoogste punt van $2.118 in 2023, wat aanzienlijk beter is dan de -60% of grotere dalingen die in eerdere cycli zijn gezien.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1698897860Group-137691600-1-.png" alt=""></p>
<p>Vergelijkbare kracht is zichtbaar voor BTC, met de diepste correctie in 2023 slechts -20,1%. De stierenmarkt van 2016-17 zag regelmatige correcties van meer dan -25%, terwijl 2019 terugviel van de hoogte van juli 2019 of $14k met meer dan -62%.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1698898063Group-137691601-1-.png" alt=""></p>
<p>Voor het beoordelen van kapitaalrotatie binnen de digitale activamarkt is het nuttig om te zoeken naar periodes waarin ETH beter presteert ten opzichte van BTC. De onderstaande grafiek toont de diepte van de maximale drawdown van de ETH-BTC-verhouding in vergelijking met de hoogste koers van de heersende opwaartse trend.</p>
<p>Vorige cycli hebben gezien dat ETH met meer dan -50% relatief gezien is gedaald tijdens de herstelfase van de berenmarkt, waarbij de huidige daling -38% heeft bereikt. Bijzondere interesse gaat uit naar de duur van deze trend, waarin ETH tot nu toe meer dan 470 dagen ten opzichte van BTC is gedueerd. Dit benadrukt een onderliggende trend tussen cycli, waarin BTC dominantie gedurende een langere periode toeneemt in de herstelperiode na een berenmarkt.</p>
<p>We kunnen deze tool ook gebruiken om te monitoren op keerpunten in de Risk-on vs Risk-off cyclus waar we het over hebben gehad in WoC 41 (en later in deze editie op terug zullen komen).</p>
<p><img src="https://gimg2.gateimg.com/image/article/1698898095Group-137691581-1.png" alt=""></p>
<p>De grafiek biedt een ander perspectief op de relatieve prestaties en toont oscillatoren voor de rollende kwartaal-, wekelijkse en wekelijkse ROI van de ETH/BTC-verhouding. Een barcode-indicator (in blauw) markeert vervolgens periodes waarin alle drie de tijdsbestekken aangeven dat ETH onderpresteert ten opzichte van BTC.</p>
<p>Hier kunnen we zien dat de recente zwakte in de ETH/BTC Ratio vergelijkbaar is met die gezien in mei-juli 2022, waarbij de prijsverhouding hetzelfde niveau van 0,052 heeft bereikt.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1698898141woc-43-08-1-.png" alt=""></p>
<h2 id="h2-Trends20in20beleggerssentiment374973"><a name="Trends in beleggerssentiment" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Trends in beleggerssentiment</h2><p>Dieper in duiken <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum prijs</a> Bij de modellen merken we op dat ETH wordt verhandeld op $1.800, wat +22% hoger is dan de Gerealiseerde Prijs ($1.475). De Gerealiseerde Prijs wordt vaak beschouwd als de gemiddelde kostprijs voor alle munten in omloop, geprijsd op het moment dat ze voor het laatst zijn verhandeld.</p>
<p>Dit suggereert dat de gemiddelde ETH-houder een bescheiden mate van winst heeft, maar het blijft nog steeds ver verwijderd van de extreme prijsniveaus die vaak worden bezocht tijdens de euforie van een bullmarkt.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1698898169Group-137691589.png" alt=""></p>
<p>Een andere manier om verschuivingen in de winstgevendheid van investeerders te visualiseren is via de MVRV Ratio, zijnde de verhouding tussen prijs en de Gerealiseerde Prijs. In dit g vergelijken we de MVRV Ratio met zijn 180-daagse voortschrijdend gemiddelde als een tool om trends te monitoren.</p>
<p>Perioden waarin de MVRV-ratio boven dit langetermijngemiddelde handelt, geven aan dat de winstgevendheid van beleggers steeds belangrijker wordt en vaak een signaal is van een stijgende markt. Ondanks de positieve marktprestaties van ETH dit jaar, ervaart de markt volgens deze maatstaf nog steeds negatieve momentum. Het lijkt erop dat de nasleep van de berenmarkt van 2022 nog steeds langzaam wordt verwerkt.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1698898223Group-137691594-1.png" alt=""></p>
<h2 id="h2-Veranderend20vertrouwen515504"><a name="Veranderend vertrouwen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Veranderend vertrouwen</h2><p>We kunnen ook gebruik maken van de relatieve prestaties van de winstgevendheid van ETH-investeerders door gebruik te maken van de Investor Confidence in Trend-indicator die we hebben ontwikkeld in WoC 38. Het doel is om de getijden van verschuivend sentiment te meten voor <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> investeerders, samengesteld door te kijken naar de afwijking van de kostprijs van twee subgroepen: houders en uitgevers.</p>
<p>🟥 Negatief sentiment is wanneer de kostprijs van uitgevers aanzienlijk lager is dan die van houders.</p>
<p>🟩 Positief sentiment is wanneer de kostprijsbasis van de uitgaven aanzienlijk hoger is dan die van de houders.</p>
<p>🟧 Overgangssentiment is wanneer de kostenbasis dicht bij de kostenbasis van de houder schommelt.</p>
<p>Volgens deze maatregel bevindt de markt zich in een overgangszone, die positief is, maar van een relatief kleine omvang.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1698898254woc-43-08.png" alt=""></p>
<h2 id="h2-Altseizoen20in20USD20maar20niet20in20BTC474961"><a name="Altseizoen in USD… maar niet in BTC" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Altseizoen in USD… maar niet in BTC</h2><p>Voortbouwend op het eerdere werk dat is uitgevoerd in de WoC 41, zijn we in staat om een nieuwe iteratie te produceren voor de Altcoin Indicator. In dit model gebruiken we de eerder gedefinieerde risk-on omgeving als onze eerste voorwaarde, waarbij kapitaalinstroom in BTC, ETH en Stablecoins vereist is. We vullen dit aan met een tweede voorwaarde, namelijk een positief momentum binnen de Total Altcoin Cap (totale crypto cap exclusief BTC, ETH en Stablecoins).</p>
<p>Hier zoeken we naar periodes waarin de totale waardering van de Altcoin sector groter is dan zijn 30-daags SMA. Deze indicator gaf een positief signaal op 20-okt, voorafgaand aan de explosieve Bitcoin beweging van $29.5k naar $35.0k.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1698898296Group-137691591.png" alt=""></p>
<p>Dit verhoogde vertrouwensniveau in digitale activa is duidelijk merkbaar bij het beoordelen van de recente prestaties van de totale marktkapitalisatie van altcoins.</p>
<p>De lokale stijging registreerde een stijging van +21,3% in de sectorwaardering, waarbij slechts zes handelsdagen een grotere procentuele verandering registreerden. Dit benadrukt een watereffect van investeringskapitaal, aangezien een stijgende Bitcoin dominantie doorgaans een stijging in altcoin waarderingen inspireert ten opzichte van fiatvaluta’s.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1698898330Group-137691588.png" alt=""></p>
<p>Het is echter belangrijk om te onthouden dat de dominantie van Bitcoin blijft stijgen. Op relatieve basis heeft BTC nu meer dan 53% van de marktwaardering van digitale activa in handen, terwijl Ethereum, Altcoins in het algemeen en Stablecoins allemaal een relatieve daling zien in hun dominantie gedurende 2023. De dominantie van Bitcoin is gestegen van een cyclisch dieptepunt van 38% dat eind 2022 werd bereikt.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1698898406Group-137691593.png" alt=""></p>
<p>Om dit perspectief af te sluiten, kunnen we de YTD-stijging van de Bitcoin vergelijken met de totale marktkapitalisatie van Altcoins (excl Stablecoins). De marktkapitalisatie van Bitcoin is in 2023 met 110% gestegen, terwijl Altcoins een indrukwekkende, maar relatief kleine stijging van 37% hebben doorgemaakt.</p>
<p>Dit wijst op een interessante marktdynamiek, waarbij de altcoin-sector beter presteert dan fiat-valuta’s en traditionele activa zoals goud, maar aanzienlijk slechter presteert dan Bitcoin.</p>
<p><img src="https://gimg2.gateimg.com/image/article/169889843705_ytd_mcapperf.png" alt=""></p>
<h2 id="h2-Conclusie20en20samenvatting227568"><a name="Conclusie en samenvatting" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie en samenvatting</h2><p>De digitale activamarkt heeft indrukwekkende rendementen behaald in 2023, waarbij de initiële herstelfase achtergelaten is en opnieuw een uptrend wordt ingezet. Markcorrecties in 2023 voor marktleiders BTC en ETH zijn aanzienlijk minder diep dan in eerdere cyclische uptrends, wat wijst op een niveau van investeerderssteun en positieve kapitaalinstroom.</p>
<p>Op verschillende indicatoren, inclusief onze ontwikkelende Altcoin-indicator, hebben we de eerste aanzienlijke stijging gezien van de marktwaarderingen van de altcoin-sector sinds de laatste piek in de cyclus. Het is echter belangrijk op te merken dat deze prestatie wordt gemeten ten opzichte van fiatvaluta, namelijk de USD. Binnen het digitale activumrijk blijft de dominantie van Bitcoin toenemen, wat heeft geleid tot een stijging van de marktkapitalisatie van BTC met meer dan 110% YTD.</p>
<p><strong>Disclaimer: Dit rapport geeft geen beleggingsadvies. Alle gegevens worden uitsluitend verstrekt ter 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 mening van de onderzoeker en vormt geen beleggingsaanbevelingen.<p></p><br></div></div></div></div>
Share
Content
gate logo
Gate
Trade Now
Join Gate to Win Rewards