R2xhc3Nub2RlIEluc2lnaHRzOiBJbCBQcmV6em8gZGVsIFRlbXBv

2023-03-28, 02:39
<p><img src="https://gimg2.gateimg.com/image/article/1679970228Industry Analysis.jpeg" alt=""></p>
<p>Il mercato ha fatto una pausa questa settimana, con i prezzi del BTC che si consolidano in un range stretto tra $26.7k e $28.7k. Dopo la significativa fuori-dalla-storia che abbiamo coperto nell’edizione della scorsa settimana, il mercato si sta prendendo una pausa.</p>
<p>Mentre avviene questa consolidazione, ci concentreremo sulla migliore classificazione del comportamento degli investitori che prendono profitto utilizzando una varietà di strumenti on-chain:</p>
<p><strong>Ingressi di scambio</strong>, incluso un’analisi dei detentori a lungo e breve termine.</p>
<p><strong>Profitti realizzati</strong> bloccato dagli investitori che accumulano monete vicino ai minimi recenti.</p>
<p><strong>Metriche di durata della vita</strong> descrivendo l’entità della distruzione del tempo di possesso, per valutare meglio la fiducia degli investitori nell’attuale trend al rialzo.</p>
<p><img src="https://gimg2.gateimg.com/image/article/167997024200_cover-11.png" alt=""></p>
<h2 id="h2-Togliere20le20fiches20dal20tavolo635566"><a name="Togliere le fiches dal tavolo" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Togliere le fiches dal tavolo</h2><p>In risposta alla forte apprezzamento del prezzo delle ultime settimane, gli investitori hanno aumentato il volume delle monete depositate negli scambi. I flussi netti degli scambi sono aumentati di circa 4,18k BTC questa settimana, il più grande aumento netto da quando LUNA è crollata nel maggio 2022.</p>
<p><img src="https://gimg2.gateimg.com/image/article/167997036101_price-2.png" alt=""></p>
<p>Questo suggerisce che è in corso un certo grado di presa di profitto, poiché gli investitori ritirano le fiches dal tavolo. Le precedenti istanze con afflussi netti simili o più grandi durante l’ultimo ciclo, si sono tutte allineate con eventi di grande volatilità di mercato, di solito al ribasso.</p>
<p><img src="https://gimg2.gateimg.com/image/article/167997037401_exchange_netflow.png" alt=""></p>
<p>Possiamo anche valutare la suddivisione delle monete inviate agli scambi sia dai detentori a lungo termine che da quelli a breve termine, consentendoci di esplorare quali coorti stanno ottenendo profitti. Entrambi i gruppi hanno visto un aumento delle monete inviate agli scambi, raggiungendo un totale di 31k BTC questa settimana.</p>
<p><strong>I detentori a breve termine dominano il 92,5% del volume totale in entrata</strong>, con il 65% del totale costituito da monete STH in profitto.</p>
<p><strong>I detentori a lungo termine rappresentano solo il 7,5% del volume totale dei depositi</strong>, tuttavia l’80% del loro volume è in profitto, il più grande aumento dal 2021.</p>
<p><img src="https://gimg2.gateimg.com/image/article/167997043302_lthsth_toexchanges.png" alt=""></p>
<p>Complessivamente, un totale di $320M/giorno di profitti netti sono stati bloccati dal mercato sulle monete spese. Si tratta della maggior presa di profitti netti dal maggio 2022, subito prima del crollo del progetto LUNA-UST. Notiamo che l’entità dei profitti realizzati rimane comunque ben al di sotto dei livelli tipici del mercato rialzista.</p>
<p>È anche evidente che la gravità delle perdite nette è diminuita anche da luglio 2022. Questo rafforza le nostre osservazioni della settimana scorsa (WoC 12) secondo cui il mercato sembra essere tornato a una marcia più neutra e assomiglia a una struttura di mercato più transitoria.</p>
<p><img src="https://gimg2.gateimg.com/image/article/167997047003_netrealpnl.png" alt=""></p>
<p>Misurare il profitto/perdita effettivo è una tecnica potente nell’analisi on-chain, resa possibile dal timbro del prezzo delle monete quando si spostano on-chain. Da questo, possiamo confrontare l’entità del profitto bloccato nell’ultimo mese, rispetto alla media annuale. Qui, possiamo vedere che abbiamo il primo cross-over di momentum positivo da ottobre-novembre 2021 ATH.</p>
<p>Questo strumento indica in modo intuitivo i periodi di incasso pesante o leggero nei mercati rialzisti o ribassisti, rispettivamente. In particolare, si noti la forma complessiva della media mobile annuale dei profitti realizzati, che tende verso l’alto nei tori e verso il basso negli orsi.</p>
<p>Porteremo questa osservazione nel nostro prossimo argomento correlato e altrettanto potente della Durata della vita.</p>
<p><img src="https://gimg2.gateimg.com/image/article/167997054204_realprofit_momentum.png" alt=""></p>
<h2 id="h2-Tracciamento20del20tempo434071"><a name="Tracciamento del tempo" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Tracciamento del tempo</h2><p>Nella sezione precedente, abbiamo osservato come i flussi di scambio possano essere correlati al grado di profitto realizzato da diverse coorti on-chain. Possiamo anche integrare questo con un’altra serie di strumenti sotto la categoria di Durata di vita. Invece di misurare la variazione del valore di una moneta per ottenere profitto/perdita, misuriamo invece quanto tempo di detenzione viene trascorso tra l’acquisizione e lo smaltimento della moneta.</p>
<p>Quando osserviamo una forte distruzione della durata della vita, di solito significa che un gran volume di monete più vecchie si sta muovendo, aiutandoci a identificare periodi in cui investitori a lungo termine e più esperti stanno uscendo.</p>
<p>Il nostro primo punto di riferimento è valutare il panorama macro tramite la metrica di vitalità. Questa metrica definisce elegantemente il rapporto tra la distruzione della durata di vita di tutti i tempi e la creazione.</p>
<p><strong>La vivacità diminuirà</strong> quando il mercato preferisce accumulare e tenere monete, costruendo una riserva di durata di vita e<br><strong>suggerendo fiducia nell’attività.</strong></p>
<p><strong>La vivacità aumenterà</strong> quando il mercato preferisce distribuire vecchie monete e esaurire il serbatoio di vita.<br><strong>suggerendo che l’attivo è considerato costoso.</strong></p>
<p><img src="https://gimg2.gateimg.com/image/article/167997056805_liveliness.png" alt=""></p>
<p>Ricordando la forma della media annuale dei profitti realizzati, possiamo vedere che esiste una forma e una relazione molto simili con la vivacità, in gran parte poiché descrivono comportamenti di mercato simili:</p>
<p><strong>Durante i mercati rialzisti</strong>, gli investitori a lungo termine spendono monete inattive da tempo e realizzano grandi profitti. Questo alla fine porta a un’eccessiva offerta e stabilisce un massimo di mercato macro.</p>
<p><strong>Durante i mercati orsi</strong>, gli investitori a lungo termine tornano a una strategia di accumulazione lenta e ci sono meno profitti giornalieri. Questo alla fine stabilisce un fondo di ciclo.</p>
<p>Al momento, possiamo vedere entrambe le metriche rimanere in trend al ribasso a livello macro, suggerendo che la maggior parte delle monete rimane inattiva on-chain.</p>
<p><img src="https://gimg2.gateimg.com/image/article/167997075206_lioveliness_realProfit.png" alt=""></p>
<p>La metrica principale per misurare la durata della vita è Coindays Destroyed (CDD), che riflette il volume di ‘tempo di possesso degli investitori’ che viene speso ogni giorno. Nel ciclo precedente, possiamo generalmente descrivere gli aumenti di CDD in due categorie:</p>
<p>Uptrend sostenuti durante i mercati rialzisti che riflettono una pressione di distribuzione costante poiché i detentori a lungo termine incassano i profitti. Picchi bruschi durante eventi di alta volatilità, tipicamente osservati durante le vendite di mercato orso. Questi riflettono periodi di panico diffuso, poiché gli investitori spendono monete di fronte a una grande volatilità.</p>
<p>Nelle ultime settimane si è potuto osservare un modesto aumento di CDD, tuttavia l’entità della distruzione rimane ben al di sotto dei livelli tipici del mercato rialzista. Ciò indica che la moneta spesa media è ancora relativamente giovane, in linea con la nostra osservazione che i detentori a breve termine dominano nel prendere profitto al momento.</p>
<p><img src="https://gimg2.gateimg.com/image/article/167997077308_cdd.png" alt=""></p>
<p>Uno strumento utile per confrontare questo attraverso i cicli è Binary CDD, che converte la metrica CDD in un risultato di uno se la magnitudine supera una media a lungo termine (restituisce zero se non lo fa). Qui abbiamo anche levigato la traccia con una media di 7 giorni per creare un oscillatore.</p>
<p>Da questa prospettiva, il prendere profitto da parte dei detentori a lungo termine nei mercati rialzisti diventa estremamente evidente, evidenziato come periodi sostenuti di rosso e arancione. Nel nostro attuale mercato, tuttavia, ci troviamo saldamente in una fase tranquilla, tipica dei mercati ribassisti, dei tori iniziali e del periodo di transizione tra i due.</p>
<p><img src="https://gimg2.gateimg.com/image/article/167997081809_binary_cdd.png" alt=""></p>
<p>L’aumento recente del CDD è abbastanza visibile quando viene analizzato nei gruppi LTH e STH. Nonostante i Long-Term Holders contribuiscano meno al volume delle monete spese, il loro tempo di detenzione è molto più lungo e quindi tendono ad avere un’influenza eccessiva sulle metriche di durata della vita.</p>
<p>Con questa misura, il recente incasso delle vincite è anche piuttosto modesto e non ha ancora stabilito un trend rialzista sostenuto in CDD.</p>
<p><img src="https://gimg2.gateimg.com/image/article/167997094907_cdd_cohorts-1.png" alt=""></p>
<p>Zoomando sugli Short-Term Holders, l’età media di una moneta STH spesa è aumentata anche, raddoppiando effettivamente da circa 10 giorni nei mesi precedenti il fallimento di FTX, fino a 21 giorni oggi. Questo aggiunge ulteriori prove all’argomento che la categoria degli Short-Term Holder, che ha accumulato BTC vicino ai minimi di ciclo, sono i principali partecipanti dietro la recente presa di profitto.</p>
<p>Inoltre, suggerisce che gli STH siano sempre più disposti ad aspettare periodi più lunghi, suggerendo un grado di fiducia nel trend di mercato prente.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1679970999Group-2914.png" alt=""></p>
<h2 id="h2-Il20Valore20del20Tempo531883"><a name="Il Valore del Tempo" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Il Valore del Tempo</h2><p>Finalmente possiamo portare la Durata della Vita nel dominio dei prezzi, attingendo alla nostra precedente ricerca nello sviluppo del Multiplo dei Giorni di Valore Distrutto (VDDM). Questa metrica confronta il valore mensile in dollari di CDD con la sua media annuale.</p>
<p>Attualmente, possiamo vedere che il valore VDDM sta accelerando dopo un lungo periodo di negoziazione intorno ai minimi del ciclo. Questo indica che la distruzione del valore CDD in risposta all’azione dei prezzi recenti sta lasciando il tipico territorio di mercato orso, e suggerisce che c’è abbastanza domanda che sta fluendo nel mercato per assorbire i profitti realizzati.</p>
<p>Questo presenta ancora molte somiglianze con le ere del 2015, 2019 e 2020, che si sono rivelate punti di transizione del ciclo di mercato.</p>
<p><img src="https://gimg2.gateimg.com/image/article/167997106410_vdd_multiple.png" alt=""></p>
<h2 id="h2-Riassunto20e20Conclusioni645854"><a name="Riassunto e Conclusioni" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Riassunto e Conclusioni</h2><p>Come il <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Il mercato fa una pausa, il profitto degli investitori sta iniziando a riscaldarsi. I detentori a breve termine che hanno accumulato vicino ai minimi del ciclo dominano la maggior parte del comportamento di spesa, anche se la loro volontà di detenere monete per periodi più lunghi è evidente.</p>
<p>Nel complesso, la maggior parte dei BTC sembra essere piuttosto inattiva on-chain, suggerendo che gli investitori continuino ad avere fiducia nell’andamento prente al rialzo. Come nel nostro articolo della scorsa settimana, attraverso l’obiettivo della durata della moneta, <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> sembra nuovamente entrare in un periodo di mercato di transizione.</p>
<hr>
<p>Avviso legale: Questo rapporto non fornisce alcun consiglio di investimento. Tutti i dati sono forniti solo a scopo informativo ed educativo. Nessuna decisione di investimento deve basarsi sulle informazioni fornite qui e sei unicamente responsabile delle tue decisioni di investimento.</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 alcuna suggerimento di investimento.<br></div><p></p><br></div></div></div>
Share
Content
gate logo
Gate
Trade Now
Join Gate to Win Rewards