R2xhc3Nub2RlIEluc2lnaHRzOiBzaG9ydCBzcXVlZXplIGUgZG9tYW5kYSBzcG90

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> I mercati hanno registrato le migliori performance dei prezzi mensili dal 2021, alimentati sia dalla domanda storica spot che da una serie di short squeeze. In questa edizione, esploreremo le dinamiche in corso sia nei mercati dei derivati che negli scambi spot.</p>
<p><img src="https://gimg2.gateimg.com/image/article/16751449788441675144022_.pic_hd.jpg" alt=""></p>
<p>Il rally degli asset digitali è continuato anche questa settimana, con <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Prezzo del Bitcoin</a> raggiungendo un massimo di $23.9k la domenica sera. Il mese di gennaio ha visto <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Alessio</a> mercati che registrano la migliore performance mensile dei prezzi dal periodo di ottobre 2021, raggiungendo oltre il +43% YTD. Questo pone <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Prezzo del Bitcoin</a> ai massimi livelli dal ago-2022, e un guadagno del +6,6% rispetto ai minimi settimanali a $22,4k.</p>
<p>In questa edizione, esploreremo alcuni dei meccanismi alla base di questo rally sia nei mercati derivati che negli scambi spot. Copriamo:</p>
<p>L’ultima pressione al ribasso dei future e il ritorno di una base dei future positiva, nonostante la leva aggregata in calo rispetto alla dimensione del mercato.</p>
<p>La prevalente diminuzione dei saldi di scambio spot, nonostante una diminuzione della dominanza dell’attività on-chain correlata agli scambi.</p>
<p>Il mercato ha superato il prezzo medio di prelievo per diverse coorti di mercato, tra cui la classe del 2019+, i clienti di Binance e Coinbase e le balene della classe del 2017.</p>
<p><img src="https://gimg2.gateimg.com/image/article/16751451668451675144058_.pic.jpg" alt=""></p>
<h2 id="h2-Spremere20i20corti724092"><a name="Spremere i corti" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Spremere i corti</h2><p>Dopo un lungo, doloroso e faticoso 2022, il nuovo anno è iniziato con un notevole ribaltamento del trend al ribasso per tutto gennaio. Come spesso accade, tali rialzi sono di solito alimentati da un certo grado di squeeze delle posizioni corte all’interno dei mercati dei derivati, e questo rally non fa eccezione.</p>
<p>Finora, sono stati liquidati oltre $495M di contratti futures di vendita a breve in tre ondate, soprattutto con una scala decrescente mentre il rally si svolgeva.</p>
<p><img src="https://gimg2.gateimg.com/image/article/16751452288461675144076_.pic.jpg" alt=""></p>
<p>Possiamo vedere che lo squeeze iniziale a metà gennaio ha colto di sorpresa molti trader, stabilendo un minimo storico del 15% per la dominanza delle liquidazioni long (il che significa che l’85% delle liquidazioni erano le posizioni corte). Questa è una magnitudine ancora più grande rispetto alle posizioni long liquidate durante l’implosione di FTX (dominanza long del 75%), mostrando quanto fossero fuori posizione molti trader.</p>
<p><img src="https://gimg2.gateimg.com/image/article/16751452728471675144096_.pic.jpg" alt=""></p>
<p>Sia nel perpetual swap che nei future sul calendario, la base cash and carry è tornata in territorio positivo, con rendimenti rispettivamente del 7,3% e del 3,3% annualizzati. Questo avviene dopo che gran parte di novembre e dicembre hanno visto la backwardation in tutti i mercati dei future e suggerisce un ritorno del sentimento positivo, forse con un pizzico di speculazione.</p>
<p>🪟 Dashboard correlati: Abbiamo diversi cruscotti disponibili per i mercati dei futures, dei perpetual swaps e delle opzioni sia per BTC che per ETH.</p>
<p><img src="https://gimg2.gateimg.com/image/article/16751453188481675144113_.pic_hd.jpg" alt=""></p>
<p>Tuttavia, nonostante questo ritorno di una base futura positiva, l’interesse aperto totale rispetto al <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> La capitalizzazione di mercato è in declino dal novembre. Il valore espresso in BTC dei contratti futures aperti è diminuito del 36% in questo periodo, passando da 650k BTC a metà novembre a 414k BTC oggi.</p>
<p>Nota che il 40% di questa diminuzione può essere direttamente attribuito alla perdita di 95k BTC di interesse aperto che era detenuto presso l’exchange FTX.</p>
<p><img src="https://gimg2.gateimg.com/image/article/16751453548491675144132_.pic_hd.jpg" alt=""></p>
<p>Se confrontiamo la dimensione nozionale dei contratti future aperti con il saldo di BTC sugli exchange corrispondenti, possiamo valutare la scala relativa della leva finanziaria all’interno del mercato. Qui possiamo vedere che questo rapporto di leva finanziaria è sceso da un open interest pari al 40% dei saldi spot degli exchange, ad appena il 25% negli ultimi 75 giorni.</p>
<p>Nel complesso, ciò riflette una significativa riduzione netta della leva finanziaria sui futures e una chiusura degli interessi speculativi al ribasso. Potenzialmente segnala anche una riduzione delle posizioni di copertura al ribasso a breve termine. In termini relativi, e insieme all’aumento dell’osservato spostamento verso la custodia personale on-chain (WoC 46), questo mette anche più enfasi sui mercati spot come principale driver della struttura di mercato attuale.</p>
<p><img src="https://gimg2.gateimg.com/image/article/16751453978501675144150_.pic.jpg" alt=""></p>
<h2 id="h2-Ispezione20degli20exchange20spot830767"><a name="Ispezione degli exchange spot" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Ispezione degli exchange spot</h2><p>Il trend delle monete che fuoriescono dagli scambi spot è stato un tema principale da marzo 2020, che segna ancora oggi il massimo storico del saldo delle monete di scambio. Oggi, il saldo totale di BTC detenuto sugli scambi che monitoriamo è di circa 2,251M di BTC, pari all’11,7% dell’offerta circolante, e un minimo pluriennale che era stato visto per l’ultima volta nel febbraio 2018.</p>
<p><img src="https://gimg2.gateimg.com/image/article/16751454448511675144170_.pic.jpg" alt=""></p>
<p>Il volume totale delle monete che entrano ed escono dagli scambi è attualmente di circa $ 625M/giorno in entrambe le direzioni (cioè $ 1,25B/giorno totale). In totale, ci sono circa $ 20M di flussi giornalieri netti, che rappresentano solo l’1,5% del totale e mostrano che i flussi degli scambi sono in un equilibrio sorprendentemente uniforme. Questo differisce da Novembre-Dicembre, quando gli scambi hanno registrato periodi di deflusso netto nell’ordine di $ 200M a $ 300M al giorno.</p>
<p><img src="https://gimg2.gateimg.com/image/article/16751454918521675144195_.pic_hd.jpg" alt=""></p>
<p>Il più grande deflusso mensile di monete nella storia è avvenuto in questo periodo novembre-dicembre, raggiungendo -200k BTC/mese in uscite su tutti gli scambi. Oggi, i flussi netti degli scambi sono tornati a essere neutrali, riflettendo un rallentamento delle uscite. Questo potrebbe significare un rallentamento della nuova domanda rispetto alla spesa appena mobilitata (WoC 4), ora che il mercato è aumentato di oltre il 43% anno su anno.</p>
<p><img src="https://gimg2.gateimg.com/image/article/16751455338531675144211_.pic.jpg" alt=""></p>
<h2 id="h2-Uneconomia20in20evoluzione958039"><a name="Un’economia in evoluzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Un’economia in evoluzione</h2><p>Transazioni on-chain per <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Alessio</a> è aumentato di oltre 50.000 transazioni al giorno questa settimana, tuttavia non possiamo vedere un aumento corrispondente nei depositi o nei conteggi dei prelievi degli scambi. Le transazioni correlate agli scambi rappresentano solo il 35% del conteggio totale delle transazioni al momento, con questa dominanza che rimane in un trend al ribasso dall’apice di mercato di maggio 2021.</p>
<p>Questo picco nel conteggio delle transazioni è visibile anche nei nostri dati regolati per entità, suggerendo che non è associato a un’unica entità o alla gestione interna del portafoglio. Ciò suggerisce che l’aumento recente dell’attività di transazione sta avvenendo altrove all’interno del <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> economia.</p>
<p><img src="https://gimg2.gateimg.com/image/article/16751455828541675144231_.pic_hd.jpg" alt=""></p>
<p>Il volume denominato in USD che fluisce dentro e fuori dagli exchange è stato relativamente stabile nelle ultime settimane; tuttavia, nonostante ciò, la dominanza relativa del volume on-chain legato agli exchange è passata dal 2,5% a oltre il 16%.</p>
<p>Come abbiamo notato in WoC 3 e WoC 2, i volumi globali delle transazioni per <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> sono precipitati notevolmente da novembre. Questo è probabilmente un riflesso di una diminuzione dei volumi on-chain gonfiati e di grande dimensione che si è verificata tra agosto 2021 e novembre 2022, principalmente a causa della de-leveraging a livello industriale e della gestione errata del portafoglio da parte dell’entità FTX/Alameda.</p>
<p><img src="https://gimg2.gateimg.com/image/article/16751456338551675144248_.pic.jpg" alt=""></p>
<p>Di solito, la forza del mercato è accompagnata da un aumento dei volumi totali di scambi on-chain, poiché gli investitori e i trader diventano più attivi. Con quanto sopra come contesto, possiamo vedere che rimane un momento aggregato negativo all’interno dei volumi di trasferimento degli scambi. La media mensile sta iniziando ad aumentare, ma rimane ancora ben al di sotto della linea di base annuale in questa fase.</p>
<p>🔔 Idea di allarme: volume di afflusso o deflusso degli scambi <a href="30D-SMA" rel="nofollow noopener noreferrer" target="_blank">USD</a> superare i $875M segnalerebbe un aumento dei flussi di scambio recenti verso la linea di base annuale.</p>
<p><img src="https://gimg2.gateimg.com/image/article/16751456968561675144272_.pic.jpg" alt=""></p>
<p>In particolare, guardando alle entità Whale, che detengono oltre 1k BTC, possiamo anche osservare un aumento sia nei volumi di deposito che di prelievo negli scambi. Durante tutto gennaio, le entità Whale hanno contribuito tra 185 milioni e 215 milioni di dollari ai flussi totali degli scambi (e dei prelievi), con un’orientamento netto di circa 25 milioni di dollari nei volumi netti di prelievo.</p>
<p><img src="https://gimg2.gateimg.com/image/article/16751457388571675144290_.pic.jpg" alt=""></p>
<h2 id="h2-Un20prezzo20medio20di20acquisizione490827"><a name="Un prezzo medio di acquisizione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Un prezzo medio di acquisizione</h2><p>Con volumi così grandi di monete che entrano e escono dagli scambi, possiamo stimare il prezzo medio di acquisizione per varie coorti di <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> economia. Questo primo grafico modella il prezzo medio di acquisizione per classe annuale, iniziando il calcolo il 1° gennaio di ogni anno e modellando una sorta di base di costo DCA a lungo termine.</p>
<p>Attraverso il trend al ribasso del 2022, solo quegli investitori del 2017 e precedenti sono riusciti a evitare una perdita non realizzata netta, con la classe del 2018+ che ha visto la loro base di costo eliminata dalla candela rossa di FTX. Tuttavia, il rally attuale ha riportato la classe del 2019 ($21.8k) e precedenti in un profitto non realizzato.</p>
<p>🗜️ Suggerimento per il banco di lavoro: Questo prezzo medio di prelievo può essere calcolato utilizzando la funzione di somma cumulativa e impostando una data di inizio definita cumsum(m1, since?)</p>
<p><img src="https://gimg2.gateimg.com/image/article/16751457938581675144307_.pic.jpg" alt=""></p>
<p>Possiamo creare un modello simile per scambio, con il grafico qui sotto che mostra che l’azione dei prezzi recente ha intersecato tre livelli chiave di base di costo:</p>
<p>Il prezzo di prelievo da tutte le borse, di tutti i tempi, è stato intersecato a $16.7k, e ha fornito una forma di supporto durante la gamma di consolidamento di fine anno. Il prezzo medio di prelievo da luglio 2017 per Coinbase e Binance, le due più grandi borse, è stato appena superato intorno ai $21k. In linea con il nostro rapporto della settimana scorsa (WoC 4), questo può essere visto anche all’interno di metriche come la Percentuale di Fornitura in Profitto, che sono aumentate drasticamente man mano che i prezzi salgono al di sopra del loro prezzo di acquisizione in catena.</p>
<p><img src="https://gimg2.gateimg.com/image/article/16751458368591675144322_.pic.jpg" alt=""></p>
<p>Infine, torniamo al nostro gruppo di balene discusso in precedenza, ma questa volta esaminando i loro prezzi medi di acquisizione dal momento in cui il mercato ha toccato il fondo. Iniziando queste tracce ai minimi di mercato, possiamo valutare i prezzi più favorevoli di questo gruppo.</p>
<p>Quello che vediamo è che anche la balena media, che è stata attiva dal mercato del 2017 🟡, ha visto i propri averi andare in perdita non realizzata nel 2022, poiché i prezzi sono scesi al di sotto di $18k. La coorte dalla minima del marzo 2020 ha un prezzo di acquisto di $23.8k, che si trova immediatamente sopra i prezzi spot al momento della scrittura.</p>
<p>Tutti e tre questi modelli dimostrano quanto sia spietato il mercato ribassista 2022-23, costringendo le coorti con punti di partenza anche i più favorevoli in una perdita non realizzata.</p>
<p><img src="https://gimg2.gateimg.com/image/article/16751458738601675144344_.pic.jpg" alt=""></p>
<h2 id="h2-Sommario20e20Conclusioni19427"><a name="Sommario e Conclusioni" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Sommario e Conclusioni</h2><p>Con l’avvicinarsi della fine di gennaio, <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> I mercati hanno registrato le migliori performance mensili dei prezzi da ottobre 2021, alimentati sia dalla storica domanda spot, sia da una serie di short squeeze. Questa impennata ha riportato una grande parte del mercato in territorio positivo e ha portato i mercati futures a scambiare in una sana contango. Notiamo anche che l’impulso iniziale degli outflow degli scambi, nel periodo successivo a FTX, si è calmato a un livello neutro e ora è bilanciato da nuovi influssi motivati.</p>
<div class="blog-details-info"><br><div>Autore: Glassnode Insights<br><div>Editor: Squadra del Blog Gate.io<br><div class="info-tips">*Questo articolo rappresenta solo le opinioni del ricercatore e non costituisce alcun suggerimento di investimento.<br></div><p></p><br></div></div></div>
Share
Content
gate logo
Gate
Trade Now
Join Gate to Win Rewards