QnJldmUgaW1wZW5uYXRhOiBsZSBjb21taXNzaW9uaSBFdGhlcmV1bSByYWdnaXVuZ29ubyBpICQxMDAgZG9wbyBsYSBwcmVzZW50YXppb25lIGRpIEVUSCBkaSBCbGFja1JvY2s=

2023-11-22, 02:56

<p><img src="https://gimg2.gateimg.com/image/article/1700024128RDZZ 1.jpeg" alt=""><br>BlackRock ha presentato una domanda di ETF ETH negli Stati Uniti.</p>
<p>Il prezzo di ETH è salito a $2,100 quando il mercato ha appreso della domanda di <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> ETF di BlackRock.</p>
<p>Il 9 novembre le commissioni ETH gas sono salite a 270 Gwei a causa di un aumento della domanda per la moneta.</p>
<p>Parole chiave: <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> ETF, ETF criptovalutari, ETF ETH, prezzo ETH, ETF spot ETH, ETF spot ethereum, approvazione ETF ETH, BlackRock ha presentato la documentazione, Commissione per le garanzie e gli scambi, BlackRock presenta ETF ETH, BlackRock ethereum ETF rally</p>
<h2 id="h2-Introduzione966177"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>Sebbene la Securities and Exchange Commission (SEC) degli Stati Uniti non abbia ancora approvato diversi spot <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Le domande relative agli exchange traded fund presentate all’inizio dell’anno, BlackRock ha presentato un’altra richiesta di ETF crypto, un ETF spot ETH.</p>
<p>Ora, in questo articolo analizziamo l’impatto della presentazione del fondo Ethereum ETF di BlackRock sul prezzo di ETH e sulle commissioni di transazione.</p>
<h2 id="h2-BlackRock20presenta20ETF20ETH20negli20Stati20Uniti93295"><a name="BlackRock presenta ETF ETH negli Stati Uniti" class="reference-link"></a><span class="header-link octicon octicon-link"></span>BlackRock presenta ETF ETH negli Stati Uniti</h2><p>Il 9 novembre, <a href="https://www.gate.io/bitwiki/detail/809" target="_blank">BlackRock</a> ha presentato una domanda per un fondo negoziato in borsa (ETF) Ethereum spot presso la Securities and Exchange Commission (SEC) degli Stati Uniti. In effetti, NASDAQ ha presentato il modulo 19b-4 per conto di BlackRock, la principale società di gestione patrimoniale valutata 9 trilioni di dollari.</p>
<p>Notizie correlate: <a href="https://www.gate.io/blog_detail/1643/blackrock-launches-blockchain-related-etf-for-european-markets." target="_blank">BlackRock lancia un ETF relativo alla blockchain per i mercati europei</a></p>
<p>Il progetto di ETF ETH proposto chiamato iShares Ethereum Trust segnala l’ambizione di BlackRock di aumentare il numero di spot crypto ETF, dopo aver presentato una domanda per un <a href="https://www.gate.io/bitwiki/detail/731/bitcoin-etfs" target="_blank">ETF su Bitcoin</a> che è in attesa di approvazione dalla SEC. Nella stessa data, la società ha acquisito il BlackRock iShares Ethereum Trust nel Delaware come passo preliminare verso la richiesta di un ETF su ETH.</p>
<p>In contesto, iShares di BlackRock è il nome della sua divisione ETF. A giugno ha utilizzato la stessa divisione <a href="https://www.gate.io/ru/blog_detail/3434/bitcoin-etf-approval-potential-catalyst-for-historic-crypto-bull-run" target="_blank">per registrare il suo Bitcoin ETF</a> Tali sviluppi dimostrano l’impegno della società di gestione del patrimonio verso le criptovalute.</p>
<p>Leggi anche: <a href="https://www.gate.io/blog_detail/2841" target="_blank">La presentazione degli ETF di BlackRock suscita sentimenti rialzisti, gli short su Bitcoin perdono 16 milioni di dollari</a></p>
<p>Il coinvolgimento di BlackRock nello spazio cripto ha molto peso considerando che è la più grande società di gestione patrimoniale al mondo. Se approvati, gli ETF cripto spot attireranno molti investimenti finanziari. È importante notare che un ETF cripto spot è un migliore asset di investimento. <a href="https://www.gate.io/blog_detail/3135" target="_blank">più di un ETH basato sui futures</a> o ETF Bitcoin.</p>
<p>Naturalmente, l’ETF Ethereum spot è un veicolo di investimento regolamentato che offre agli investitori l’esposizione a Ether senza tenerlo. Per le società di gestione del patrimonio, l’ETF ETH ha un vantaggio rispetto all’ETF BTC in quanto possono mettere in gioco l’ETH che sostiene gli ETF Ethereum spot.</p>
<h2 id="h2-Il20prezzo20di20ETH2020salito20a202100328389"><a name="Il prezzo di ETH è salito a $2.100" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Il prezzo di ETH è salito a $2.100</h2><p>A seguito della notizia della presentazione del file ETF spot ETH di BlackRock, il prezzo di ETH è salito a $2.100. Questo è stato il risultato degli investitori di ETH che hanno gonfiato il mercato, determinando il raggiungimento da parte dell’altcoin di un massimo di quasi 6 mesi. In sostanza, il rally dell’ETF Ethereum di BlackRock ha permesso ad ETH di superare il livello di resistenza dei $2.000.</p>
<p>Nel settore delle criptovalute si è accumulato slancio <a href="https://www.gate.io/blog_detail/3424/how-the-highly-anticipated-spot-bitcoin-etf-impacts-the-market" target="_blank">a seguito delle richieste di ETF Bitcoin spot</a> presentata da diverse società di gestione patrimoniale, tra cui BlackRock e Fidelity. Ora, la richiesta di BlackRock per un ETF ETH spot indica un interesse istituzionale per i derivati crittografici.</p>
<p>Secondo un importante analista, Ali, l’attività delle balene potrebbe ulteriormente alimentare il momentum del prezzo degli altcoin. <a href="https://twitter.com/ali_charts/status/1722865923399258557" rel="nofollow noopener noreferrer" target="_blank">Ali ha detto</a>“Ethereum ha riconquistato la soglia dei $2.000, e in modo interessante, tutto ciò sta accadendo prima ancora che le balene inizino ad acquistare $ETH!”</p>
<p>Tuttavia, il prezzo dell’ETH potrebbe ritracciare a causa dell’attività degli investitori dell’ETH che hanno aperto posizioni lunghe a $1.900 e potrebbero voler vendere le loro partecipazioni quando il suo valore supera il livello di prezzo di $2.000.</p>
<p>Un analista crittografico Pentoshi, con oltre 711K follower su X, ha commentato l’andamento recente del prezzo di ETH. Ha detto: ‘Alcuni pensieri su $ETH qui: Non è arrivato così in alto per non superare almeno i massimi annuali. Potrebbe lasciare che si accumulino prima alcune posizioni corte in quell’area per aumentare la liquidità’.</p>
<p>L’analista ha aggiunto: “Se l’ETF $BTC viene approvato, buona probabilità che ETH si rialzi più duramente.”</p>
<p>Tuttavia, Santiment ha evidenziato che l’incremento del 38% del prezzo dell’ETH nelle ultime quattro settimane non è stato solo il risultato dell’impulso derivante dalle richieste di ETF cripto. È stato anche il risultato della sua espansione di rete. Ad esempio, ha registrato di recente oltre 100.000 nuovi indirizzi ETH che detengono più di 0,1 ETH.</p>
<p>Dopo che BlackRock ha presentato la documentazione per un ETF Ethereum spot, i prezzi di diverse altre criptovalute sono aumentati. Ad esempio, il <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">bitcoin</a> ha raggiunto un nuovo massimo di prezzo di 18 mesi di $38.000, rispetto ai $35.000 dello stesso giorno. Tuttavia, più tardi nel corso della giornata, il suo prezzo è tornato a $36.300.</p>
<p>Il recente aumento del prezzo dell’ETH gli ha permesso di guadagnare una maggiore dominanza di mercato rispetto al passato. Di fatto, la sua dominanza è aumentata di 1,3 punti percentuali, attestandosi al 17%. Nonostante l’entusiasmo sugli ETF, potrebbe essere necessario del tempo prima che venga approvato l’ETF sull’ETH, poiché la SEC sta adottando un approccio cauto su questi derivati crittografici.</p>
<p>Significativamente, molti ETF criptati ancora <a href="https://www.gate.io/blog_detail/3289/sec-postpones-decision-on-spot-bitcoin-etfs-from-blackrock-and-others" target="_blank">attendere l’approvazione della SEC</a>. Come sappiamo, la SEC non ha ancora approvato un singolo ETF crypto spot. Invece, gli Stati Uniti hanno diversi ETF basati su futures crypto.</p>
<h2 id="h2-Il20gas20ETH2020salito20a2027020Gwei264838"><a name="Il gas ETH è salito a $270 Gwei" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Il gas ETH è salito a $270 Gwei</h2><p>Giovedì 9 novembre, nonostante il mercato stesse festeggiando l’improvviso aumento del prezzo dell’ETH, si è verificato uno sviluppo sconfortante. Le commissioni del gas di Ethereum sono aumentate fino a 270 Gwei, raggiungendo un livello che non si vedeva dall’ultima volta nel giugno 2022. L’aumento delle commissioni di transazione è stato il risultato dell’alta domanda di ETH.</p>
<p>L’incremento significativo delle commissioni di transazione ETH ha influenzato il costo degli swap commerciali. In particolare, i trader dovevano pagare tra $60 e $100 per transazione. In particolare, l’aumento delle commissioni di gas è stato il risultato della corsa all’acquisto dell’ETF ethereum di BlackRock che ha portato a una forte domanda per la moneta, causando congestione di rete.</p>
<p>Un tale scenario indica la sfida attuale che la blockchain Ethereum deve affrontare, ovvero la congestione della rete e la scalabilità. Tuttavia, sappiamo che il team di sviluppo di Ethereum continua a esplorare soluzioni ai problemi, inclusa Ethereum 2.0.</p>
<h2 id="h2-Possibile20obiezione20della20SEC20alla20sorveglianza6355"><a name="Possibile obiezione della SEC alla sorveglianza" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Possibile obiezione della SEC alla sorveglianza</h2><p>BlackRock ha un aspetto chiave che potrebbe influenzare la SEC nell’approvare i suoi ETF criptovalutari. È l’accordo di condivisione della sorveglianza con Coinbase che aiuterà a individuare attività fraudolente nel mercato spot.</p>
<p>A tal proposito, <a href="https://listingcenter.nasdaq.com/assets/rulebook/nasdaq/filings/SR-NASDAQ-2023-045.pdf" rel="nofollow noopener noreferrer" target="_blank">il deposito afferma</a> O CME surveillance può rilevare frodi di mercato spot che influiscono sia sugli ETF futures che sui prodotti scambiati in borsa spot, oppure tale sorveglianza non può farlo per entrambi i tipi di prodotto.</p>
<p>Ha aggiunto: ‘Aver approvato gli ETF futures ETH in parte sulla base di tale sorveglianza, la Commissione ha chiaramente stabilito che la sorveglianza del CME può individuare frodi nel mercato spot che potrebbero influenzare gli ETP spot, e il promotore ritiene quindi che debba anche approvare gli ETP spot sull’ETH sulla base di ciò’.</p>
<p>Quell’accordo di sorveglianza probabilmente darà fiducia alla SEC sulla potenziale capacità di BlackRock di gestire un ETF Ethereum con poche possibilità di manipolazione di mercato. Ciò perché Coinbase è un mercato cripto regolamentato rispettato ed affermato.</p>
<h2 id="h2-Conclusione194344"><a name="Conclusione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusione</h2><p>Il prezzo di ETH è aumentato il 9 novembre a seguito della presentazione della documentazione da parte di BlackRock sull’ETF Ethereum spot. Il rally dell’ETF Ethereum ha portato ETH a superare il livello di resistenza di $2.000 per raggiungere $2.100. Tuttavia, questa impennata dei prezzi è stata accompagnata da un picco temporaneo delle commissioni di gas ETH a circa 270 Gwei. Nel frattempo, BlackRock ritiene di aver soddisfatto i requisiti di approvazione di base di Ethereum spot della SEC.</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 il punto di vista 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 Gate.io venga menzionato. In tutti i casi, saranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div>