R2xhc3Nub2RlIEluemljaHRlbjogV2hhbGUgV2F0Y2hpbmc=

2023-07-26, 02:12
<p><img src="https://gimg2.gateimg.com/image/article/1690336807SDFX.jpeg" alt=""></p>
<h2 id="h2-Samenvatting66124"><a name="Samenvatting" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Samenvatting</h2><p>Door observaties van de balansverandering van verschillende on-chain entiteiten isoleren we walvissen (1k+ BTC) als een van de primaire groepen die de afgelopen weken met beurzen interageren.</p>
<p>De dominantie van walvisinstroomvolumes naar beurzen is aanzienlijk en goed voor 41% van het totaal. Hiervan is meer dan 82% van de walvisinstromen bestemd voor Binance, de grootste beurs in de branche.</p>
<p><img src="https://gimg2.gateimg.com/image/article/169033682900_cover-10.png" alt=""></p>
<p>We kunnen ook vaststellen dat veel van deze actieve walvisentiteiten worden geclassificeerd als korte termijn houders, met opmerkelijke activiteit rond lokale marktpieken/dalen.</p>
<p>Op basis hiervan ontwikkelen we een reeks indicatoren om hun on-chain gedrag te monitoren, met als doel periodes van buitensporige winst of verliesgebeurtenissen te signaleren.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1690337168woc-30-01.png" alt=""></p>
<p>We onderzochten het langetermijngedrag van walvissen in ons recente rapport getiteld De garnalenvoorraadgootsteen. In dit stuk hebben we aangetoond dat walvisentiteiten hun totale saldo hebben zien dalen gedurende de geschiedenis van Bitcoin. De onderstaande grafiek versterkt dit, waarbij walvisentiteiten goed zijn voor 46% van de totale voorraad, een daling van 63% begin 2021.</p>
<p>Het is belangrijk op te merken dat hier, Wal entiteiten zullen beurzen omvatten, evenals grote gecentraliseerde holdings zoals ETF-producten, GBTC, WBTC, en bedrijfsholdings zoals Microstrategy.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1690337232woc-30-1.2.png" alt=""></p>
<p>Om Exchanges uit de dataset te verwijderen, kunnen we alleen munten isoleren die stromen tussen Whale-entiteiten en exchanges. De onderstaande grafiek laat zien dat het totale Whale-saldo sinds 30 mei met 255k BTC is gedaald.</p>
<p>Dit is de grootste maandelijkse daling van het saldo in de geschiedenis, met een negatieve waarde van -148k BTC/maand. Dit geeft aan dat er opmerkelijke verschuivingen plaatsvinden binnen de <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Walvissen cohort dieper waard om in te duiken.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1690337255woc-30-1.3.png" alt=""></p>
<h2 id="h2-Walvis20Herschikking264040"><a name="Walvis Herschikking" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Walvis Herschikking</h2><p>Om de afwijking binnen de walvisgroep te onderzoeken, kunnen we veranderingen in het aanbod dat eigendom is van elke subgroep gedurende de afgelopen 30 dagen observeren:</p>
<p>🔴 Walvissen met &gt;100K BTC hebben een saldoverhoging gezien van +6,6k BTC.</p>
<p>🔵 Walvissen met 10k-100k BTC hebben hun saldo verminderd met -49.0k BTC.</p>
<p>🟢 1k-10k Walvissen hebben een saldo verhoging gezien van ongeveer +33.8k BTC.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1690337346woc-30-02.png" alt=""></p>
<p>Bij alle walvisgroepen (inclusief beurzen) zien we een nettodaling van slechts -8,7k BTC in de afgelopen maand. Ondanks de extreme waarden die worden weergegeven in de Trend Accumulation Score, zijn de walvisentiteiten de afgelopen maanden enigszins neutraal geweest.</p>
<p>We hebben een g waar:</p>
<p>De instroom van walvissen naar beurzen is historisch groot, met 255k BTC die van walvissen naar beurzen stroomt.</p>
<p>Intern, walvis sub-cohorten zien verschuivingen in grootte van -49k tot +33.8k BTC.</p>
<p>In totaal heeft de walvisgroep slechts -8,7k BTC aan nettostromen gezien.</p>
<p>Aangezien de totale balansverandering relatief vlak is, maar er wel significante veranderingen plaatsvinden, zowel intern als via uitwisselingsstromen, is het zeer waarschijnlijk dat deze walvisentiteiten intern geld verplaatsen. We zullen dit ‘Walvisherindeling’ noemen.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1690337382woc-30-03.png" alt=""></p>
<p>Om deze hypothese van Walvis-Herschikking te testen, kunnen we de positieverandering van 30 dagen onderzoeken voor walvisverdelingen (&gt;10K BTC 🟥 en 1k-10k BTC 🟦). Ons doel is om periodes te vinden waarin de ene groep een toename van het saldo ziet, terwijl de andere groep een vergelijkbare schaalvermindering ziet.</p>
<p>In de onderstaande grafiek hebben we de periodes gemarkeerd waarin een sterke omgekeerde correlatie van -0,55 of minder 🟩 kan worden geïdentificeerd. We kunnen zien dat zo’n interval samenvalt met de recente marktstijging richting het $30k-bereik.</p>
<p>Dit suggereert dat walvissen inderdaad een relatief neutrale balansverandering hebben vertoond, waarbij een groot deel van hun recente activiteit het herschikken via beurzen is geweest.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1690337412woc-30-04.png" alt=""></p>
<h2 id="h2-Walvissen20en20beurzen593498"><a name="Walvissen en beurzen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Walvissen en beurzen</h2><p>Met dit walvisgedrag in gedachten, kunnen we nu proberen om eventuele effecten op de markt te observeren, met de nadruk op beurzen. De volgende grafiek kan worden gebruikt om de relatie tussen walvisentiteiten en beurzen te analyseren aan de hand van twee sporen:</p>
<p>🟪 Inkomende uitwisselingen in BTC-genoteerd aan walvissen toegeschreven</p>
<p>🔵 Percentage van alle instromen toegeschreven aan walvissen.</p>
<p>Tijdens de recente rally namen de volumes van walvis instroom naar beurzen behoorlijk toe, met een piek van +16,3k BTC/dag. Dit komt overeen met 41% van alle instroom op de beurs, wat vergelijkbaar is met zowel de LUNA-crash (39%) als het falen van FTX (33%).</p>
<p><img src="https://gimg2.gateimg.com/image/article/1690338533woc-30-05.png" alt=""></p>
<p>Analyse van de Whale Netflow naar beurzen kan worden gebruikt als een proxy voor hun invloed op het evenwicht tussen vraag en aanbod. Whale-to-exchange Netflows hebben de neiging gehad om te oscilleren tussen ±5k BTC/dag gedurende de afgelopen vijf jaar.</p>
<p>Echter hebben walvisinstromen gedurende juni en juli van dit jaar een verhoogde instroom-bias van tussen de 4,0k tot 6,5k BTC / dag in stand gehouden.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1690338585woc-30-07.png" alt=""></p>
<p>We zullen terugkeren naar een eenvoudig correlatiemiddel om periodes te identificeren waarin walvissen de wereldwijde uitwisselingsnetstroom domineren. De onderstaande grafiek toont periodes met een hoge correlatie (0,75 of meer) tussen Whale Netflows en wereldwijde uitwisselingsnetstromen 🟥 (wat wijst op walvishoofdschap), met drie belangrijke periodes zichtbaar:</p>
<p>De stier van 2017 naar de berenmarkt van 2018 (markttransitie en volwassenheid).</p>
<p>De periode na maart 2020 (institutionele adoptie en uitbreiding van GBTC).</p>
<p>Eind 2021 tot 2022 (de ongelukkige malversatie van het FTX/Alameda entiteit).</p>
<p>Vanuit dit perspectief kunnen we opnieuw zien dat het gedrag van Walvissen (sterke instroombias) behoorlijk afwijkt van de rest van de markt (bescheiden uitstroombias).</p>
<p><img src="https://gimg2.gateimg.com/image/article/1690338634Group-3262.png" alt=""></p>
<p>Misschien wel het meest interessante onderdeel van dit verhaal is de bestemming van whale-munten. Als we de instroomvolumes van whales opsplitsen, zien we dat ongeveer 82% van de stromen van whales naar beurzen naar Binance 🟨 gaat, terwijl Coinbase 🟦 goed is voor 6,8%, en alle andere beurzen goed zijn voor 11,2%.</p>
<p>Dit impliceert dat bijna 34% van de walvisinstroom tijdens de rally in juli naar Binance werd gestuurd, met een buitengewone stijging van de dominantie van Binance zichtbaar gedurende de afgelopen 12 maanden. Dit wijst ook op enkele van de regionale verschillen die we hebben waargenomen in eerdere weken (WoC 26).</p>
<p><img src="https://gimg2.gateimg.com/image/article/1690338661woc-30-06.png" alt=""></p>
<h2 id="h2-Korte20termijn20walvissen732299"><a name="Korte termijn walvissen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Korte termijn walvissen</h2><p>Nu we hebben vastgesteld dat walvis-entiteiten op dit moment de dominante rol spelen in de uitwisselingsactiviteit, kunnen we deze observaties verbinden met het rapport van vorige week, waarin we opmerkten dat de meeste uitwisselingsactiviteit verband hield met korte termijn houders (WoC 29).</p>
<p>De dominantie van korte termijn houders in de instroom van uitwisselingen is explosief gestegen tot 82%, wat nu drastisch boven het langetermijnbereik ligt van de afgelopen vijf jaar (typisch 55% tot 65%). Hieruit kunnen we concluderen dat een groot deel van de recente handelsactiviteit wordt gedreven door Walvissen die actief zijn binnen de markt van 2023 (en dus geclassificeerd als STHs).</p>
<p><img src="https://gimg2.gateimg.com/image/article/1690338695Group-3263.png" alt=""></p>
<p>Als we kijken naar de mate van gerealiseerde winst/verlies door korte-termijn houders die naar beurzen stromen, wordt het duidelijk dat deze nieuwe investeerders handelen op basis van lokale marktomstandigheden. Elke rally en correctie sinds de FTX-implosie heeft geleid tot respectievelijk een toename van 10k+ BTC in winst of verlies voor korte-termijn houders.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1690338711woc-30-11.png" alt=""></p>
<p>We kunnen dit gedrag nog duidelijker zien door te kijken naar de nettowinst- / verliesbias voor munten die door de STH-cohort naar beurzen worden gestuurd. Hier kunnen we zien dat lokale marktextremen STH’s een hoge mate van winst 🟥 of verlies 🟩 laten vastleggen, aangegeven door deze metriek die respectievelijk boven of onder ±0,3 handelt.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1690338750woc-30-12.png" alt=""></p>
<p>Short-Term Holder SOPR 🟠 is een ander krachtig instrument om samenhang te bieden voor dit lokale handelsgedrag op spotmarkten. SOPR volgt de verhouding tussen de gemiddelde uitgaveprijs (afvoer) en de aanschafprijs voor munten van Short-Term Holders.</p>
<p>De volgende grafiek maakt gebruik van bands van één standaardafwijking (90 dagen) voor periodes waarin er sprake is van een teveel aan winst of verlies. We zien verschillende glen waarin deze prijsbanden werden overschreden rond de lokale marktextremen van 2023.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1690338764Group-3264.png" alt=""></p>
<p>Tenslotte kunnen we deze waarnemingen combineren met Workbench om een tool te ontwikkelen die aangeeft wanneer aan beide voorwaarden is voldaan:</p>
<ol>
<li><p>STH SOPR handelt boven de gemiddelde + 1sd-band (90 dagen).</p>
</li><li><p>De relatieve nettowinst/verliesbias ten opzichte van beurzen overschrijdt 0,3.</p>
</li></ol>
<p>Deze tool kan helpen bij het identificeren wanneer de STH-cohort een groot deel van de winst vastzet ten opzichte van de recente geschiedenis. Er zijn verschillende van dergelijke gebeurtenissen geweest gedurende 2023, waarbij velen lokale marktpieken hebben vastgesteld.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1690338779Group-3266.png" alt=""></p>
<h2 id="h2-Samenvatting20en20conclusies356614"><a name="Samenvatting en conclusies" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Samenvatting en conclusies</h2><p>Walvisentiteiten voor <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> worden vaak genoemd als een belangrijke invloed op de marktprijsactie. Hoewel het vrij uitdagend is om deze entiteiten bij te houden en te monitoren, lijken ze de laatste maanden steeds actiever te zijn. In het bijzonder is 42% van de instromen op beurzen gerelateerd aan walvisentiteiten, waarbij een overgrote meerderheid hiervan bestemd is voor Binance.</p>
<p>We kunnen ook afleiden dat de meeste actieve walvisentiteiten worden geclassificeerd als kortetermijnhouders. Door deze waarnemingen te combineren, kunnen we een reeks tools ontwikkelen om periodes van sterke winst- en verliesrealisatie door deze groep bij te houden. Hieruit kunnen we een reeks tools ontwikkelen om lokale marktextremen te helpen navigeren met behulp van on-chain gegevens.</p>
<p><strong>Disclaimer: Dit rapport verstrekt 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 volledig verantwoordelijk voor uw eigen beleggingsbeslissingen.</strong></p>
<div class="blog-details-info"><br><div>Auteur: Glassnode Insights<br><div>Redacteur: Gate.io Blog Team<br><div class="info-tips">*Dit artikel vertegenwoordigt alleen de visie 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