Vm9sYXRpbGl0w6AgVHJpZ2dlciwgQnVsbCBNYXJrZXQgVHJpZ2dlcj86IFJldmlzaW9uZSBzZXR0aW1hbmFsZSBkZWwgbWVyY2F0byBkYSBCbG9maW4gQWNhZGVteQ==

2023-03-10, 06:03

<p><img src="https://gimg2.gateimg.com/image/article/167842656311.png" alt=""><br>La corsa delle criptovalute in bassa liquidità ha alimentato un improvviso aumento della volatilità, innescando il primo periodo di alta volatilità del 2023.</p>
<p>L’aumento dei prezzi degli asset cripto è correlato ai cambiamenti nell’ambiente macro. Allo stesso tempo, non si può ignorare la “gamma squeeze” nei mercati spot e derivati a bassa liquidità.</p>
<p>Il cambiamento nel sentiment degli investitori ha sostenuto il livello attuale dei prezzi, e la riunione del FOMC questa settimana sarà fondamentale per sostenere il rally.</p>
<h2 id="h2-Rally20di20Capodanno895212"><a name="Rally di Capodanno" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Rally di Capodanno</h2><p>Alla fine delle vacanze di Capodanno del 2023, le aspettative che il “ciclo di rialzo dei tassi stia per terminare” sono diventate più forti. I dati economici suggeriscono che le aspettative di recessione iniziate ad accumularsi l’anno scorso sono diventate “più significative” a causa di una serie di forti aumenti dei tassi di interesse nel 2022. Uno degli indicatori più sensibili del ciclo economico, la differenza tra i rendimenti dei T-Notes a 10 anni e a 2 anni, ha toccato un minimo record di 40 anni, secondo solo all’era Volcker.<br><img src="https://gimg2.gateimg.com/image/article/1678427479BLO1.png" alt=""><em>La differenza tra i rendimenti dei titoli T a 10 anni e a 2 anni, al 31 gennaio 2023. Fonte: <a href="TradingView.com" rel="nofollow noopener noreferrer" target="_blank" title="TradingView.com">TradingView.com</a></em></p>
<p>La crescente minaccia di recessione ha costretto la Fed a considerare di allentare la sua politica restrittiva in qualche misura. Dopo aver adottato politiche restrittive aggressive per importanti mercati finanziari come gli Stati Uniti, l’UE e il Canada, i livelli di inflazione sono diminuiti significativamente, meglio della media dei paesi dell’OCSE. Allo stesso tempo, i dati del PCE sono anche tornati indietro di un anno.<br><img src="https://gimg2.gateimg.com/image/article/1678427548BLO2.png" alt=""><em>Variazioni dell’IPC nei principali paesi dell’OCSE selezionati, al 31 gennaio 2023. Fonte: <a href="oecd.org" rel="nofollow noopener noreferrer" target="_blank" title="oecd.org">oecd.org</a></em></p>
<p><img src="https://gimg2.gateimg.com/image/article/1678427618BLO3.png" alt=""><em>Variazioni nell’IPC degli Stati Uniti, al 31 gennaio 2023. Fonte: <a href="tradingeconomics.com" rel="nofollow noopener noreferrer" target="_blank" title="tradingeconomics.com">tradingeconomics.com</a></em></p>
<p>È importante notare che sebbene l’incremento brusco dei tassi di interesse abbia avuto un impatto significativo sull’economia, i dati sul PIL non hanno mostrato una diminuzione sostanziale nel breve termine, e il tasso di disoccupazione non ha ancora mostrato un aumento considerevole, mostrando un certo grado di resilienza economica. La situazione di ‘inflazione o recessione’ prevista per il 2022 non è ancora completamente diventata realtà, e la possibilità di un ‘soft landing’ è relativamente aumentata.<br><img src="https://gimg2.gateimg.com/image/article/1678427689BLO4.png" alt=""><em>Variazioni del tasso di disoccupazione negli Stati Uniti da gennaio 2022 ad oggi, al 31 gennaio 2023. Fonte: <a href="tradingeconomics.com" rel="nofollow noopener noreferrer" target="_blank" title="tradingeconomics.com">tradingeconomics.com</a></em></p>
<p><img src="https://gimg2.gateimg.com/image/article/1678427740BLO5.png" alt=""><em>Il PIL reale degli Stati Uniti cambia dal 2019 ad oggi, al 31 gennaio 2023. Fonte: US Bureau of Economic Analysis</em></p>
<p>Agli occhi degli investitori, rallentare il ritmo delle aumenti dei tassi di interesse sembra ragionevole: è una migliore opportunità per le banche centrali e mantenere le precedenti politiche di strettezza aggressive causerà solo una recessione. La decisione della Banca del Canada sui tassi di interesse di gennaio ha già mostrato un atteggiamento simile.</p>
<p>Data la coerenza delle politiche delle banche centrali negli Stati Uniti e in Canada, sembra che anche la Federal Reserve “dovrebbe” alleviare la pressione delle politiche. Gli operatori dei tassi di interesse sono fiduciosi che la Fed non rischierà una recessione aumentando bruscamente i tassi di interesse e non si aspettano che il tasso di fine ciclo superi il 5%.<br><img src="https://gimg2.gateimg.com/image/article/1678428068BLO6.png" alt=""><em>Le aspettative sui tassi di fine periodo, al 31 gennaio 2023. Fonte: Gruppo CME</em></p>
<p>Le aspettative ottimistiche della pressione della politica di facilitazione della Fed hanno spinto gli investitori in attesa a tornare sui mercati, portando a un rally di inizio anno nel 2023. Il Nasdaq ha guadagnato più del 12% all’inizio del nuovo anno e l’indice SP500 ha superato i 4.000. Sembra che ci sia finalmente un barlume di luce nel prolungato mercato ribassista.<br><img src="https://gimg2.gateimg.com/image/article/1678428115BLO7.png" alt=""><em>Le performance del Nasdaq 100, al 31 gennaio 2023. Fonte: <a href="TradingView.com" rel="nofollow noopener noreferrer" target="_blank" title="TradingView.com">TradingView.com</a></em></p>
<p><img src="https://gimg2.gateimg.com/image/article/1678428163BLO8.png" alt=""><em>La performance del S&amp;P 500, al 31 gennaio 2023. Fonte: <a href="TradingView.com" rel="nofollow noopener noreferrer" target="_blank" title="TradingView.com">TradingView.com</a></em></p>
<p>Tuttavia, all’inizio del rally azionario statunitense, il mercato delle criptovalute non ha seguito. Data la posizione del mercato crypto nella catena di liquidità e la serie di eventi verificatisi a fine 2022, la liquidità “attesa da tempo” non sembra irragionevole. Oltre a creare una serie di opportunità di trading, la tempistica dell’arrivo della liquidità fornisce anche più tempo per le balene delle criptovalute. Il “Rally di Capodanno” del mercato crypto è pronto per il lancio.</p>
<h2 id="h2-Soglia20di20volatilit43349"><a name="“Soglia di volatilità”" class="reference-link"></a><span class="header-link octicon octicon-link"></span>“Soglia di volatilità”</h2><p>Durante le vacanze di Capodanno, la liquidità nel mercato delle criptovalute è scesa ai minimi livelli dal 2021, con il volume mensile dei contratti spot e Delta 1 di dicembre 2022 quasi uguale a quello di fine 2020. La riduzione della liquidità significa anche opportunità: fondi relativamente limitati sono necessari per spingere significativamente al rialzo i prezzi attraverso operazioni nei mercati spot e dei derivati. Il “Gamma Squeeze” è diventato famoso durante l’evento di GME nel 2021. Tuttavia, nel mercato delle criptovalute, il gamma squeeze si è verificato quasi ogni anno dal 2021.<br><img src="https://gimg2.gateimg.com/image/article/1678428274BLO9.png" alt=""><em>Variazioni nel volume mensile di trading spot su scambi di criptovalute. Fonte: The Block</em><img src="https://gimg2.gateimg.com/image/article/1678428315BLO10.png" alt=""> <em>Variazioni del volume di trading mensile del contratto Delta 1 su borse cripto. Fonte: The Block</em></p>
<p>Una settimana prima dell’impennata di metà gennaio, i trader di blocco avevano iniziato a comprare opzioni call di BTC ed ETH, mettendo sotto pressione gli operatori di mercato. Intorno all’11 gennaio, i prezzi del <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> hanno superato i $17k. In questo momento, gli operatori di mercato si sono trovati con un’esposizione gamma negativa considerevole:<br><img src="https://gimg2.gateimg.com/image/article/1678428359BLO11.png" alt=""><em>Distribuzione GEX delle opzioni BTC il 11 gennaio. Fonte: Amberdata Derivati</em></p>
<p>Gamma è un indicatore che misura l’accelerazione delle variazioni del prezzo delle opzioni rispetto al prezzo sottostante, che è una delle principali esposizioni al rischio a cui i trader di opzioni, in particolare i market maker, devono prestare attenzione. I market maker di opzioni sono di solito delta neutral e coprono le loro esposizioni al rischio acquistando e vendendo lo spot sottostante o i contratti futures/perpetui. A diversi livelli di gamma, i market maker adottano tipicamente due strategie di copertura opposte:</p>
<p>● Ai prezzi di esercizio in cui l’esposizione gamma è positiva, man mano che il prezzo sale, i market maker devono vendere più attività sottostanti per coprire il rischio aggiuntivo. Quando il prezzo scende, i market maker mantengono la neutralità del delta acquistando attività sottostanti. Sotto l’influenza del comportamento dei market maker di “vendere alto e comprare basso”, l’intervallo di movimenti dei prezzi e la volatilità di mercato diminuiscono.</p>
<p>● Tuttavia, una volta che il prezzo si sposta in una posizione in cui l’esposizione gamma è negativa, la situazione si ribalta completamente. Con l’aumento dei prezzi, i market maker devono comprare asset per coprire il rischio aggiuntivo e, quando i prezzi scendono, i market maker vendono asset per mantenere il delta neutrale. Data la dimensione del capitale del market maker, il comportamento di “inseguire al rialzo e vendere al ribasso” aumenterà significativamente la volatilità di mercato.</p>
<p>● “Volatility Trigger” è il nodo in cui i market maker cambiano le strategie di copertura. Questo concetto è stato proposto da SpotGamma e da altri fornitori di servizi di dati sulle opzioni azionarie statunitensi per definire i prezzi di esercizio delle strategie di copertura degli switch.</p>
<p>Con l’accumulo di gamma negativa, i market maker hanno dovuto comprare molti spot e contratti a Delta 1 lungo: è iniziata la “Gamma Squeeze”. Anche se la volatilità di mercato non è ancora aumentata, il “Volatility Trigger” è già stato azionato e l’onda di acquisti è stata innescata.</p>
<p>Quando si discute del “Trigger di volatilità”, è necessario considerare anche un altro concetto correlato, il “Strike di gamma assoluta”. Il strike di gamma assoluta si riferisce al prezzo di esercizio in cui i market maker hanno la gamma positiva più alta. Intorno a questo prezzo di esercizio, molte posizioni di copertura dei market maker sono collegate ad esso. Inoltre, il comportamento di copertura dei market maker rende anche questo prezzo di esercizio un importante livello di supporto/resistenza sul mercato. Una volta superato questo prezzo di esercizio, è probabile che il mercato subisca una significativa volatilità.</p>
<p>L’11 gennaio, lo sciopero gamma assoluto era di circa $ 19k. Tuttavia, il 13 gennaio, il prezzo spot ha superato il prezzo di esercizio poiché i tori hanno continuato ad acquistare. I market maker non hanno scelta. Affrontando il gamma negativo, “acquistare” è l’unica opzione:<br><img src="https://gimg2.gateimg.com/image/article/1678428511BLO12.png" alt=""><em>Distribuzione delle opzioni BTC GEX il 13 gennaio. Fonte: Derivati Amberdata</em></p>
<p>Che sia volontario o forzato, l’acquisto su larga scala ha fatto schizzare i prezzi degli asset crittografici principali. In un giorno, il prezzo di BTC ed ETH è salito di oltre il 10%, e la volatilità implicita è aumentata rapidamente. I tori della volatilità e i tori del prezzo hanno raccolto il loro primo tesoro nel 2023, mentre la liquidazione delle posizioni corte ha raggiunto un livello record in quasi 3 mesi.<br><img src="https://gimg2.gateimg.com/image/article/1678428560BLO13.png" alt=""><em>Performance delle IV degli ATM delle opzioni BTC a gennaio. Fonte: Amberdata Derivatives</em></p>
<p><img src="https://gimg2.gateimg.com/image/article/1678428597BLO14.png" alt=""><em>Variazioni della scala di liquidazione dei contratti Delta 1 nel mercato delle criptovalute, al 1 febbraio 2023. Fonte: Coinglass</em></p>
<p>Tuttavia, questo non è la fine della volatilità. Il 16 gennaio, i market maker hanno affrontato una situazione ancora peggiore: più gamma negativo ai prezzi di esercizio vicino al prezzo spot. Hanno dovuto continuare a coprirsi e stimolare ulteriori acquisti sul mercato. Anche nei mercati OTC, gli acquisti hanno lasciato un segno evidente, sia per copertura che semplicemente comprando i ribassi.<br><img src="https://gimg2.gateimg.com/image/article/1678428647BLO15.png" alt=""><em>Distribuzione GEX delle opzioni BTC il 16 gennaio. Fonte: Derivati Amberdata</em></p>
<p><img src="https://gimg2.gateimg.com/image/article/1678428688BLO16.png" alt=""><em>Saldo totale degli OTC desk di BTC. Fonte: Glassnode</em></p>
<h2 id="h2-Trigger20di20mercato20toro716804"><a name="Trigger di mercato toro?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Trigger di mercato toro?</h2><p>Nel mercato dei futures, il differenziale dei futures a lungo termine BTC è ripartito rapidamente e il divario con il rendimento dei titoli di stato decennali si è ridotto significativamente. Nel mercato delle opzioni, la skewness delle opzioni BTC è tornata rialzista per la prima volta dal 2022, mentre la skewness delle opzioni ETH è tornata neutrale.<br><img src="https://gimg2.gateimg.com/image/article/1678428766BLO17.png" alt=""><em>Skewness delle opzioni BTC da gennaio 2022 a febbraio 2, 2023. Fonte: Amberdata Derivatives</em></p>
<p>Tuttavia, non c’è così tanto slancio per ulteriori rialzi. Da un punto di vista macro, la fine delle rialzi dei tassi da parte della Fed è almeno a qualche mese di distanza. Gli ufficiali della Fed ritengono che se ci saranno ulteriori prove di un’inflazione in calo, potrebbero mettere in pausa i rialzi dei tassi nella seconda metà del 2023. Tuttavia, la Fed prenderà in considerazione una pausa nei rialzi dei tassi solo nella sua riunione di maggio se il trend al ribasso dell’inflazione continuerà nel primo trimestre del 2023.</p>
<p>Da una prospettiva micro, l’entusiasmo degli investitori deriva principalmente dall’aspettativa della “fine degli aumenti dei tassi di interesse”, e il fulcro del sostegno dei prezzi - la liquidità sufficiente - non è ancora tornato.</p>
<p>Non è difficile vedere che prima e dopo aver spinto il prezzo fino a circa 23.000 dollari, il volume di trading settimanale delle opzioni è diminuito rapidamente, addirittura inferiore al volume durante le festività di Natale. Le aspettative degli investitori sembrano essere state in parte valutate: vicino al prezzo di esercizio di 23.000 dollari delle opzioni BTC, è stata formata una nuova gamma assoluta di colpi e il prezzo è saldamente ‘bloccato’.<br><img src="https://gimg2.gateimg.com/image/article/1678428820BLO18.png" alt=""><em>Il volume di trading settimanale delle opzioni BTC da dicembre 2022 ad oggi, al 2 febbraio 2023. Fonte: Derivati Amberdata</em><img src="https://gimg2.gateimg.com/image/article/1678428862BLO19.png" alt=""> <em>Distribuzione GEX delle opzioni BTC il 1 febbraio. Fonte: Amberdata Derivatives</em></p>
<p>Anche se l’aumento del tasso del 25bps è stato completamente incorporato nel mercato, la politica di liquidità della Fed nel 2023 è ancora sconosciuta. Pertanto, la dichiarazione della Fed è cruciale.</p>
<p>Dal punto di vista dell’esposizione gamma, se la dichiarazione della Fed è orientata verso la tendenza dovish sotto minaccia di recessione, il ulteriore rimbalzo dei prezzi delle criptovalute non incontrerà molta resistenza. Al contrario, la dichiarazione hawkish potrebbe rompere i supporti attuali e portare il nuovo “Volatility Trigger” vicino al prezzo di strike di $23k. Anche se gli investitori pregano da tempo per un ritorno del mercato rialzista, è comunque necessario acquistare alcune put come assicurazione durante l’acquisto delle correzioni.</p>
<p><strong><em>Divulgazione: questo articolo è stato scritto in collaborazione con Blofin</em></strong></p>
<div class="blog-details-info"><br><div>Autore: <strong>Blofin</strong><br><div class="info-tips"><em>Questo articolo rappresenta solo le opinioni del ricercatore e non costituisce alcun suggerimento di investimento.<br></em><div class="info-tips"><em></em>Nessun contenuto qui costituirà un consiglio di investimento e non costituisce alcuna offerta o sollecitazione di offerta o raccomandazione di alcun prodotto o progetto di investimento.<br><div class="info-tips"><em>L'inclusione di qualsiasi prodotto, servizio, entità o contenuto di terze parti non costituisce un'approvazione, raccomandazione o affiliazione da parte di Gate.io. Si prega di condurre una ricerca approfondita e cercare consigli professionali prima di prendere qualsiasi decisione di investimento.<br></em><div class="info-tips"><em></em>Gate.io si riserva tutti i diritti su questo articolo. Sarà consentito ripostare l'articolo a condizione che si faccia riferimento a Gate.io. In tutti i casi, saranno intraprese azioni legali per violazione del copyright.<p></p><br><br><p></p></div><p></p><br></div></div></div></div></div>