R2xhc3Nub2RlIEluc2lnaHRzOiBBbGxhIHJpY2VyY2EgZGVsbCdlcXVpbGlicmlv

2023-05-30, 14:56

<p><img src="https://gimg2.gateimg.com/image/article/1685458699SDFX.jpeg" alt=""></p>
<p>Dal mese di ottobre 2022, la liquidità del mercato globale ha registrato un aumento, con gli asset digitali e i prezzi dei metalli preziosi che hanno risposto positivamente e in modo sempre più correlato. Entrambe le classi di asset stanno attualmente vivendo la loro seconda correzione al rialzo dell’anno, con BTC e Silver in calo del -10,8% e -10,6%, rispetto ai rispettivi massimi degli ultimi 90 giorni.<br><img src="https://gimg2.gateimg.com/image/article/168545738300_cover_v2-7.png" alt=""><br>L’oro si sta comportando meglio, registrando un calo del -5,4% finora, mentre i prezzi del petrolio greggio WTI continuano a lottare, scambiando in un range limitato e in calo del -12,1% dall’aprile.<br><img src="https://gimg2.gateimg.com/image/article/1685457434woc-22-00.png" alt=""><br>Negli ultimi 90 giorni, il petrolio greggio (WTI) è diminuito del -4,0%, mentre l’oro (XAU) e l’argento (XAG) si sono ripresi rispettivamente del 7,5% e del 12,7%. <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> tuttavia, continua a superare, rimanendo il 14.5% al di sopra della chiusura di febbraio. Le prestazioni di BTC sono più deboli rispetto alle prestazioni di picco del primo trimestre del 72%, ma rimane il performer più forte tra queste principali materie prime.<br><img src="https://gimg2.gateimg.com/image/article/1685457448woc-22-01.png" alt=""><br>Come abbiamo coperto la settimana scorsa, il mercato sembra essere in fase di preparazione per un regime di maggiore volatilità. In questa relazione settimanale, cercheremo di circoscrivere il problema e valutare i livelli psicologici superiori e inferiori, dove è probabile che entri in gioco una partecipazione rinnovata degli investitori.</p>
<h2 id="h2-Momentum20in20diminuzione140016"><a name="Momentum in diminuzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Momentum in diminuzione</h2><p>Man mano che il momentum rallenta nel mercato del Bitcoin, la volatilità realizzata mensile è scesa al 34,1%, che è al di sotto della banda di Bollinger a 1 deviazione standard. Storicamente, regimi di bassa volatilità come questo rappresentano solo il 19,3% della storia del mercato, pertanto le aspettative di una volatilità elevata sull’orizzonte a breve termine sono una conclusione logica.</p>
<p>🗜️ Suggerimento per la postazione di lavoro: Questo grafico è costruito utilizzando la funzione deviazione standard std(m2, 365) per calcolare bande in stile Bollinger per la volatilità effettiva.<br><img src="https://gimg2.gateimg.com/image/article/1685457540woc-22-02.png" alt=""><br>I volumi di trasferimento on-chain rimangono ciclicamente bassi (WoC 21), il che si traduce in una diminuzione dell’attività associata agli scambi. Per quantificare questo concetto, possiamo confrontare il numero di transazioni di deposito/prelievo di scambio che avvengono oggi con la media degli ultimi 6 mesi, producendo un rapporto di attività.</p>
<p>Possiamo vedere la tendenza ciclica dell’attività di scambio per tutti gli scambi 🟦 e notare che l’attività recente è diminuita del 27,3% rispetto agli ultimi sei mesi. Per tener conto di FTX, che ha interrotto completamente le operazioni nel novembre 2022, possiamo osservare un momento di attività simile solo per Binance 🟨, suggerendo che l’attività degli investitori sia effettivamente eccezionalmente ridotta.<br><img src="https://gimg2.gateimg.com/image/article/1685457566woc-22-03.png" alt=""></p>
<h2 id="h2-Mappare20un20equilibrio305042"><a name="Mappare un equilibrio" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Mappare un equilibrio</h2><p>La minore volatilità e la diminuzione dell’attività on-chain indicano tutte una sorta di fase di equilibrio. Utilizzeremo ora la metrica del Profitto/Perdita non realizzato netto (NUPL) per verificare questa ipotesi.</p>
<p>Questo indicatore esamina il valore in dollari del profitto netto totale o della perdita come percentuale della capitalizzazione di mercato. Da una prospettiva macro, possiamo definire quattro fasi in un ciclo:</p>
<p>Scoperta del fondo 🔴: NUPL &lt; 0<br>Capitolazione e ripresa 🟠: 0 &lt; NUPL &lt; 0,25<br>Fase di equilibrio 🟡: 0,25 &lt; NUPL &lt; 0,5<br>Euforia del mercato toro 🟢: 0,5 &lt; NUPL</p>
<p>Il valore attuale di NUPL pari a 0,29 si trova sul limite inferiore della fase di equilibrio, che è una zona in cui il 37,5% di tutti i giorni di trading di <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> sono stati. Questa zona è stata raggiunta all’inizio di marzo 2023 e ha persistito per circa 16 mesi negli ultimi due cicli.</p>
<p>🔔 Idea di allerta: NUPL (SMA a 7 giorni) che scende sotto lo 0,25 indicherebbe che la redditività del mercato è tornata nella fase di Capitulazione e Recupero, e potrebbe suggerire debolezza.<br><img src="https://gimg2.gateimg.com/image/article/1685457613woc-22-04.png" alt=""></p>
<h2 id="h2-Intervalli20psicologici9799"><a name="Intervalli psicologici" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Intervalli psicologici</h2><p>Possiamo anche utilizzare un insieme di base di costo degli investitori per delimitare i confini probabili della volatilità a breve termine. L’obiettivo è trovare livelli di prezzo che probabilmente susciteranno una significativa risposta psicologica da parte di una maggioranza di detentori.</p>
<p>Il costo base dell’investitore attivo 🔵 è attualmente in negoziazione a $33.5k, che tiene conto solo degli investitori che partecipano attivamente al mercato e offre un modello di prezzo limite a breve termine. Con l’MVRV dell’investitore attivo a 0.83, si suggerisce che molti acquirenti del ciclo 2021-22 siano ancora in perdita e potrebbero essere in attesa di prezzi di pareggio per liquidare le loro posizioni.</p>
<p>🔔 Idea di allarme: Il superamento del prezzo di $33.5k indicherebbe che l’investitore medio del ciclo 2021-22 è ora tornato in profitto, e riflette un’area di interesse psicologico.<br><img src="https://gimg2.gateimg.com/image/article/1685457644woc-22-05-1-.png" alt=""><br>Un modello di prezzo inferiore può anche essere identificato, cercando un’approssimazione di supporto macro nel caso di un significativo deterioramento del mercato, come il COVID Crash di marzo 2020. Il modello del prezzo limite per gli investitori viene calcolato come la differenza tra il Realized Cap e il Thermocap, riflettendo un modello di base basato sulle detenzioni degli investitori, escludendo i minatori.</p>
<p>Possiamo vedere che il modello del prezzo degli investitori è stato brevemente intersecato durante la vendita di marzo 2020, e attualmente si sta scambiando a $17.65k. Con l’MVRV del capitale degli investitori attualmente a 1.58, si colloca all’interno di un intervallo di equilibrio molto simile al mini-ciclo di mercato 2019-20.<br><img src="https://gimg2.gateimg.com/image/article/1685458147woc-22-06-1-.png" alt=""><br>Il mercato sembra non avere una particolare gravità che lo trascini in una direzione o nell’altra al momento. Possiamo anche vedere che i prezzi sono tornati alla base di costo del detentore a breve termine (STH) e hanno azzerato diverse metriche di profitto/perdita non realizzati.</p>
<p>Il rapporto di profitto / perdita non realizzato STH (introdotto in WoC 18) si è raffreddato significativamente, tornando a un livello di pareggio di 1,0 e poi rimbalzando a 2,6. Ciò indica una posizione equilibrata di profitto e perdita per i nuovi investitori. Scendere sotto questo livello tende a precedere una contrazione dei prezzi più estesa, tuttavia, il mercato tende a trovare supporto a questo livello durante le fasi di resilienza dei tori.<br><img src="https://gimg2.gateimg.com/image/article/1685458171woc-22-07.png" alt=""></p>
<h2 id="h2-La20strada20pi20alta743530"><a name="La strada più alta" class="reference-link"></a><span class="header-link octicon octicon-link"></span>La strada più alta</h2><p>Avendo stabilito che il mercato è in equilibrio, possiamo utilizzare strumenti on-chain per fornire una roadmap macro di questa fase rispetto ai cicli precedenti.</p>
<p>Il primo strumento traccia il lato dell’offerta dei Long-Term Holders (LTH). Possiamo vedere che l’offerta a lungo termine tende ad essere abbastanza ciclica e abbiamo evidenziato diversi regimi di forte spesa 🔴 e di forte mantenimento 🟢 sui grafici qui sotto.</p>
<p>Prima di riconquistare l’ATH, l’offerta detenuta a lungo termine attraversa un lungo periodo di riaccumulo, con un aumento generalmente piatto o modesto dell’offerta complessiva detenuta.</p>
<p>Poiché il mercato supera il precedente ATH del ciclo, l’incentivo a aumentare le spese aumenta significativamente. Ciò comporta un drastico calo dell’offerta a lungo termine, trasferendo le monete ai nuovi acquirenti, a prezzi elevati.</p>
<p>Durante il mercato ribassista del 2022, la prima fase del modello di offerta LTH si è esattamente verificata, mostrando la notevole resilienza dei detentori di BTC in mezzo a una volatilità estrema.<br><img src="https://gimg2.gateimg.com/image/article/1685458203woc-22-08.png" alt=""><br>Possiamo utilizzare queste osservazioni per costruire uno strumento che misuri il sentiment del mercato. Innanzitutto, suddivideremo la lunga e rocciosa strada tra i minimi del mercato ribassista e l’ultimo ciclo ATH in tre sottointervalli:</p>
<p>Bottom Discovery 🟥: Prezzo inferiore alla base di costo dei detentori a lungo termine.</p>
<p>Equilibrio 🟧: Il prezzo è al di sopra della base di costo a lungo termine dei detentori, ma al di sotto dell’ATH precedente.</p>
<p>Price Discovery 🟩: Il prezzo è al di sopra dell’ultimo massimo ciclo ATH.</p>
<p>Successivamente, sovrapponiamo le prestazioni di mercato all’intensità delle spese LTH (di solito associate a prese di profitto o capitulazione). Qui, mostriamo le spese LTH tramite l’Indicatore Binario di Spesa (SBI), che semplicemente tiene traccia se le spese LTH sono di un’intensità sufficiente a diminuire l’offerta totale di LTH, mediata nell’ultimo periodo di 7 giorni.<br><img src="https://gimg2.gateimg.com/image/article/1685458295woc-22-09.png" alt=""><br>Da ciò possiamo vedere che le spese LTH sono state estremamente leggere nelle ultime settimane, ma sono aumentate durante questa correzione. L’indicatore ha raggiunto un livello che suggerisce che 4 su 7 giorni hanno registrato un disinvestimento netto da parte dei LTH, che è un livello simile agli eventi di liquidità di uscita osservati finora quest’anno.<br><img src="https://gimg2.gateimg.com/image/article/1685458471woc-22-11.png" alt=""><br>Per concludere, possiamo combinare questi due indicatori per costruire un nuovo strumento per suddividere il sentiment di mercato in quattro sottocategorie e individuare periodi di disinvestimento LTH elevato:</p>
<p>Capitulation 🟥: Il prezzo spot è inferiore alla base di costo LTH e pertanto qualsiasi forte spesa è probabilmente dovuta a pressioni finanziarie e capitulazione (Condizioni: LTH-MVRV &lt; 1 e SBI &gt; 0,55).</p>
<p>Transizione 🟧: Il mercato sta scambiando leggermente al di sopra della base di costo dei detentori a lungo termine, e una spesa occasionale leggera fa parte del commercio quotidiano (Condizioni: 1.0 &lt; LTH-MVRV &lt; 1.5 e SBI &gt; 0.55).</p>
<p>Equilibrio 🟨: Dopo essersi ripreso da un lungo periodo di ribasso, il mercato cerca un nuovo equilibrio tra la domanda minima in entrata, una liquidità più leggera e i detentori subacquei del ciclo precedente. Le forti spese a lungo termine durante questa fase sono di solito associate a improvvisi rally o correzioni (Condizioni: 1.5 &lt; LTH-MVRV &lt; 3.5 e SBI &gt; 0.55).</p>
<p>Euforia 🟩: Quando LTH-MVRV raggiunge 3,5 (storico allineato al raggiungimento del massimo storico del mercato), gli LTH mantengono in media un profitto superiore al 250%. Il mercato entra in una fase di euforia, che motiva questi investitori a spendere a tassi molto elevati e in rapida accelerazione (Condizioni: LTH-MVRV &gt; 3,5 e SBI = 1,00).</p>
<p>Il nostro attuale mercato ha recentemente raggiunto la fase di transizione, segnalando un picco locale nelle spese a lungo termine questa settimana. A seconda della direzione in cui erompe la volatilità, possiamo utilizzare questo strumento per individuare periodi locali di condizioni surriscaldate, come osservato dal punto di vista dei detentori a lungo termine.<br><img src="https://gimg2.gateimg.com/image/article/1685458443woc-22-10.png" alt=""></p>
<h2 id="h2-Sommario20e20Conclusioni115127"><a name="Sommario e Conclusioni" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Sommario e Conclusioni</h2><p>Il mercato degli asset digitali continua a superare le principali materie prime nel 2023, tuttavia attualmente stanno tutti vivendo una correzione significativa. Dopo essersi ripresi dalle profondità del mercato orso del 2022, gli investitori di Bitcoin si trovano in una forma di equilibrio, con poca gravità in entrambe le direzioni.</p>
<p>Data l’estrema bassa volatilità e gli angusti intervalli di trading degli ultimi tempi, sembra che questo equilibrio sia destinato presto a essere disturbato. In risposta, abbiamo visto un modesto aumento della spesa dei detentori a lungo termine e sviluppato una serie di livelli di prezzo e modelli di comportamento da monitorare mentre la situazione si evolve.</p>
<hr>
<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 totalmente 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 alcun suggerimento di investimento.<br></div><p></p><br></div></div></div>