R2xhc3Nub2RlIEluc2lnaHRzOiBFc2F1cmltZW50byBlIEFwYXRpYQ==

<p><img src="https://gimg2.gateimg.com/image/article/1692174593SDFX.jpeg" alt=""></p>
<h2 id="h2-Sommario20esecutivo433089"><a name="Sommario esecutivo" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Sommario esecutivo</h2><p>Il mercato degli asset digitali continua a scambiare all’interno di un regime di volatilità storicamente bassa, con diversi indicatori che indicano un’apatia estrema e un’esaurimento raggiunto nell’intervallo di $29k a $30k.</p>
<p>Ci sono alcuni indicatori che il mercato è leggermente ‘sovraccarico’ come indicato dalla concentrazione di offerta a breve termine e base di costo intorno al prezzo attuale.</p>
<p>Esploriamo diverse nuove iterazioni di SOPR per fascia di età come strumento per monitorare il comportamento di vendita di profitto da parte di diverse sezioni trasversali del mercato.</p>
<p><img src="https://gimg2.gateimg.com/image/article/169217462600_cover-3.png" alt=""></p>
<h2 id="h2-Modeste20flussi20di20capitale72763"><a name="Modeste flussi di capitale" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Modeste flussi di capitale</h2><p>Il Realized Cap è una delle metriche più importanti nel toolbox di analisi on-chain, rappresentando l’afflusso cumulativo di capitale sin dalla sua creazione. Sia la magnitudo che il gradiente del Realized Cap sono informativi, suggerendo che oltre 16 miliardi di dollari (+4,1%) sono stati investiti. <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> YTD.</p>
<p>Tuttavia, possiamo anche vedere che la salita è piuttosto bassa, ben lontana dal forte aumento visto durante il trend rialzista del 2021-22. Ciò indica che, mentre il capitale affluisce, lo fa a un ritmo molto modesto.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1692174656Group-137691307--1-.png" alt=""></p>
<p>Possiamo scomporre il Realized Cap nei componenti Long-Term e Short-Term Holder. La ricchezza detenuta dalla coorte STH ha registrato un aumento di +$22 miliardi quest’anno, mentre la coorte LTH ha subito una riduzione approssimativamente equivalente di -$21 miliardi.</p>
<p>Questo riflette due meccanismi:</p>
<p>I detentori a breve termine inseguono il mercato al rialzo, creando una base di costo medio elevata.</p>
<p>Fornitura acquisita a prezzi inferiori a $24k nel Q1 maturando nello status LTH, portando ad una base di costo media in declino.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1692174694Group-137691310--1-.png" alt=""></p>
<p>Possiamo vedere questo all’interno delle stime della base di costo per ciascuna coorte. La base di costo di STH è aumentata del +59% YTD, attualmente scambiata a $28.6k. La base di costo di LTH è molto più bassa, intorno a $20.3k.</p>
<p>La separazione tra queste due basi di costo è un indicatore del fatto che molti acquirenti recenti hanno un prezzo di acquisto relativamente elevato.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1692174718Group-137691311--1-.png" alt=""></p>
<p>Possiamo confermarlo utilizzando la distribuzione URPD suddivisa in queste due coorti. Si noti come un grande gruppo di monete 🔴 STH si trovi tra $ 25k e $ 31k. Su scala macro, questa distribuzione dell’offerta assomiglia a periodi simili durante le riprese del mercato ribassista in passato. Tuttavia, su un orizzonte temporale più breve, si potrebbe sostenere che si tratti di un mercato leggermente più alto, con molti investitori sensibili ai prezzi che rischiano di cadere in una perdita non realizzata.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1692174747Untitled1.png" alt=""></p>
<p>Notiamo che la fornitura detenuta dai Long-Term Holders continua ad aumentare, raggiungendo un ATH di 14,6M BTC. In netto contrasto, l’offerta di Short-Term Holder è diminuita fino a raggiungere un minimo pluriennale di 2,56M BTC.</p>
<p>In generale, ciò suggerisce che la convinzione degli investitori di <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> rimane impressionantemente alta e in pochi sono disposti a liquidare le proprie posizioni.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1692174777Group-137691309--1-.png" alt=""></p>
<h2 id="h2-Apatia20Esaurimento20e20Mancanza20di20Volatilit956263"><a name="Apatia, Esaurimento e Mancanza di Volatilità" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Apatia, Esaurimento e Mancanza di Volatilità</h2><p>Come abbiamo trattato nella edizione della settimana scorsa (WoC 32), la volatilità dei prezzi per BTC è crollata ai minimi storici. Attualmente le bande di Bollinger superiori e inferiori sono separate solo dal 2,9%, con una minore dispersione osservata solo in due occasioni nella storia:</p>
<p>Settembre 2016 - Il prezzo era di $604 ed è stato all’inizio dell’impennata del 2016-17.<br>Gennaio 2023 - Il prezzo era di $16.8k e ha negoziato all’interno di un range di $52 per iniziare l’anno (WoC 2).</p>
<p><img src="https://gimg2.gateimg.com/image/article/1692174810Group-137691333.png" alt=""></p>
<p>Un altro modo per osservare questa compressione della volatilità (esaurimento degli investitori) è tramite il comportamento di spesa degli investitori. Qui utilizziamo il Valore Realizzato come misura all’interno del seguente quadro:</p>
<p>L’alta volatilità motiva gli investitori a spendere le monete che sono state acquisite ad un costo di base molto più alto (in perdita) o più basso (in profitto) rispetto al tasso di cambio spot.</p>
<p>La bassa volatilità (e l’esaurimento degli investitori) fa sì che la maggior parte delle monete trasferite in catena abbiano un costo molto vicino al tasso di mercato (e quindi realizzino un profitto/perso molto piccolo).</p>
<p>Uno strumento ideale per monitorare questo è il Sell-Side Risk Ratio, che confronta il valore assoluto del profitto o della perdita effettiva (il cambiamento nella valutazione dell’attivo) con il limite effettivo (valutazione dell’attivo). Per gli STH, possiamo vedere che questa metrica è effettivamente ai minimi storici, con meno di 27 giorni di negoziazione (0,57%) che registrano un valore inferiore.</p>
<p>Ciò indica che tutti gli investitori che cercavano di trarre profitto o perdita in questo intervallo di prezzo lo hanno fatto, e il mercato deve compiere un movimento per motivare nuove spese (cioè un indicatore di imminente volatilità).</p>
<p><img src="https://gimg2.gateimg.com/image/article/1692174843Group-137691312--1-.png" alt=""></p>
<p>Il rapporto tra profitto e perdita a breve termine mostra che il prelievo di profitti rimane dominante per questa categoria, tuttavia si è raffreddato tornando verso la neutralità nelle ultime settimane. Se flussi di domanda sufficienti entrano, questo rapporto dovrebbe rimanere al di sopra di 1. Tuttavia, se le perdite iniziano ad accelerare (il rapporto P/L scende al di sotto di 1), potrebbe indicare che lo stress all’interno del ‘mercato fortemente sbilanciato’ sta iniziando a manifestarsi.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1692174867Group-137691313--1-.png" alt=""></p>
<p>Se ci rivolgiamo alla coorte LTH, possiamo anche vedere che si trovano anche all’interno di un regime guidato dal profitto, avendo appena recuperato dalle gravi perdite durante il mercato ribassista del 2022. Il rapporto profitto/perdita LTH rimane di piccole dimensioni e molto lontano dalle condizioni precedenti del mercato rialzista.</p>
<p>Solo 472 / 4963 (9,5%) di tutti i giorni di trading redditizi hanno registrato un valore inferiore, evidenziando la giovinezza di questo trend al rialzo.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1692174893Group-137691316--1-.png" alt=""></p>
<p>Il rapporto di rischio di vendita a lungo termine sta anche spingendo verso minimi storici, con solo 44 giorni di negoziazione (1,1%) registrando un valore più basso. Nel complesso, questo suggerisce che è probabile che sia necessaria volatilità e espansione dei prezzi (in entrambe le direzioni) per rompere questo periodo di apatia ed esaurimento degli investitori.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1692174916Group-137691314--2-.png" alt=""></p>
<h2 id="h2-La20temperatura20di20alimentazione102452"><a name="La temperatura di alimentazione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>La temperatura di alimentazione</h2><p>L’analisi del bilancio dell’offerta e della domanda di Bitcoin spesso utilizza la dimensione del ‘tempo di possesso dell’investitore’, tenendo conto del tempo trascorso dall’ultima volta che una moneta è stata spostata sulla catena. Spesso possiamo correlare questi intervalli di età alla convinzione dell’investitore, come nel caso dell’euristica a lungo/corto termine a 155 giorni (ricerca qui).</p>
<p>Possiamo anche considerare l’offerta in un quadro leggermente diverso per identificare gli spostamenti di mercato:</p>
<p>🔴<br><strong>Fornitura calda (&lt; 1w)</strong> è la parte più attiva e liquida che è stata transata negli ultimi 7 giorni.</p>
<p>🟠<br><strong>Fornitura calda (1w-6m)</strong> comprende il componente meno attivo dell’offerta a breve termine, fino all’inizio della coorte dei detentori a lungo termine.</p>
<p>🔵<br><strong>Detentori a lungo termine di un singolo ciclo (6m-3y)</strong> essendo l’offerta che è stata transatta negli ultimi tre anni ed è quindi ragionevolmente probabile che risponda alle tendenze di mercato macro (vedere il nostro rapporto dettagliato su questa coorte qui).</p>
<h3 id="h3-Offerta20calda20lt20120settimana328736"><a name="Offerta calda (< 1 settimana)" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Offerta calda (&lt; 1 settimana)</h3><p>Iniziando con le monete più attive e liquide, possiamo vedere che l’offerta calda rappresenta attualmente solo il 2,8% di tutto il valore investito detenuto in BTC. Questo è in linea con i periodi di ‘illiquidità’ estremamente visti dopo tutti i mercati orsi tardivi. Descrive un mercato in cui rimangono solo i membri del gruppo HODLer e i volumi di scambio tendono ad essere estremamente bassi.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1692175008Group-137691334.png" alt=""></p>
<p>Di recente abbiamo introdotto il supporto di Workbench per il Realized Cap HODL <a href="/price/waves-waves" rel="nofollow noopener noreferrer" target="_blank">Onde</a> e grafici simili a più righe). Possiamo utilizzare questo strumento per calcolare la base di costo per l’offerta calda e confrontarla con quella della coorte dei detentori a breve termine. Da ciò possiamo identificare due interessanti elementi della struttura di mercato:</p>
<p>Il costo base STH tende a fornire supporto nei trend al rialzo poiché gli investitori acquistano vicino al loro punto di pareggio durante le correzioni.<br>Grandi deviazioni tra il costo base dell’offerta calda e il costo base STH spesso si allineano con i massimi di mercato locali.</p>
<p>Quest’ultimo punto è il risultato degli speculatori che inseguono il prezzo verso picchi locali, aumentando la base di costo dell’offerta calda, ma aumentando il volume di offerta a rischio di un ritiro. Ciò può creare una pausa nel rally a breve termine fino a quando non torna una domanda sufficiente durante la correzione.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1692175039Group-137691335.png" alt=""></p>
<p>Se guardiamo alla famiglia SOPR per Hot Supply, possiamo vedere che questo si ripercuote sul loro comportamento nel prendere i profitti:</p>
<p>🔴 Le monete &lt; 24h tendono ad essere spese vicino al loro prezzo di pareggio.</p>
<p>Le monete 1d-1w prendono profitto (SOPR &gt; 1) durante le crescite e i massimi di mercato locali.</p>
<p>🟢 Le monete da 1w-1m vedono un picco di redditività simile, anche se con un’ampiezza maggiore a causa del tempo di detenzione più lungo (e quindi un delta di prezzo maggiore dall’acquisizione).</p>
<p>Questo primo lavoro sulle varianti SOPR per fasce d’età fornisce un’interessante visione della struttura dell’offerta e della domanda che si svolge giorno dopo giorno.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1692175074Group-137691326--1-.png" alt=""></p>
<h2 id="h2-Fornitura20Calda886115"><a name="Fornitura Calda" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Fornitura Calda</h2><p>Passando al gruppo Warm Supply (1w-6m), possiamo vedere un lieve aumento YTD, che rappresenta circa il 30% della ricchezza conservata in Bitcoin.</p>
<p>Sebbene questo valore sia significativo in termini di grandezza, è estremamente basso in un contesto comparativo. Per estensione, la piccolissima proporzione di ricchezza detenuta sia nella fornitura Hot che nella fornitura Warm indica che le detenzioni più significative si trovano nella fornitura a lungo termine più matura.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1692175108Group-137691336.png" alt=""></p>
<p>Dato che l’approvvigionamento caldo rappresenta la maggior parte dell’intervallo di età (e del volume di monete) all’interno della coorte dei detentori a breve termine, la base di costo media è molto simile a quella degli STH. Se lo guardiamo attraverso il rapporto MVRV dell’approvvigionamento caldo, possiamo vedere che si sta avvicinando a un retest del suo livello di pareggio a $27.6K.</p>
<p>Ciò supporta ulteriormente le osservazioni del Sell-side Risk Ratio della sezione precedente, dove è probabile che si stia preparando la volatilità.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1692175120Group-137691328--1-.png" alt=""></p>
<p>Le pause prolungate al di sopra o al di sotto della base di costo dell’offerta calda si sono storicamente allineate con uno spostamento macro nella tendenza di mercato, con la media della tendenza al rialzo che dura 227 giorni e una media della tendenza al ribasso che dura 132 giorni.</p>
<p>Il rally del 2023 ha ora superato questo modello per 212 giorni fino ad oggi, rimanendo leggermente al di sopra di esso oggi.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1692175152Group-137691327--1-.png" alt=""></p>
<p>La forza di mercato del 2023 è stata sfruttata con successo, con il ritiro dei profitti visibile in tutti i componenti del SOPR all’interno del gruppo di approvvigionamento caldo. La moneta spesa media si sta bloccando tra il 4% e il 9% di profitto negli ultimi mesi.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1692175176Group-137691330--1-.png" alt=""></p>
<h2 id="h2-Detentori20a20lungo20termine20a20ciclo20singolo814452"><a name="Detentori a lungo termine a ciclo singolo" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Detentori a lungo termine a ciclo singolo</h2><p>L’ultima coorte sono i detentori a lungo termine del ciclo singolo. Questa coorte comprende gli investitori che hanno resistito a tutta la gamma di eccitazione, caos e volatilità del ciclo 2020-23.</p>
<p>HODLing rimane la dinamica di mercato preferita per questo gruppo, rappresentando oltre il 63% del capitale investito. Ciò ha raggiunto altezze simili alle fasi di transizione passate tra i mercati orsi di fase avanzata e nuove macro tendenze al rialzo.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1692175206Group-137691323--1-.png" alt=""></p>
<p>Il costo base di questi detentori di ciclo singolo è attualmente di $33.8k, suggerendo che questo gruppo sta ancora sostenendo una perdita media non realizzata del -13.3%. Questo si confronta con la media LTH con un costo base di $20.4k e un profitto non realizzato del +43.6%.</p>
<p>Dato che la coorte classica LTH include un’offerta a lungo dormiente, perduta e profondamente HODLed, gran parte della quale porta un enorme profitto non realizzato, è probabile che sottovaluti il vero prezzo di acquisizione dell’investitore medio con alta convinzione. Come tale, suggerisce che gran parte del mercato del Bitcoin rimane ancora in perdita sulle loro posizioni e che il danno del mercato bear del 2022 continua a svolgere un ruolo significativo nel guidare le decisioni degli investitori.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1692175239Group-137691337.png" alt=""></p>
<p>Infine, vediamo una divergenza molto interessante tra le varianti di SOPR all’interno di questo gruppo:</p>
<p>🟡 6m-12m SOPR descrive gli investitori che acquisiscono monete tra agosto 2022 (dopo il crollo di LUNA e 3AC) e febbraio 2023. Questo gruppo sta attualmente fissando un profitto medio del +27% (acquirenti a prezzi minimi del ciclo).</p>
<p>🟤 Il SOPR di 1-2 anni descrive gli investitori dall’agosto 2021 all’agosto 2022, che registrano ancora perdite medie superiori al -21% (principalmente acquirenti al ciclo di picco).</p>
<p>🟣 Il SOPR a 2-3 anni oscilla intorno al pareggio e cattura gli investitori da agosto 2020 ad agosto 2021 con prezzi che vanno da $10k a $64k (gli acquirenti del mercato toro).</p>
<p>Questo dimostra che la grande maggioranza dei LTH sta effettivamente effettuando transazioni in perdita e solo quelli del gruppo di età compreso tra i 6 mesi e 1 anno sono in un grado significativo di profitto.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1692175403Group-137691332--1-.png" alt=""></p>
<h2 id="h2-Sommario20e20Conclusioni95886"><a name="Sommario e Conclusioni" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Sommario e Conclusioni</h2><p>La volatilità nello spazio degli asset digitali rimane storicamente bassa, con gli investitori che raggiungono un livello minimo assoluto di disponibilità a spendere monete in blockchain. Le condizioni del mercato del Bitcoin continuano a somigliare alla depressione del mercato orso vista nei cicli precedenti, con una grande quantità di ricchezza detenuta da detentori di lungo termine con una forte convinzione.</p>
<p>Tuttavia, con questa bassa volatilità arriva apatia ed esaurimento, che spesso comporta un flusso relativamente debole della domanda. Il Realized Cap sta salendo, ma solo molto leggermente, suggerendo che un mercato molto noioso, increspato e laterale possa rimanere sulla strada davanti. Questo è probabilmente aggravato dal fatto che la grande maggioranza del mercato del Bitcoin è ancora in perdita sulle loro posizioni e probabilmente creerà resistenza durante il recupero.</p>
<p><strong>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 unicamente responsabile delle tue decisioni di investimento.</strong></p>
<div class="blog-details-info"><br><div>Autore: Glassnode Insights<br><div>Editor: Team 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>