R2xhc3Nub2RlIEluc2lnaHRzOiBCaXRjb2luIEZsYXNoIENyYXNo

<p><img src="https://gimg2.gateimg.com/image/article/1692694480SDFX 1.jpeg" alt=""></p>
<h2 id="h2-Sommario20Esecutivo455650"><a name="Sommario Esecutivo" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Sommario Esecutivo</h2><p>Il mercato ha subito una violenta liquidazione la scorsa settimana, facendo scendere i prezzi del BTC sotto i 25.000 dollari e ponendo fine a un periodo di bassa volatilità storica.</p>
<p>Il mercato ha tagliato diversi modelli di supporto dei prezzi importanti, mettendo i tori sulla difensiva.</p>
<p>Un fattore determinante sembra essere un’eliminazione di leva nel mercato dei derivati, che ha portato alla liquidazione di oltre $2.5 miliardi di interesse aperto in poche ore.</p>
<p>I mercati delle opzioni hanno riprezzato nettamente i premi di volatilità dai minimi storici, anche se l’interesse aperto rimane sorprendentemente stabile.</p>
<p>I mercati spot sono ancora relativamente ‘top-heavy’, con oltre l’88,3% dell’offerta di detentori a breve termine ora detenuta in perdita non realizzata.</p>
<p>Introduciamo un indicatore sperimentale reattivo che aiuta a identificare i punti di svolta nella redditività e nel trend di mercato.</p>
<p><img src="https://gimg2.gateimg.com/image/article/169269451500_cover-5.png" alt=""></p>
<h2 id="h2-Danno20tecnico220585"><a name="Danno tecnico" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Danno tecnico</h2><p>Il mercato degli asset digitali ha subito una violenta vendita la settimana scorsa, segnando una fine drammatica alla esauriente mancanza di volatilità che ha dominato da luglio. Come abbiamo trattato nelle ultime due edizioni (WoC 32, WoC 33), l’azione del prezzo per BTC aveva raggiunto alcuni dei livelli di volatilità più bassi mai registrati, e i mercati delle opzioni in particolare avevano fortemente scontato la possibilità di una significativa volatilità al ribasso.</p>
<p>Dopo diverse settimane di negoziazione appena sopra i $29,3k, i prezzi del BTC sono esplosi al ribasso, tagliando diversi medie mobili a lungo termine, tra cui la media mobile a 111 giorni, a 200 giorni e a 200 settimane. Con il mercato che ha chiuso la settimana intorno ai $26,1k, questo rappresenta una significativa perdita di supporto di mercato e i tori ora hanno il loro lavoro tagliato fuori per loro.</p>
<p><img src="https://gimg2.gateimg.com/image/article/169269454701_price_tech.png" alt=""></p>
<p>Il sell-off ha anche spinto i prezzi al di sotto della base di costo a breve termine del detentore, un modello di prezzo on-chain che storicamente ha fornito supporto durante trend al rialzo robusti. Con il prezzo realizzato e la base di costo a lungo termine del detentore che scambia a una certa distanza al di sotto ($20.3k), questo pone il mercato in una posizione alquanto precaria dal punto di vista psicologico.</p>
<p>Come abbiamo osservato la scorsa settimana (WoC 33), l’offerta detenuta dalla coorte dei detentori a breve termine è in qualche modo ‘sovraccarica’, con una significativa maggioranza che ha una base di costo superiore a $29.0k. Questo è un argomento che affronteremo più avanti in questa edizione.</p>
<p><img src="https://gimg2.gateimg.com/image/article/169269455702_price_onchain.png" alt=""></p>
<p>L’azione dei prezzi settimanale ha registrato un calo del -11,3%, che rappresenta una caduta significativa, ma non la più significativa degli ultimi anni. Questa performance è leggermente inferiore alla deviazione standard a lungo termine di -12,6%, un livello che è stato superato durante eventi di capitulazione importanti come i crolli di FTX, 3AC e LUNA.</p>
<p><img src="https://gimg2.gateimg.com/image/article/169269458103_weeklyperf.png" alt=""></p>
<p>Tuttavia, su base giornaliera, questa è la più grande vendita singola del giorno fino ad oggi, con una diminuzione del -7,2% il 17 agosto. Questo superava un movimento di una deviazione standard verso il basso, cogliendo di sorpresa i tori.</p>
<p><img src="https://gimg2.gateimg.com/image/article/169269460404_dailyperf-1.png" alt=""></p>
<h2 id="h2-Opzioni20Ricalcolo20Volatilit925024"><a name="Opzioni Ricalcolo Volatilità" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Opzioni Ricalcolo Volatilità</h2><p>La volatilità implicita nei mercati delle opzioni aveva raggiunto minimi storici all’inizio della settimana, scambiando al 50% al di sotto della linea di base a lungo termine osservata nel corso del 2021-2022. Naturalmente, con l’inizio del sell-off di questa settimana, la volatilità è stata rapidamente riprezzata. La volatilità implicita è più che raddoppiata per i contratti a breve termine con scadenza fino alla fine di settembre.</p>
<p><img src="https://gimg2.gateimg.com/image/article/169269466105_impliedvol.png" alt=""></p>
<p>Le opzioni put hanno naturalmente subito la ricalibrazione più decisa, con lo Skew 25-Delta che si è invertito completamente, passando dai minimi storici del -10% a oltre il +10%. Nel complesso, i trader di opzioni sono stati svegliati violentemente dal loro sonno, costretti a rivalutare le aspettative di volatilità in avanti.</p>
<p><img src="https://gimg2.gateimg.com/image/article/169269467106_deltaskew.png" alt=""></p>
<p>È interessante notare che l’interesse aperto sia per le opzioni call che put è rimasto sorprendentemente stabile, con pochissime variazioni nette nonostante l’azione esplosiva dei prezzi. Ciò suggerisce che, sebbene la volatilità fosse probabilmente sottostimata, non c’è stata molta dismissione forzata nei mercati delle opzioni.</p>
<p>Uno sviluppo che abbiamo evidenziato in WoC 32 è che l’entità dell’open interest in <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> I mercati delle opzioni ora sono paragonabili ai mercati dei futures, il che significa che gli analisti dovrebbero tenere d’occhio entrambi.</p>
<p><img src="https://gimg2.gateimg.com/image/article/169269469707_optionsoi.png" alt=""></p>
<p>Il volume degli scambi delle opzioni è aumentato notevolmente, aumentando del 200%+ a $620M/giorno per le call e $326M/giorno per le put. Resta da vedere se questo regime di volatilità elevata rimarrà, o se l’attuale bassa liquidità tornerà a un mercato con scarsa entusiasmo.</p>
<p><img src="https://gimg2.gateimg.com/image/article/169269475408_optionsvolume.png" alt=""></p>
<h2 id="h2-Futures20Flushout200582"><a name="Futures Flush-out" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Futures Flush-out</h2><p>A differenza dei mercati delle opzioni, i trader di future hanno vissuto un importante evento di deleveraging che presenta notevoli somiglianze con il crollo di FTX. Sebbene su scala più ridotta, oltre 2,5 miliardi di dollari di contratti futures perpetui sono stati chiusi in un solo giorno. Ciò rappresenta un calo del -24,5% e un completo annullamento di tutto il leverage accumulato tra luglio e agosto.</p>
<p><img src="https://gimg2.gateimg.com/image/article/169269479109_futuresoi.png" alt=""></p>
<p>Un totale di $230M in posizioni lunghe sono state liquidate e forzate a chiudere in poche ore, facendo dell’evento di liquidazione più grande dal crollo di LUNA nel maggio 2022. Questo evento di liquidazione è stato di maggiore entità rispetto allo squeeze delle posizioni corte che ha dato il via al rally del 2023 a gennaio, suggerendo che potrebbe avere un potenziale di cambiamento di tendenza.</p>
<p><img src="https://gimg2.gateimg.com/image/article/169269480310_longliq.png" alt=""></p>
<p>Anche i mercati dei futures hanno sperimentato una dislocazione negativa a causa della vendita forzata, facendo scendere i prezzi dei futures ben al di sotto dell’indice del mercato spot. I tassi di finanziamento sono diventati negativi per creare un incentivo per i market maker ad aprire posizioni lunghe e sfruttare le differenziali di prezzo.</p>
<p>Questa è il tasso di finanziamento negativo più basso dal sell-off di marzo a $19.8k, anche se la dislocazione della scorsa settimana è di dimensioni minori. In generale, ciò suggerisce che l’accumulo di leva finanziaria e il successivo smobilizzo nei mercati future sono stati un fattore primario che ha guidato questo sell-off.</p>
<p><img src="https://gimg2.gateimg.com/image/article/169269483411_fundingrate.png" alt=""></p>
<h2 id="h2-Mercati20spot20topheavy176617"><a name="Mercati spot top-heavy" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Mercati spot top-heavy</h2><p>Un concetto che abbiamo rivisto la settimana scorsa (WoC 33) è stato quello di un mercato ‘top heavy’, in cui volumi significativi di offerta spot hanno una base di costo vicina o superiore al prezzo attuale. Quando il prezzo del BTC si muove improvvisamente, possiamo vedere l’entità dell’offerta che cade in perdita tramite cambiamenti nella metrica della Percentuale di Offerta in Profitto.</p>
<p>Qui vediamo che il 12,8% (2,48M BTC) dell’offerta è sceso in una perdita non realizzata questa settimana, fissando un minimo inferiore su questa metrica. Questo suggerisce che la ‘pesantezza al top’ nei mercati spot potrebbe anche essere un fattore in gioco.</p>
<p><img src="https://gimg2.gateimg.com/image/article/169269486312_pctsupplyloss-1.png" alt=""></p>
<p>Se guardiamo alla risposta dei Long-Term Holders (LTH), possiamo vedere che c’è praticamente nessuna risposta. Il gruppo dei LTH non ha aumentato in modo significativo il volume inviato agli scambi, e il loro saldo aggregato è effettivamente salito a un nuovo ATH questa settimana.</p>
<p>Pertanto, possiamo concludere che i detentori a breve termine (STHs) sono più rilevanti per valutare.</p>
<p><img src="https://gimg2.gateimg.com/image/article/169269488613_lthreaction.png" alt=""></p>
<p>Con l’offerta di LTH al massimo storico, possiamo anche vedere che l’offerta di STH rimane ai minimi plurianuali. Tuttavia, il grafico sottostante sovrappone la proporzione di offerta di STH che è detenuta in perdita non realizzata.</p>
<p>Nota come i forti aumenti della fornitura di STH in perdita tendano a seguire ‘mercati sbilanciati’ come maggio 2021, dicembre 2021 e ancora questa settimana. Dei 2,56M di BTC detenuti dagli STH, solo 300k BTC (11,7%) è ancora in profitto.</p>
<p><img src="https://gimg2.gateimg.com/image/article/169269493114_sthsupplyinloss.png" alt=""></p>
<h2 id="h2-Approfondimento20metrico20Momentum20delle20perdite20realizzate298328"><a name="Approfondimento metrico: Momentum delle perdite realizzate" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Approfondimento metrico: Momentum delle perdite realizzate</h2><p>Infine, concluderemo con uno degli strumenti più avanzati e reattivi in fase di sviluppo da parte del team di Glassnode. L’obiettivo di questo strumento è identificare punti di svolta significativi del mercato, come ‘mercati pesanti in alto o in basso’. È progettato come segue:</p>
<p>Durante i trend macro al rialzo, gli investitori tendono in generale a diventare sempre più redditizi, con perdite che diventano meno frequenti (e viceversa nei trend al ribasso).</p>
<p>Questo risultato il rapporto tra il profitto/perdita realizzato (P/L) che rimane sopra 1.0 per periodi prolungati durante i trend al rialzo del mercato. Al contrario, il rapporto perdita/profitto (L/P) rimane sopra 1.0 durante i downtrend.</p>
<p>Se confrontiamo il rapporto P/L con la sua media mobile di 1 anno, possiamo stabilire un indicatore di momentum P/L 🟢 che aumenterà rapidamente quando la dominanza del profitto aumenta rapidamente. Ciò accade spesso dopo un regime dominante di perdita (come vicino ai punti di inflessione inferiori pesanti). Un indicatore di momentum L/P 🔴 simile può essere calcolato per identificare i punti di inflessione superiori pesanti.</p>
<p>Un oscillatore di dominanza (in fondo al grafico) può anche essere costruito per fornire un’altra prospettiva per identificare i punti di flessione.</p>
<p>La variante di questo parametro mostrata di seguito è specifica per i detentori a breve termine, che sono la coorte più reattiva alla volatilità del mercato. Possiamo vedere che dopo diversi mesi di declino della dominance degli utili, lo slancio delle perdite e la dominance sono aumentati in modo significativo. I falsi segnali si verificano, come durante la correzione di marzo 2023, e storicamente si sono ripresi rapidamente.</p>
<p>Tuttavia, cali sostenuti hanno preceduto anche trend ribassisti più violenti come nel maggio e dicembre 2021, rendendo questa vendita della settimana da tenere d’occhio.</p>
<p><img src="https://gimg2.gateimg.com/image/article/169269686816_sthrealizedmomentum.png" alt=""></p>
<h2 id="h2-Sommario20e20Conclusioni915330"><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> è stato violentemente scosso questa settimana, vendendo il -7,2% il 17 agosto, per il più grande calo giornaliero dell’anno. Molti indicatori indicano un futuro deleveraging del mercato come il driver più probabile, con i trader di opzioni costretti a riconsiderare e ri-prezzare i premi di volatilità.</p>
<p>I detentori a lungo termine rimangono in gran parte imperturbati e non reattivi, che è un tipico comportamento di questa fascia durante i periodi di crisi del mercato. I detentori a breve termine, tuttavia, suscitano maggiore interesse, con l’88,3% del loro approvvigionamento detenuto (2,26M BTC) ora detenuto a una perdita non realizzata. Ciò è aggravato dall’accelerazione delle perdite realizzate da STH inviate agli scambi, nonché dalla perdita di supporto chiave della media mobile tecnica, mettendo i tori in difficoltà.</p>
<p><strong>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 essere basata sulle informazioni qui fornite e sei unicamente responsabile delle tue decisioni di investimento.</strong></p>
<div class="blog-details-info"><br><div>Autore: Glassnode Insights<br><div>Editor: Squadra del Blog 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>