R2xhc3Nub2RlIEluemljaHRlbjogSG9ldmVlbCBCaXRjb2luIHppam4gZXIgdGUga29vcD8=

<p><img src="https://gimg2.gateimg.com/image/article/1687840306SDFX.jpeg" alt=""></p>
<h2 id="h2-Samenvatting643077"><a name="Samenvatting" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Samenvatting</h2><p>Het analyseren van het fonds <a href="/price/flow-flow" rel="nofollow noopener noreferrer" target="_blank">Stromen</a> toegeschreven aan topbeurzen in de VS en Azië, toont een sterke accumulatie tijdens de handelsuren in Azië, terwijl de Amerikaanse markten zwakkere vraag hebben getoond in 2023.</p>
<p>Met behulp van een raamwerk dat in dit artikel wordt geïntroduceerd, identificeren we periodes van vraaguitbreiding (of inkrimping) met behulp van het concept van ‘hete aanbod’, dat het munthoeveelheid isoleert die actief deelneemt aan prijsvinding.</p>
<p>De analyse van het gedrag van korte termijn houders in 2023 suggereert dat de marktpsychologie is veranderd ten opzichte van de bearish omgeving van 2022, waarbij de recente rally steunde op hun kostprijsbasis, die als steun fungeerde.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1687840377woc-26-cover.png" alt=""></p>
<h2 id="h2-Regionale20sentimentanalyse360112"><a name="Regionale sentimentanalyse" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Regionale sentimentanalyse</h2><p>In de afgelopen weken heeft de SEC druk uitgeoefend op de twee belangrijkste cryptocurrency-beurzen in de VS. Deze week zagen we echter een goudkoorts van aanvragen voor spot <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> ETF’s, geleid door Blackrock, de grootste wereldwijde vermogensbeheerder. Als reactie hierop is BTC gestegen van $25k naar meer dan $31k, waarmee nieuwe jaarlijkse hoogtepunten worden bereikt.</p>
<p>De rally werd geleid door handelaren in de VS 🔵, gevolgd door handelaren in de EU 🟠 en tenslotte in Azië 🔴.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1687840465woc-26-00.png" alt=""></p>
<p>We kunnen een kader verkennen voor deze regionale verschuivingen door de munstroom te beoordelen via fiat on-ramping entiteiten (beurzen). Hiervoor hebben we de top drie beurzen uit de VS en Azië geïsoleerd zoals gerangschikt door CoinGecko.</p>
<p><strong>VS (On-shore)</strong>: Coinbase, Kraken en Gemini</p>
<p><strong>Azië (off-shore)</strong>: Binance, OKX en Houbi</p>
<p>Door te focussen op de wekelijkse gemiddelde BTC netstroom worden interessante patronen in hun gedrag blootgelegd. Tijdens de vroege stadia van de 2020-2021 stierenmarkt leidden de LUNA-affaire en FTX-nasleep tot een regime van sterke accumulatie en voorkeur voor zelfbewaring. De meeste beurzen ondervonden dagelijkse netto-uitstroom van 5k-10k BTC.</p>
<p>Echter heeft Binance op meerdere gelegenheden het tegenovergestelde gedrag vertoond, waarbij grote instroomvolumes gepaard gingen met marktverkoop-evenementen en neerwaartse trends. Dit kan deels te wijten zijn aan beleggers die hun bezittingen verplaatsen van beurzen die als riskanter worden beschouwd (zoals FTX) naar de grootste beurs ter wereld.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1687848106woc-26-01.png" alt=""></p>
<p>We kunnen ook beurzen categoriseren op basis van hun hoofdkantoor (On- vs Off-shore) en vervolgens de totale netto stromen voor elke subcategorie samenvoegen.</p>
<p>De volgende grafiek toont de maandelijkse cumulatieve netto instroom voor elke regio. We kunnen vaststellen dat beide regio’s een netto uitstroom (accumulatie) zagen tijdens de bodem ontdekkingsfase tussen nov-2022 en jan-2023. Daarentegen hebben Off-shore beurzen na het LUNA-debacle en gedurende een groot deel van 2023 netto instromen gezien, terwijl On-shore beurzen netto uitstroom zien, aangezien Amerikaanse investeerders accumuleren of neutraal blijven.</p>
<p>Waarnemers kunnen deze indicator gebruiken om verschuivingen in het sentiment van de regionale markt te volgen naarmate ze reageren op externe factoren. Bijvoorbeeld, nadat de SEC rechtszaak tegen BinanceUS en Coinbase werd aangekondigd, reageerden beide regio’s op prijscorrectie via opmerkelijke uitstroom van beurzen. Momenteel tonen off-shore beurzen een nettouitstroom van -37,7k BTC/maand, terwijl de koopdruk op on-shore beurzen is gedaald tot -3,2k BTC/maand.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1687848151woc-26-02.png" alt=""></p>
<h2 id="h2-Peilen20van20vraag20via20hete20aanbod443937"><a name="Peilen van vraag via hete aanbod" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Peilen van vraag via hete aanbod</h2><p>Onze recente nieuwsbrieven benadrukten de voortdurende overdracht van rijkdom van investeerders met een hoge tijdsvoorkeur naar HODLers. Dit patroon van groeiende illiquiditeit is een belangrijk onderdeel van alle eerdere Bitcoin bullmarkten. Echter, hoewel een ‘aanbodschok’ de prijsontdekking positief kan beïnvloeden, hangt de duurzaamheid van de trend nog steeds af van de instroom van nieuwe vraag op de markt.</p>
<p>Gezien het belang van de vraagzijde, streven we ernaar een kader te creëren voor het traceren van de uitbreiding (of inkrimping) van de vraag aan de hand van on-chain metrieken. Om dit doel te bereiken, zullen we de momentum van het aanbod meten, dat zeer actief is als een proxy-representatie van de vraag.</p>
<p>💡 Het kwantificeren van kapitaalstromen kan worden gemeten aan de hand van veranderingen in de omvang van het zeer actieve gebied van circulerende voorraad.</p>
<p>Met andere woorden, wanneer er nieuwe vraag op de markt komt, reageren bestaande investeerders meestal door transacties uit te voeren en hun munten te distribueren tegen hogere prijzen. Het uitgeven van oudere munten 🟦 vereist daarom een uitbreiding van de jongere voorraad 🟥 regio.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1687848214woc-26-03-1-.png" alt=""></p>
<p>We beginnen met het definiëren van ‘jonge voorraad’ als alle munten die in de laatste 155 dagen zijn verplaatst (kortetermijnhouders), die een grote kans hebben om op korte termijn te worden uitgegeven. We kunnen echter dieper kijken en alleen het meest liquide en zeer actieve subset van het jonge voorraadgebied isoleren, dat we zullen definiëren als ‘Hot Supply’.</p>
<p><strong>Hot Supply</strong> is een onderverdeling van jonge voorziening die een snelheid heeft van één of meer. Een snelheid van meer dan één betekent gemiddeld dat elke munt in dat gebied meer dan eens per dag beweegt.<br>Met behulp van de volgende formule kunnen we de snelheid van een willekeurige onderverdeling van munten berekenen.</p>
<p>Velocity_i = Dagelijkse Volume_i / Aanbodgrootte_i</p>
<p>De onderstaande grafiek toont de gemiddelde snelheid van alle tijden voor de volgende markten:</p>
<p>Permanente Futures Markt 🔵 (snelheid = handelsvolume gedeeld door open interest).</p>
<p><strong>Spotmarkt (&lt;1w munten)</strong> 🔴 (snelheid = on-chain volume gedeeld door aanbod &lt; 1wk).</p>
<p><strong>Spotmarkt (&lt;1m munten)</strong> 🟠 (snelheid = on-chain volume gedeeld door aanbod &lt; 1m).</p>
<p>De snelheid van zowel de eeuwigdurende futures markten als het aanbod &lt; 1wk is meer dan één. Als we munten uit de volgende leeftijdsgroep (1 maand) beschouwen, daalt de snelheid onder één, wat het idee versterkt dat oudere munten een lagere kans hebben om te worden uitgegeven.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1687848387woc-26-04.png" alt=""></p>
<p>Om de omvang van deze Hot Supply 🟥 in perspectief te plaatsen, wordt deze aanbodregio gepresenteerd tegenover Perpetual Open Interest 🟪, Totale Circulerende Voorraad 🟧 en (waarschijnlijk) Verloren Voorraad ⬛. Het interessante is dat gedurende de hele geschiedenis van Bitcoin het prijsvormingsproces wordt aangedreven door een relatief klein deel van de totale circulerende voorraad.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1687848645woc-26-04-1-.png" alt=""></p>
<p>Met een mediane grootte van 0,67M BTC en een maximum van 2,2M BTC vertegenwoordigt Hot Supply tussen de 3,5% en 11,3% van de totale voorraad. Dit is vergelijkbaar met het volume van waarschijnlijk verloren munten (1,46M BTC ~ 7,2%), die niet zijn getransacteerd sinds de eerste handelsprijs van Bitcoins in juli 2010.</p>
<p>De openstaande rente voor eeuwigdurende futures (472k BTC) en de hete voorraad (511k BTC) zijn ook qua omvang vergelijkbaar, zoals hieronder wordt getoond, wat suggereert dat er momenteel een volume van ongeveer 983k BTC (~$29.5B) ‘beschikbaar’ is voor verkoop, waarvan iets minder dan de helft spot BTC is.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1687848664woc-26-06.png" alt=""></p>
<p>We kunnen ook de onderlinge relatie tussen prijsbewegingen en veranderingen in deze Hot Supply en Perpetual Open Interest componenten aantonen. De onderstaande grafiek bekijkt de 90-daagse Netto Positieverandering in deze regio’s, waar we de richting en omvang van kapitaalstromen naar de markt kunnen identificeren.</p>
<p>Gedurende voorgaande bull-markten en ernstige capitulatie-evenementen wordt er doorgaans tussen 250k en 500k BTC aan waarde op de markt ingezet. Tijdens langdurige bearmarkten wordt een vergelijkbare omvang van volume geaccumuleerd en lang genoeg van de markt gehaald om deze Hot Supply-cohort (verworven en vastgehouden door HODLers) te verlaten.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1687849000woc-26-07-1-.png" alt=""></p>
<p>Het effect op de prijsontwikkeling als gevolg van deze uitbreidingen in de warme voorraad wordt weergegeven in de onderstaande grafiek. Er zijn zeven belangrijke <a href="/price/waves-waves" rel="nofollow noopener noreferrer" target="_blank">Golven</a> van kapitaalinstroom gedurende de afgelopen 5 jaar, variërend in omvang van 400k BTC tot 900k BTC per kwartaal. Deze waren gekoppeld aan marktbewegingen van tussen de 26% en 154%.</p>
<p>Vanuit deze grafiek kunnen we ook de potentiële impact van de liquidatie van belangrijke aanbodbronnen vergelijken, zoals de Mt. Gox-fondsen (137k BTC) en in beslag genomen <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> gehouden door de Amerikaanse overheid (204k BTC). Hieruit kunnen we concluderen dat een enkel kwartaal van vergelijkbare vraaginstroom in staat kan zijn om de volledige distributie van beide bronnen te absorberen.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1687849285woc-26-08.png" alt=""></p>
<h2 id="h2-Reageren20op20OnChain20Kostenbasis86696"><a name="Reageren op On-Chain Kostenbasis" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Reageren op On-Chain Kostenbasis</h2><p>In ons WoC 18-rapport hebben we de betekenis van het gedrag van korte termijn houders tijdens cycluspivotpunten geïllustreerd. Sinds 2023 zijn er twee belangrijke intersecties geweest tussen prijs en de Short Term Holders-Cost Basis 🔴 waar het sterke ondersteuning bood.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1687849028woc-26-09.png" alt=""></p>
<p>De wekelijkse veranderingssnelheid voor zowel de langetermijn 🟦 als de kortetermijnhouder 🟥 kostprijs daalde vorige week richting nul, wat wijst op een stabiel evenwicht dat rond de $26k is bereikt. Dit suggereert dat de investeerderspsychologie is verschoven van de berenmentaliteit van 2022 naar een perceptie van break-even niveaus als een kans om een positie op te bouwen, in plaats van exit-liquiditeit te nemen.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1687849300woc-26-10.png" alt=""></p>
<p>We zien ook een sterke reactie in de Short-Term Holder MVRV-indicator, die sterk reageert op het break-even niveau van MVRV = 1.</p>
<p>Deze ratio staat momenteel op 1,12, wat suggereert dat de korte termijn houdersgroep gemiddeld genomen een winst van 12% heeft. Het risico op marktcorrecties neemt toe wanneer deze maatstaf niveaus boven 1,2 (~$33,2k) en 1,4 (~$38,7k) overschrijdt, omdat beleggers steeds grotere ongerealiseerde winsten behalen.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1687849346woc-26-10-1-.png" alt=""></p>
<p>Ter afronding kijken we naar het uitgavenpatroon van korte termijn houders YTD, gepresenteerd in de STH-SOPR-indicator. We hebben bovenste en onderste banden geplot met behulp van 90-daagse ± standaarddeviatiebanden als een instrument om waarschijnlijke reactiepunten te identificeren. Op meerdere momenten in de afgelopen weken kunnen we uitputting van verkoperspots identificeren die plaatsvindt onder de onderste band 🟢, inclusief de uiteindelijke laag die is ingesteld op $25.1k vóór het herstel boven $30k.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1687849375woc-26-12.png" alt=""></p>
<h2 id="h2-Samenvatting20en20Conclusies127085"><a name="Samenvatting en Conclusies" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Samenvatting en Conclusies</h2><p>Nu er een goudkoorts van institutionele ETF-aanvragen wordt ingediend in de VS, zien we vroege tekenen van een heropleving van de door de VS geleide vraag. Dit komt na een periode van zwakkere relatieve Amerikaanse vraag in 2023, waarbij de topbeurzen in Azië de sterkste accumulatie tot nu toe zien.</p>
<p>Met het vooruitzicht van een nieuwe grote koper van spot BTC op tafel, hebben we een kader ontwikkeld om het beschikbare volume van BTC-aanbod te beoordelen, en een toolkit om de uitbreiding (of inkrimping) van nieuwe vraag te beoordelen.</p>
<p>We sluiten af door het gedrag van de Short-Term Holder-cohort te onderzoeken en merken op dat hun marktpsychologie lijkt te zijn veranderd van de bearmarkt-blues van 2022. Hun acties spreken van een nieuw gevonden perceptie van ‘break-even’-niveaus als een kans om posities toe te voegen, in plaats van te liquideren in welke uitgangsliquiditeit dan ook beschikbaar is.</p>
<p><strong>Disclaimer: Dit rapport biedt 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 als enige 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 beleggingsadvies.<br></div><p></p><br></div></div></div>