Q2FtYmlhbWVudG8gZGkgc2VudGltZW50OiBpbCBkZWNsaW5vIGRlbGwnaW50ZXJlc3NlIGRlZ2xpIGludmVzdGl0b3JpIG5lZ2xpIEVURiBFdGhlcmV1bSBTcG90

2024-09-04, 03:10

<p><img src="https://gimg2.gateimg.com/image/article/17254191441692587449analysis.jpeg" alt=""></p>
<h2 id="h2-TL20DR333641"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p>Il settore degli ETF su ETH ha registrato molte uscite nette di capitale nel primo mese di negoziazione.</p>
<p>Concorrenza tra <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Gli ETF e gli ETF ETH potrebbero aver portato a una grande fuoriuscita di capitale da <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> ETFs.</p>
<p>La SEC ha escluso il componente di staking dagli ETF ETH.</p>
<h2 id="h2-Introduzione839573"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>Gli ETF spot Ethereum, lanciati il 23 luglio, non hanno avuto lo stesso successo dei loro omologhi ETF spot bitcoin, lanciati a gennaio. Dopo il loro lancio all’inizio di quest’anno, gli ETF BTC quotati negli Stati Uniti hanno attirato molti capitali in entrata. Fino ad oggi, questi derivati <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">bitcoin</a> sono ancora popolari tra gli investitori. Tuttavia, non si può dire lo stesso degli ETF spot ETH, recentemente quotati negli Stati Uniti. Hanno registrato molte uscite dal loro lancio a luglio.</p>
<h2 id="h2-Performance20degli20ETF20ETH20Spot20quotati20negli20Stati20Uniti598050"><a name="Performance degli ETF ETH Spot quotati negli Stati Uniti" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Performance degli ETF ETH Spot quotati negli Stati Uniti</h2><p>Anche se c’era molto entusiasmo per gli ETF spot su Ethereum, le loro prestazioni sono state al di sotto della media. Nelle ultime settimane gli ETF spot su <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> <a href="https://www.gate.io/post/CryptoNews_/status/6738646" target="_blank">hanno registrato enormi deflussi</a> che ha anche pesato molto sul <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">prezzo ETH</a>. Dati da <a href="https://m.sosovalue.com/assets/etf/us-eth-spot" rel="nofollow noopener noreferrer" target="_blank">Sosovalue mostra</a> che gli ETF spot ETH hanno registrato deflussi dalla prima settimana del loro lancio. In particolare, durante la prima settimana i prodotti crypto ETF hanno avuto un deflusso netto di 341,35 milioni di dollari. Ancora una volta, durante la seconda settimana hanno avuto un deflusso netto di 169,35 milioni di dollari. Va notato che, all’interno di questi due periodi, il valore totale degli asset netti è sceso da 9,24 miliardi di dollari a 8,33 miliardi di dollari. La causa principale della caduta del valore degli asset è stata il calo del crypto ETH.</p>
<p>Sebbene gli ETF cripto continuino a registrare grandi deflussi a partire dalla terza settimana, hanno anche registrato alcuni influssi notevoli. Ad esempio, durante la terza settimana c’è stato un afflusso di 104,76 milioni di dollari. Durante la terza settimana di agosto si è verificato un notevole afflusso di capitali nel settore degli ETF Ethereum spot negli Stati Uniti per la prima volta. Nonostante i deflussi ammontassero a 38 milioni di dollari, l’iShares Ethereum Trust (ETHA) di BlackRock ha avuto flussi netti superiori a 1 miliardo di dollari. Fino ad ora è l’unico ETF cripto in questa categoria ad aver raggiunto un tale traguardo. Attualmente, ETHA ha attivi netti valutati oltre gli 860 milioni di dollari. Sulla base dell’analisi del mercato degli ETF, solo il mini trust ether (ETH) e il trust Ethereum (ETHE) di Grayscale hanno un valore superiore a ETHA.</p>
<h2 id="h2-Comprensione20degli20ETF20Ethereum20Spot456283"><a name="Comprensione degli ETF Ethereum Spot" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Comprensione degli ETF Ethereum Spot</h2><p>Gli exchange traded fund (ETF) spot su Ethereum sono asset di investimento che seguono il valore di Ether, la principale altcoin sul mercato. In pratica, attraverso un ETF spot su ETH gli investitori raccolgono i loro fondi per acquistare ETH. Tuttavia, una società di investimento gestisce questo fondo che viene scambiato su borse tradizionali. Di conseguenza, un ETF criptato è un asset di investimento regolamentato. È inoltre essenziale notare che ogni ETF su ETH dovrebbe avere una società di gestione degli asset crittografici che detiene l’asset sottostante, cioè Ether.</p>
<p>Gli ETF su Ethereum aiutano a semplificare gli investimenti per gli investitori al dettaglio che desiderano investire in criptovalute senza possederle. Gli investitori possono comprare e vendere quote dei fondi sulle tradizionali borse valori. Pertanto, possono utilizzare i loro conti di intermediazione esistenti per investire in prodotti legati alle criptovalute. ETF spot <a href="https://www.gate.io/learn/articles/the-impact-of-the-ethereum-etf-etf-an-analysis/3473" target="_blank">aiutare gli investitori al dettaglio ad adottare diverse strategie di investimento in criptovalute</a> È importante notare che la volatilità del mercato influenza il valore degli ETF ETH. Tuttavia, una persona che investe in un ETF ETH affronta meno complessità rispetto a chi sceglie. <a href="https://www.gate.io/how-to-buy/ethereum-eth" target="_blank">acquistare ETH</a>.</p>
<h2 id="h2-Analisi20ETF20ETH20Motivi20per20lInteresse20in20Declino518496"><a name="Analisi ETF ETH: Motivi per l’Interesse in Declino" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Analisi ETF ETH: Motivi per l’Interesse in Declino</h2><p>La notizia del <a href="https://www.gate.io/blog/4263/the-launch-of-spot-ethereum-etfs-is-imminent-will-the-market-first-fall-and-then-rise" target="_blank">possibile approvazione degli ETF ETH è stata sufficiente a guidare</a> il prezzo di Ether verso l’alto. Purtroppo, settimane dopo il lancio degli ETF ETH l’interesse per il prodotto è diminuito. Ci sono diverse possibili ragioni per questo, tra cui la volatilità del mercato e le sfide regolamentari.</p>
<p>Concorrenza da Bitcoin ETF: Uno dei principali fattori che potrebbe aver contribuito alla diminuzione dell’interesse degli ETF ETH spot è la concorrenza da parte degli ETF bitcoin. Molti investitori sembrano preferire investire in ETF bitcoin che hanno già un noto track record. Quando sono stati lanciati gli ETF Bitcoin, hanno avuto molti afflussi di capitale. Tuttavia, quando gli ETF ETH sono stati introdotti, la maggior parte di essi ha avuto deflussi netti. Un tale contrasto potrebbe aver indotto molti potenziali investitori a optare invece per gli ETF Bitcoin. Inoltre, la continua debolezza della coppia ETH/BTC dovrebbe aver influenzato gli investitori ETF a scegliere gli ETF BTC invece di quelli Ethereum.</p>
<p>Da notare che il bitcoin è classificato sopra l’ETH a livello globale, il che potrebbe influenzare gli investitori a sceglierlo invece che ETH. Infatti, il bitcoin è al primo posto mentre ETH è al secondo posto. Ciò può influenzare psicologicamente le persone a investire in ETF di bitcoin anziché in ETF di ETH.</p>
<p>Cambiamento del sentiment di mercato verso altri investimenti: La verità è che ci sono molti prodotti di investimento nello spazio cripto al momento. Gli investitori che originariamente hanno investito in ETF ETH potrebbero aver trovato altre opportunità di investimento. Esempi di prodotti notevoli che potrebbero aver scelto di investire includono ETF BTC, fondi indicizzati alle criptovalute, azioni correlate a Ethereum e prodotti generatori di rendimento come lo staking e il prestito di ETH.</p>
<p>Preoccupazione normativa: il fatto che la SEC degli Stati Uniti abbia escluso lo staking come componente di ETH potrebbe aver portato al declino degli ETF crittografici. Di solito, non sembra usuale occuparsi degli investimenti in Ethereum senza considerare lo staking. È un fatto che Franklin Templeton, Fidelity e BlackRock abbiano chiesto di aggiungere lo staking ai loro ETF ETH spot. Tuttavia, la SEC ha respinto le loro richieste. Con lo staking, gli utenti depositano i loro ETH nei nodi validatori per guadagnare ricompense dalle commissioni di rete. In questo caso, significa che gli ETH detenuti dagli emittenti dell’ETF non saranno idonei allo staking.</p>
<h2 id="h2-Pu20il20Declino20dellInteresse20per20gli20ETF20ETH20Influire20sul20Prezzo20dellETH428997"><a name="Può il Declino dell’Interesse per gli ETF ETH Influire sul Prezzo dell’ETH" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Può il Declino dell’Interesse per gli ETF ETH Influire sul Prezzo dell’ETH</h2><p>Il calo dell’interesse per gli ETF ETH potrebbe influenzare anche il prezzo degli ETH. Innanzitutto, se le notizie sulle uscite nette degli ETF ETH dominano il settore delle criptovalute, creano un sentimento negativo nei confronti della criptovaluta. Inoltre, da quando sono stati lanciati gli ETF Bitcoin, c’è stata una correlazione tra gli afflussi di capitale negli ETF e i movimenti dei prezzi. Ad esempio, quando ci sono alti afflussi negli ETF BTC, il suo prezzo di solito aumenta. D’altra parte, quando ci sono forti uscite nette, il suo prezzo tende a diminuire.</p>
<p>Questo esempio di ETF di bitcoin illustra che probabilmente esiste una relazione tra prodotti finanziari strutturati come gli ETF e il prezzo dell’attivo sottostante. In questo caso, il cambiamento risultante nella domanda di ETF di ETH, la liquidità e la partecipazione degli investitori possono influenzare il prezzo di ETH.</p>
<div class="blog-details-info"><br><div>Autore: Mashell C., Ricercatore di Gate.io<br><div class="info-tips"><em>Questo articolo rappresenta solo le opinioni del ricercatore e non costituisce alcun suggerimento 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, saranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div>