R2xhc3Nub2RlIEluc2lnaHRzOiBsYSBmaWR1Y2lhIGRlZ2xpIGludmVzdGl0b3JpIHNjZW5kZQ==

<p><img src="https://gimg2.gateimg.com/image/article/1695108350SDFX 1.jpeg" alt=""></p>
<h2 id="h2-Sommario20esecutivo405117"><a name="Sommario esecutivo" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Sommario esecutivo</h2><p>Rivediamo la posizione di mercato rispetto a due modelli di prezzo on-chain, entrambi intersecati durante i minimi ciclici passati e nella vendita di marzo 2020.</p>
<p>I modelli di accumulo e distribuzione tendono ad allinearsi con i massimi e minimi locali e mostriamo come ciò si manifesta nei dati on-chain.</p>
<p>Una maggioranza superiore di detentori a breve termine è ora in perdita sulla loro posizione, con un nuovo indicatore che suggerisce che il sentiment negativo dominano in questa categoria al momento.</p>
<p><img src="https://gimg2.gateimg.com/image/article/169510836500_cover-4.png" alt=""></p>
<h2 id="h2-Trova20Piani134007"><a name="Trova Piani" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Trova Piani</h2><p>La <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Il mercato continua a languire intorno ai $26k, dopo che i prezzi non sono riusciti a mantenersi al di sopra del livello di metà ciclo intorno ai $31.4k. Entrambi i tentativi in aprile e luglio hanno effettivamente creato un modello a doppio top nei prezzi. Tra gli altri indicatori relativi ai detentori a breve termine trattati la scorsa settimana (WoC 37), ciò potrebbe suggerire che il mercato stia vivendo una fase iniziale di cambiamento nella psicologia e fiducia di mercato.</p>
<p>Il grafico qui sotto presenta due modelli di prezzi:</p>
<p>🟢<br><strong>Prezzo dell’investitore</strong>($17,6k), che riflette il prezzo medio di acquisizione per tutte le monete escluse quelle acquisite dai minatori (cioè nei mercati secondari).</p>
<p>🟣<br><strong>Prezzo Delta</strong>($11.1k), che è un modello di pricing combinato on-chain e tecnico, spesso utilizzato per modellare i minimi ciclici.</p>
<p>L’azione del prezzo in entrambi i cicli 2018-19 e 2022-23 ha trascorso una quantità simile di tempo scambiando all’interno di questi modelli di prezzo ai minimi. Da notare che il mercato ha rivisitato il livello di prezzo degli Investitori durante il caos del sell-off di marzo 2020.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1695108438woc-38-00.png" alt=""></p>
<p>Oltre alla durata trascorsa tra questi modelli, possiamo anche misurare la compressione e l’espansione tra questi modelli di prezzo come indicatore per il recupero del mercato. La distanza tra questi modelli si comprimerà vicino ai massimi ciclici con grandi volumi di capitale. <a href="/price/flow-flow" rel="nofollow noopener noreferrer" target="_blank">Flusso</a> nel mercato. Al contrario, la divergenza indica un flusso di capitale più morbido, in cui i prezzi in calo diventano il fattore trainante.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1695108461image-3.png" alt=""></p>
<p>Questo modello può essere utilizzato per monitorare la transizione dalla fase più profonda di un mercato orso verso una ripresa di mercato. Da questo possiamo vedere che la struttura di mercato prente è simile alla fase di decompressione osservata nel 2016 e anche nel 2019.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1695108486woc-38-01.png" alt=""></p>
<h2 id="h2-Cicli20di20rotazione20del20capitale400171"><a name="Cicli di rotazione del capitale" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Cicli di rotazione del capitale</h2><p>Il Realized HODL Ratio (RHODL) è un indicatore di mercato che tiene traccia del saldo della ricchezza investita detenuta all’interno di monete recentemente spostate (&lt; 1 settimana) e di HODLer più maturi (1-2 anni). Nel grafico seguente, abbiamo applicato un valore soglia di 2 anni (mezzo ciclo) come valore soglia per i periodi in cui i regimi di flusso di capitale passano dalla struttura di mercato rialzista a quella ribassista.</p>
<p>Possiamo vedere che secondo questa misura, il 2023 ha visto un modesto afflusso di nuovi investitori, tuttavia, il Rapporto RHODL è solo appena in competizione con il livello mediano di 2 anni. L’afflusso di nuovi investitori è positivo ma relativamente debole in termini di slancio.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1695108508woc-38-02.png" alt=""></p>
<p>Possiamo anche visualizzare questo flusso di capitali positivo ma morbido sfruttando il Punteggio della Tendenza di Accumulo. Questo strumento riflette il cambiamento del saldo relativo degli investitori attivi negli ultimi 30 giorni.</p>
<p>Qui possiamo vedere che il rally di ripresa del 2023 è stato alimentato da una significativa accumulazione nei massimi locali sopra i $30k. Questo descrive un grado di FOMO 🔴 da parte degli investitori. Questo è in contrasto con gli eventi di capitulazione nella seconda metà del 2022, dove i nuovi investitori hanno colto l’opportunità e accumulato ai minimi 🟢.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1695108720woc-38-05.png" alt=""></p>
<p>Ingrandendo questo comportamento vicino ai massimi di mercato recenti, possiamo utilizzare gli indicatori di profitto e perdita realizzati per valutare improvvisi cambiamenti nella redditività degli investitori. Le metriche di profitto e perdita realizzati misurano la variazione del valore di tutte le monete spese, confrontando il valore a disposizione con il valore all’acquisizione. Il grafico qui sotto mostra la somma settimanale di profitto realizzato 🟩 e perdita 🟥, normalizzata per la capitalizzazione di mercato per confrontare i cicli.</p>
<p>Qui possiamo vedere che si verifica una convergenza tra questi periodi di intensa accumulazione e di elevati incassi. Entrambi erano presenti ai massimi locali nel 2023, e una simile convergenza esiste ai picchi di mercato del 2021 in gennaio e dicembre.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1695108736woc-38-03.png" alt=""></p>
<h2 id="h2-Titolari20subacquei88673"><a name="Titolari subacquei" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Titolari subacquei</h2><p>Nell’edizione della scorsa settimana, abbiamo esaminato un insieme di metriche che esplorano come una significativa proporzione dei detentori a breve termine ora detenga monete con perdite, mostrato di seguito come percentuale dell’approvvigionamento STH in profitto 🔵.</p>
<p>Durante i mercati ribassisti, quando oltre il 97,5% dell’offerta acquisita dai nuovi investitori è in perdita 🟥, la possibilità di esaurimento del venditore aumenta esponenzialmente. D’altra parte, quando oltre il 97,5% dell’offerta a breve termine è in profitto, questi attori tendono a sfruttare l’opportunità e ad uscire in pareggio o con un profitto 🟩.</p>
<p>Durante il rally sopra i $30k, questa metrica ha raggiunto una completa saturazione dei profitti per la prima volta dall’ultimo massimo storico di novembre 2021. Tuttavia, dopo essere sceso al di sotto dei $26k nelle settimane recenti, oltre il 97,5% dell’offerta di STH è ora detenuta in perdita, raggiungendo il livello più basso dal crollo di FTX.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1695108825woc-38-04.png" alt=""></p>
<p>Con così tanti Short-Term Holder ormai sott’acqua, possiamo valutare la loro posizione utilizzando due potenti metriche:</p>
<p><strong>STH-MVRV</strong> che descrive l’entità del Profitto/Perdita Non Realizzata detenuta e una misura dell’incentivo finanziario per vendere.</p>
<p><strong>STH-SOPR</strong> che descrive l’entità del Profitto/Perdita Realizzati bloccati, fornendo un indicatore della pressione effettiva sul lato venditore.</p>
<p>Partendo da STH-MVRV, possiamo valutare gli estremi in questo indicatore rispetto alla sua media di 155 giorni️, così come una Banda Superiore (media più una deviazione standard) 🟢 e una Banda Inferiore (media meno una deviazione standard) 🔴.</p>
<p>Possiamo vedere che diversi dei massimi e minimi di mercato recenti sono avvenuti insieme a deviazioni significative al di fuori di questi limiti. Ciò indica che gli investitori recenti erano in un grado statisticamente elevato di profitto o perdita al momento.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1695108967woc-38-06.png" alt=""></p>
<p>Possiamo osservare un comportamento simile nell’indicatore STH-SOPR, che indica che anche questi investitori stavano agendo, optando per realizzare profitti vicino ai massimi e vendere monete a una perdita statisticamente significativa vicino ai minimi.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1695109013woc-38-07.png" alt=""></p>
<h2 id="h2-Cambiamento20di20fiducia894940"><a name="Cambiamento di fiducia" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Cambiamento di fiducia</h2><p>Ora che abbiamo stabilito una relazione tra cambiamenti improvvisi nella redditività implicita (non realizzata) e lo spostamento della spesa da parte degli STH (redditività realizzata), introdurremo ora un metodo per valutare la direzione del trend di questa relazione.</p>
<p>L’obiettivo è quello di valutare le maree del cambio di sentiment per i nuovi investitori, costruito guardando la deviazione tra la base di costo di due sottogruppi; detentori e spenditori.</p>
<p>🟥<br><strong>Sentimento negativo</strong> è quando la base di costo degli spenditori è<br><strong>inferiore</strong> di detentori.</p>
<p>🟩<br><strong>Sentimento positivo</strong> è quando la base di costo degli spenditori è<br><strong>più alto</strong> di detentori.</p>
<p>Da questa prospettiva, possiamo vedere che la base di costo degli STH che stanno spendendo è scesa al di sotto della base di costo dei detentori mentre il mercato vendeva da $29k a $26k a metà agosto. Questo suggerisce un grado di panico e sentimento negativo che si è impadronito nel breve termine.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1695109085woc-38-08.png" alt=""></p>
<p>Per visualizzare meglio questo indicatore, abbiamo normalizzato questa metrica in base al prezzo spot.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1695109139image-4.png" alt=""></p>
<p>Notevolmente, l’intervallo macro per questo indicatore è per lo più compreso tra gli estremi di -0,25 e 0,25, con occasionali picchi fuori dall’intervallo al punto di inversione estremo del mercato. Qui trascureremo anche l’intervallo di transizione neutrale di -0,05 a 0,05 🟧 (che è arbitrario)</p>
<p>Il primo punto chiave è che gli intervalli di sentiment negativo durante il recupero dal mercato orso di solito durano tra 1,5 e 3,5 mesi. Come osservato, il mercato è di recente entrato nel primo intervallo di sentiment negativo dal termine del 2022.</p>
<p>Gli analisti possono prendere in considerazione questo strumento durante il monitoraggio di cambiamenti positivi nel sentimento STH. Se la tendenza inizia a salire verso il territorio di transizione e poi positivo (&gt; -0.05), ciò suggerirebbe che il capitale sta iniziando a tornare nel mercato e i detentori sono di nuovo in una posizione più favorevole.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1695109179woc-38-09.png" alt=""></p>
<h2 id="h2-Sommario20e20conclusioni244608"><a name="Sommario e conclusioni" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Sommario e conclusioni</h2><p>Il mercato del <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> sta vivendo un cambiamento non banale nel sentimento, con quasi tutti i titolari a breve termine ora in perdita sul loro approvvigionamento. Ciò ha comportato un cambiamento negativo nel sentimento, con gli investitori che spendono ora con un costo inferiore rispetto al resto del gruppo. Ciò suggerisce che un certo grado di panico sta dominando questo gruppo, che è la prima volta da quando FTX è collassato.</p>
<p>Diversi indicatori suggeriscono che il 2023 ha visto un afflusso positivo, ma a basso momentum, di nuovo capitale e nuovi investitori. Questo fa riferimento alla persistente incertezza derivante dalle condizioni macroeconomiche, dalle pressioni regolamentari e dalla strettezza della liquidità in tutti i mercati.</p>
<p><strong>Avviso: 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.</strong></p>
<div class="blog-details-info"><br><div>Autore: Glassnode Insights<br><div>Redattore: Squadra del Blog di Gate.io<br><div class="info-tips">*Questo articolo rappresenta solo le opinioni del ricercatore e non costituisce alcun suggerimento di investimento.<p></p><br></div></div></div></div>