TCdlbnR1c2lhc21vIHBlciBnbGkgRVRGIGRpIEV0aGVyZXVtIHNpIGFmZmlldm9saXNjZTogdW5vIHNndWFyZG8gcGnDuSBhdHRlbnRvIGFsbGEgc3RhZ25hemlvbmUgaW5mZXJpb3JlIGFpIDQuMDAwIGRvbGxhcmk=

2024-06-05, 07:23

<p><img src="https://gimg2.gateimg.com/image/article/1692587449analysis.jpeg" alt=""></p>
<h2 id="h2-TL20DR415796"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p>La Securities and Exchange Commission degli Stati Uniti ha approvato gli ETF di <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> il 23 maggio.</p>
<p>Potrebbe richiedere settimane o mesi agli emittenti degli ETF per lanciare gli ETF ETH.</p>
<p>Gli ETF su ETH aumenteranno la liquidità nel mercato di Ethereum.</p>
<h2 id="h2-Introduzione364472"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>L’approvazione della SEC degli Stati Uniti dei fondi negoziati in borsa (ETF) per lo scambio di criptovalute ha inaugurato una nuova era nell’industria delle criptovalute in quanto ha attirato molti investimenti istituzionali. Mentre il lancio di spot <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Gli ETF hanno segnalato l’inizio dell’accettazione mainstream delle criptovalute, l’approvazione degli ETF Ethereum spot ha annunciato l’espansione del ruolo degli asset digitali nel mondo finanziario.</p>
<p>Oggi discutiamo del percorso di Ethereum verso le approvazioni ETF negli Stati Uniti. Valuteremo anche lo stato attuale delle cose all’interno del mercato ETF ETH.</p>
<h2 id="h2-Approvazioni20degli20ETF20di20Ethereum20Una20breve20celebrazione744844"><a name="Approvazioni degli ETF di Ethereum: Una breve celebrazione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Approvazioni degli ETF di Ethereum: Una breve celebrazione</h2><p>A seguito della SEC degli Stati Uniti <a href="https://www.gate.io/blog_detail/4168" target="_blank">approvazione degli ETF Ethereum spot il 23 maggio</a> la comunità delle criptovalute ha risposto positivamente, risultando in un breve periodo di aumento di Ether (ETH). Diverse società di gestione patrimoniale, tra cui Fidelity, Bitwise, VanEck, Franklin, ARK Invest e Grayscale, hanno ottenuto il diritto di lanciare spot ETH ETF, previa compilazione della documentazione richiesta.</p>
<p>Il <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Prezzo di Ethereum</a> L’analisi mostra che dopo l’approvazione degli ETF, il prezzo di ETH è salito sopra i 3.900 dollari, ma è poi diminuito a 3.720 dollari nel giro di breve tempo. Il grafico seguente mostra il movimento del prezzo di ETH dopo l’approvazione degli ETF.<br><img src="https://gimg2.gateimg.com/image/article/17175719741.jpg" alt=""><br>Movimento del prezzo di Ethereum dopo l’approvazione della SEC degli Stati Uniti degli ETF ETH - CoinGecko</p>
<p>Come mostra il diagramma, il prezzo di Ethereum ha raggiunto i $3.946 dopo l’approvazione degli ETF. Anche se il prezzo è diminuito, è rimasto abbastanza alto da allora, oscillando sopra i $3.600. Ciò che è anche degno di nota nel diagramma è il picco del prezzo di ETH che è avvenuto il 20 maggio, una settimana prima della data di approvazione degli ETF. L’anticipazione dell’approvazione degli ETF spot di ETH negli Stati Uniti è stata la ragione dietro quella forte azione del prezzo.</p>
<h2 id="h2-Pizzino20Perch20il20prezzo20di20Ethereum20non2020salito20oltre20i20400020e20la20tiepida20corsa20della20coppia20ETHBTC645319"><a name="Pizzino: Perché il prezzo di Ethereum non è salito oltre i $4.000 e la tiepida corsa della coppia ETH/BTC" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Pizzino: Perché il prezzo di Ethereum non è salito oltre i $4.000 e la tiepida corsa della coppia ETH/BTC</h2><p>Senza dubbio, il mercato delle criptovalute si aspettava che il prezzo di ETH superasse il livello di resistenza di $4.000 dopo l’approvazione degli ETF. Ma ciò non è accaduto. Quindi, quale potrebbe essere la spiegazione per questo?</p>
<p>Nonostante un’azione dei prezzi promettente il 23 maggio che ha portato a un aumento del 0,65% della sua capitalizzazione di mercato, ETH non è riuscito a superare il livello di resistenza di $4.000. Jason Pizzino, un analista di criptovalute, ritiene che l’approccio cauto degli investitori abbia bloccato il potenziale rialzo del prezzo di ETH.</p>
<p>Come per <a href="https://beincrypto.com/ethereum-etf-approval-price-below-4000/" rel="nofollow noopener noreferrer" target="_blank">Pubblicazione di BeInCrypto</a>, Pizzino ha detto: “L’ETF Ethereum è stato approvato. Tuttavia, ciò non è bastato a spingere il prezzo oltre i $4.000. Anche la coppia ETH/BTC ha visto un rally più debole del previsto.” Tuttavia, alcuni analisti crittografici ritengono che il prezzo dell’ETH raggiungerà probabilmente gli $8.000 entro la fine del 2024 a seguito dell’afflusso di capitale dagli ETF.</p>
<p>Il mercato potrebbe non aver risposto con la forza che le persone si aspettavano poiché gli ETF non sono ancora stati lanciati. Pertanto, gli investimenti in criptovalute nel mercato Ethereum sono ancora limitati. La ragione è che gli emittenti degli ETF dovranno ottenere l’approvazione della SEC prima di lanciare gli ETF. Di conseguenza, potrebbe volerci settimane o mesi prima che gli ETF siano negoziati sulle borse. La situazione è stata diversa da quanto accaduto agli ETF di <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">bitcoin</a> spot che sono stati lanciati sulle borse entro 24 ore dall’approvazione della SEC.</p>
<h2 id="h2-Breve20trionfo20e20declino20di20Pepe20Dettaglio20della20reazione20immediata20della20meme20coin20alla20notizia20dellETF33299"><a name="Breve trionfo e declino di Pepe: Dettaglio della reazione immediata della meme coin alla notizia dell’ETF" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Breve trionfo e declino di Pepe: Dettaglio della reazione immediata della meme coin alla notizia dell’ETF</h2><p>Oltre alla tiepida risposta dell’ETH alla notizia dell’approvazione dell’ETF statunitense sull’ETH <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> I token basati sulla rete hanno reagito in modo misto. Le tendenze di mercato di Ethereum mostrano che PEPE ha reagito positivamente alla notizia poiché il suo prezzo è aumentato significativamente raggiungendo un nuovo massimo storico di $0.00001576. Tuttavia, il momentum rialzista non è durato a lungo poiché si è ritracciato dell’8% in seguito.</p>
<p>Anche se inizialmente il prezzo di Arbitrum è aumentato, è anche diminuito del 3% in un breve periodo. Il prezzo di <a href="/price/lido-dao-ldo" rel="nofollow noopener noreferrer" target="_blank">Lido DAO</a> (LDO) è salito alle stelle prima di scendere di nuovo, seguendo le tendenze di PEPE, ARB e ETH. La stessa tendenza che bitcoin ha sperimentato è stata osservata tra questi token basati sulla blockchain di Ethereum. Infatti, dopo l’approvazione degli ETF spot di bitcoin, il prezzo del BTC è inizialmente sceso prima di aumentare di molto. Alla fine, il momentum rialzista di bitcoin è durato mesi dopo il lancio degli ETF.</p>
<h2 id="h2-Differenze20tra20lapprovazione20dellETF20di20Ethereum20e20Bitcoin109249"><a name="Differenze tra l’approvazione dell’ETF di Ethereum e Bitcoin" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Differenze tra l’approvazione dell’ETF di Ethereum e Bitcoin</h2><p>Come detto, l’approvazione degli ETF Ethereum spot ha segnato la consolidazione del mercato crittografico. Ora c’è molta fiducia che le criptovalute siano qui per restare e contribuiranno in modo significativo al settore finanziario. Ciò che è significativo è l’approvazione sia degli ETF ETH che <a href="https://www.gate.io/blog_detail/379/what-are-bitcoin-etfs-bitcoin-etfs-explained" target="_blank">Bitcoin ETFs</a> La notizia ha portato molta gioia nel settore delle criptovalute. Tuttavia, il processo di approvazione degli ETF Bitcoin è stato diverso da quello degli ETF ETH.</p>
<p>Fondamentalmente, il <a href="https://www.gate.io/learn/articles/what-the-official-approval-of-bitcoin-spot-etfs-means-for-the-crypto-industry/2055" target="_blank">l’approvazione degli ETF di bitcoin è stata storica</a> dal momento in cui sono stati i primi ETF criptovalutari negli Stati Uniti. Questi ETF hanno aperto le prime porte per l’afflusso di fondi istituzionali nel settore delle criptovalute. Anche gli investitori al dettaglio hanno iniziato a trarre vantaggio dal bitcoin poiché ora potevano investire indirettamente in BTC senza la necessità di gestire portafogli digitali. Inoltre, il mercato delle criptovalute ha visto l’approvazione degli ETF bitcoin come legittimazione non solo del bitcoin, ma di tutte le valute digitali.</p>
<p>Verso l’approvazione degli ETF Bitcoin, la SEC era più preoccupata per la possibilità di manipolazione del mercato dopo il loro lancio. Pertanto, si è concentrata nel garantire che il mercato degli ETF avesse le misure necessarie per proteggere i consumatori. Ora, la situazione che si è verificata dopo il lancio degli ETF Bitcoin sembra aver convinto la SEC che il mercato degli ETF abbia misure adeguate per prevenire e affrontare la manipolazione del mercato.</p>
<p>Il percorso verso l’approvazione degli ETF di Bitcoin ha avuto meno ostacoli rispetto alla strada verso gli ETF di Ethereum. Innanzitutto, l’approvazione degli ETF di ETH è arrivata dopo molto dibattito sulla legislazione necessaria per regolare le criptovalute. Ad esempio, gli Stati Uniti e l’Unione Europea stanno lavorando per introdurre una regolamentazione delle criptovalute. Molta discussione è stata anche sul fatto di classificare ETH come una criptovaluta o un titolo. Pertanto, l’approvazione degli ETF di ETH è arrivata durante un periodo di maggiore incertezza regolamentare rispetto al lancio degli ETF di BTC.</p>
<p>Leggi anche: <a href="https://www.gate.io/learn/articles/bitcoin-efts-have-been-trading-around-the-world-for-years/2801" target="_blank">Gli ETF di Bitcoin sono stati scambiati in tutto il mondo da anni</a></p>
<h2 id="h2-Paralleli20tra20lapprovazione20dellETF20di20Ethereum20e20Bitcoin20e20il20comportamento20passato20del20mercato616163"><a name="Paralleli tra l’approvazione dell’ETF di Ethereum e Bitcoin e il comportamento passato del mercato" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Paralleli tra l’approvazione dell’ETF di Ethereum e Bitcoin e il comportamento passato del mercato</h2><p>Il mercato delle criptovalute ha reagito in modo diverso al lancio degli ETF su bitcoin e degli ETF su Ethereum negli Stati Uniti. Tuttavia, c’erano una o due somiglianze.</p>
<p>Impatto sul mercato e reazioni: l’approvazione degli ETF di bitcoin ed ETH ha suscitato interesse per gli asset. Sia gli investitori istituzionali che quelli al dettaglio hanno mostrato la volontà di investire in queste due criptovalute tramite gli asset finanziari regolamentati (ETF). Coloro che non sono disposti a comprare ETH o bitcoin direttamente possono ora investire nei loro derivati, in particolare nei fondi negoziati in borsa.</p>
<p>Volumi di trading e movimenti dei prezzi: dopo l’approvazione degli ETF su bitcoin, il prezzo del BTC è aumentato, accompagnato da volumi di trading elevati. Allo stesso modo, l’approvazione della SEC per Ethereum ha portato a una tendenza simile. Sia il volume di trading di Ethereum che il prezzo sono aumentati durante un periodo di 24 ore dopo l’approvazione degli ETF.</p>
<p>La differenza notevole tra Bitcoin e <a href="https://www.gate.io/price-prediction/ethereum-eth" target="_blank">Movimenti dei prezzi ETH</a> dopo l’approvazione dei rispettivi ETF è stata la durata dei loro periodi di prospettive rialziste post-ETF. Il prezzo dell’ETH è salito per un breve periodo di circa 24 ore mentre il <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Prezzo Bitcoin</a> ha registrato un aumento per oltre tre mesi durante la fase successiva all’approvazione degli ETF.</p>
<p>Correlazione tra Bitcoin ed Ethereum: anche se Bitcoin ed ETH avevano una correlazione, l’approvazione degli ETF Ethereum è probabile che rafforzi questa relazione positiva. Questo perché l’approvazione della SEC… <a href="https://www.gate.io/blog_detail/207/why-do-people-choose-crypto-etfs-what-are-the-advantages-and-disadvantages" target="_blank">di ETF criptovalutari</a> ha agito come il riconoscimento degli Stati Uniti dei due asset come strumenti di investimento di valore. Pertanto, sia gli investitori istituzionali che quelli al dettaglio sono probabilmente <a href="https://www.gate.io/how-to-buy/ethereum-eth" target="_blank">acquistare Ethereum</a> e bitcoin in quantità più proporzionali rispetto prima. Inoltre, gli investitori possono versare i loro fondi nella coppia ETH/BTC.</p>
<h2 id="h2-Cambiamento20di20posizione20della20SEC20sugli20ETF20criptovaluta393404"><a name="Cambiamento di posizione della SEC sugli ETF criptovaluta" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Cambiamento di posizione della SEC sugli ETF criptovaluta</h2><p>Non sorprende che la SEC abbia cambiato la sua posizione nei confronti degli ETF cripto. In primo luogo, sembrava precario per la SEC di disapprovare gli ETF Ethereum a causa del precedente di bitcoin. Se la SEC avesse respinto le domande di ETF ETH, i richiedenti avrebbero potuto fare causa all’organo di regolamentazione sulla base legale che sia ETH che BTC sono criptovalute, non lasciando spazio per la discriminazione.</p>
<p>In secondo luogo, nel breve periodo in cui gli ETF di bitcoin spot sono esistiti, non c’è stata manipolazione di mercato né altre minacce agli investitori di ETF crypto. Tale scenario potrebbe aver creato fiducia nell’organo di regolamentazione affinché la stessa situazione cooperativa continui dopo l’approvazione degli ETF ETH.</p>
<p>Infine, c’è stata molta pressione politica affinché l’amministrazione Biden adotti politiche pro-crypto. Ad esempio, durante la sua campagna elettorale, Donald Trump ha attaccato l’amministrazione Biden e il presidente della SEC, Gensler, per il rallentamento dei progressi nel settore delle criptovalute. Tale pressione politica potrebbe aver attenuato la dura posizione della SEC nei confronti degli asset criptati.</p>
<h2 id="h2-Il20ruolo20degli20ETF20per20gli20investimenti20in20criptovalute958711"><a name="Il ruolo degli ETF per gli investimenti in criptovalute" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Il ruolo degli ETF per gli investimenti in criptovalute</h2><p>Gli ETF cripto, che sono derivati, semplificano i processi di investimento in criptovalute. Innanzitutto, gli investitori non devono acquistare e conservare criptovalute come bitcoin ed ETH. Beneficiano semplicemente dei loro movimenti di prezzo attraverso gli investimenti in ETF. Di conseguenza, il processo di investimento in criptovalute diventa comodo e meno rischioso. Ciò è dovuto al fatto che non c’è alcuna possibilità che gli asset cripto degli investitori possano essere rubati attraverso hacking o altri mezzi.</p>
<p>Poiché gli ETF sono asset di investimento tradizionali, molti investitori tradizionali possono anche scambiarli. Il fatto che essi siano strumenti finanziari regolamentati crea fiducia tra gli investitori conservatori. In generale, gli ETF criptovalutari attirano molti investimenti nel settore, aumentando la liquidità sul mercato e promuovendo il trading di asset digitali.</p>
<h2 id="h2-Conclusione625329"><a name="Conclusione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusione</h2><p>Dopo che la SEC degli Stati Uniti ha approvato gli ETF Ethereum il 27 maggio, il prezzo dell’ETH è aumentato del 22%, ma in seguito è nuovamente diminuito. L’approvazione sia degli ETF ETH che degli ETF Bitcoin ha attirato molti investimenti istituzionali nel settore. Un’altra cosa positiva sugli ETF criptati è che semplificano gli investimenti nelle criptovalute. Dopo il lancio degli ETF bitcoin, c’è stato un grande afflusso di capitali nel mercato del BTC. Il mercato criptato prevede che dopo il lancio degli ETF ETH ci sarà più investimento istituzionale nell’altcoin rispetto a prima.</p>
<div class="blog-details-info"><br><div>Autore:<strong>Mashell C.</strong>, 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. La ripubblicazione dell'articolo sarà consentita a condizione che venga citato Gate.io. In tutti i casi, saranno intraprese azioni legali a causa della violazione del copyright.<br></div><p></p><br></div></div></div>