R2xhc3Nub2RlIEluc2lnaHRzOiBRdWFudGkgQml0Y29pbiBzb25vIGluIHZlbmRpdGE/

2023-06-27, 07:03
<p><img src="https://gimg2.gateimg.com/image/article/1687840306SDFX.jpeg" alt=""></p>
<h2 id="h2-Sommario20Esecutivo864582"><a name="Sommario Esecutivo" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Sommario Esecutivo</h2><p>Analizzando il fondo <a href="/price/flow-flow" rel="nofollow noopener noreferrer" target="_blank">Flusso</a> attribuito ai principali scambi negli Stati Uniti e in Asia, mostra una forte accumulazione durante le ore di negoziazione in Asia, mentre i mercati statunitensi hanno mostrato una domanda più debole nel 2023.</p>
<p>Utilizzando un framework introdotto in questo articolo, identifichiamo periodi di espansione della domanda (o contrazione) utilizzando il concetto di ‘hot supply’, che isola il volume di monete che partecipa attivamente alla scoperta del prezzo.</p>
<p>L’analisi del comportamento dei detentori a breve termine nel 2023 suggerisce che la psicologia di mercato si è spostata dall’ambiente ribassista del 2022, con il recente rally che è scaturito dalla loro base di costo, che ha agito come supporto.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1687840377woc-26-cover.png" alt=""></p>
<h2 id="h2-Analisi20del20sentiment20regionale320222"><a name="Analisi del sentiment regionale" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Analisi del sentiment regionale</h2><p>Nelle ultime settimane, la SEC ha esercitato pressioni sulle prime due borse di criptovalute negli Stati Uniti. Tuttavia, questa settimana si è assistito a una corsa all’oro delle richieste di spot <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> ETF guidate da Blackrock, il più grande gestore patrimoniale globale. In risposta, BTC è salito da $25k a oltre $31k, raggiungendo nuovi massimi annui.</p>
<p>Il rally è stato guidato dai trader negli Stati Uniti 🔵, seguiti dai trader nell’UE 🟠 e infine in Asia 🔴.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1687840465woc-26-00.png" alt=""></p>
<p>Possiamo esplorare un framework per queste variazioni regionali valutando i flussi di monete attraverso le entità di fiat on-ramping (scambi). Per farlo, abbiamo isolato i primi tre scambi dalle regioni degli Stati Uniti e dell’Asia come classificati da CoinGecko.</p>
<p><strong>US (On-shore)</strong>: Coinbase, Kraken e Gemini</p>
<p><strong>Asia (Off-shore)</strong>: Binance, OKX e Houbi</p>
<p>Concentrandosi sulla media settimanale del flusso netto BTC si evidenziano alcuni schemi interessanti nel loro comportamento. Durante le prime fasi del mercato rialzista 2020-2021, la debacle LUNA e la caduta FTX hanno portato a un regime di forte accumulazione e preferenza per la custodia personale. La maggior parte degli scambi ha registrato deflussi netti giornalieri di BTC compresi tra 5.000 e 10.000.</p>
<p>Tuttavia, in più occasioni, Binance ha dimostrato un comportamento opposto, dove volumi di ingresso elevati hanno accompagnato eventi di vendita sul mercato e trend al ribasso. Questo potrebbe essere, in parte, dovuto agli investitori che spostano le proprie posizioni dagli exchange considerati più rischiosi (come FTX) verso il più grande exchange al mondo.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1687848106woc-26-01.png" alt=""></p>
<p>Possiamo anche categorizzare gli scambi in base alla loro sede (On- vs Off-shore) e poi aggregare i flussi netti totali per ogni sottocategoria.</p>
<p>Il grafico seguente mostra il flusso netto cumulativo mensile per ciascuna regione. Possiamo osservare che entrambe le regioni hanno registrato deflussi netti (accumulo) durante la fase di scoperta del fondo tra nov-2022 e gen-2023. Al contrario, dopo il disastro di LUNA e per gran parte del 2023, gli scambi off-shore hanno registrato afflussi netti, mentre gli scambi on-shore stanno registrando deflussi netti, poiché gli investitori statunitensi accumulano o rimangono neutrali.</p>
<p>Gli osservatori possono utilizzare questo indicatore per monitorare i cambiamenti del sentiment del mercato regionale mentre reagiscono a fattori esterni. Ad esempio, dopo l’annuncio della causa della SEC contro BinanceUS e Coinbase, entrambe le regioni hanno reagito alla correzione dei prezzi attraverso notevoli deflussi dagli exchange. Attualmente, gli exchange off-shore mostrano -37,7k BTC/mese di deflussi netti, mentre la pressione d’acquisto negli exchange on-shore è scesa a -3,2k BTC/mese.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1687848151woc-26-02.png" alt=""></p>
<h2 id="h2-Valutare20la20domanda20attraverso20lofferta20calda893341"><a name="Valutare la domanda attraverso l’offerta calda" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Valutare la domanda attraverso l’offerta calda</h2><p>Le nostre recenti newsletter hanno evidenziato il continuo trasferimento di ricchezza dagli investitori con alte preferenze temporali verso gli HODLers. Questo modello di crescente illiquidità è un componente primario di tutti i precedenti mercati rialzisti di Bitcoin. Tuttavia, mentre uno ‘shock dell’offerta’ può influenzare positivamente la scoperta dei prezzi, la sostenibilità del trend dipende ancora dall’afflusso di nuova domanda che entra sul mercato.</p>
<p>Dato l’importanza del lato della domanda, cerchiamo di stabilire un framework per tracciare l’espansione (o la contrazione) della domanda utilizzando metriche on-chain. Per raggiungere questo obiettivo, misureremo il momentum del’offerta, che è molto attivo come rappresentazione di proxy della domanda.</p>
<p>💡 La quantificazione dei flussi di capitale può essere misurata dai cambiamenti nella dimensione della regione altamente attiva dell’offerta circolante.</p>
<p>In altre parole, quando entra nuova domanda nel mercato, gli investitori esistenti di solito reagiscono trasferendo e distribuendo le loro monete a prezzi più alti. La spesa delle monete più vecchie 🟦, quindi, richiede un ampliamento della regione di offerta più giovane 🟥.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1687848214woc-26-03-1-.png" alt=""></p>
<p>Iniziamo definendo ‘young supply’ come tutte le monete spostate negli ultimi 155 giorni (Short-Term Holders), che hanno una alta probabilità di essere spese nel breve termine. Tuttavia, possiamo approfondire ulteriormente e isolare solo il sottoinsieme più liquido e altamente attivo della regione di young supply, che definiremo ‘Hot Supply’.</p>
<p><strong>Fornitura calda</strong> è una suddivisione dell’offerta giovane che ha una velocità pari o superiore a uno. Una velocità superiore a uno significa, in media, che ogni moneta in quella regione si sposta più di una volta al giorno.<br>Utilizzando la seguente formula, possiamo calcolare la velocità di qualsiasi suddivisione arbitraria di monete i.</p>
<p>Velocity_i = Volume giornaliero_i / Dimensione dell’offerta_i</p>
<p>Il grafico qui sotto mostra la velocità media di tutti i tempi per i seguenti mercati:</p>
<p>Mercato dei futures perpetui 🔵 (velocità = volume di scambi diviso per interesse aperto)</p>
<p><strong>Mercato Spot (monete &lt;1w)</strong> 🔴 (velocità = volume on-chain diviso per l’offerta &lt; 1 settimana).</p>
<p><strong>Mercato Spot (&lt;1m monete)</strong> 🟠 (velocità = volume on-chain diviso per l’offerta &lt; 1m).</p>
<p>La velocità dei mercati dei futures perpetui e dell’offerta &lt; 1 settimana è superiore a uno. Se consideriamo le monete della prossima fascia di età (1 mese), la velocità scende al di sotto di uno, rafforzando l’idea che le monete più vecchie hanno una probabilità più bassa di essere spese.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1687848387woc-26-04.png" alt=""></p>
<p>Per mettere in prospettiva la portata di questo Hot Supply 🟥, questa regione di fornitura è presentata rispetto all’Interesse Aperto Perpetuo 🟪, alla Fornitura Circolante Totale 🟧 e alla Fornitura Persa (Probabilmente) ⬛. La cosa interessante da notare è che per tutta la storia di Bitcoin, il processo di determinazione dei prezzi è stato guidato da una frazione relativamente piccola della fornitura circolante totale.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1687848645woc-26-04-1-.png" alt=""></p>
<p>Con una dimensione media di 0,67 milioni di BTC e un massimo di 2,2 milioni di BTC, l’offerta calda rappresenta tra il 3,5% e l’11,3% dell’offerta totale. Questo è paragonabile al volume delle monete probabilmente perse (1,46 milioni di BTC ~ 7,2%), essendo quelle che non hanno effettuato transazioni da quando il prezzo di Bitcoin è stato scambiato per la prima volta nel luglio 2010.</p>
<p>L’interesse aperto per i futures perpetui (472k BTC) e l’offerta calda (511k BTC) sono anche simili in dimensioni come mostrato di seguito, suggerendo che un volume di circa 983k BTC (~$29,5 miliardi) è attualmente ‘disponibile’ per la vendita, con poco meno della metà di questa quantità di BTC spot.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1687848664woc-26-06.png" alt=""></p>
<p>Possiamo anche dimostrare l’interrelazione tra l’andamento dei prezzi e le variazioni di questi componenti di Hot Supply e Perpetual Open Interest. Il grafico qui sotto analizza la Variazione netta della posizione a 90 giorni in queste regioni, dove possiamo identificare la direzione e l’entità del flusso di capitale dentro e fuori il mercato.</p>
<p>Durante i passati mercati rialzisti e i gravi eventi di capitolazione, di solito vengono impiegati sul mercato tra 250k e 500k BTC di valore. Durante i lunghi mercati ribassisti, si accumula un volume simile e viene tolto dal mercato abbastanza a lungo da uscire da questa Hot Supply cohort (acquistata e detenuta dai HODLers).</p>
<p><img src="https://gimg2.gateimg.com/image/article/1687849000woc-26-07-1-.png" alt=""></p>
<p>L’impatto sull’azione dei prezzi derivante da queste espansioni nell’offerta calda è mostrato nel grafico qui sotto. Ci sono stati sette importanti <a href="/price/waves-waves" rel="nofollow noopener noreferrer" target="_blank">Onde</a> di afflusso di capitale negli ultimi 5 anni, con una variazione di entità compresa tra 400k BTC e 900k BTC per trimestre. Questi sono stati associati a movimenti di mercato tra il 26% e il 154%.</p>
<p>Da questo grafico, possiamo anche confrontare il potenziale impatto della liquidazione delle principali fonti di approvvigionamento come i fondi Mt. Gox (137k BTC) e confiscati <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> detenuto dal governo degli Stati Uniti (204k BTC). Da questo possiamo vedere che un singolo trimestre di flussi di domanda simili potrebbe essere in grado di assorbire l’intera distribuzione da entrambe le fonti.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1687849285woc-26-08.png" alt=""></p>
<h2 id="h2-Reagire20alla20base20di20costo20onchain369336"><a name="Reagire alla base di costo on-chain" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Reagire alla base di costo on-chain</h2><p>Nel nostro rapporto WoC 18, abbiamo illustrato l’importanza del comportamento dei detentori a breve termine durante i punti di svolta del ciclo. Attraverso il 2023, ci sono stati due importanti intersezioni tra il prezzo e la base di costo dei detentori a breve termine 🔴 dove ha fornito un forte supporto.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1687849028woc-26-09.png" alt=""></p>
<p>Il tasso di variazione settimanale sia per il costo di base del detentore a lungo termine 🟦 che per il detentore a breve termine 🟥 è sceso quasi a zero la scorsa settimana, riflettendo un equilibrio stabile raggiunto intorno a $26k. Ciò suggerisce che la psicologia degli investitori si sia spostata lontano dalla mentalità negativa del 2022 e verso una percezione dei livelli di pareggio come opportunità per costruire una posizione, anziché per uscire dalla liquidità.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1687849300woc-26-10.png" alt=""></p>
<p>Possiamo anche vedere una forte reazione nell’indicatore MVRV dei detentori a breve termine, che reagisce fortemente al livello di pareggio di MVRV = 1.</p>
<p>Questo rapporto è attualmente a 1,12, suggerendo che, in media, il gruppo di detentori a breve termine si trova su un profitto del 12%. Il rischio di correzioni di mercato tende ad aumentare quando questa metrica supera i livelli tra 1,2 (~$33,2k) e 1,4 (~$38,7k), poiché gli investitori ottengono profitti irrealizzati sempre più grandi.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1687849346woc-26-10-1-.png" alt=""></p>
<p>Per concludere, guardiamo al comportamento di spesa dei detentori a breve termine YTD, presentato nell’indicatore STH-SOPR. Abbiamo tracciato bande superiori e inferiori utilizzando bande di deviazione standard di 90 giorni ± come strumento per identificare i punti di reazione probabili. In molteplici occasioni nelle settimane recenti, possiamo identificare l’esaurimento delle vendite spot che si verifica al di sotto della banda inferiore 🟢, compreso l’ultimo minimo fissato a $25,1k prima della ripresa al di sopra dei $30k.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1687849375woc-26-12.png" alt=""></p>
<h2 id="h2-Sommario20e20Conclusioni818583"><a name="Sommario e Conclusioni" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Sommario e Conclusioni</h2><p>Con l’impennata delle domande di ETF di grado istituzionale presentate negli Stati Uniti, abbiamo visto segni precoci di un revival della domanda guidata dagli Stati Uniti. Ciò arriva dopo un periodo di debolezza relativa della domanda statunitense nel 2023, con le principali borse in Asia che registrano la più forte accumulazione dell’anno fino a oggi.</p>
<p>Con la prospettiva di un nuovo grande acquirente di spot BTC in gioco, abbiamo sviluppato un framework per valutare il volume disponibile dell’offerta di BTC, e un toolkit per valutare l’espansione (o contrazione) della nuova domanda.</p>
<p>Chiudiamo esaminando il comportamento della coorte dei detentori a breve termine e osserviamo che la loro psicologia di mercato sembra essersi spostata dai bassi del mercato ribassista del 2022. Le loro azioni indicano una nuova percezione dei livelli di ‘pareggio’ come un’opportunità per aggiungere posizioni, piuttosto che liquidare in qualsiasi liquidità di uscita disponibile.</p>
<p><strong>Disclaimer: Questo rapporto non fornisce alcun consiglio di investimento. Tutti i dati sono forniti esclusivamente a scopo informativo ed educativo. Nessuna decisione di investimento deve basarsi sulle informazioni fornite qui e sei completamente responsabile delle tue stesse decisioni di investimento.</strong></p>
<div class="blog-details-info"><br><div>Autore: Glassnode Insights<br><div>Editor: Team 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