SWwgY29tbWlzc2FyaW8gZGVsbGEgU0VDIGRpc2N1dGUgZGVsbGEgcHJvc3BldHRpdmEgZGkgYXBwcm92YXJlIHVuIEVURiBFdGhlcmV1bQ==

2024-02-08, 16:00

<p><img src="https://gimg2.gateimg.com/image/article/1707407263SDFXnew.jpeg" alt=""></p>
<h2 id="h2-In20breve866156"><a name="In breve;" class="reference-link"></a><span class="header-link octicon octicon-link"></span>In breve;</h2><p>La SEC prenderà la sua decisione sull’ETF ETH di BlackRock nel maggio 2024.</p>
<p>Hester Peirce, la commissaria della SEC, ha suggerito che l’autorità di regolamentazione potrebbe approvare ETF ETH spot prima o poi.</p>
<p>L’approvazione degli ETF ETH potrebbe legittimare l’ETH come un asset di investimento valido.</p>
<h2 id="h2-Introduzione796680"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>C’è molta speranza nel settore delle criptovalute che la SEC degli Stati Uniti possa presto approvare <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> exchange traded funds ( <a href="https://www.gate.io/blog_detail/538/what-are-etfs-etps-etns" target="_blank">ETF</a>). Il mercato si aspetta che l’approvazione arrivi entro i prossimi 45 giorni dopo che la SEC ha prorogato la data della sua decisione finale. L’approvazione dei depositi <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Gli ETF hanno stabilito un forte precedente per gli ETF ETH.</p>
<p>Questo post esplora le opinioni di un commissario della SEC sulla possibilità di approvazione degli ETF ETH durante il 2024. Esamineremo anche le ragioni del ritardo della SEC nel prendere una decisione finale sulle domande di <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> ETF.</p>
<h2 id="h2-La20SEC2020vicina20allapprovazione20degli20ETF20Ethereum368636"><a name="La SEC è vicina all’approvazione degli ETF Ethereum" class="reference-link"></a><span class="header-link octicon octicon-link"></span>La SEC è vicina all’approvazione degli ETF Ethereum</h2><p>Basandosi su Hester Peirce, le recenti osservazioni di un commissario della SEC, la Securities and Exchange Commission (SEC) potrebbe approvare gli ETF Ethereum in un prossimo futuro. Le sue opinioni indicano che la posizione della SEC sugli exchange traded funds (ETF) criptovalutari potrebbe essere cambiata.</p>
<p>Il commento di Peirce ha dato un <a href="https://youtu.be/b-LmqVMF8I0" rel="nofollow noopener noreferrer" target="_blank">suggerire una possibile svolta normativa della SEC</a> riguardante le criptovalute come <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">bitcoin</a> ed ETH. Hester Peirce, popolarmente conosciuta come “Crypto Mom”, ha mantenuto il suo sostegno alle criptovalute. Ha parlato della correlazione tra i futures criptati e i mercati spot delle criptovalute, una percezione che indica la possibilità di un’approvazione ETF di ETH.</p>
<p>Secondo Peirce, l’approccio dell’autorità di regolamentazione nei confronti degli ETF di criptovalute non dovrebbe dipendere dal fatto che un asset sia un titolo o una merce. Quello che è importante è mantenere un approccio coerente verso i prodotti degli exchange traded fund. Il suo punto di vista indica che la SEC dovrebbe adottare una posizione più ampia e inclusiva sugli ETF.</p>
<p>Leggi anche: <a href="https://www.gate.io/learn/articles/these-are-the-high-profile-spot-bitcoin-etf-applications-currently-in-pllay/1258" target="_blank">Queste sono le domande di alto profilo per le applicazioni di Bitcoin ETF</a></p>
<p>Peirce <a href="https://youtu.be/b-LmqVMF8I0" rel="nofollow noopener noreferrer" target="_blank">ha detto</a>“Non dovremmo aver bisogno di un tribunale che ci dica che il nostro approccio è arbitrario e capriccioso per fare le cose nel modo giusto. Spero davvero che non sarà così. Le persone si baseranno sui precedenti per argomentare su altri prodotti e noi, guardando i fatti e le circostanze, presumeremo di applicare quel precedente.”</p>
<p>Pierce ritiene che non sia necessario che qualcuno vada in tribunale per costringere la SEC ad approvare gli ETF ETH. Questo perché il tribunale molto probabilmente si baserà sul precedente del caso, dopo <a href="https://www.gate.io/learn/articles/what-is-a-bitcoin-etf/218" target="_blank">bitcoin ETF</a> approvazioni.</p>
<p>Spesso, Peirce ha criticato i suoi colleghi della SEC per la loro posizione sulle questioni legate alle criptovalute. Coindesk <a href="https://au.finance.yahoo.com/news/eth-etfs-inevitable-195202296.html" rel="nofollow noopener noreferrer" target="_blank">recentemente segnalato</a> che il commissario ha recentemente criticato Gary Gensler, presidente della SEC, per aver sperperato “un decennio di opportunità per fare il nostro lavoro” in una “saga necessaria, ma significativa” che ha tenuto lontani dai investitori prodotti richiesti e “ha spinto gli investitori al dettaglio verso mezzi meno efficienti per ottenere Bitcoin.”</p>
<p>Notizie correlate: <a href="https://www.gate.io/learn/articles/crypto-market-investment-outlook-2024/1690" target="_blank">Prospettive di investimento nel mercato delle criptovalute per il 2024</a></p>
<p>Ha aggiunto: “Il Congresso non ci ha autorizzato a dire alle persone se un particolare investimento è giusto per loro, ma abbiamo abusato delle procedure amministrative per trattenere gli investimenti che non ci piacciono dal pubblico.”</p>
<h2 id="h2-La20SEC20ritarda20la20decisione20su20diverse20richieste20di20ETF20Ethereum973196"><a name="La SEC ritarda la decisione su diverse richieste di ETF Ethereum" class="reference-link"></a><span class="header-link octicon octicon-link"></span>La SEC ritarda la decisione su diverse richieste di ETF Ethereum</h2><p>La SEC ha posticipato la sua decisione finale sulla domanda di ETF spot ETH di BlackRock, anticipando la data del verdetto di 45 giorni. Legalmente, la sua scadenza per proporre una modifica alle regole su quella particolare domanda di ETF ETH era il 25 gennaio.</p>
<p>Commentando il ritardo, la SEC ha affermato di essere ancora in attesa di un feedback pubblico sulla proposta di modifica normativa relativa a Blackrock ETH ETF. Si <a href="https://www.sec.gov/files/rules/sro/nasdaq/2024/34-99419.pdf" rel="nofollow noopener noreferrer" target="_blank">ha detto che</a>“La Commissione ritiene opportuno designare un periodo più lungo entro il quale agire sulla proposta di modifica alle regole, in modo da avere il tempo sufficiente per valutare la proposta di modifica alle regole e le questioni sollevate al riguardo.”</p>
<p>Ha aggiunto: “Di conseguenza, la Commissione, ai sensi della Sezione 19(b)(2) del Decreto, designa il 10 marzo 2024 come la data entro la quale la Commissione dovrà approvare o respingere, o avviare procedimenti per determinare se respingere, la proposta di modifica delle regole.”</p>
<p>Il rinvio della data di approvazione o disapprovazione del BlackRock’s ETF arriva una settimana dopo che ha fatto lo stesso per l’ETF Ethereum spot di Fidelity Investments, che ha posticipato al 5 marzo.</p>
<p>Leggi anche: <a href="https://www.gate.io/learn/articles/eths-path-to-10k---the-ethereum-2024-roadmap/1696" target="_blank">Il percorso di ETH verso i 10.000 dollari - La roadmap di Ethereum 2024</a></p>
<p>Comunque, BlackRock è abituata alle tattiche dilatorie della SEC nell’approvazione di fondi negoziati in borsa e altri veicoli di investimento. Nel caso del suo ETF bitcoin, la SEC ha impiegato più di 6 mesi per approvarlo.</p>
<p>Secondo <a href="https://twitter.com/ItsBitcoinWorld/status/1751982211291836772" rel="nofollow noopener noreferrer" target="_blank">Bitcoinworld Media, banca d’investimento TD Cowen</a> crede che la SEC approverà solo ETF ETH nel 2025 o nel 2026.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1707407992ETHapproval1.png" alt=""><br>Origine: <a href="https://twitter.com/ItsBitcoinWorld/status/1751982211291836772" rel="nofollow noopener noreferrer" target="_blank">x.com</a></p>
<p>In passato, la SEC ha rinviato l’approvazione di varie domande ETF ETH. Ad esempio, ha ritardato le domande ETF Ethereum di Grayscale Investments e VanEck. Oltre a BlackRock, Distributed Capital e Hashdex sono le altre società di gestione del patrimonio che hanno presentato domanda per lanciare ETF Ethereum sul posto.</p>
<p>Uno dei motivi di questi ritardi è la richiesta della SEC di ulteriori divulgazioni. Per molto tempo, la SEC si è opposta agli ETF crypto spot per paura di manipolazione del mercato e volatilità dei prezzi che potrebbero mettere a rischio gli investimenti negli ETF Ethereum.</p>
<p>Secondo Wu Blockchain, il rinomato analista degli ETF cripto, Eric Balchunas, ritiene che gli ETF ETH spot abbiano il 70% di probabilità di approvazione.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1707408004ETHapproval2.png" alt=""><br>Fonte: <a href="https://twitter.com/WuBlockchain/status/1745312885298041012" rel="nofollow noopener noreferrer" target="_blank">x.com</a></p>
<p>L’intera comunità criptovalutaria è in attesa di maggio per scoprire se la SEC approverà o respingerà <a href="https://www.gate.io/blog_detail/3499/etf%E7%94%B3%E8%BE%BC-%E5%85%AC%E5%BC%8F" target="_blank">ETF criptovalutario di BlackRock</a>. L’approvazione di un ETF ETH negli Stati Uniti potrebbe portare a una maggiore adozione di ETH rispetto al passato. Aspettiamo anche di vedere il numero di investitori disposti a comprare ETF crypto.</p>
<h2 id="h2-Conclusione720646"><a name="Conclusione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusione</h2><p>Peirce, il commissario della SEC, ha lasciato intendere che l’autorità di regolamentazione potrebbe approvare gli ETF Ethereum, anche se non ha specificato il periodo di tempo. Nel frattempo, l’agenzia ha spostato la data di decisione dell’ETF ETH di BlackRock a maggio di quest’anno. L’approvazione di un ETF ETH negli Stati Uniti potrebbe portare a una maggiore adozione dell’asset crittografico.</p>
<h2 id="h2-Domande20frequenti20sugli20ETF20Spot20ETH585792"><a name="Domande frequenti sugli ETF Spot ETH" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Domande frequenti sugli ETF Spot ETH</h2><h3 id="h3-Ci20sar20un20ETF20per20Ethereum716721"><a name="Ci sarà un ETF per Ethereum?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Ci sarà un ETF per Ethereum?</h3><p>Ci sono ETF Futures di ETH che includono Global X Ethereum ETP, WisdomTree Physical Ethereum, DDA Physical Ethereum ETP e VanEck Ethereum ETN. Tuttavia, il mercato crittografico prevede che la SEC degli Stati Uniti approverà diversi spot ETH ETF tra il 2024 e il 2026.</p>
<h3 id="h3-Qual2020il20miglior20ETF20per20Ethereum465479"><a name="Qual è il miglior ETF per Ethereum?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Qual è il miglior ETF per Ethereum?</h3><p>I popolari ETF futuri ETH includono Global X Ethereum ETP, WisdomTree Physical Ethereum, DDA Physical Ethereum ETP e VanEck Ethereum ETN. In base alla capitalizzazione di mercato, il Grayscale Ethereum Trust (ETHE) è il più grande ETF ETH sul mercato.</p>
<h3 id="h3-ETH20ha20un20ETF440639"><a name="ETH ha un ETF?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>ETH ha un ETF?</h3><p>ETH ha diversi future ETF che includono Grayscale Ethereum Trust (ETHE), XBT Provider Ethereum Tracker One (COINETH), CI Galaxy Ethereum ETF (ETHX.B) e 21Shares Ethereum Staking ETP (AETH). La maggior parte di questi ETF sono basati in Europa e negli Stati Uniti.</p>
<h3 id="h3-Come20investire20in20ETF20ETH632428"><a name="Come investire in ETF ETH?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Come investire in ETF ETH?</h3><p>Poiché gli ETF ETH vengono negoziati nelle borse tradizionali, un investitore dovrebbe aprire un conto con un broker. Una volta che ha finanziato il suo conto presso il broker, può acquistare gli ETF ETH di sua scelta.</p>
<h3 id="h3-Ethereum20risorger20di20nuovo20nel202024893074"><a name="Ethereum risorgerà di nuovo nel 2024?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Ethereum risorgerà di nuovo nel 2024?</h3><p>C’è una alta probabilità che il prezzo di ETH aumenterà nel 2024. Quello che non è definito al momento è di quanto aumenterà.</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 suggerimenti di investimento.<br></em><div><em></em>Gate.io si riserva tutti i diritti di 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>