Q29tZSBpbmZsdWlzY2UgbGEgbHVjZSB2ZXJkZSBkZWdsaSBFVEYgRXRoZXJldW0gc3BvdCBzdWwgZnV0dXJvIGRlbCBtZXJjYXRvPw==

2024-05-28, 12:37

<p><img src="https://gimg2.gateimg.com/image/article/1692587449analysis.jpeg" alt=""></p>
<h2 id="h2-TLDR524157"><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 (SEC) degli Stati Uniti ha approvato <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Il 23 maggio è previsto il piano di trading spot ETF, che è ampiamente interpretato dal mercato come una forza trainante politica nel contesto delle elezioni presidenziali di quest’anno.</p>
<p>L’approvazione degli ETF spot di <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> stimolerà senza dubbio la scoperta del valore di Ethereum e dei suoi token dell’ecosistema, e da una prospettiva a lungo termine, aprirà la strada all’adozione di più criptovalute di alta qualità.</p>
<p>Riferendosi all’impatto della conversione di GBTC in ETF spot sul prezzo di <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a>, anche se Ethereum potrebbe subire pressioni al ribasso nel breve termine, avrà un impatto più positivo nel lungo periodo.</p>
<h2 id="h2-Introduzione500169"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>Diversi mesi dopo l’elenco degli ETF <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> spot, il mercato delle criptovalute ha fatto un altro passo avanti. La Securities and Exchange Commission (SEC) degli Stati Uniti ha approvato il piano di trading degli ETF Ethereum spot il 23 maggio, che sarà attuato dalla Borsa di New York (NYSE), Chicago Board of Options Exchange (CBOE) e Nasdaq. Si prevede che le negoziazioni inizieranno più avanti quest’anno, con potenziali emittenti tra cui BlackRock, Fidelity Grayscale, VanEck e Franklin Templeton, tra gli altri.</p>
<p>L’articolo fornirà un’interpretazione approfondita delle peripezie vissute dal processo di approvazione degli ETF di Ethereum, partendo da un iniziale forte svalutazione fino a un improvviso cambiamento di atteggiamento della SEC, e quale impatto avrà sul futuro mercato.</p>
<h2 id="h2-Lapprovazione20dellETF20spot20accoglie20il20semaforo20verde20Ethereum20vola20del2020766648"><a name="L’approvazione dell’ETF spot accoglie il “semaforo verde”, Ethereum vola del 20%" class="reference-link"></a><span class="header-link octicon octicon-link"></span>L’approvazione dell’ETF spot accoglie il “semaforo verde”, Ethereum vola del 20%</h2><p>Sullo sfondo della diffusa convinzione di mercato che la Securities and Exchange Commission (SEC) degli Stati Uniti probabilmente non avrebbe approvato gli ETF spot di Ethereum, questa aspettativa pessimistica è stata completamente ribaltata nelle prime ore del 20 maggio.</p>
<p>In precedenza, la controversia su se Ethereum sia o meno un titolo ha ostacolato il processo di approvazione degli ETF spot. Al momento dell’approvazione, il ritiro da parte di Grayscale della domanda di ETF futures su Ethereum è stato addirittura oggetto di speculazioni al fine di aumentare la probabilità di approvazione dell’ETF spot. Il 20 maggio, la SEC degli Stati Uniti ha richiesto alla borsa di aggiornare i documenti di presentazione 19b-4 dell’ETF spot su Ethereum, il che ha suscitato speculazioni positive sul mercato.<img src="https://gimg2.gateimg.com/image/article/17168996731.jpg" alt=""><br>Fonte: @EricBalchunas</p>
<p>Curiosamente, anche la prima ondata di richieste non aveva molte speranze iniziali. Il CEO di Van Eck, Jan van Eck, ha dichiarato il mese scorso di essere pronto a essere respinto.</p>
<p>Per gli investitori, ciò che è importante non è quando approvare, ma l’approvazione stessa. Dopo l’annuncio di notizie positive, i prezzi di Ethereum, che erano originariamente in una lenta discesa, hanno rapidamente ripreso, con un aumento giornaliero del 20%, battendo il record del più grande aumento giornaliero degli ultimi quasi 4 anni, avvicinandosi a $4000 in un punto, e guidando così l’aumento di Layer2, Layer1, MEME, AI e altri settori hanno portato a una ripresa del sentimento rialzista nel mercato.<br><img src="https://gimg2.gateimg.com/image/article/17168996972.jpg" alt=""><br>Origine: Gate.io</p>
<p>Secondo i dati di CoinGlass, in questa giornata altamente volatile, l’importo di liquidazione dell’intera posizione derivata cripto leva nel mercato è aumentato a oltre $360 milioni, il livello più alto dal 1 maggio. Tra le posizioni liquidate, la maggioranza sono posizioni corte con un valore di circa $250 milioni, indicando che i trader altamente leva sono concentrati nel scommettere sull’immediata crescita degli ETF. I trader ETH sono stati colpiti duramente, con un importo di liquidazione di $132 milioni.</p>
<p>Nella mattinata del 24 maggio, la SEC ha finalmente approvato le richieste dei moduli 19b-4 per gli ETF di Ethereum spot presentate da diverse istituzioni, tra cui BlackRock, Fidelity e Grayscale.</p>
<p>Sebbene queste forme siano state approvate, gli emittenti di ETF devono ancora attendere che la dichiarazione di registrazione S-1 abbia effetto prima di poter negoziare, il che potrebbe richiedere diverse settimane fino a cinque mesi. Tuttavia, gli ETF spot sono già una certezza.</p>
<p>Secondo alcune fonti, avvicinandosi le elezioni, la SEC potrebbe aver modificato la sua precedente e negativa attitudine per motivi politici. L’ex presidente Trump ha espresso frequentemente il suo supporto alle criptovalute nel corso del mese scorso, mentre la squadra di campagna dell’attuale presidente Biden ha anche iniziato a reclutare i gestori MEME. Il Partito Democratico potrebbe dimostrare il suo sostegno per le tecnologie innovative approvando gli ETF Ethereum spot per conquistare i voti dei sostenitori delle criptovalute.</p>
<p>Vale la pena notare che con l’aumento del sentiment di mercato, Ethereum non ha continuato a salire ma è entrato in uno stato forte e volatile, e molti giganti e istituzioni hanno iniziato a regolare le loro strategie di investimento. Alcune istituzioni e individui che puntano al ribasso su Ethereum hanno venduto le loro posizioni su Ethereum, indicando preoccupazioni di mercato sulla volatilità e l’incertezza dei prezzi di Ethereum.</p>
<h2 id="h2-Dietro20lapprovazione20le20potenziali20sfide20e20opportunit20di20Ethereum764466"><a name="Dietro l’approvazione, le potenziali sfide e opportunità di Ethereum" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Dietro l’approvazione, le potenziali sfide e opportunità di Ethereum</h2><p>La ragione principale dell’approvazione degli ETF Ethereum spot è attualmente attribuita all’impulso politico ricevuto dalla SEC, ma è anche dovuta all’influenza combinata di molti fattori pratici.</p>
<p>Innanzitutto, il lancio di successo degli ETF Bitcoin spot fornisce un precedente per l’approvazione degli ETF Ethereum spot, dove la SEC ha precedentemente approvato gli ETF futures per Bitcoin ed Ethereum.</p>
<p>In secondo luogo, nel precedente causa contro Grayscale, la SEC ha perso. Al fine di evitare conflitti legali, la SEC potrebbe scegliere di utilizzare gli ETF spot di Ethereum per evitare ulteriori contenziosi.</p>
<p>Inoltre, l’approvazione del disegno di legge FIT 21 ha chiarito la giurisdizione dell’industria delle criptovalute, creando un ambiente legale più chiaro per l’approvazione degli ETF spot di Ethereum. Nel frattempo, il disegno di legge SAB 121 precedentemente formulato dalla SEC è stato abrogato, riducendo la regolamentazione rigorosa delle criptovalute e creando condizioni favorevoli per l’approvazione degli ETF spot di Ethereum.</p>
<p>Ultimo ma non meno importante, durante le elezioni negli Stati Uniti, entrambi i partiti stanno cercando attivamente voti dalla comunità delle criptovalute, il che senza dubbio aumenta la pressione politica sulla SEC per rispondere passivamente all’Ethereum ETF.<br><img src="https://gimg2.gateimg.com/image/article/17168997373.jpg" alt=""><br>Origine: @matthew_sigel</p>
<p>In ogni caso, l’approvazione degli ETF Ethereum spot stimolerà senza dubbio la scoperta del valore di Ethereum e dei suoi token di ecosistema, e da una prospettiva a più lungo termine, aprirà anche la strada all’adozione di criptovalute di alta qualità in generale.</p>
<p>In primo luogo, l’adozione di Ethereum spot ETF aumenterà l’esposizione degli investitori istituzionali e al dettaglio ad Ethereum, senza la necessità di acquistare e gestire direttamente ETH, il che potrebbe aumentare significativamente la domanda complessiva di Ethereum e migliorare ulteriormente la sua posizione di mercato.</p>
<p>In secondo luogo, il volume degli scambi sulla rete Ethereum potrebbe aumentare, portando ad un aumento delle commissioni di gas e della congestione della rete, il che incoraggerà gli investitori e gli sviluppatori a prestare maggiore attenzione a soluzioni come Layer2 e modularità. Questo potrebbe portare nuove narrazioni al mercato di Ethereum. Naturalmente, c’è anche pressione regolamentare per frenare i potenziali rischi di innovazione.</p>
<p>Infine, questo sviluppo positivo aiuterà la SEC a mettere da parte controversie come quella su Ethereum che è un titolo, alleviare la pressione regolamentare sull’innovazione dell’ecosistema Ethereum e contribuire anche alla promozione attiva di altre criptovalute. Ad esempio, abbiamo osservato che alcuni hanno persino proposto SOL. <a href="/price/xrp-xrp" rel="nofollow noopener noreferrer" target="_blank">XRP</a> concetto di ETF spot.</p>
<h2 id="h2-20possibile20raggiungere20nuovi20massimi20in20futuro20con20larrivo20della20pressione20delle20vendite20di20Grayscale954206"><a name="È possibile raggiungere nuovi massimi in futuro con l’arrivo della pressione delle vendite di Grayscale?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>È possibile raggiungere nuovi massimi in futuro con l’arrivo della pressione delle vendite di Grayscale?</h2><p>A lungo termine, il lancio degli ETF spot Ethereum attirerà più fondi tradizionali nel settore delle criptovalute, spingendo l’intera industria verso una direzione di maggiore scala e conformità, e il prezzo della moneta aumenterà naturalmente.</p>
<p>Se confrontati con l’esperienza di successo degli ETF Bitcoin spot, anche gli ETF Ethereum hanno un forte effetto di “aspirazione dell’oro” e ci si aspetta che portino significativi flussi di capitale all’industria.</p>
<p>È ampiamente creduto che sebbene le dimensioni di mercato degli ETF spot su Ethereum potrebbero non essere paragonabili a quelli su Bitcoin, ci sia comunque un significativo margine di crescita. Si prevede che gli ETF spot su Ethereum potrebbero ricevere dal 10% al 15% degli asset acquisiti dagli ETF spot su Bitcoin, raggiungendo i 5 miliardi di dollari fino a 8 miliardi di dollari. Secondo Geoff Kendrick, responsabile della ricerca su forex e asset digitali presso Standard Chartered Bank, è più ottimista che dopo l’approvazione dell’ETF spot su Ethereum, si prevede di attirare circa 15 miliardi di dollari fino a 45 miliardi di dollari di afflussi di asset entro 12 mesi.</p>
<p>Considerando le modifiche in ETHE simili a GBTC prima e dopo l’ETF spot di Bitcoin, il premio di ETHE rispetto al suo valore patrimoniale netto (NAV) si è notevolmente ridotto dal -20,52% del 17 maggio al -1,27% di oggi, e il tasso di premio è addirittura aumentato fino al -26% il mese scorso. Da questa prospettiva, il mercato ha rapidamente iniziato a prezzare il sentiment positivo di Ethereum.<br><img src="https://gimg2.gateimg.com/image/article/17168997774.jpg" alt=""><br>Fonte: THE BLOCK</p>
<p>Poiché Grayscale converte i prodotti fiduciari in prodotti ETF, il mercato potrebbe affrontare una certa pressione di arbitraggio e vendita. Ad esempio, gli analisti di Kaiko ritengono che gli ETHE di Grayscale possano avere un deflusso medio giornaliero di $110 milioni nel primo mese dopo il lancio come ETF spot.</p>
<p>Dopo la riuscita conversione di Grayscale GBTC in Bitcoin spot ETF, anche se l’uscita di fondi da GBTC ha portato una certa pressione venditrice su Bitcoin e ha causato un calo temporaneo dei prezzi delle monete, ora è stata assorbita dagli altri ETF su Bitcoin. Da questa prospettiva, anche se potrebbe esserci una pressione al ribasso sui prezzi di Ethereum nel breve termine, l’impatto a lungo termine è più positivo.</p>
<p>Abbiamo precedentemente scritto diversi articoli suggerendo che Bitcoin e Ethereum hanno le loro principali caratteristiche funzionali, e la loro riconoscibilità e accettazione di mercato sono destinate a continuare a crescere. In particolare, per Ethereum, si prevede che il suo prezzo continuerà ad aumentare in futuro, soprattutto mentre gli investitori istituzionali entreranno gradualmente nel mercato, e la sua accelerazione di crescita sarà ancora più significativa.</p>
<p>In sintesi, questo evento storico avrà senza dubbio un profondo impatto sul mercato delle criptovalute, indicando ulteriori sviluppi e maturità del mercato delle criptovalute in futuro. Non solo promuove il processo di conformità dell’industria crittografica, ma attira anche una grande quantità di fondi tradizionali ad entrare nel mercato, offrendo agli investitori scelte di investimento più diverse. Allo stesso tempo, ciò fornisce un solido supporto per la crescita dei prezzi degli asset crittografici come Ethereum.</p>
<p>Va notato che nel contesto di politiche favorevoli e rapido sviluppo dell’industria, il mercato a breve termine potrebbe subire un surriscaldamento, con livelli di leva significativamente aumentati, il che aumenta fino a un certo punto la preferenza per il rischio di alcuni investitori. Come investitori, dovremmo sempre mantenere la razionalità e l’oggettività, valutare in modo completo l’ambiente di mercato, le preferenze di investimento e i fattori di controllo del rischio, evitare di seguire ciecamente la tendenza e prendere decisioni di investimento razionali.</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 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 venga citato Gate.io. In tutti i casi, verranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div></div>