R2xhc3Nub2RlIEluc2lnaHRzOiBWYXN0eml0dGVuIGluIGhldCBNaWRkZW4=

2023-07-11, 10:14
<p><img src="https://gimg2.gateimg.com/image/article/1689069864SDFX.jpeg" alt=""></p>
<h2 id="h2-Samenvatting87717"><a name="Samenvatting" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Samenvatting</h2><p>Bitcoin-prijzen consolideren zich rond het $30k middelpunt van de cyclus 2021-23, met YTD-prijsprestaties die historisch sterk blijven.</p>
<p>Inies zijn aanzienlijk afgekoeld en <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Netwerkcongestie begint op te klaren. Echter nemen de geldoverdrachtsvolumes toe, nu +75% hoger sinds het dieptepunt in november.</p>
<p>Het evenwicht tussen aanbod dat winstgevend en verliesgevend is, heeft een evenwichtspunt bereikt dat synoniem is aan de al enkele maanden durende ‘her-accumulatieperiode’ die in eerdere cycli is gezien.</p>
<p><img src="https://gimg2.gateimg.com/image/article/168906989200_cover-4.png" alt=""></p>
<h2 id="h2-Redelijk20in20orde20houden56683"><a name="Redelijk in orde houden" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Redelijk in orde houden</h2><p>De Bitcoin-markt heeft tot nu toe het grootste deel van zijn winst in 2023 weten vast te houden en is de afgelopen weken weer gestegen boven de $31k. Met de markt die consolideert nabij de jaarlijkse hoogtepunten, kunnen we deze prijsprestaties vergelijken met eerdere cycli, vanuit zowel een bull- als een bear-marktperspectief.</p>
<p>Als we aannemen dat de november 2022-laagte inderdaad de cyclusvloer is, kunnen we de diepte van de ‘bullmarktcorrecties’ tot nu toe vergelijken. We kunnen zien dat de piekdaling in 2023 slechts -18% is geweest, wat opmerkelijk ondiep is in vergelijking met alle voorgaande cycli. Dit suggereert misschien een relatief sterke vraag naar het bezit.</p>
<p><img src="https://gimg2.gateimg.com/image/article/168906992501_pricebull.png" alt=""></p>
<p>Als we in plaats daarvan onze berenmarktbril opzetten, kunnen we de prestaties van 2023 beoordelen op basis van de index van het ATH van de cyclus. Vanuit dit perspectief is het krachtige herstel van de dieptepunten in november met 91% gestegen en vertoont het opmerkelijke overeenkomsten met de herstelrally’s van eerdere cycli.</p>
<p>Met uitzondering van 2019 waren alle eerdere cycli die een vergelijkbare omvang hadden vanaf de bodem, in feite het beginpunt van een nieuwe cyclische opwaartse trend.</p>
<p><img src="https://gimg2.gateimg.com/image/article/168906993502_pricebear.png" alt=""></p>
<h2 id="h2-Inies20maken20plaats20voor20investeerders93985"><a name="Inies maken plaats voor investeerders" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Inies maken plaats voor investeerders</h2><p>Eén van de meest verrassende gebeurtenissen van 2023 is de opkomst van ordinaals en inies op Bitcoin. Dit fenomeen heeft twee verschillende <a href="/price/waves-waves" rel="nofollow noopener noreferrer" target="_blank">Golven</a> van activiteit:</p>
<p>Golf 1: Voornamelijk op afbeeldingen gebaseerde inies, wat leidt tot de opkomst van NFT-assets op Bitcoin. Tot nu toe zijn er in totaal 1,08 miljoen afbeeldingen ingeschreven.</p>
<p>Golf 2: Voornamelijk tekstgebaseerde inies met hoge kosten die verband houden met ‘BRC-20 tokens’. Over het algemeen biedt <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> nu onderdak aan 14,8 miljoen tekstgebaseerde inies.</p>
<p>Op basis van het aantal inschrijvingen was Wave 2 een orde van grootte groter, maar de activiteit is sinds mei voortdurend afgenomen. Er is deze week een korte opleving geweest in tekstinschrijvingen, maar onbevestigde transacties in Bitcoin mempools beginnen over het algemeen te verminderen.</p>
<p><img src="https://gimg2.gateimg.com/image/article/168907068503_Count.png" alt=""></p>
<p>Inies hebben ook een zeer intrigerende ontwikkeling afgedwongen in ons interpretatiekader van on-chain activiteitsmetingen. Over het algemeen zijn stijgingen in Bitcoin on-chain activiteitsmetingen een signaal van groeiende adoptie en een gezond netwerk (dwz omhoog is meestal goed om te zien).</p>
<p>Vanwege het significante hergebruik van adressen (WoC 20) en zeer kleine overdrachtsvolumes (~10k sats) die gepaard gaan met inies, vereisen periodes van hoge vraag nu een iets meer genuanceerde interpretatie, samengevat in de volgende tabel.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1689070030activity_table-3.png" alt=""></p>
<p>Met dit in gedachten kunnen we zien dat terwijl inschrijvingen afkoelen, het momentum van actieve adressen weer begint te stijgen.</p>
<p>Een traditionele interpretatie zou de laatste 2-3 maanden hebben gezien als een impliciete daling in de activiteit van het Bitcoin-netwerk. De juiste interpretatie is echter dat het simpelweg het gevolg was van aanzienlijke hergebruik van adressen door iniehandelaren en dat de netwerkactiviteit eigenlijk bloeide, met blokken die vol zaten.</p>
<p><img src="https://gimg2.gateimg.com/image/article/168907005805_newaddrmomentum.png" alt=""></p>
<p>Transactieaantallen bereikten ook een eerder onbereikbare piek, waarbij inschrijvingen gebruik maakten van de SegWit-gegevenskorting. Dit betekende dat miners meer transactiegegevens in elk blok konden passen, waarbij sommige blokken zelfs de theoretische harde limiet van 4 MB benaderden.</p>
<p>Het dagelijkse aantal transacties is ook aanzienlijk afgenomen in de afgelopen weken, in lijn met de vertraging in inschrijvingsactiviteit.</p>
<p><img src="https://gimg2.gateimg.com/image/article/168907006706_txcountmom.png" alt=""></p>
<p>Na enkele maanden van netwerkcongestie beginnen de mempools langzaam maar zeker op te ruimen en dalen de transactiekosten op de keten. USD-genoteerde transactiekosten voor Bitcoin zijn sinds de hoogte van de BRC-20-rage in mei met meer dan 96% gedaald, waarbij de gemiddelde vergoeding nu $1,33 bedraagt, met mediane vergoedingen van $0,16.</p>
<p>Fee metrieken, boven alle anderen, wijzen erop dat er momenteel een algehele vertraging in de on-chain activiteit gaande is.</p>
<p><img src="https://gimg2.gateimg.com/image/article/168907009604_feespaid.png" alt=""></p>
<p>Terwijl de activiteit afneemt, beginnen de volumes BTC die worden overgedragen betekenisvol toe te nemen. Het aantal BTC dat van eigenaar wisselt is met 75% gestegen ten opzichte van de laagste punten op FTX en bereikt nu $4,2 miljard per dag aan totale afwikkeling.</p>
<p><img src="https://gimg2.gateimg.com/image/article/168907015107b_entadjvol.png" alt=""></p>
<p>Als we alleen de in- en uitstroom van de beurs isoleren, zien we dat het Bitcoin-netwerk een periode van positieve momentum ingaat. Het maandelijkse gemiddelde van de beursstromen ligt nu stevig boven het jaarlijkse, een teken dat historisch gezien duidt op toenemende adoptie vanuit een monetair perspectief.</p>
<p>Terwijl verschillende andere on-chain activiteitsmetrieken afkoelen, suggereert deze dat er teruggekeerd wordt naar een dominantie van BTC-monetaire overdrachten.</p>
<p><img src="https://gimg2.gateimg.com/image/article/168907017407_exchvolmom.png" alt=""></p>
<p>Van deze beursgerelateerde activiteit kunnen we een NVT Prijsmodel ontwikkelen, oorspronkelijk ontwikkeld door Will Woo. Dit model streeft ernaar een ‘eerlijke waarde’ te impliceren voor een bepaalde hoeveelheid on-chain volume settlement.</p>
<p>Op basis van een korte periode van 28 dagen impliceert dit model een ‘eerlijke waarde’ van $35,9k, wat voor het eerst sinds november 2022 boven de spotprijzen ligt. Het langzamere model van 90 dagen stijgt ook scherp, en haalt in vanaf een niveau van $24,7k.</p>
<p><img src="https://gimg2.gateimg.com/image/article/168907019508_nvtprice.png" alt=""></p>
<h2 id="h2-Sterke20fundamenten104792"><a name="Sterke fundamenten" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Sterke fundamenten</h2><p>Tot dusver hebben we vastgesteld dat het herstel van de Bitcoin-markt in 2023 opmerkelijk robuust is geweest, zowel wat betreft de prijsprestaties als het gebruik van het netwerk. De onderstaande grafiek helpt dit in perspectief te plaatsen en toont de stevige basis van aanbod die is verkregen tegen prijzen onder de $30.000.</p>
<p>We kunnen zien dat de aanbodcluster tussen $15k en $30k behoorlijk significant is, wat aantoont dat er in de afgelopen 12 maanden een grote hoeveelheid munten van eigenaar is veranderd. Daarentegen werd slechts 25% van het aanbod verworven tegen prijzen boven $30k, in handen van kopers uit de cyclus 2021-22.</p>
<p><img src="https://gimg2.gateimg.com/image/article/168907023909_urpd.png" alt=""></p>
<p>We kunnen de heuristiek voor de lange en korte termijn in onze URPD-grafiek brengen en de volgende observaties maken:</p>
<p>🔵 Een aanzienlijk volume van LTH-aanbod werd verworven tussen $ 15k en $ 25k (dus in winst), en blijft onuitgegeven, ondanks prijzen die $ 31k bereiken.</p>
<p>🔵 Bijna alle munten met een aankoopprijs boven $30k worden vastgehouden door LTHs. Deze investeerders zijn de overlevenden van de berenmarkt van 2021-22 en zijn ofwel geharde HODLers, of zullen waarschijnlijk weerstand bieden als de markt hoger stijgt.</p>
<p>🔴De prijsklasse tussen $20k en $30k heeft een toenemende accumulatie gezien sinds februari, ondanks de golf van regelgevende druk in de VS.</p>
<p>Over het algemeen is deze voorraadverdeling vrij ‘onderaan zwaar’, wat suggereert dat er een relatief stevige ‘basis’ van investeerdersbezit bestaat onder de $30.000.</p>
<p><img src="https://gimg2.gateimg.com/image/article/168907027011_urpd_lthsth.png" alt=""></p>
<p>We kunnen ook de omvang van het aanbod zien dat is verkregen tijdens de recente correctie tot $ 25k in de onderstaande grafiek. Het aanbodvolume dat van de status ‘in-verlies’ naar ‘in-profit’ sprong, bedroeg ongeveer 2,47 miljoen BTC, wat overeenkomt met 12,7% van het totale aanbod.</p>
<p>Daarentegen is het aanbod dat ‘in-verlies’ wordt gehouden, gedaald tot slechts 4,79M BTC, wat vergelijkbare niveaus bereikt zoals gezien in juli 2021 ($30k), juli 2020 ($9,2k), april 2016 ($6,5k) en maart 2016 ($425).</p>
<p><img src="https://gimg2.gateimg.com/image/article/168907027913_supplyprofitloss.png" alt=""></p>
<h2 id="h2-Vast20in20het20midden219161"><a name="Vast in het midden" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Vast in het midden</h2><p>Bitcoin-gegevens vertonen vaak vreemd repetitieve patronen, cyclus na cyclus. In de cyclus 2021-22 vormde het prijsniveau van $ 30k een soort ‘middelpunt’ en werd het verschillende keren getest, zowel van boven als van onderaf.</p>
<p>Een zeer vergelijkbaar niveau werd waargenomen in 2013-16 rond het $425 niveau, en opnieuw in 2018-19 op ongeveer $6.5k. Let ook op dat deze niveaus hierboven zijn genoemd als punten waar een vergelijkbare hoeveelheid aanbod ‘in-verlies’ werd vastgehouden.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1689070316image-8.png" alt=""></p>
<p>Met de markt die consolideert onder dit $30k ‘mid-point’, kunnen we zien dat ongeveer 75% van het totale aanbod winstgevend is, en 25% verlies lijdt. Dit is vreemd genoeg hetzelfde evenwicht dat werd bereikt toen de prijs de middelpunten bereikte in zowel 2016 als 2019.</p>
<p>In feite is deze 75:25 balans van aanbod dat winst:verlies vasthoudt het evenwichtspunt voor Bitcoin. 50% van alle handelsdagen heeft een hoger winst/verlies-balans gezien, en 50% een lagere balans.</p>
<p><img src="https://gimg2.gateimg.com/image/article/168907033612_pctsupplyprofit-1.png" alt=""></p>
<p>Dit evenwichtspunt heeft historisch gezien tijd gekost voor de markt om te verwerken en zich er weer omheen te consolideren. Veel Bitcoin-analisten verwijzen hiernaar als de ‘heraccumulatieperiode’, die neigt te overlappen met het halveringsevenement.</p>
<p>We kunnen dit visualiseren door te kijken naar het aandeel van de marktkapitalisatie dat in een ongerealiseerd verlies wordt gehouden. Tijdens de primaire berenmarkt wordt de markt diep in het rood gestort, waarbij investeerders geleidelijk capituleren. Naarmate de markt zich vormt en vervolgens herstelt van de dieptepunten, ziet de winstgevendheid een scherpe opleving, waardoor niveaus worden bereikt die vergelijkbaar zijn met waar we vandaag zijn.</p>
<p>Eerdere ‘her-accumulatieperiodes’ worden gekenmerkt door een gebrek aan macro-marktrichting, en hebben de neiging om zijwaarts te handelen (en volatiel) gedurende enkele maanden. Met de markt terug op dit evenwichtspunt, moet nog blijken of een soortgelijk langdurig en hobbelig proces nodig is om dit te overwinnen.</p>
<p><img src="https://gimg2.gateimg.com/image/article/168907036514_relunrealizedloss.png" alt=""></p>
<h2 id="h2-Samenvatting20en20conclusies395961"><a name="Samenvatting en conclusies" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Samenvatting en conclusies</h2><p>Bitcoin consolideert momenteel onder het 2021-22 cyclusmiddelpunt van $30k, waarbij verschillende metrics een niveau van evenwicht en balans bereiken. Dit is synoniem met de ‘heraccumulatieperiode’ die in eerdere cycli is gezien, gekenmerkt door enkele maanden met weinig macro-richting.</p>
<p>De prestaties van de prijs YTD zijn echter relatief sterk geweest, met een maximale drawdown tot nu toe van slechts -18%. De on-chain activiteit voor Bitcoin koelt enigszins af, voornamelijk gedreven door een daling van de Inion-activiteit. De volumes van geldovermakingen nemen echter toe, wat wijst op positieve momentum dat vaak gepaard gaat met groeiende liquiditeit en adoptie.</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 Blogteam<br><div class="info-tips">*Dit artikel vertegenwoordigt alleen de standpunten van de onderzoeker en vormt geen beleggingsadvies.<p></p><br></div></div></div></div>
Share
Content
gate logo
Gate
Trade Now
Join Gate to Win Rewards