R2xhc3Nub2RlIEluc2lnaHRzOiBNYXJlZSBDYW1iaWFudGk=

2023-02-07, 03:59
<p><img src="https://gimg2.gateimg.com/blog/167117004537106004920221216-135350.jpeg" alt=""></p>
<p>Dopo un mese esplosivo di azioni volatili dei prezzi, <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Alessio</a> sta consolidando al di sopra della base di costo on-chain di diverse coorti. Nonostante un calo del -6,2% a un minimo settimanale di $22,6k, il detentore medio di BTC sta ora mantenendo un profitto non realizzato, con diversi indicatori on-chain su scala macro che suggeriscono un potenziale cambio di tendenza di mercato in corso.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1675741648Group-2661.png" alt=""></p>
<p>In questa edizione, esploreremo questo dal punto di vista dell’attività di spesa in risposta all’ultimo aumento dei prezzi, considerando un’ampia sezione trasversale del mercato. L’obiettivo è identificare modelli comportamentali emergenti per valutare lo spostamento delle maree macro. Indagheremo anche se l’incentivo a vendere sta iniziando a prere sul costo opportunità di HODLing (e come possiamo identificare questo cambio), nonché la relazione tra partecipanti maturi e nuovi, poiché i capitali iniziano a cambiare di mano.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1675741722Group-2669.png" alt=""></p>
<h2 id="h2-Un20ritorno20alla20redditivit309769"><a name="Un ritorno alla redditività" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Un ritorno alla redditività</h2><p>Inizieremo la nostra indagine analizzando i profitti realizzati bloccati dal mercato durante il ciclo più recente. Possiamo vedere un’esplosione nel prendere i profitti dopo ottobre 2020 in risposta a politiche monetarie straordinarie. Questo può essere visto diminuire drasticamente dal picco di gennaio 2021, disintossicandosi nei due anni successivi ai livelli del 2020.</p>
<p>Un recente risveglio dei profitti realizzati può essere osservato in risposta all’azione dei prezzi recenti, tuttavia rimane contenuto in risposta all’euforia sperimentata durante il ciclo 2021-22.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1675741758Group-2654--4-.png" alt=""></p>
<p>Le perdite realizzate dal mercato nello stesso periodo hanno iniziato a espandersi dopo gennaio 2021, raggiungendo un picco iniziale nella vendita di maggio 2021 (Un orso di proporzioni storiche).</p>
<p>Tuttavia, si può osservare che il livello attuale delle perdite realizzate è diminuito fino al livello di base del ciclo di circa $200M/giorno, con una contrazione complessiva del profilo di perdita escludendo eventi di capitulazione esplicita (ad es. LUNA / FTX).</p>
<p><img src="https://gimg2.gateimg.com/image/article/1675741809Group-2655.png" alt=""></p>
<p>Calcolando il rapporto tra Profitti e Perdite Realizzati, possiamo identificare i cambiamenti strutturali nella dominanza tra i due. Dopo il crollo del prezzo dopo il massimo storico di novembre 2021, è seguito un periodo dominato dalle perdite, che ha portato il rapporto tra Profitti e Perdite Realizzati al di sotto di 1, con una gravità sempre maggiore ad ogni successiva capitulazione del prezzo.</p>
<p>Tuttavia, possiamo osservare il primo periodo sostenuto di redditività dall’evento di liquidità di uscita di aprile 2022, suggerendo segni iniziali di un cambiamento nel regime di redditività.</p>
<p>🔔<strong>Idea di allerta:</strong> il rapporto P/L realizzato (7D-EMA) che torna al di sotto di 1,0 indicherebbe un aumento significativo della dominanza delle perdite realizzate, indicando una maggior spesa da parte degli investitori che detengono monete con una base di costo più elevata.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1675741854Group-2656.png" alt=""></p>
<p>Il <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> Il rapporto di rischio lato venditore è una metrica che possiamo utilizzare per confrontare l’entità del profitto e della perdita totali realizzati come percentuale del Realized Cap (una misura della valutazione della rete).</p>
<p>Da questa prospettiva, il volume combinato del profitto e della perdita realizzati rimane relativamente piccolo rispetto alla dimensione dell’attivo. Ciò indica che la magnitudine degli eventi di spesa rimane marginale in scala, specialmente rispetto all’euforia sperimentata durante il mercato rialzista e all’evento di capitolazione di FTX.</p>
<p>Nel complesso, questo suggerisce che, in generale, la maggior parte delle monete che si stanno muovendo sono state acquisite relativamente vicino al prezzo attuale, e quindi non stanno bloccando un grande ‘carico’ realizzato.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1675741886Group-2663.png" alt=""></p>
<h2 id="h2-Tornato20al20verde399557"><a name="Tornato al verde" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Tornato al verde</h2><p>Il rapporto tra profitto/perdita non realizzato netto (NUPL) mostra che la recente impennata ha lanciato il prezzo spot di <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Alessio</a> sopra il prezzo di acquisto medio del mercato più ampio. Questo riporta il mercato in un regime di profitto non realizzato, dove il detentore medio è di nuovo in positivo.</p>
<p>Confrontando la durata del NUPL negativo in tutti i passati mercati ribassisti, osserviamo una somiglianza storica tra il nostro ciclo attuale (166 giorni) e i mercati ribassisti del 2011-12 (157 giorni) e del 2018-19 (134 giorni). Il mercato ribassista del 2015-16 rimane eccezionale per quanto riguarda la durata del mercato ribassista, vivendo un regime di perdita non realizzata quasi due volte più lungo del secondo classificato (ciclo 2022-23).</p>
<p>🗜️<br><strong>Suggerimento per la postazione di lavoro</strong>: Questo grafico è sviluppato utilizzando due tracce, per i valori positivi e negativi, tracciati sullo stesso asse e utilizzando grafici a barre per riempire le aree.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1675741939Group-2665.png" alt=""></p>
<p>Il rapporto tra il profitto non realizzato totale detenuto dal mercato e la sua media annuale può quindi fornire un indicatore su scala macro per un mercato in ripresa.</p>
<p>L’ultima impennata nel prezzo ha superato diversi modelli di costo aggregati on-chain, portando a un significativo miglioramento della posizione finanziaria del mercato. Questo indicatore di momentum sta ora avvicinandosi al punto di rottura dell’equilibrio e presenta somiglianze con le riprese degli anni del mercato orso del 2015 e del 2018.</p>
<p>I rottture confermate al di sopra di questo punto di equilibrio hanno storicamente coinciso con una transizione nella struttura di mercato macro. Notiamo anche che la durata del tempo trascorso al di sotto di questo punto di equilibrio è stata simile durante i principali mercati ribassisti.</p>
<p>🗜️ <strong>Suggerimento per il banco da lavoro: </strong>Questo grafico utilizza l’impostazione predefinita della funzione value_at(m1) per restituire il valore attuale di questo indicatore di momentum.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1675741973Group-2662.png" alt=""></p>
<p>Varianti della metrica SOPR (Spent Output Profit Ratio) possono essere utilizzate per esaminare il profitto aggregato bloccato da una varietà di gruppi di mercato in qualsiasi giorno dato.</p>
<p>Per la categoria di detentori a breve termine 🔴, si può vedere che STH-SOPR sta ora scambiando su una base sostenuta sopra un valore di 1,0, mostrando il primo scoppio di presa di profitto dal marzo 2022. Ciò riflette il grande volume di monete acquisite a prezzi più bassi negli ultimi mesi.</p>
<p>Anche il mercato più ampio 🔵 ha registrato un ritorno alla spesa redditizia, riprendendosi dopo un periodo molto profondo ed esteso di pesanti perdite.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1675742006Group-2666.png" alt=""></p>
<p>Valutando la coorte dei detentori a lungo termine, possiamo osservare un regime persistente di perdite sostenute dalla caduta di LUNA. Nonostante questa coorte continui a subire perdite negli ultimi 9 mesi, ci sono segni iniziali di un recupero, con un potenziale trend al rialzo nel LTH-SOPR che sta iniziando a formarsi.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1675742034Group-2660.png" alt=""></p>
<h2 id="h2-Un20cambiamento20di20carattere50984"><a name="Un cambiamento di carattere" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Un cambiamento di carattere</h2><p>Il metrica del rischio di riserva aggiustata può essere utilizzato per contestualizzare il comportamento della classe HODLer. Questo oscillatore ciclico quantifica l’equilibrio tra l’incentivo aggregato alla vendita e la spesa effettiva di monete inattive da tempo.</p>
<p><strong>Valori più alti</strong> indica che sia il prezzo che la spesa degli HODLer sono elevati.</p>
<p><strong>Valori inferiori</strong> indica che sia il prezzo sia la spesa degli HODLer stanno diminuendo.</p>
<p>Sembra in corso un cambiamento strutturale nel trend, poiché questo oscillatore continua ad avvicinarsi alla sua posizione di equilibrio (con il 55% di tutti i giorni di negoziazione al di sotto del valore attuale). Ciò suggerisce che il costo opportunità di HODLing sta diminuendo mentre l’incentivo alla vendita sta aumentando.</p>
<p>Precedenti break-out al di sopra di questa posizione di equilibrio hanno storicamente denotato una transizione da un regime di HODLing, a uno di realizzazione di profitto in aumento, e una rotazione di capitale da vecchi accumulanti nel mercato bear, verso nuovi investitori e speculatori.</p>
<p><img src="https://gimg2.gateimg.com/image/article/167574209006_reserverisk.png" alt=""></p>
<p>Possiamo aggiungere peso a questa tesi di rotazione del capitale ispezionando le Onde Realized Cap HODL. Qui abbiamo isolato le monete detenute per 3 mesi o meno e notiamo due osservazioni chiave:</p>
<ul>
<li><p>La percentuale di ricchezza detenuta dai nuovi detentori sta aumentando, seppur marginalmente. Poiché si tratta di un sistema binario, ciò indica che la ricchezza deve essere trasferita dalle mani più anziane a quelle nuove.</p>
</li><li><p>La profondità di questo punto di svolta è molto in linea con i precedenti storici.</p>
</li></ul>
<p><img src="https://gimg2.gateimg.com/image/article/1675742185Group-2657--2-.png" alt=""></p>
<p>Successivamente, possiamo impiegare<br><strong>il rapporto di HODL realizzato</strong> per integrare ulteriormente l’osservazione sopra. Questa metrica confronta questo equilibrio della ricchezza detenuta tra le monete di 1 settimana e 1-2 anni, producendo un oscillatore su scala macro.</p>
<p><strong>Valori più elevati</strong> indica una ricchezza sproporzionata detenuta da nuovi acquirenti e speculatori.</p>
<p><strong>Valori più bassi</strong> indicano una ricchezza sproporzionata detenuta da HODLers a lungo termine e con una maggiore convinzione.</p>
<p>Quando si valuta il Realized HODL Ratio, sia il tasso di cambiamento che la direzione del trend sono generalmente di maggiore importanza rispetto al valore assoluto. Attualmente, stiamo assistendo alla formazione di una struttura a fondo arrotondato, suggerendo un trasferimento netto di ricchezza in atto, nonché l’inizio della transizione del trend al rialzo.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1675742227Group-2664.png" alt=""></p>
<p>Con questo come contesto, possiamo introdurre una nuova variante del rapporto RHODL, che confronta la ricchezza detenuta dai titolari a lungo termine del ciclo singolo (6m-2y) con i titolari a breve termine più giovani (1d-3m). Ciò cerca di valutare il punto di svolta della rotazione del capitale attraverso le transizioni del ciclo.</p>
<p>La ricchezza può lasciare solo la fascia di età compresa tra i 6 mesi e i 2 anni mediante la maturazione in una fascia di età più avanzata o tramite la spesa di monete, che a sua volta resetta l’età della moneta. Attualmente, possiamo osservare un punto di inflessione ampio e netto in questa variante del rapporto RHODL, che suggerisce una rotazione significativa e improvvisa di capitale dagli HODLers a lungo termine dell’ultimo ciclo a una nuova fascia di acquirenti.</p>
<p>Questo fenomeno di mercato è stato sorprendentemente costante durante i precedenti mercati ribassisti, con grandi inflessioni nella rotazione del capitale che segnalano un cambiamento significativo nel carattere e nella struttura del mercato.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1675742256Group-2659--1-.png" alt=""></p>
<h2 id="h2-Sommario20e20Conclusioni295582"><a name="Sommario e Conclusioni" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Sommario e Conclusioni</h2><p>Dopo un lungo e selvaggio mercato orso, segnato da eventi consecutivi di deleveraging, ci sono segnali che si è verificata una completa disintossicazione dell’euforia e che potrebbe essere in corso una transizione ciclica. Di solito questi periodi sono caratterizzati da un brusco cambiamento nella dominanza del profitto e della perdita aggregati, che sembra stia avvenendo.</p>
<p>Tuttavia, questa tendenza rimane giovane, sia dal punto di vista della durata, sia per l’entità del profitto e della perdita realizzati rispetto alle dimensioni del mercato. Come discusso in precedenza nel WoC#45, la rotazione di capitale dai detentori a lungo termine alla coorte dei detentori a breve termine è stata una tendenza persistente nell’ultimo anno. Questo si riflette elegantemente nella crescente ricchezza detenuta dalla coorte dei detentori a breve termine, che assorbe monete dai loro omologhi a lungo termine che continuano a distribuire (in genere a perdita).</p>
<p>Sembra che il mercato si trovi in una fase di transizione, che si evolve dalle ultime fasi di un orso all’inizio di un nuovo ciclo. Con i cicli passati come guida, la strada da percorrere rimane ardua, con esempi chiave come il 2015 e il 2019. Questi periodi di transizione sono stati storicamente caratterizzati da un esteso mercato macroeconomico laterale, disseminato di movimenti volatili locali, di solito in entrambe le direzioni.</p>
<p>Disclaimer: Questo rapporto non fornisce alcun consiglio di investimento. Tutti i dati sono forniti solo a scopo informativo ed educativo. Nessuna decisione di investimento deve essere basata sulle informazioni fornite qui e sei completamente responsabile delle tue decisioni di investimento.</p>
<div class="blog-details-info"><br><div>Autore: Glassnode Insights<br><div>Editore: 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