R2xhc3Nub2RlIEluc2lnaHRzOiBCaXRjb2luIENhbWJpYSBNYXJjaWE=

2023-03-22, 02:12
<p><img src="https://gimg2.gateimg.com/image/article/1679450167SDFX.jpeg" alt=""></p>
<p><a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> ha vissuto una delle settimane con le migliori performance di sempre, chiudendo in rialzo del 35,8% nella settimana. Solo 124 giornate di negoziazione nella storia hanno visto un rally al rialzo di 7 giorni più grande, con appena 16 giorni che si sono verificati dal 2015 in poi. Quasi tutti i casi si sono verificati all’interno dei trend del mercato rialzista, sebbene tipicamente vicino alle fasi finali della corsa.</p>
<p>La forte sovraperformance di BTC si accompagna a condizioni sfidanti per il sistema finanziario e bancario tradizionale. Restano elevate le preoccupazioni per la vulnerabilità delle banche più piccole in un’era di corse bancarie digitali, e nuove strutture di finanziamento della liquidità vengono stabilite tra la Federal Reserve degli Stati Uniti, le banche statunitensi e le linee di swap con altre banche centrali.</p>
<p>Con questo come sfondo, esploreremo come gli investitori stanno reagendo on-chain e dimostreremo attraverso diversi metodi come il <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Alessio</a> il mercato sembra stia cambiando marcia, uscendo dal territorio di un profondo mercato orso e dirigendosi verso una struttura simile ai passati mercati toro iniziali. Analizzeremo <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> dai seguenti angoli:</p>
<p><img src="https://gimg2.gateimg.com/image/article/167945021000_cover-8.png" alt=""></p>
<p>Momentum on-chain: poiché diversi parametri indicano che è in corso una sana espansione dell’utilizzo della rete.</p>
<p>Passare a una marcia superiore come <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Abbandona le condizioni sinonime dei minimi del ciclo ed entra nella “via di mezzo” tipica dei primi cicli rialzisti.</p>
<p>Seguire il Cold Money valutando se i detentori a lungo termine stanno prendendo profitti significativi e se il rischio di un eccesso di offerta a breve termine sta aumentando.</p>
<p><img src="https://gimg2.gateimg.com/image/article/167945023801_price-1.png" alt=""></p>
<h2 id="h2-20Momentum20Onchain343595"><a name="💨 Momentum On-chain" class="reference-link"></a><span class="header-link octicon octicon-link"></span>💨 Momentum On-chain</h2><p>Inizieremo osservando lo spazio di attività on-chain, dove si applica generalmente un concetto semplice di ‘più è meglio’. Più persone interagiscono e fanno transazioni all’interno del <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> nell’economia, è tipicamente associato a periodi di crescente adozione, effetti di rete e attività degli investitori.</p>
<p>Il numero medio mensile delle transazioni ha raggiunto 309,5k/giorno questa settimana, che è il livello più alto da aprile 2021 e un significativo aumento rispetto alla media annuale.<br><strong>Meno del 12,2% di tutti i giorni ha registrato una maggiore attività di transazione per <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a>, un segno di salute.</strong></p>
<p><img src="https://gimg2.gateimg.com/image/article/167945031302_tx_mom.png" alt=""></p>
<p>Utilizzando i nostri algoritmi di clustering avanzati, possiamo stimare il numero di nuove entità uniche che operano on-chain come migliore stima per nuovi utenti unici. Questa metrica ha raggiunto 122k nuove entità/giorno, con solo il 10,2% dei giorni che registrano tassi più elevati di adozione di nuovi utenti, ovvero durante il picco del 2017 e durante la corsa al rialzo del 2020-21.</p>
<p><img src="https://gimg2.gateimg.com/image/article/167945037703_ent_mom.png" alt=""></p>
<p>Di conseguenza, la congestione di rete sta aumentando, mettendo pressione al rialzo sulle commissioni di transazione. Sostenuto da una nuova domanda da Ordinals e Inions, lo Z-Score di 2 anni per i ricavi dei minatori dalle commissioni è diventato positivo.</p>
<p>La pressione sui tassi elevati è un comune precursore dei mercati più costruttivi, coincidente con i nuovi. <a href="/price/waves-waves" rel="nofollow noopener noreferrer" target="_blank">Onde</a> dell’adozione, espressa attraverso l’aumento della domanda di spazio sui blocchi.</p>
<p><img src="https://gimg2.gateimg.com/image/article/167945039804_fee_mom.png" alt=""></p>
<p>I minatori sono ovviamente i principali beneficiari di questo afflusso, vedendo il loro guadagno totale salire a $22.6M/giorno. Questa settimana, i guadagni dei minatori sono saliti ai livelli più alti dal giugno 2022, superando convincentemente la media annuale.</p>
<p>Simile ai modelli di attività sopra, questo è tipicamente osservato nei punti di transizione verso un mercato più costruttivo.</p>
<p><img src="https://gimg2.gateimg.com/image/article/167945044305_miner_rev.png" alt=""></p>
<h2 id="h2-20Nuove20Ricerche20Fornitura20di20Gamberi20in20Calo249777"><a name="📖 Nuove Ricerche: Fornitura di Gamberi in Calo" class="reference-link"></a><span class="header-link octicon octicon-link"></span>📖 Nuove Ricerche: Fornitura di Gamberi in Calo</h2><p>La distribuzione dell’offerta di <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> continua ad essere un argomento di grande interesse, per l’analisi dei flussi di capitale, ma anche per osservare i comportamenti delle diverse categorie di investitori. In questo articolo, analizziamo la distribuzione del BTC in base alla dimensione del portafoglio, esploriamo come le monete si disperdono nel tempo e dimostriamo come i detentori di piccole quantità hanno continuato ad aumentare la loro quota del mercato. <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> torta.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1679450565image-16.png" alt=""></p>
<h2 id="h2-20Cambiare20marcia858639"><a name="⚙️ Cambiare marcia" class="reference-link"></a><span class="header-link octicon octicon-link"></span>⚙️ Cambiare marcia</h2><p>Come abbiamo esplorato all’inizio di febbraio (WoC 6), diversi indicatori on-chain stanno passando da condizioni tipiche dei mercati orsi profondi, tornando verso territori più neutri e costruttivi. MVRV è una tale metrica, che modella il multiplo di profitto non realizzato detenuto all’interno dell’offerta di monete.</p>
<p>Il grafico qui sotto mostra che MVRV ha scambiato fino a 1,36, che si trova tra la media storica di 1,82 e il livello di deviazione standard ‘-1’ ipervenduto. Storicamente, <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> ha negoziato all’interno di questa fascia intermedia per il 54% di tutti i giorni di negoziazione, sia durante le fasi finali degli orsi, sia durante le prime fasi di ripresa del mercato toro.</p>
<p><img src="https://gimg2.gateimg.com/image/article/167945062806_mvrv_bands.png" alt=""></p>
<p>Dato che MVRV è un rapporto derivato dal Prezzo Realizzato, possiamo calcolare inversamente un livello di prezzo che corrisponderebbe a questi livelli chiave di MVRV. Con i prezzi del BTC che superano i $27k questa settimana, il mercato sta ora operando all’interno della zona neutra di ±0.5 deviazioni standard dalla media a lungo termine.</p>
<p>Questo indica che i prezzi del BTC non sono più fortemente scontati rispetto alla media del costo di mercato in catena.</p>
<p><img src="https://gimg2.gateimg.com/image/article/167945064707_mvrv_pricing.png" alt=""></p>
<p>L’oscillatore di slancio MVRV è uno strumento potente per identificare questi cambiamenti di fase macro, ed attualmente è in fase di superamento dello 0. Questo indicatore risponde molto velocemente agli eventi in cui una grande quantità di monete viene acquistata sopra o al di sotto del prezzo spot, e ritorna rapidamente a detenere una perdita o un profitto non realizzati rispettivamente (cioè nei punti di inversione del ciclo).</p>
<p>Il momento MVRV è appena diventato positivo, segnalando che una grande proporzione dell’offerta di monete è stata acquisita al di sotto del prezzo attuale ed è ora tornata in profitto. Similmente alle metriche sopra, le precedenti istanze di inversioni positive tendono anche a correlarsi con aumenti dell’adozione della rete e dell’attività on-chain.</p>
<p><img src="https://gimg2.gateimg.com/image/article/167945072208_mvrv_mom.png" alt=""></p>
<h2 id="h2-20Analisi20correlata20Dominare20MVRV324496"><a name="📖 Analisi correlata: Dominare MVRV" class="reference-link"></a><span class="header-link octicon octicon-link"></span>📖 Analisi correlata: Dominare MVRV</h2><p>Le metriche MVRV sopra si basano su una metodologia per identificare deviazioni estreme dalla media a lungo termine, con dashboard in tempo reale e grafici disponibili per entrambi i<br><strong><a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> MVRV</strong> e<br><strong><a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> MVRV</strong>.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1679450820image-15.png" alt=""></p>
<h2 id="h2-20Seguendo20il20denaro20freddo175198"><a name="🧊 Seguendo il denaro freddo" class="reference-link"></a><span class="header-link octicon octicon-link"></span>🧊 Seguendo il denaro freddo</h2><p>Uno degli strumenti più potenti nell’analisi on-chain è la nostra capacità di monitorare il tempo di detenzione delle monete, chiamato Durata di vita. Ciò ci consente di identificare quando le monete più vecchie, tipicamente detenute da HODLer a lungo termine e alta convinzione, sono in movimento.</p>
<p>Il grafico qui sotto mostra la proporzione di ricchezza USD detenuta in ‘hot coins’, definite come monete che hanno transato entro gli ultimi 7 giorni. Questa metrica aumenta principalmente quando le vecchie monete vengono spese e si prendono profitti, trasferendo monete vecchie e a basso costo a nuovi acquirenti a prezzi elevati.</p>
<p>Sebbene ci sia stato un lieve aumento della proporzione di ‘monete calde’, rimane vicino ai minimi ciclici, ancora una volta simile ai periodi di transizione dopo significativi trend ribassisti. Ciò indica che nonostante le forti performance dei prezzi, è ancora insufficiente per motivare la maggior parte dei proprietari di monete più vecchie a prendere profitti.</p>
<p><img src="https://gimg2.gateimg.com/image/article/167945085209_hotcoins.png" alt=""></p>
<p>Possiamo vederlo in Long-Term Holder SOPR, che è nel processo di ritornare in territorio neutrale. I Long-Term Holder (LTH) sono in gran parte acquirenti del ciclo 2020-22 e hanno registrato perdite per quasi 12 mesi consecutivi.</p>
<p>Il valore medio mensile di LTH-SOPR sta attualmente superando la media annuale, suggerendo un ritorno della fiducia e un ritorno di slancio positivo nei loro modelli di spesa.</p>
<p><img src="https://gimg2.gateimg.com/image/article/167945091111_lth_soprmultiple.png" alt=""></p>
<p>Infine, prendendo in considerazione l’intero mercato, rivediamo diverse varianti di SOPR, che è una metrica che abbiamo trattato anche nella scorsa edizione settimanale (WoC 11). SOPR è una metrica adatta a tutte le condizioni meteorologiche che può essere utilizzata per tracciare il grado di profitto e perdita realizzati dai gruppi di mercato.</p>
<p>Qui abbiamo sovrapposto quattro varianti di SOPR:</p>
<p>🟢<br><strong>SOPR</strong>- copertura del comportamento di spesa di tutta la rete.<br>🔵<br><strong>SOPR regolato</strong>- filtraggio delle transazioni di relay non economiche (&lt; 1 ora di durata).<br>🟠<br><strong>SOPR regolata per entità</strong>- il nostro filtraggio più pulito per l’attività di spesa più significativa dal punto di vista economico in tutta la rete.<br>🔴<br><strong>SOPR a breve termine per i detentori</strong> - Filtro solo per le monete acquisite negli ultimi 155 giorni.<br>Notiamo che è attualmente in corso una struttura di ripresa simile a quella del ciclo 2018-19. La scorsa settimana si è verificato un salutare evento di “wash-out”, con tutte le varianti SOPR che hanno superato il livello di 1,0. Ciò indica un evento di perdita realizzata su larga scala durante il sell-off di $ 19,8k.</p>
<p>Questa settimana, tuttavia, ha registrato il più alto valore di SOPR dalla massima storica di Novembre 2021, suggerendo che, sebbene i profitti vengano senza dubbio presi, non hanno ancora frenato il trend prente in rialzo.</p>
<p><img src="https://gimg2.gateimg.com/image/article/167945091111_lth_soprmultiple.png" alt=""></p>
<h2 id="h2-Sommario20e20Conclusioni623510"><a name="Sommario e Conclusioni" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Sommario e Conclusioni</h2><p><a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> gli investitori hanno vissuto uno dei più forti guadagni settimanali di sempre, in mezzo a uno sfondo di stress, consolidamento e iniezioni di liquidità in tutto il sistema bancario globale. Diversi indicatori on-chain suggeriscono che il <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Il mercato sta uscendo dalle condizioni storicamente associate ai mercati orsi profondi e sta tornando verso pascoli più verdi.</p>
<p>L’adozione on-chain sta accelerando ulteriormente e la maggior parte dei detentori di monete che hanno resistito alla volatilità per oltre 5 mesi rimane saldamente in mano. Sembra che pochi investitori a lungo termine siano motivati a realizzare profitti in questa corsa, segnalando una notevole forza e una riflessione delle convinzioni detenute su <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> ruolo importante nel futuro del sistema finanziario globale.</p>
<hr>
<p>Avviso: Questo rapporto non fornisce alcun consiglio di investimento. Tutti i dati sono forniti esclusivamente 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.</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