R2xhc3Nub2RlIEluc2lnaHRzOiBUcmFjY2lhcmUgaWwgc2VudGltZW50IHRyYW1pdGUgbGUgTGlxdWlkaXR5IFBvb2xz

2023-09-05, 07:32
<p><img src="https://gimg2.gateimg.com/image/article/1693898020SDFX 1.jpeg" alt=""></p>
<h2 id="h2-Sommario20Esecutivo259772"><a name="Sommario Esecutivo" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Sommario Esecutivo</h2><p>La volatilità guidata dagli eventi è rientrata nei mercati degli asset digitali nelle ultime settimane, con importanti indicatori di deflussi di capitale aggregati segnalati in anticipo.</p>
<p>I mercati dei derivati mostrano un continuo deflusso di liquidità, in particolare nei futures ETH, suggerendo che il capitale continui a muoversi verso l’alto della curva del rischio verso la sicurezza relativa.</p>
<p>Ci immergiamo a fondo in come <a href="/price/uniswap-uni" rel="nofollow noopener noreferrer" target="_blank">Uniswap</a> I pool di liquidità hanno molte somiglianze con i mercati delle opzioni, con i fornitori di liquidità che esprimono un punto di vista sia sulla volatilità che sui livelli di prezzo.</p>
<p><img src="https://gimg2.gateimg.com/image/article/169389810000_cover.png" alt=""></p>
<h2 id="h2-I20mercati20degli20asset20digitali20si20svegliano268091"><a name="I mercati degli asset digitali si svegliano" class="reference-link"></a><span class="header-link octicon octicon-link"></span>I mercati degli asset digitali si svegliano</h2><p>Nelle ultime settimane, i mercati degli asset digitali sono stati scossi da un periodo di volatilità storicamente bassa. Ciò è stato determinato principalmente da due eventi chiave:</p>
<ul>
<li><p><strong>Il crollo improvviso del 17 agosto</strong> dove BTC e ETH sono scesi del -11% e -13%, rispettivamente.</p>
</li><li><p><strong>La notizia della vittoria legale di Greyscale sulla SEC è stata diffusa il 29 agosto</strong>, guidando brevemente i prezzi al rialzo, tuttavia tutto il terreno guadagnato è stato perso nei tre giorni successivi.</p>
</li></ul>
<p>I prezzi spot sia per BTC che per ETH attualmente si trovano intorno ai minimi di agosto.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1693898086Group-137691447-2.png" alt=""></p>
<p>Una misura chiave per tracciare i flussi di capitale aggregati nell’industria è la metrica del Valore Realizzato Aggregato. Questo strumento combina:</p>
<ul>
<li><p>La capitalizzazione realizzata delle due principali criptovalute BTC ed ETH</p>
</li><li><p>L’offerta delle principali cinque stablecoin USDT, USDC, BUSD, DAI e TUSD.</p>
</li></ul>
<p>Da questo, diventa chiaro che il mercato era entrato in un regime di deflusso di capitale all’inizio di agosto, ben prima di questi due eventi principali. Circa $55 miliardi di capitale hanno lasciato lo spazio degli asset digitali attraverso agosto.</p>
<p>Questo trend è guidato da deflussi di capitali su tutti e tre gli asset <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a>, Etheruem e stablecoin.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1693898311Group-137691448.png" alt=""></p>
<p>All’interno del <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Nell’ecosistema, c’è stata una reazione mista tra gli indici per i settori DeFi, GameFi e Staking. Ciascun indice è costruito dal prezzo medio ponderato per l’offerta dei token ‘Blue-Chip’ nel settore.</p>
<p>Possiamo vedere che i token DeFi e GameFi hanno avuto una performance relativamente scarsa (-17%) e (-20%) rispetto ai principali, mentre i token Liquid Staking erano leggermente migliori (-7,7%). In generale, tuttavia, l’azione dei prezzi al ribasso è stata simile o meno grave rispetto ai ribassi registrati a marzo, aprile e giugno.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1693898515Group-137691436-1-.png" alt=""></p>
<h2 id="h2-La20propensione20al20rischio20diminuisce20nei20mercati20dei20derivati696826"><a name="La propensione al rischio diminuisce nei mercati dei derivati" class="reference-link"></a><span class="header-link octicon octicon-link"></span>La propensione al rischio diminuisce nei mercati dei derivati</h2><p>Uno dei principali sviluppi nel ciclo 2021-23 è stata la maturazione dei mercati dei derivati, soprattutto per BTC ed ETH. Il modo in cui i mercati dei derivati prezzano questi asset può fornire informazioni sul sentiment di mercato e sul posizionamento.</p>
<p>L’attività generale nei mercati dei futures e delle opzioni <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> nel 2023 è notevolmente inferiore rispetto ai livelli osservati nel 2021 e nel 2022. Il volume medio giornaliero delle negoziazioni in entrambi i mercati è sceso a soli $14.3 miliardi al giorno, circa la metà del volume medio degli ultimi due anni. Questa settimana il volume è ancora più basso, a $8.3 miliardi al giorno, suggerendo che la liquidità continua a scarseggiare nello spazio.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1693898768Group-137691437-1-.png" alt=""></p>
<p>Questo trend si riflette nell’Open Interest dei derivati. Dopo i minimi di mercato stabiliti a seguito del crollo di FTX, l’Open Interest ha iniziato a salire all’inizio del 2023. Per le Opzioni, l’open interest ha raggiunto il picco durante la crisi bancaria di marzo quando USDC ha subito una depeggio da $1. L’open interest dei futures su Ethereum ha raggiunto il picco intorno all’Upgrade di Shanghai, suggerendo che questo è stato l’ultimo grande evento speculativo per l’asset.</p>
<p>Da allora, il valore nominale dei contratti attivi in entrambi i mercati è stato piuttosto stabile. Similmente alla nostra osservazione per i mercati BTC (WoC 32), i mercati delle opzioni ETH sono ora di una scala simile ($5.3 miliardi) rispetto ai mercati futuri ($4.2 miliardi) e sono effettivamente di dimensioni maggiori al momento.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1693898795Group-137691449.png" alt=""></p>
<p>Dall’inizio dell’anno, c’è stato un notevole aumento dei mercati delle opzioni Ethereum, con un volume che è aumentato del +256% raggiungendo un volume di scambi giornaliero di $326M/giorno. Nel frattempo, i volumi dei futures hanno subito un costante declino quest’anno, passando da $20 miliardi/giorno all’inizio di gennaio a soli $8 miliardi/giorno oggi. L’unica eccezione degna di nota è stato un breve aumento a circa $30 miliardi/giorno intorno all’aggiornamento di Shanghai.</p>
<p>Dato che non ci sono stati cambiamenti significativi nei volumi di scambio per entrambi i mercati ad agosto, ciò suggerisce che i trader stanno continuando a spostare la liquidità verso l’alto sulla curva del rischio.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1693898838Group-137691450.png" alt=""></p>
<p>Guardando il rapporto Pull/Call, possiamo vedere un alto grado di reattività agli importanti eventi di notizie. Ad esempio, dopo che BlackRock ha presentato una richiesta per un ETF di Bitcoin, il sentiment è diventato più rialzista, spingendo il rapporto Pull/Call verso il basso da 0,72 a 0,40.</p>
<p>Tuttavia, ciò è cambiato con il sell-off del 17 agosto, poiché il rapporto Pull/Call è aumentato a 0,50 e con i volumi di chiamata che sono diminuiti drasticamente da $320M/giorno a $140M/giorno.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1693898867Group-137691439.png" alt=""></p>
<h2 id="h2-Sono20i20Liquidity20Pools20mercati20delle20opzioni440024"><a name="Sono i Liquidity Pools mercati delle opzioni?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Sono i Liquidity Pools mercati delle opzioni?</h2><p>Per rafforzare la nostra analisi sopra, esamineremo ora le attività che si svolgono su Automated Market Makers come il Pool ETH/USDC di Uniswap. Dall’introduzione della liquidità concentrata su <a href="/price/uniswap-uni" target="_blank" class="blog_inner_link">Uniswap</a> V3, è circolata una tesi secondo cui le posizioni di liquidità di Uniswap possono essere considerate alla stessa stregua delle opzioni put e call. Sebbene non crediamo che i concetti delle opzioni descrivano completamente queste dinamiche, ci sono sicuramente molti parallelismi degni di ulteriori approfondimenti.</p>
<p>La nostra analisi si concentrerà sul Pool USDC/ETH dello 0,05%, che è il pool Uniswap più attivo e quindi si può prevedere che fornisca il segnale più alto. Questo pool ha un volume di scambi di 7 giorni di 1,51 miliardi di dollari e un Valore Totale Bloccato (TVL) di 260 milioni di dollari.</p>
<p>Uniswap V3 ha una caratteristica unica di liquidità concentrata. I fornitori di liquidità (LP) possono selezionare un intervallo di prezzo in cui la loro liquidità fornita sarà concentrata. Le commissioni verranno guadagnate solo quando il mercato scambia in questo intervallo (analogamente ai prezzi di esercizio), e più stretto è l’intervallo, maggiore è il ricavo relativo delle commissioni. Ciò porta sia a una migliore esperienza utente per i trader DEX, poiché gli spread tendono ad essere più stretti, sia a un miglioramento dell’efficienza del capitale per i fornitori di liquidità (LP).</p>
<p>In questo modo, si può sostenere che la posizionamento del capitale degli LP deve tener conto di un’aspettativa di volatilità (differenza tra il limite superiore e inferiore) e degli intervalli di prezzo previsti (livello di strike sopra e sotto). La tesi è che assumendo che gli LP gestiscano attivamente la loro posizione, potremmo essere in grado di trarre conclusioni simili a quelle dai dati di mercato delle opzioni.</p>
<p><img src="https://gimg2.gateimg.com/image/article/16938989020-VGxxFh0ovRn_xAQb-1.png" alt=""></p>
<p>Iniziamo osservando l’attività generale nel pool USDC/ETH 0.05%. Per varie ragioni, eviteremo di utilizzare la metrica TVL come misura dell’attività in un pool o in una coppia di token rispettiva. Invece, esprimeremo l’attività in base a due metriche:</p>
<ul>
<li><p>i.<br> <strong>Menta al giorno</strong> rappresenta il numero di posizioni di liquidità aperte dagli LP e</p>
</li><li><p>ii.<br> <strong>Bruciore al giorno</strong> rappresenta il numero di posizioni di liquidità chiuse dai LP.</p>
</li></ul>
<p>Con queste misure, l’attività si è contratta dopo la crisi bancaria di marzo e l’aggiornamento di Shanghai in aprile, per poi rimanere relativamente bassa fino all’inizio di giugno. Vediamo poi un picco di nuove Mints e Burns intorno all’annuncio dell’ETF di BlackRock e poi di nuovo durante la vendita del 17 agosto.</p>
<p>Il grafico qui sotto mostra anche la variazione netta dei conteggi delle posizioni LP come misura dell’equilibrio tra l’apertura e la chiusura delle posizioni. Noto che questa metrica è meno influenzata dalle tendenze di mercato ma più da eventi discreti che suggeriscono che la volatilità a breve termine è un fattore chiave.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1693898935Group-137691451.png" alt=""></p>
<p>Quando si esamina la distribuzione della liquidità nelle diverse fasce di prezzo nel pool Uniswap, si può vedere che attualmente gli LP stanno fornendo la maggior parte della liquidità al di sopra del prezzo corrente.</p>
<p>La liquidità più concentrata (circa il 30,4% del capitale) si trova all’interno di una fascia di prezzo dell’11%, con un potenziale ribasso del -2,7% e un potenziale rialzo del +8,6%. Un secondo livello di liquidità è posizionato con un margine di sicurezza del -8,5% al ribasso e un margine di sicurezza del +23,7% al rialzo. Si potrebbe sostenere che gli LP di Uniswap esprimano un’aspettativa di <a href="/price/optimism-op" rel="nofollow noopener noreferrer" target="_blank">Ottimismo</a> e potenziale di mercato al rialzo per ETH in generale.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1693899021Group-137691441-1-.png" alt=""></p>
<p>Se confrontiamo questo con i prezzi di esercizio delle opzioni per i contratti che scadono alla fine di settembre, possiamo vedere un’analoga prospettiva positiva. Il 70% delle chiamate ha un prezzo di esercizio compreso tra $1,7k e $2,3k, mentre il 75% delle put ha uno sciopero compreso tra $1,3k e $1,9k. Questi livelli di prezzo si allineano in gran parte con la distribuzione di liquidità del pool di liquidità di Uniswap.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1693899049Group-137691452.png" alt=""></p>
<p>Tornando al Pool USDC/ETH Uniswap, possiamo analizzare come le concentrazioni di liquidità si sono adattate nel tempo. La mappa di calore qui sotto mostra la densità della liquidità, espressa in colori sempre più freddi o caldi.</p>
<p>Con l’espansione delle strategie LP automatizzate e dell’esecuzione, i fornitori di liquidità sono diventati piuttosto riusciti nell’organizzare la liquidità molto vicino al prezzo spot durante i periodi di maggiore volatilità. Il 1° giugno, una grande quantità di liquidità è stata espansa appena sopra il prezzo di quel momento (indicato da una zona giallo più profondo). Questo indicava probabilmente un’aspettativa di maggiori entrate per commissioni in questa zona da parte dei market maker. Questa liquidità è rimasta fino al flash crash di agosto, quando le concentrazioni di liquidità sono state regolate per essere sempre più al di sotto dei $1.8k. Questo grafico fornisce una visione notevole di quanto siano reattivi i LP rispetto agli eventi di mercato e alla volatilità.</p>
<p>È interessante notare anche come alte concentrazioni di liquidità, rappresentate dalle zone rosse, coincidano con forti movimenti dei prezzi e spesso inversioni di tendenza. Dall’ispezione, si può dedurre che le pool di liquidità di Uniswap potrebbero essere effettivamente una fonte preziosa di informazioni per valutare il sentiment del mercato e la posizione.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1693899076Group-137691443.png" alt=""></p>
<h2 id="h2-Sommario20e20conclusione260733"><a name="Sommario e conclusione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Sommario e conclusione</h2><p>L’ottimismo iniziale che circondava la vittoria di Grayscale sulla SEC è stato di breve durata, con il valore di Ethereum che è tornato ai minimi di agosto nel giro di pochi giorni. I mercati spot continuano a vedere deflussi di capitale e i mercati dei derivati stanno assistendo a una costante diminuzione della liquidità. Nel complesso, gli investitori sembrano esitare nel tornare ai mercati, preferendo spostare il capitale verso livelli di rischio più elevati.</p>
<p>Abbiamo effettuato uno studio sui pool di liquidità di Uniswap, cercando di identificare se informazioni di prezzo simili a quelle dei mercati delle opzioni potessero essere ottenute. La nostra analisi dimostra che il capitale di liquidità è piuttosto reattivo agli eventi di mercato e che probabilmente si possono trovare spunti riguardo alla volatilità e alle aspettative di prezzo degli LP.</p>
<p><strong>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 unicamente responsabile delle tue decisioni di investimento.</strong></p>
<div class="blog-details-info"><br><div>Autore: Glassnode Insights<br><div>Editor: 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.<p></p><br></div></div></div></div>
Share
Content
gate logo
Gate
Trade Now
Join Gate to Win Rewards