R2xhc3Nub2RlIEluc2lnaHRzOiBSb3RhemlvbmUgZGkgY2FwaXRhbGUgYSBiYXNzbyByaXNjaGlv

2023-06-06, 09:52
<p><img src="https://gimg2.gateimg.com/image/article/1686044173SDFX.jpeg" alt=""></p>
<p>La quiete e la calma persistono nei mercati degli asset digitali, con il prezzo dell’ETH che rimane confinato in un intervallo di $68 questa settimana (3,6%), scambiando tra un minimo di $1.861 e un massimo di $1.931. A parte una piccola impennata nei mercati dell’ETH a seguito dell’aggiornamento di Shanghai, i prezzi dell’ETH sono stati più o meno piatti dal marzo.</p>
<p>Mentre il mercato si muove lateralmente, stanno emergendo crescenti divergenze nelle preferenze di mercato che si verificano sotto la superficie, molte delle quali suggeriscono un ambiente a basso rischio. I volumi di scambio rimangono depressi, l’uso di DeFi sta diventando sempre più automatizzato e c’è una crescente preferenza di mercato per le stablecoin, in particolare per <a href="/price/tether-usdt" rel="nofollow noopener noreferrer" target="_blank">Tether</a> (USDT).</p>
<p><img src="https://gimg2.gateimg.com/image/article/168604420500_cover-5.png" alt=""></p>
<p>In questa edizione, esploreremo queste correnti sotterranee in via di sviluppo e come possiamo osservarle attraverso dati on-chain e off-chain.</p>
<p><img src="https://gimg2.gateimg.com/image/article/168604424501_price.png" alt=""></p>
<h2 id="h2-Arbitraggio20automatizzato651811"><a name="Arbitraggio automatizzato" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Arbitraggio automatizzato</h2><p>Sebbene i prezzi di ETH siano rimasti relativamente piatti e confinati in un range dal mese di marzo, i prezzi del gas hanno subito un incremento non trascurabile nel mese di maggio. I prezzi del gas sono aumentati fino ad una media di 76 Gwei, corrispondenti a $1.14 per una normale transazione di trasferimento di ETH. Il prezzo medio del gas ha raggiunto oltre 155 Gwei all’inizio di maggio ($6.53 per trasferimento di ETH), che è quasi altrettanto alto durante il ciclo bullish del 2021-22.</p>
<p><img src="https://gimg2.gateimg.com/image/article/16860443022.png" alt=""></p>
<p>Le interazioni con i contratti intelligenti sono più intensive dal punto di vista del gas e possono costare molto di più rispetto a un semplice trasferimento. L’utilizzo del gas associato ai protocolli DeFi è aumentato del 270% alla fine di aprile, portando il consumo giornaliero di gas del settore oltre le 20 miliardi di unità di gas.</p>
<p><img src="https://gimg2.gateimg.com/image/article/16860460103.png" alt=""></p>
<p>Se scomponiamo il gas DeFi per protocollo, determiniamo rapidamente che il principale aumento dell’attività è guidato dall’attività di trading sulle borse decentralizzate. <a href="/price/uniswap-uni" rel="nofollow noopener noreferrer" target="_blank">Uniswap</a> rimane il luogo principale, con un aumento del 388% nell’uso del gas da aprile e ora rappresenta tra il 7,7% e il 14,4% del totale <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> domanda di gas.</p>
<p><img src="https://gimg2.gateimg.com/image/article/16860460634.png" alt=""></p>
<p>Coloro che seguono le notizie potrebbero presumere che questo aumento di attività sia dovuto all’attuale eccitazione per i Memecoin, che ruotava attorno a token come PEPE e HEX. Tuttavia, un’analisi più dettagliata del volume di scambio su <a href="/price/uniswap-uni" target="_blank" class="blog_inner_link">Uniswap</a> dipinge un quadro più dettagliato.</p>
<p>Il grafico qui sotto mostra i pool più scambiati su Uniswap, rivelando che i volumi più alti degli ultimi 30 giorni erano principalmente legati ad asset con una capitalizzazione di mercato più elevata come ETH, stablecoin, WBTC e il derivato di staking di Coinbase cbETH.</p>
<p><img src="https://gimg2.gateimg.com/image/article/16860455455.png" alt=""></p>
<p>Dopo aver confrontato gli indirizzi dei primi 10 trader con le nostre etichette, abbiamo scoperto che tutti tranne uno erano associati a bot MEV. Con il famigerato bot MEV jaredfromsubway.eth che ha guadagnato oltre 3 miliardi di dollari nel mese scorso.</p>
<p>Sebbene sia necessaria ulteriore ricerca per determinare quanti dei trader globali siano bot, la dimensione del volume generato dai primi dieci ci dà già un’idea di quanto del volume di Uniswap potrebbe essere effettivamente arbitraggio automatizzato.</p>
<p>Un modo per razionalizzare ciò è considerare l’ampio campo di opportunità di arbitraggio disponibili attraverso gli <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> DEX:</p>
<ul>
<li><p>Man mano che il prezzo di ogni token (+ slippage) cambia, alla fine la commissione di gas giustificherà una transazione di arbitraggio.</p>
</li><li><p>Ogni pool DEX che ospita quel token fornisce uno spazio per una transazione di arbitraggio.</p>
</li><li><p>Così, il numero di potenziali opportunità di transazione di arbitraggio crescerà in modo esponenziale, legato sia al numero di pool di liquidità DEX, sia al numero di token disponibili per il trading.</p>
</li></ul>
<p>Se consideriamo che molti bot si impegnano in arbitraggio o attacchi sandwich, il grado di volume di trading ‘organico’ su Uniswap potrebbe rappresentare oltre due terzi di tutte le attività DEX.</p>
<p><img src="https://gimg2.gateimg.com/image/article/16860464136.png" alt=""></p>
<p>Sebbene le attività di questi bot di trading possano essere considerate dannose per gli utenti finali di Ethereum, hanno benefici per i validatori di Ethereum. Nel mese scorso, i validatori non solo hanno guadagnato ricompense più elevate a causa dei fee di priorità aumentati, ma hanno anche beneficiato dei pagamenti MEV-boost. Questi pagamenti vengono raccolti dai trader e dai bot che pagano per ordinare le loro transazioni nel modo più redditizio all’interno di un blocco.</p>
<p>In molti modi, questo mette in evidenza una tendenza sempre più favorevole per l’ETH messo in gioco come asset primario all’interno dell’ecosistema di Ethereum. Questo stabilisce anche un tasso di ostacolo nativo con cui i token devono competere al fine di attrarre flussi di capitale.</p>
<p><img src="https://gimg2.gateimg.com/image/article/16860456517.png" alt=""></p>
<h2 id="h2-Rotazione20al20ribasso20del20rischio114254"><a name="Rotazione al ribasso del rischio" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Rotazione al ribasso del rischio</h2><p>Ci sono anche forti indicazioni di rotazione del capitale che si sposta verso il basso sulla curva del rischio, spostandosi verso stablecoin e BTC man mano che la liquidità si alleggerisce. Se iniziamo con i mercati dei Futures di Ethereum, possiamo ottenere una visione dei partecipanti al mercato al di là dei trader nativi di criptovalute di solito trovati sugli scambi decentralizzati.</p>
<p>Dopo il crollo di FTX, il volume degli scambi futures è crollato a soli ~$7.5 miliardi al giorno. Tuttavia, nel 2023 i volumi hanno registrato un ritorno, anche se la media dei 30 giorni ($12.0 miliardi al giorno) rimane ben al di sotto della media annuale ($21.5 miliardi al giorno).</p>
<p>A differenza dell’aumento dell’attività di trading di Uniswap, il trading futures è continuato a contrarsi nel mese di maggio, indicando che l’interesse e la liquidità del trading istituzionale rimangono piuttosto deboli.</p>
<p><img src="https://gimg2.gateimg.com/image/article/16860456838.png" alt=""></p>
<p>Possiamo vedere un trend di supporto nel dominio del volume relativo tra BTC e ETH nei mercati di swap perpetui. Mentre il volume degli scambi tra entrambi gli asset ha raggiunto la parità alla fine del 2022, la quota relativa del volume dei futures di Ethereum è diminuita massicciamente nel 2023.</p>
<p>Attualmente, l’ETH rappresenta il 34,5% del volume di scambi tra i due principali, suggerendo che la liquidità si sta spostando verso la curva del rischio, preferendo concentrarsi nei mercati BTC su base relativa.</p>
<p><img src="https://gimg2.gateimg.com/image/article/16860457199.png" alt=""></p>
<p>I dati on-chain forniscono un’ulteriore visione sui flussi di capitale e sulle rotazioni all’interno dei mercati cripto. Il grafico qui sotto confronta il valore denominato in USD totale di ETH rispetto alle stablecoin che entrano ed escono dagli exchange. Durante la massiccia deleveraging del 2022, si è sviluppato un evidente cambiamento nelle preferenze degli investitori, con la dominanza di ETH nei flussi di capitale che è scesa dal ~35% al 10%.</p>
<p>Nel 2023, abbiamo osservato un forte inversione, con la proporzione di flussi di scambio di ETH che risale al 25%. Tuttavia, questa tendenza si è fermata all’inizio di maggio, suggerendo un potenziale cambiamento nell’appetito per il rischio. Gli investitori che hanno beneficiato dei forti rendimenti del primo trimestre potrebbero iniziare a spostare il capitale verso le stablecoin.</p>
<p><img src="https://gimg2.gateimg.com/image/article/168604576610.png" alt=""></p>
<p>Un altro modo per consolidare questa conclusione è confrontare i flussi giornalieri di scambio di ogni asset come misura della pressione dell’acquirente e del venditore. Per questo modello semplificato, assumiamo che i flussi di scambio di BTC + ETH rappresentino la pressione di vendita, mentre i flussi di stablecoin rappresentino la pressione di acquisto.</p>
<p>I valori negativi suggeriscono che abbiamo assistito a un regime di vendita netta dall’inizio di aprile 2023, dove gli afflussi di BTC+ETH hanno iniziato a superare quelli delle stablecoin. Questo rappresenta una netta rottura rispetto alla significativa pressione di acquisto osservata nel primo trimestre, con un indebolimento del lato dell’acquisto all’inizio di aprile, che coincideva con l’inizio della correzione di mercato prente.</p>
<p><img src="https://gimg2.gateimg.com/image/article/168604579711.png" alt=""></p>
<p>In generale, il capitale tende a <a href="/price/flow-flow" rel="nofollow noopener noreferrer" target="_blank">Flusso</a> nelle attività digitali attraverso le due principali, BTC ed ETH, o tramite stablecoin. Pertanto, possiamo stimare la direzione dei flussi di capitale aggregati aggregando e confrontando due metriche:</p>
<ul>
<li><p>Realized Cap per BTC ed ETH (essendo la variazione netta del valore delle monete spostate sulla catena)</p>
</li><li><p>Fornitura circolante per stablecoin (considerando USDT, USDC, BUSD, TUSD e DAI)</p>
</li></ul>
<p>Da questo, possiamo vedere che i flussi di capitale nei mercati crittografici sono stati principalmente guidati da un aumento dei flussi di capitale in BTC (+$4.47B/mese), seguito da ETH (+$3.5B/mese). Tuttavia, ciò è stato in parte compensato da circa -$1.2B di deflussi di capitale dai stablecoin, poiché si verificano significative riscossioni nel settore dei stablecoin.</p>
<p><img src="https://gimg2.gateimg.com/image/article/168604583412.png" alt=""></p>
<p>Le recenti fuoriuscite di capitale dalle stablecoin sono guidate principalmente dal secondo (USDC) e terzo (BUSD) asset più grandi, con una diminuzione delle forniture nel 2023 di -$15,7 miliardi e $-11,5 miliardi, rispettivamente. USDT ha assorbito una significativa proporzione di questi flussi, spingendo verso un nuovo ATH di forniture pari a $83,1 miliardi.</p>
<p>È probabile che ciò rifletta una divergenza geografica, con le entità regolamentate degli Stati Uniti che storicamente hanno espresso una preferenza per USDC rispetto a USDT.</p>
<p><img src="https://gimg2.gateimg.com/image/article/168604586613.png" alt=""></p>
<p>Concludiamo osservando che una divergenza simile è visibile nel cambiamento dell’offerta di BTC anno su anno in base alle regioni geografiche. La predominanza estrema delle entità statunitensi nel 2020-21 si è chiaramente invertita, con una diminuzione del dominio dell’offerta statunitense dell’11% dal 2022. I mercati europei sono stati abbastanza neutrali nell’ultimo anno, mentre un aumento significativo del dominio dell’offerta è visibile durante le ore di trading asiatiche.</p>
<p><img src="https://gimg2.gateimg.com/image/article/168604589714.png" alt=""></p>
<h2 id="h2-Sommario20e20Conclusioni262678"><a name="Sommario e Conclusioni" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Sommario e Conclusioni</h2><p>Nel corso dell’ultimo mese, c’è stata un’attività crescente sugli scambi decentralizzati, in particolare su Uniswap. Sebbene si possa pensare che i Memecoins abbiano scatenato queste attività, uno sguardo più attento rivela che la maggior parte del volume è stata generata su pool WETH-stablecoin più grandi e più profondi. Notevolmente, solo una frazione di queste attività di trading sembra essere stata organica, suggerendo che si tratti principalmente di arbitraggio, MEV e trading algoritmico.</p>
<p>Poiché i tassi di interesse statunitensi sono ora superiori al 5%, le stablecoin senza interessi sono diventate meno attrattive, specialmente per gli investitori con accesso ai mercati di capitale statunitensi. Tether, d’altra parte, ha storicamente trovato una maggiore adozione nei mercati al di fuori degli Stati Uniti, dove le valute nazionali sono spesso più deboli e l’accesso al dollaro statunitense è meno comune. Allo stesso modo, poiché si sta stabilendo un ambiente regolatorio sempre più ostile negli Stati Uniti, il capitale sembra fluire verso est, nel settore degli asset digitali.</p>
<p>Gran parte di questo suggerisce un ambiente generalmente a basso rischio, con il capitale rimanente che si concentra sui principali più liquidi e una crescente preferenza per il capitale stabilecoin.</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.<br></div><p></p><br></div></div></div>
Share
Content
gate logo
Gate
Trade Now
Join Gate to Win Rewards