R2xhc3Nub2RlIEluc2lnaHRzOiBTaG9ydCBTcXVlZXplcyBlbiBTcG90IERlbWFuZA==

2023-01-31, 06:22
<p><img src="https://gimg2.gateimg.com/blog/167117004537106004920221216-135350.jpeg" alt=""></p>
<p><a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> Markten hebben de sterkste maandelijkse prijsprestaties gezien sinds oktober 2021, gedreven door zowel historische spotvraag als een reeks short squeezes. In deze editie onderzoeken we de dynamiek die zich afspeelt op zowel de derivatenmarkten als de spotbeurzen.</p>
<p><img src="https://gimg2.gateimg.com/image/article/16751449788441675144022_.pic_hd.jpg" alt=""></p>
<p>De rally in digitale activa heeft deze week voortgeduurd, met <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin prijs</a> een hoogtepunt van $23.9k bereiken op zondagavond. De maand januari heeft gezien <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Tegen Bitcoin</a> markten boeken de beste maandelijkse prijsprestatie sinds okt-2021, waarmee het jaarlijks rendement oploopt tot meer dan +43%. Dit plaatst <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin prijs</a> op het hoogste niveau sinds aug 2022, en een winst van +6,6% vanaf de wekelijkse laagtes op $22,4k.</p>
<p>In deze editie zullen we enkele van de mechanismen verkennen die ten grondslag liggen aan deze rally binnen zowel de derivatenmarkten als de spotbeurzen. We behandelen:</p>
<p>De recente futures short squeeze en een terugkeer van positieve futures basis, ondanks een afnemende hefboomwerking ten opzichte van de marktomvang.</p>
<p>De heersende daling van spotwisselingsbalansen, ondanks een afnemende dominantie van on-chain activiteit met betrekking tot uitwisseling.</p>
<p>De markt breekt boven de gemiddelde opnamewaarde uit voor verschillende marktcohorten, waaronder de klas van 2019+, Binance- en Coinbase-klanten en Walvissen uit de klas van 2017.</p>
<p><img src="https://gimg2.gateimg.com/image/article/16751451668451675144058_.pic.jpg" alt=""></p>
<h2 id="h2-Knijpen20Shorts900323"><a name="Knijpen Shorts" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Knijpen Shorts</h2><p>Na een lang, pijnlijk en uitputtend 2022 is het nieuwe jaar geopend met een opmerkelijke ommekeer van de neerwaartse trend gedurende januari. Zoals vaak het geval is, worden dergelijke rallies meestal gevoed door enige mate van short squeezes binnen derivatenmarkten, en deze rally is niet anders.</p>
<p>Tot op heden is er meer dan $495M aan liquiderende shorttermijncontracten geweest in drie golven, met name met afnemende schaal naarmate de rally zich afspeelde.</p>
<p><img src="https://gimg2.gateimg.com/image/article/16751452288461675144076_.pic.jpg" alt=""></p>
<p>We kunnen zien dat de initiële short squeeze in het midden van januari veel handelaren verraste, met een all-time-low van 15% voor de dominantie van long-liquidatie (wat betekent dat 85% van de liquidaties shorts waren). Dit is zelfs een grotere omvang in verhouding tot de longs die werden geliquideerd tijdens de FTX-implosie (75% lange dominantie), wat laat zien hoeveel handelaren buiten de boot vielen.</p>
<p><img src="https://gimg2.gateimg.com/image/article/16751452728471675144096_.pic.jpg" alt=""></p>
<p>Zowel in de eeuwigdurende swap als in de futureskalender is de cash and carry-basis nu weer in positief gebied, respectievelijk 7,3% en 3,3% op jaarbasis. Dit komt nadat een groot deel van november en december backwardation liet zien in alle futuresmarkten en wijst op een terugkeer van positief sentiment en misschien ook wel wat speculatie.</p>
<p>🪟 Gerelateerd Dashboard: We hebben verschillende dashboards beschikbaar voor zowel futures, eeuwigdurende swaps en optiemarkten voor zowel BTC en ETH.</p>
<p><img src="https://gimg2.gateimg.com/image/article/16751453188481675144113_.pic_hd.jpg" alt=""></p>
<p>Echter, ondanks deze terugkeer van een positieve futures-basis, is het totale openstaande belang ten opzichte van de <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> De marktkapitalisatie is sinds medio november afgenomen. De waarde van openstaande futurescontracten, uitgedrukt in BTC, is in deze periode met 36% gedaald, van 650k BTC medio november naar 414k BTC vandaag.</p>
<p>Let op dat 40% van deze daling rechtstreeks kan worden toegeschreven aan het verlies van 95k BTC ter waarde van openstaande rente die werd aangehouden bij de FTX-beurs.</p>
<p><img src="https://gimg2.gateimg.com/image/article/16751453548491675144132_.pic_hd.jpg" alt=""></p>
<p>Als we de nominale omvang van openstaande futurescontracten vergelijken met het BTC-saldo op de bijbehorende beurzen, kunnen we de relatieve omvang van de hefboomwerking binnen de markt inschatten. Hier zien we dat deze hefboomverhouding is gedaald van een openstaand belang dat gelijk is aan 40% van de balansen van spotbeurzen tot slechts 25% in de afgelopen 75 dagen.</p>
<p>Over het algemeen weerspiegelt dit een aanzienlijke nettodaling in futures hefboomwerking en een sluiting van korte speculatieve belangen. Het zou ook kunnen wijzen op een vermindering van short-term downside hedge posities. Relatief gezien, en samen met de toename in waargenomen verschuiving terug naar on-chain zelfbewaring (WoC 46), legt dit ook meer nadruk op spotmarkten als een belangrijke drijvende kracht van de huidige marktstructuur.</p>
<p><img src="https://gimg2.gateimg.com/image/article/16751453978501675144150_.pic.jpg" alt=""></p>
<h2 id="h2-Het20inspecteren20van20spotbeurzen48821"><a name="Het inspecteren van spotbeurzen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Het inspecteren van spotbeurzen</h2><p>De trend van munten die uit spotbeurzen stromen, is sinds maart 2020 een belangrijk thema, wat tot op de dag van vandaag het hoogste saldo van uitwisselingsmunten markeert. Vandaag bedraagt het totale BTC-saldo dat we volgen op de beurzen ongeveer 2.251M BTC, wat 11,7% vertegenwoordigt van de circulerende voorraad, en een meerjarig dieptepunt dat voor het laatst werd gezien in februari 2018.</p>
<p><img src="https://gimg2.gateimg.com/image/article/16751454448511675144170_.pic.jpg" alt=""></p>
<p>Het totale handelsvolume van munten dat zowel naar binnen als naar buiten stroomt, bedraagt momenteel ongeveer $625M per dag in beide richtingen (dat wil zeggen $1.25B per dag in totaal). Per saldo is er een dagelijkse nettostroom van ongeveer $20M, wat slechts 1.5% van het totaal vertegenwoordigt, en laat zien dat de stromen op beurzen in een opmerkelijk evenwicht zijn. Dit verschilt van nov-dec, waar beurzen periodes van nettouitstroom zagen van ongeveer $200M tot $300M per dag.</p>
<p><img src="https://gimg2.gateimg.com/image/article/16751454918521675144195_.pic_hd.jpg" alt=""></p>
<p>De grootste maandelijkse uitstroom van munten in de geschiedenis vond plaats in deze nov-dec periode, waarbij -200k BTC/maand aan uitstroom plaatsvond op alle beurzen. Vandaag zijn de nettostromen van de beurs teruggekeerd naar neutraal, wat duidt op een afkoeling van de uitstroom. Dit kan wijzen op een vertraging in de nieuwe vraag ten opzichte van de nieuw gemobiliseerde uitgaven (WoC 4), nu de markt dit jaar meer dan 43% is gestegen.</p>
<p><img src="https://gimg2.gateimg.com/image/article/16751455338531675144211_.pic.jpg" alt=""></p>
<h2 id="h2-Een20zich20ontwikkelende20economie638683"><a name="Een zich ontwikkelende economie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Een zich ontwikkelende economie</h2><p>On-chain transacties voor <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> is deze week met meer dan 50.000 transacties per dag gestegen, maar we zien geen overeenkomstige toename in stortingen of opnames van beurzen. Transacties gerelateerd aan beurzen vertegenwoordigen op dit moment slechts 35% van het totale aantal transacties, waarbij deze dominantie sinds de piek van de markt in mei 2021 afneemt.</p>
<p>Deze piek in het aantal transacties is ook zichtbaar in onze gegevens die zijn aangepast aan de entiteit, wat suggereert dat het niet geassocieerd is met een enkele entiteit of interne portefeuillebeheer. Dit suggereert dat de recente toename van de transactieactiviteit elders plaatsvindt binnen de <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> economie.</p>
<p><img src="https://gimg2.gateimg.com/image/article/16751455828541675144231_.pic_hd.jpg" alt=""></p>
<p>De in en uit van de beurzen stromende USD-gedenomineerde volume is de afgelopen weken relatief stabiel geweest, maar ondanks dit is de relatieve dominantie van gerelateerd on-chain volume van de beurzen gegroeid van 2,5% naar meer dan 16%.</p>
<p>Zoals we hebben opgemerkt in WoC 3 en WoC 2, wereldwijde transactievolumes voor <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Tegen Bitcoin</a> zijn sinds november sterk gedaald. Dit is waarschijnlijk een weerspiegeling van een afname van opgeblazen, grote on-chain volumes die plaatsvonden tussen aug 2021 en nov 2022, grotendeels als gevolg van de algemene afbouw van de hefboomwerking binnen de sector en het slechte beheer van wallets door de FTX/Alameda entiteit.</p>
<p><img src="https://gimg2.gateimg.com/image/article/16751456338551675144248_.pic.jpg" alt=""></p>
<p>Gewoonlijk gaat marktsterkte gepaard met een toename van de totale on-chain uitwisselingsvolumes, omdat investeerders en handelaren actiever worden. Met het bovenstaande als context kunnen we zien dat er nog steeds een negatief aggregaat momentum is binnen uitwisselingsvolumes. Het maandelijkse gemiddelde begint echter toe te nemen, maar blijft op dit moment ver onder de jaarlijkse basislijn.</p>
<p>🔔 Alert Idee: Inkomende of Uitgaande Volume van de Exchange <a href="30D-SMA" rel="nofollow noopener noreferrer" target="_blank">USD</a> Een doorbraak boven $875M zou wijzen op een toename van recente uitwisselingsgerelateerde stromen terug naar de jaarlijkse basislijn.</p>
<p><img src="https://gimg2.gateimg.com/image/article/16751456968561675144272_.pic.jpg" alt=""></p>
<p>Specifiek op zoek naar Whale-entiteiten die meer dan 1k BTC bezitten, zien we ook een stijging van zowel stortings- als opnamenvolumes naar beurzen. Gedurende januari hebben Whale-entiteiten tussen de $185M en $215M bijgedragen aan totale instroom (en uitstroom) van beurzen, met een nettotekort van ongeveer $25M aan nettouitnamevolumes.</p>
<p><img src="https://gimg2.gateimg.com/image/article/16751457388571675144290_.pic.jpg" alt=""></p>
<h2 id="h2-Een20gemiddelde20aankoopprijs362098"><a name="Een gemiddelde aankoopprijs" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Een gemiddelde aankoopprijs</h2><p>Met zulke grote volumes munten die zowel in als uit beurzen stromen, kunnen we de gemiddelde verkrijgingsprijs schatten voor verschillende cohorten van de <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> economie. Deze eerste grafiek modelleert de gemiddelde aankoopprijs per jaarlijkse klasse, waarbij de berekening begint op 1 januari van elk jaar en een soort long-only DCA-kostprijs modelleert.</p>
<p>Door de neerwaartse trend van 2022 wisten alleen investeerders van 2017 en eerder een netto ongerealiseerd verlies te vermijden, waarbij de groep van 2018+ hun kostprijs zag verdwijnen door de rode kaars van FTX. De huidige rally heeft echter de groep van 2019 ($21,8k) en eerder weer in een ongerealiseerde winst geduwd.</p>
<p>🗜️ Werkbanktip: Deze gemiddelde opnameprijs kan worden berekend met behulp van de cumulatieve somfunctie en het instellen van een gedefinieerde startdatum cumsum(m1,sinds?)</p>
<p><img src="https://gimg2.gateimg.com/image/article/16751457938581675144307_.pic.jpg" alt=""></p>
<p>We kunnen een vergelijkbaar model per beurs creëren, waarbij de onderstaande grafiek laat zien dat de recente prijsactie drie belangrijke kostenniveaus doorkruiste.</p>
<p>🟠 De all-exchange, all-time opnameprijs werd doorsneden op $ 16,7k en bood een vorm van ondersteuning tijdens het consolidatiebereik aan het einde van het jaar.<br>🟡 + 🔵 De gemiddelde opnameprijs sinds juli 2017 voor Coinbase en Binance, de twee grootste beurzen, was net doorbroken rond de $21k.<br>In lijn met ons rapport van vorige week (WoC 4), is dit ook te zien in statistieken zoals Percentage Supply in Profit, die dramatisch zijn gestegen naarmate de prijzen boven hun on-chain acquisitieprijs stijgen.</p>
<p><img src="https://gimg2.gateimg.com/image/article/16751458368591675144322_.pic.jpg" alt=""></p>
<p>Ten slotte keren we terug naar onze eerder besproken Whale-cohort, maar deze keer bekijken we hun gemiddelde aankoopprijzen sinds belangrijke marktdieptepunten. Door deze sporen te beginnen bij marktdieptepunten, kunnen we de meest gunstige mogelijke prijzen van deze cohort beoordelen.</p>
<p>Wat we zien is dat zelfs de gemiddelde walvis, die actief is geweest sinds de markt van 2017 🟡, zijn bezittingen in 2022 in een ongerealiseerd verlies heeft zien veranderen, omdat de prijzen onder de $18k zijn gezakt. De groep sinds de dieptepunten van maart 2020 heeft een aankoopprijs van $23,8k, wat net boven de spotprijzen op het moment van schrijven ligt.</p>
<p>Alle drie deze modellen laten zien hoe meedogenloos de bearmarkt van 2022-23 is geweest, waardoor cohorten met zelfs de meest gunstige uitgangsposities tot een niet-gerealiseerd verlies leidden.</p>
<p><img src="https://gimg2.gateimg.com/image/article/16751458738601675144344_.pic.jpg" alt=""></p>
<h2 id="h2-Samenvatting20en20Conclusies924264"><a name="Samenvatting en Conclusies" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Samenvatting en Conclusies</h2><p>Naarmate het einde van januari nadert, <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> De markten hebben de sterkste maandelijkse prijsprestaties gezien sinds oktober 2021, aangewakkerd door zowel historische spotvraag als een reeks short squeezes. Deze rally heeft een groot deel van de markt weer winstgevend gemaakt en heeft geleid tot een gezonde contango in de termijnmarkten. We merken ook op dat de initiële impuls van uitstroom van uitwisselingen, in de nasleep van FTX, tot rust is gekomen en nu in evenwicht wordt gebracht door nieuw gemotiveerde instroom.</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 standpunten 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