R2xhc3Nub2RlIEluc2lnaHRzOiBJbCBEZUZpIMOoIHRvcm5hdG8gaW4gYXR0aXZpdMOgPw==

2023-08-01, 09:29
<p><img src="https://gimg2.gateimg.com/image/article/1690880674SDFX.jpeg" alt=""></p>
<h2 id="h2-Sommario20Esecutivo465661"><a name="Sommario Esecutivo" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Sommario Esecutivo</h2><p>Diversi sviluppi positivi nell’industria degli asset digitali, così come gli sviluppi all’interno del settore DeFi, hanno suscitato un rinnovato interesse da parte degli investitori nei token DeFi.</p>
<p>L’aumento dell’interesse per i token DeFi ha suscitato l’interesse degli operatori di mercato, che hanno aumentato la liquidità nei rispettivi pool, indicando una prospettiva positiva per le attività di trading e prezzi legate a questi token.</p>
<p>Ulteriori analisi di <a href="/price/uniswap-uni" rel="nofollow noopener noreferrer" target="_blank">Uniswap</a> La distribuzione del volume di trading di Gate.io rivela che una parte significativa dell’attività di trading può essere attribuita ai bot, che si concentrano principalmente sulle coppie ETH-Stablecoin.</p>
<p><img src="https://gimg2.gateimg.com/image/article/169088144700_cover-14.png" alt=""></p>
<h2 id="h2-Altcoin20di20nuovo20in20voga597680"><a name="Altcoin di nuovo in voga?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Altcoin di nuovo in voga?</h2><p>Nel corso degli ultimi mesi, i mercati delle altcoin hanno assistito a una lotta tra notizie positive e negative, alimentata da diversi sviluppi chiave:</p>
<p>All’inizio di giugno, la SEC ha classificato 68 criptovalute come titoli non registrati, mettendo un freno all’interesse di mercato verso le altcoin al di fuori <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> e <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Molti di questi token avevano registrato prestazioni scadenti anche prima di questa notizia, di cui abbiamo parlato nel nostro rapporto ‘Affrontare il trend negativo dei DeFi’.</p>
<p>La presentazione dei depositi di <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> spot ETF da parte di giganti finanziari come BlackRock e Fidelity ha portato a un aumento del sentiment di mercato, che si è esteso oltre il Bitcoin e nello spazio più ampio degli asset digitali.</p>
<p>Inoltre, la sentenza del caso Ripple Labs vs. SEC a metà luglio, che ha stabilito che la società di criptovalute non ha violato la legge federale sui titoli vendendo il suo <a href="/price/xrp-xrp" rel="nofollow noopener noreferrer" target="_blank">XRP</a> Il token sulle borse pubbliche, ha inviato un segnale positivo per altri progetti di criptovalute con sede negli Stati Uniti e per l’industria in generale. La vittoria di <a href="/price/xrp-xrp" target="_blank" class="blog_inner_link">XRP</a> ha fornito un certo grado di speranza agli investitori di altcoin riguardo alla robustezza contro ulteriori azioni regolamentari.</p>
<p>In particolare, i token legati al settore DeFi hanno registrato le migliori performance, con il prezzo del nostro indice DeFi che ha registrato un rialzo del 56% rispetto al minimo registrato l’11 giugno. Altri settori chiave del mercato come GameFi e Staking hanno registrato performance inferiori in confronto.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1690881458Group-137691265.png" alt=""></p>
<p>Il nostro indice DeFi è composto dai primi 8 token DeFi per capitalizzazione di mercato, e ha stabilito un trend al rialzo di quasi due mesi rispetto a ETH. Questa è la prima sovraperformance da settembre 2022, e finora con una performance molto simile.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1690881467The-Metric-Factory-52-.png" alt=""></p>
<p>Tuttavia, se guardiamo separatamente i primi otto token DeFi, due token si distinguono come principali motori di questa tendenza: MKR e COMP. A una più attenta osservazione, possiamo vedere che le prestazioni potrebbero essere strettamente legate ai nuovi fondamentali del progetto, piuttosto che agli sviluppi del mercato più ampio.</p>
<p>Il 28 giugno, <a href="/price/compound-comp" rel="nofollow noopener noreferrer" target="_blank">Compound</a>‘s fondatore e CEO, Robert Leshner, ha annunciato la sua partenza dal protocollo di prestito così come il lancio di un nuovo progetto che si concentra sulla portabilità della finanza regolamentata alle reti blockchain. In seguito a questo annuncio, il token COMP ha registrato un aumento fino all’83% in una settimana.</p>
<p>Nello stesso periodo, MakerDAO ha attivato il suo Smart Burn Engine, un programma di riacquisto che utilizza l’eccesso di DAI posseduto dal protocollo per acquistare MKR da un pool Uniswap. La prospettiva di rimuovere circa $7 milioni di MKR in un mese ha causato un aumento del prezzo del token fino al 43% nella settimana.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1690881575Group-137691266-1-.png" alt=""></p>
<p>Esaminando i flussi di scambio DEX vs CEX per i primi otto token DeFi, possiamo vedere un rinnovato interesse nell’attività DEX. La quota relativa del volume scambiato su DEX è aumentata dal 3,75% all’inizio di giugno al 29,2% oggi, vicino ai massimi registrati durante la seconda metà del 2022.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1690881586Group-137691267-1-.png" alt=""></p>
<h2 id="h2-Tipi20misti20di20trading20Uniswap6771"><a name="Tipi misti di trading Uniswap" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Tipi misti di trading Uniswap</h2><p>Con questo aumento dell’attività DEX, possiamo indagare su come questi sviluppi recenti abbiano influenzato l’attività DEX e le eventuali implicazioni potenziali per le parti interessate. Il nostro focus principale sarà su Uniswap, il principale DEX, che è stato anche il consumatore più significativo di gas nell’ultima settimana.</p>
<p>In termini di volume di trading <a href="/price/uniswap-uni" target="_blank" class="blog_inner_link">Uniswap</a> su Ethereum, il livello attuale di $5.57B/settimana rimane significativamente inferiore rispetto agli anni precedenti. C’è stata una forte crescita del volume legata all’interesse per i Liquid Staking Tokens all’inizio del 2023, così come un breve aumento dei ‘meme-token’ che si è poi attenuato.</p>
<p>Da questa lente, possiamo vedere che l’entusiasmo recente intorno alle presentazioni di BTC ETF e alla sentenza Ripple vs. SEC non ha suscitato un aumento apprezzabile dell’attività di trading su Uniswap.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1690881656Group-137691269.png" alt=""></p>
<p>Esaminando la distribuzione del volume degli scambi di Uniswap tra diversi Layer 2, otteniamo un quadro più chiaro. Diventa evidente che una parte apprezzabile degli scambi si è spostata dalla mainnet di <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> ad Arbitrum, attirando fino al 32% del volume a marzo. Questa tendenza è rimasta elevata a giugno e luglio, il che fornisce una spiegazione per il volume inferiore su Ethereum che abbiamo osservato sopra.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1690881688Group-137691270.png" alt=""></p>
<h2 id="h2-Bots20vs20Humans532001"><a name="Bots vs. Humans" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Bots vs. Humans</h2><p>Un altro modo per contestualizzare l’attività di trading di Uniswap è guardare al tipo di trader che la esegue. Dal 2019 abbiamo assistito all’emergere di vari tipi di bot MEV, ovvero programmi automatizzati che monitorano la blockchain per rilevare operazioni redditizie da sfruttare. Ai fini di questa analisi, ci concentreremo solo su due tipi; Arbitraggio e Sandwich bot.</p>
<p>I bot di arbitraggio mirano a ottenere profitto dalle differenze di prezzo tra la stessa coppia di token su vari DEX e CEX.</p>
<p>I bot per sandwich funzionano inserendo i loro scambi di fronte al trader target (assumiamo un acquirente), il che provoca un’esecuzione a uno spread più ampio. Dopo ciò, il bot per sandwich venderà nuovamente l’asset per chiudere lo spread, massimizzando il valore su entrambi i lati.<br>Il grafico qui sotto mostra la proporzione di volume su Uniswap (su Ethereum) che proviene dal trading di bot rispetto al trading umano.</p>
<p>Osserviamo che i bot Sandwich rappresentano generalmente oltre il 60% del volume giornaliero. La quota di volume dei bot Arbitrage è diminuita da circa il 20% al 10% dall’inizio dell’anno. Nel frattempo, la quota di volume generata dai trader umani è aumentata fino al 30% dall’inizio di luglio, in linea con il periodo di maggiore interesse per i token DeFi.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1690881764Group-137691271-1-.png" alt=""></p>
<p>Poiché il volume può essere inflazionato in modo diverso da diversi tipi di attacchi di bot, il numero giornaliero di scambi per tipi di trader fornisce un’altra visione del confronto.</p>
<p>Possiamo vedere che i trader umani erano molto attivi durante eventi importanti come il depegging di USDC o la mania dei meme-token. Con una maggiore volatilità dei prezzi e un afflusso di ‘trader target’, sia gli arbitraggi che i bot sandwich fanno altrettanto, diventando fino a tre volte più attivi durante questi picchi nel trading umano.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1690881794Group-137691273.png" alt=""></p>
<p>Il grafico interattivo qui sotto mostra il token preferito e il pool per ogni tipo di trader, con tutti e tre i tipi di trader che preferiscono chiaramente le coppie di trading più grandi e liquide ETH-USDC e ETH-USDT.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1690881941WX20230801-172521@2x.png" alt=""></p>
<h2 id="h2-Pool20di20liquidit20come20mercati20delle20informazioni631718"><a name="Pool di liquidità come mercati delle informazioni" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Pool di liquidità come mercati delle informazioni</h2><p>Da quando è stata introdotta Uniswap V3, i fornitori di liquidità possono distribuire la liquidità all’interno di specifici intervalli di prezzo all’interno del pool. Invece di distribuire la liquidità su un intervallo di prezzo infinito, la liquidità può essere concentrata in modo più efficiente sugli intervalli di prezzo in cui l’investitore si aspetta i volumi di scambio più elevati (per catturare le commissioni).</p>
<p><img src="https://gimg2.gateimg.com/image/article/1690881978image-11.png" alt=""></p>
<p>Dall’annuncio del programma di riacquisto di Maker, il pool di liquidità più di successo per Maker su Uniswap V3 è stato il pool MKR/WETH, che ha registrato un aumento significativo della liquidità.</p>
<p>Sebbene il pool abbia tradizionalmente detenuto principalmente fondi MKR, la profondità di liquidità di WETH è aumentata di oltre il 700%. Ciò suggerisce che i fornitori di liquidità stanno segnalando un’aspettativa di volumi di scambio più elevati per la coppia MKR-WETH.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1690882014pool_liq-1.png" alt=""></p>
<p>Esaminando la composizione del pool, possiamo chiaramente vedere un aumento della quota di WETH, che ora rappresenta il 21,2% del totale. Questo è il risultato di trader che sempre più acquistano MKR con WETH, indicando una chiara crescita della domanda per MKR dall’inizio di giugno.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1690882039Group-137691275.png" alt=""></p>
<p>Come ultima nota, proponiamo un’idea su come le pool di liquidità di Uniswap potrebbero funzionare come una forma di mercato delle informazioni per lo sviluppo previsto del prezzo dei token. Se analizziamo più da vicino la liquidità di MKR-WETH, che è posizionata fuori dalla portata, possiamo chiaramente vedere che la liquidità è elevata a prezzi molto più alti rispetto al tasso di cambio MKR/ETH.</p>
<p>Poiché i fornitori di liquidità spostano il loro capitale verso fasce di prezzo più alte, esprimono in un certo senso una forma di opzione out-of-the-money sulle entrate delle commissioni a livelli di prezzo più alti. Sotto l’assunzione che i fornitori di liquidità siano attori razionali alla ricerca di profitto, lo spostamento della loro liquidità potrebbe fornire un’idea simile al mercato delle opzioni sulla volatilità attesa e sull’intervallo previsto per il token di interesse.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1690882064Group-137691276.png" alt=""></p>
<h2 id="h2-Sommario20e20Conclusioni880907"><a name="Sommario e Conclusioni" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Sommario e Conclusioni</h2><p>L’ambiente normativo che circonda gli asset digitali è stato altalenante nel 2023, con una variegata alternanza di notizie positive e negative. Nelle ultime settimane, in particolare i token DeFi hanno registrato una performance superiore, guidati da MKR e COMP. Tuttavia, dopo aver esaminato le attività di trading su Uniswap, sembra che questi aumenti di prezzo non si siano riflessi in un aumento delle attività di trading DEX.</p>
<p>Una spiegazione per questo è sia una quota crescente del volume degli scambi che si verificano su L2 come Arbitrum, ma anche una presenza meno significativa di operatori umani. Con meno scambi umani, c’è anche un grado leggero di arbitraggio e attività di bot sandwich.</p>
<p>Nel caso di MKR, c’è stato un notevole aumento dei market maker che forniscono liquidità nei pool di Uniswap, segnalando un certo grado di attesa per un aumento dei volumi di scambio. Da ciò, proponiamo un concetto secondo il quale la distribuzione della liquidità potrebbe fornire informazioni sui range di scambio previsti per il token in questione.</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 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: Squadra del Blog Gate.io<br><div class="info-tips">*Questo articolo rappresenta solo le opinioni del ricercatore e non costituisce suggerimenti di investimento.<p></p><br></div></div></div></div>
Share
Content
gate logo
Gate
Trade Now
Join Gate to Win Rewards