UGVyY2jDqSBnbGkgRVRGIEV0aGVyZXVtIFNwb3Qgbm9uIGhhbm5vIHN1Yml0byB1biBzaWduaWZpY2F0aXZvIGF1bWVudG8gZGkgcHJlenpvIGRvcG8gaWwgbGFuY2lvPw==

2024-08-01, 08:18

<p><img src="https://gimg2.gateimg.com/image/article/17225000271692587449analysis.jpeg" alt=""></p>
<h2 id="h2-TLDR983583"><a name="[TL;DR]:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL;DR]:</h2><p>Il lancio di <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Gli ETF non hanno immediatamente scatenato una reazione positiva sul mercato, ma hanno invece causato un significativo sell-off sul mercato. Questo fenomeno è simile al modello di reazione di mercato quando <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Gli ETF sono stati lanciati in passato, indicando che ci sono aspettative e reazioni complesse nel mercato nei confronti del lancio di tali prodotti.</p>
<p>La consapevolezza del pubblico su <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> è molto inferiore rispetto a quella di Bitcoin. A causa delle elevate commissioni di gestione per grayscale ETHE e dell’incapacità degli utenti di ottenere profitti attraverso lo staking, la volontà del pubblico di configurare Ethereum è relativamente bassa.</p>
<p>A lungo termine, il lancio di ETF Ethereum spot è previsto per promuovere ulteriormente l’accettazione e l’adozione mainstream di Ethereum e dell’intera criptovaluta. <a href="/price" rel="nofollow noopener noreferrer" target="_blank">mercato delle criptovalute</a>.</p>
<h2 id="h2-Introduzione474021"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>Gli ETF Ethereum spot sono stati lanciati a fine luglio, con il volume di trading iniziale che indica il suo successo. Tuttavia, in mezzo all’euforia di mercato, è stata la debole diminuzione dei prezzi dell’ETH.</p>
<p>In questo articolo, esploreremo le ragioni dietro questo fenomeno anomalo e indagheremo sul futuro trend dei prezzi di ETH.</p>
<h2 id="h2-Spot20ETF20elencato20Ethereum20non20sta20salendo20ma20sta20cadendo720632"><a name="Spot ETF elencato, Ethereum non sta salendo ma sta cadendo" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Spot ETF elencato, Ethereum non sta salendo ma sta cadendo</h2><p>Dalla quotazione degli ETF Ethereum statunitensi il 23 luglio, il trading dei prodotti è stato attivo, ma l’attesa impennata non si è verificata e le prestazioni di Ethereum sono state deboli e in declino.<br><img src="https://gimg2.gateimg.com/image/article/17225000911.jpg" alt=""><br>Origine: Gate.io</p>
<p>Secondo gli ultimi dati di monitoraggio, oltre a un flusso netto di oltre 100 milioni di dollari nel primo giorno di quotazione degli ETF, c’è stato un significativo trend di deflusso nei giorni di negoziazione successivi.<img src="https://gimg2.gateimg.com/image/article/17225001182.jpg" alt=""><br>Fonte: coinglass</p>
<p>Anche se la tendenza di Ethereum replica parzialmente le caratteristiche di volatilità di <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> prima e dopo l’approvazione e la quotazione degli ETF, in termini di fondo <a href="/price/flow-flow" rel="nofollow noopener noreferrer" target="_blank">flusso</a>, Ethereum non è così ampiamente accettato dal mercato come Bitcoin e le sue prestazioni di prezzo sono relativamente deboli.</p>
<p>Nel frattempo, alcuni token nell’ecosistema Ethereum non hanno mostrato una performance complessiva eccezionale e hanno addirittura rendimenti inferiori rispetto all’ETH stesso. L’ultimo rapporto mostra che nessun token L2 ha superato l’ETH quest’anno, con il miglior rendimento di GNO che è aumentato del 34% ma è comunque inferiore al 44% dell’ETH. Tra i top-tier Altcoin L1, ad eccezione di AVAX, gli altri token hanno rendimenti migliori dell’ETH.<img src="https://gimg2.gateimg.com/image/article/17225001353.jpg" alt=""><br>Sorgente: Thor</p>
<p>Da questo punto di vista, sembra insostenibile l’idea che ETH possa innescare una deviazione dei fondi verso il token dell’ecosistema dopo il suo lancio negli ETF spot.</p>
<h2 id="h2-Limitato20potere20dacquisto20e20stretta20liquidit20di20mercato20di20fondo609230"><a name="Limitato potere d’acquisto e stretta liquidità di mercato di fondo" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Limitato potere d’acquisto e stretta liquidità di mercato di fondo</h2><p>A causa del fatto che la consapevolezza del pubblico su Ethereum è molto inferiore a quella di Bitcoin, unita alle elevate commissioni di gestione per grayscale ETHE e all’incapacità degli utenti di ottenere rendimenti tramite staking, la volontà del pubblico di investire e allocare fondi è relativamente bassa.</p>
<p><strong>La logica degli investimenti in ETH è complessa, il consenso è inferiore a BTC</strong><br>Come l’oro del mondo digitale, il Bitcoin ha una chiara scarsità, una quantità totale limitata ed è stato emesso per primo. Questo concetto semplice e facile da comprendere è amato profondamente dal pubblico e si adatta perfettamente al loro quadro di investimento. Al contrario, Ethereum, come una fondamentale catena pubblica di riferimento, ha un meccanismo di mining complesso che viene influenzato da molteplici forze dell’ecosistema. La sua offerta come prodotto di investimento coinvolge complessi meccanismi di inflazione e deflazione, rendendolo difficile per gli investitori ordinari capirlo intuitivamente.</p>
<p>Soprattutto dopo che Ethereum è passato a PoS, lo sviluppo dell’ecosistema sulla blockchain non è stato fluido e occasionalmente si verifica inflazione nella produzione di token, il che porta gli investitori a mancare di pazienza e fiducia in prodotti con un alto livello di accesso.</p>
<p>In realtà, i dati pubblici confermano ulteriormente la significativa differenza di popolarità tra gli ETF di Ethereum e gli ETF di Bitcoin. Secondo i risultati della ricerca di Google, la popolarità di Ethereum è solo circa un sesto di quella di Bitcoin, e dopo il lancio degli ETF di Ethereum, la sua popolarità è ancora più bassa rispetto a quella di Bitcoin.<br><img src="https://gimg2.gateimg.com/image/article/17225001844.jpg" alt=""><br>Fonte: tendenze.google</p>
<p><strong>Simile alla pressione venditrice di conversione precoce degli ETF Bitcoin</strong><br>Simile ai primi giorni dell’elenco di Bitcoin ETF, i detentori originali di Grayscale Ethereum Trust (ETHE) sono stati in grado di vendere e monetizzare in grandi quantità in un ambiente di maggiore liquidità. Allo stesso tempo, la differenza delle commissioni di gestione tra ETHE e i concorrenti era fino a 10 volte, il che ha portato anche a una pressione di vendita nelle fasi iniziali del trasferimento degli asset a causa delle commissioni elevate.</p>
<p>Come mostrato nella figura sottostante, dopo l’elenco dell’ETF Bitcoin dell’11 gennaio di quest’anno, Grayscale ha subito anche una continua pressione di vendita a causa delle elevate commissioni di gestione, con conseguente debole tendenza al ribasso dei prezzi di Bitcoin durante questo periodo.<br><img src="https://gimg2.gateimg.com/image/article/17225002165.jpg" alt=""><br>Sorgente: Gate.io</p>
<p>Naturalmente, al fine di evitare la pressione commerciale causata dalla continua fuoriuscita dei fondi Bitcoin nel passato, Grayscale ha contemporaneamente diviso il 10% dei suoi attivi netti per creare un mini ETF Ethereum a basso costo durante la conversione in ETF. Grayscale avrà due ETF Ethereum nel suo portafoglio, con commissioni di gestione del 2,5% e dello 0,15%, rispettivamente. Inoltre, a causa della convergenza precoce di ETH sul prezzo attuale di ETH, la pressione di fuoriuscita degli ordini di arbitraggio e di sblocco è relativamente bassa. Tuttavia, le conversioni e le vendite anticipate causeranno comunque una pressione a breve termine.</p>
<p><strong>La mancanza di staking ha ridotto la domanda degli investitori per rendimenti privi di rischio</strong><br>A causa delle restrizioni normative, gli ETF Ethereum non possono ottenere un rendimento base di staking del 3% -5% sulla catena, il che rende gli investitori professionisti più inclini a mantenere lo spot di Ethereum piuttosto che acquistare direttamente gli ETF.</p>
<p>Naturalmente, secondo i commissari della SEC, gli staking degli ETF Ethereum “possono sempre essere rivalutati. Ciò naturalmente libererà una certa domanda da parte degli acquirenti, e siamo ottimisti al riguardo.</p>
<h2 id="h2-Quando20smetter20di20cadere20lETH20e20diventer20forte180002"><a name="Quando smetterà di cadere l’ETH e diventerà forte?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Quando smetterà di cadere l’ETH e diventerà forte?</h2><p>Basandosi unicamente sulla limitata risposta di mercato e sulle performance dei prezzi delle criptovalute, è ancora necessario considerare le opinioni precedenti secondo cui gli ETF spot miglioreranno le scarse performance e le prospettive negative dell’ecosistema Ethereum, il che riflette l’incertezza degli investitori e l’instabilità di mercato associata a questi ETF.</p>
<p>In netto contrasto, non abbiamo ancora visto alcuna discussione da parte della Fondazione Ethereum sull’effetto degli ETF spot sui prezzi di Ethereum e ci concentriamo ancora sull’architettura teorica sottostante.<img src="https://gimg2.gateimg.com/image/article/17225002546.jpg" alt=""><br>Origine: @VitalikButerin</p>
<p>D’altra parte, il successo di Ethereum non risiede solo nella sua leadership tecnologica e negli effetti di rete, ma anche nella sua capacità di continuare ad attrarre sviluppatori, mantenere la vitalità dell’ecosistema e gestire efficacemente il sentimento di mercato e la narrazione per mantenere il suo vantaggio competitivo a lungo termine.</p>
<p>Ethereum ha dimostrato significativi vantaggi in termini di anti-manipolazione, liquidità e trasparenza dei prezzi. Rispetta anche gli standard di approvazione della SEC, gettando le basi affinché più cripto-attività (come SOL) possano entrare nell’occhio del pubblico attraverso ETF spot in futuro.</p>
<p>Sebbene le prestazioni di mercato degli ETF Ethereum siano relativamente piatte rispetto agli ETF Bitcoin, il loro impatto a lungo termine sui prezzi di Ethereum potrebbe riflettersi nel miglioramento della stabilità dei prezzi e nella riduzione della volatilità, offrendo agli investitori opzioni di investimento più solide.</p>
<p>A lungo termine, il lancio degli ETF Ethereum segna una nuova fase di integrazione tra l’ecosistema cripto e il mondo mainstream. Sebbene questo processo sia accompagnato da un aggiustamento cognitivo e da fluttuazioni di mercato, queste fluttuazioni creano nuove opportunità per gli investitori. È prevedibile che, man mano che la pressione di vendita iniziale degli ETF si ridurrà gradualmente, i prezzi di ETH torneranno anche ad una tendenza al rialzo.</p>
<p>Pertanto, nonostante affronti sfide, Ethereum ha ancora una grande opportunità di diventare la piattaforma crittografica dominante in futuro grazie al suo vantaggio di primo arrivato, ai forti effetti di rete e agli obiettivi di sviluppo a lungo termine chiari. Nel contesto dell’aumento dell’integrazione del mondo crittografico e del mondo mainstream, lo sviluppo di Ethereum e dei suoi ETF continuerà a ricevere attenzione e potrebbe diventare un fattore chiave che guida il progresso dell’intera industria.</p>
<div class="blog-details-info"><br><div>Autore:<strong>Carl Y.</strong>, Ricercatore di Gate.io<br><div>Traduttore: Joy Z.<br><div class="info-tips"><em>Questo articolo rappresenta solo le opinioni del ricercatore e non costituisce suggerimenti di investimento.<br></em><div><em></em>Gate.io si riserva tutti i diritti su questo articolo. Sarà consentito il ripostaggio dell'articolo a condizione che sia citato Gate.io. In tutti i casi, verranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div></div>