TCdleCBkaXJldHRvcmUgZGkgQmxhY2tSb2NrIHZlZGUgdW4gY2FtYmlhbWVudG8gZGkgc2VudGltZW50aSB2ZXJzbyBsJ0VURiBCaXRjb2luIGFsIGNvbnRhbnRp

<p><img src="https://gimg2.gateimg.com/image/article/1690791857hotspot.jpeg" alt=""></p>
<h2 id="h2-TL20DR775607"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p>La SEC probabilmente approverà diversi ETF criptati nei prossimi tre mesi.</p>
<p>L’approvazione degli ETF criptovalutari potrebbe aumentare gli investimenti nelle criptovalute.</p>
<p>Il ritardo della SEC degli Stati Uniti nell’approvare <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> ETF non è un segno del suo rifiuto degli ETF criptovaluta.</p>
<h2 id="h2-Introduzione228451"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>Nello spazio crittografico stanno avvenendo molti cambiamenti con sempre più prodotti che arrivano sul mercato. Recentemente, abbiamo visto l’interesse crescente del mercato finanziario per gli exchange traded fund (ETF) criptati. Di conseguenza, diverse aziende stanno cercando l’approvazione di ETF criptati come <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> ETF ed ETH ETF. Questo post esamina la possibilità di approvazione degli ETF BTC negli Stati Uniti.</p>
<h2 id="h2-BlackRock20e20altre20societ20attendono20la20decisione20della20SEC20sugli20ETF20di20BTC526444"><a name="BlackRock e altre società attendono la decisione della SEC sugli ETF di BTC" class="reference-link"></a><span class="header-link octicon octicon-link"></span>BlackRock e altre società attendono la decisione della SEC sugli ETF di BTC</h2><p>BlackRock e altre società di gestione degli asset finanziari come <a href="https://www.gate.io/blog_detail/3289" target="_blank">VanEck, Invesco Galaxy, Bitwise, WiseOrigin e Valkyrie stanno aspettando l’approvazione dei loro ETF</a> Purtroppo, la Securities and Exchange Commission degli Stati Uniti ha ritardato l’annuncio della sua decisione su diverse domande per i fondi negoziati in borsa (ETF) di bitcoin.</p>
<p>Leggi anche: <a href="https://www.gate.io/blog_detail/2841/blackrock-s-etf-filing-sparkle-bullish-sentiments-bitcoin-shorts-lose-16-m" target="_blank">La presentazione dell’ETF di BlackRock suscita sentimenti rialzisti, i bearish di Bitcoin perdono 16 milioni di dollari</a></p>
<p>La principale ragione del ritardo nell’annunciarlo <a href="https://www.gate.io/blog_detail/379/what-are-bitcoin-etfs-bitcoin-etfs-explained" target="_blank">esito delle domande ETF BTC</a> è avere più tempo per valutare alcune proposte di modifiche alle regole che le governano. La SEC ha dichiarato: “La Commissione ritiene opportuno designare un periodo più lungo entro il quale prendere provvedimenti sulla proposta di modifica delle regole, in modo da avere il tempo sufficiente per valutare la proposta di modifica delle regole e le questioni sollevate in essa.”</p>
<p>Le modifiche proposte alle regole che disciplinano l’approvazione o il rifiuto degli ETF cripto come il mercato degli ETF bitcoin spot sono state pubblicate il 19 luglio 2023. Si prevede che il pubblico dia il suo contributo sulle nuove linee guida legali.</p>
<h2 id="h2-Gli20esperti20di20criptovalute20ritengono20che20la20SEC20approver20gli20ETF20di20Bitcoin20spot784525"><a name="Gli esperti di criptovalute ritengono che la SEC approverà gli ETF di Bitcoin spot" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Gli esperti di criptovalute ritengono che la SEC approverà gli ETF di Bitcoin spot</h2><p>L’ex direttore generale di BlackRock, Steven Schoenfield, ritiene che la SEC sia probabile <a href="https://www.gate.io/blog_detail/3076/can-spot-bitcoin-etfs-become-market-catalysts-if-approved" target="_blank">approvare diversi ETF criptovaluta come ETF bitcoin entro i prossimi tre mesi</a>.</p>
<p>Schoenfield, che è anche CEO di MarketVector Indexes, ha detto ai partecipanti al Digital Asset Summit di Londra che se la SEC approva le domande ETF, è probabile che generino più di 200 miliardi di dollari.</p>
<p>Schoenfield ha proposto varie ipotesi su come la SEC probabilmente gestirà gli ETF BTC. Ad esempio, ha detto: “La SEC probabilmente approverà [tutte le domande di ETF bitcoin spot] contemporaneamente; Non penso che vogliano dare a nessuno un vantaggio del primo arrivato.”</p>
<p>D’altra parte, Schoenfield ha detto che il ritardo della SEC nell’approvare l’ETF cripto di BlackRock e il resto è normale poiché l’organo di regolamentazione sta prendendo il suo tempo per effettuare valutazioni. La cosa buona e positiva è che la SEC non ha disapprovato il <a href="https://www.gate.io/blog_detail/380" target="_blank">BTC ETF</a> applicazioni.</p>
<p>Leggi anche: <a href="https://www.gate.io/blog_detail/3194/crypto-influencers-fuel-speculation-sec" target="_blank">Gli influencer delle criptovalute alimentano le speculazioni mentre la SEC ritarda la decisione sull’ETF Bitcoin</a></p>
<p>Shoenfield ha aggiunto: “Invece di rifiutare completamente l’intera lista, hanno chiesto commenti, il che rappresenta un miglioramento marginale ma significativo nel dialogo.”</p>
<p>Tim Bevan, CEO presso ETC Group, condivide lo stesso sentimento nei confronti del bitcoin e non vede l’ora dell’approvazione di vari ETF criptovalutari. Ha detto: “Non crediamo che la SEC agirà da arbitro e l’esito più probabile è l’approvazione in blocco delle domande che soddisfano i requisiti, probabilmente nel Q1 ‘24.”</p>
<p>Secondo Bevan, è probabile che la SEC approvi diversi ETF criptovalutari, il che porterà a un ampio mercato degli ETF bitcoin a breve termine. Il fatto che il mese scorso quattro rappresentanti del Congresso abbiano esortato la SEC ad approvare gli ETF bitcoin aumenta la probabilità che presto avremo alcuni ETF bitcoin sul mercato.</p>
<p>Tuttavia, Schoenfield non pensa che BlackRock avrà un vantaggio rispetto agli altri candidati spot di bitcoin. Ha dichiarato: “Per quanto BlackRock cercherà di schiacciare la concorrenza, ci sono una buona mezza dozzina, forse otto o nove, di altre aziende profondamente impegnate negli asset digitali negoziabili”.</p>
<p>Ha aggiunto: “Tutti hanno presentato domanda e alcuni sono effettivamente molto più vicini all’ecosistema delle criptovalute rispetto a BlackRock. Quindi, penso che BlackRock dovrà affrontare una vera sfida. La SEC probabilmente approverà [tutte le domande per gli ETF] contemporaneamente; non credo che vogliano concedere a nessuno un vantaggio del primo arrivato.”</p>
<h2 id="h2-BlackRock20ha20registrato20un20cambiamento20di20sentiment20nei20confronti20del20Bitcoin628024"><a name="BlackRock ha registrato un cambiamento di sentiment nei confronti del Bitcoin" class="reference-link"></a><span class="header-link octicon octicon-link"></span>BlackRock ha registrato un cambiamento di sentiment nei confronti del Bitcoin</h2><p>Secondo Bednall, ex direttore generale di BlackRock, negli ultimi anni c’è stata molta trasformazione nel settore della gestione patrimoniale. Ha chiaramente affermato che c’è stato un grande cambiamento in BlackRock su come vede il bitcoin e i prodotti correlati come gli ETF.</p>
<p>Per molto tempo, il CEO attuale di BlackRock, Larry Fink, non era interessato alle criptovalute come il bitcoin. Fink considerava il bitcoin come uno strumento per commettere attività finanziarie illegali. Ora, il fatto che <a href="https://www.gate.io/blog_detail/1643/blackrock-launches-blockchain-related-etf-for-european-markets." target="_blank">BlackRock ha presentato domanda per l’ETF spot bitcoin negli Stati Uniti</a> mostra il cambio di atteggiamento di Fink sulle criptovalute.</p>
<p>Dato che molti investitori sono ottimisti riguardo a Bitcoin e agli ETF criptovalutari, BlackRock ha ritenuto opportuno introdurre tali prodotti finanziari.</p>
<p>Bednall ha detto: “Blackrock ha decisamente cambiato tono nel corso degli anni, da Bitcoin che era un indice per il riciclaggio di denaro, a lui che dice, è un bene globale sotto forma di oro digitale. Quindi, ci è voluto del tempo per arrivarci.”</p>
<p>Bednall ritiene anche che BlackRock sia in contatto con persone molto esperte nel settore criptato e finanziario, nonché con i regolatori degli Stati Uniti. Questo è il motivo per cui la SEC è probabile che approvi il suo ETF bitcoin.</p>
<p>In particolare, Bednall ha commentato: “Direi che BlackRock è molto vicino ai regolatori di tutto il mondo. Hanno un grande team nel loro braccio regolatorio e parlano spesso con i regolatori. Quindi, devono ricevere dei sondaggi. Questo è un ulteriore segnale del cambiamento del clima e della SEC che si avvicina all’approvazione di uno di questi? Altrimenti, a BlackRock non sarebbe importato.”</p>
<p>Ancora più interessante, Fink ha detto che ora crede nelle criptovalute e nei prodotti finanziari correlati. In una recente intervista con Fox News ha detto: “Le criptovalute stanno digitalizzando l’oro in molti modi. Gli ETF sono stati una grande rivoluzione per l’industria dei fondi comuni e stanno realmente conquistando l’industria dei fondi comuni.”</p>
<p>Fink ha anche indicato il suo <a href="/price/optimism-op" rel="nofollow noopener noreferrer" target="_blank">Ottimismo</a> che la domanda di ETF BTC di BlackRock verrà approvata prima o poi. Ha commentato: “Speriamo, come in passato, di poter lavorare con i nostri regolatori e ottenere l’approvazione di questa richiesta un giorno. Non ho idea di quando sarà questo giorno.”</p>
<p>Ha aggiunto: “Non posso entrare in dettagli, ma… lavoriamo molto vicino ai nostri regolatori e vogliamo sentire quali sono le loro preoccupazioni e come possiamo risolverle.”</p>
<h2 id="h2-Possibili20esiti20delle20domande20ETF20su20Bitcoin564303"><a name="Possibili esiti delle domande ETF su Bitcoin" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Possibili esiti delle domande ETF su Bitcoin</h2><p>Come accennato in precedenza, la SEC ha esteso il periodo di revisione degli ETF Bitcoin per verificare eventuali possibilità di abuso del prodotto una volta approvato. Infatti, la SEC sta effettuando una valutazione simultanea dei diversi ETF, tra cui quello di Fidelity e BlackRock.</p>
<p>Lo sforzo di valutazione della SEC potrebbe indicare anche una probabilità elevata che possa approvare contemporaneamente diversi ETF bitcoin. A tal proposito, Bednall ha dichiarato: “Penso che la SEC probabilmente approverà tutte le richieste contemporaneamente. Non penso che vorranno dare a nessuno un vantaggio di primo arrivato.”</p>
<p>Eric Balchunas, un analista senior di ETF di Bloomberg, supporta il punto di vista di Bednall. Ha detto: “Il fatto che la SEC stia interagendo attivamente con gli emittenti di bitcoin spot sulle loro attuali domande - cosa che non è mai successa prima - ci fa pensare che un rifiuto sia improbabile e che ci sia una probabilità del 75% di approvazione entro la fine di quest’anno.”</p>
<p>Nel frattempo, alcuni analisti di criptovalute hanno previsto che l’approvazione dell’ETF avrà probabilmente un grande impatto sul prezzo del bitcoin. Questo perché le loro approvazioni potrebbero attrarre gli investitori finanziari tradizionali per ottenere esposizione a <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">prezzo Bitcoin</a> che potrebbe aumentare il suo slancio verso l’alto.</p>
<h2 id="h2-Notizie20in20breve775016"><a name="Notizie in breve" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Notizie in breve</h2><p>Il mercato delle criptovalute è concentrato sulle notizie di BlackRock in quanto ha un impatto significativo sui prezzi di molte criptovalute.</p>
<h3 id="h3-La20campagna20di20espansione20ambiziosa20degli20ETF20di20BlackRock20e20la20diversificazione20dei20prodotti245065"><a name="La campagna di espansione ambiziosa degli ETF di BlackRock e la diversificazione dei prodotti" class="reference-link"></a><span class="header-link octicon octicon-link"></span>La campagna di espansione ambiziosa degli ETF di BlackRock e la diversificazione dei prodotti</h3><p>BlackRock sta espandendo la sua presenza nel settore finanziario aumentando i suoi prodotti. La società di gestione patrimoniale sta cercando l’approvazione del suo ETF su bitcoin nel prossimo futuro. Il ritardo della SEC nella decisione sugli ETF su BTC non dovrebbe suonare come uno “scandalo BlackRock” in quanto l’approvazione dell’ETF potrebbe avvenire presto.</p>
<p>Oltre all’atteso ETF bitcoin, BlackRock è pronta a introdurre l’Advantage Large Cap Income ETF BALI che venderà opzioni call attraverso l’indice S&amp;P 500. È interessante notare che l’anno scorso BlackRock ha introdotto anche i suoi ETF obbligazionari che hanno ampliato la gamma dei suoi prodotti di investimento.</p>
<h3 id="h3-La20SEC20ha20prorogato20il20periodo20di20revisione20delle20domande20di20Spot20Bitcoin20ETF684427"><a name="La SEC ha prorogato il periodo di revisione delle domande di Spot Bitcoin ETF" class="reference-link"></a><span class="header-link octicon octicon-link"></span>La SEC ha prorogato il periodo di revisione delle domande di Spot Bitcoin ETF</h3><p>La Securities and Exchange Commission degli Stati Uniti ha rinviato la decisione sull’approvazione ETF di varie società di gestione patrimoniale, tra cui Valkyrie, BlackRock e Bitwise. L’autorità di regolamentazione mira ad assicurare che non ci sia alcuna possibilità di pratiche manipolatorie nel mercato degli ETF.</p>
<h2 id="h2-Conclusione248274"><a name="Conclusione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusione</h2><p>La Securities and Exchange Commission degli Stati Uniti ha rinviato la sua decisione sulle domande ETF presentate dalle principali società di gestione del patrimonio, tra cui Valkyrie, BlackRock e Bitwise. Anche il mercato delle criptovalute ha notato un cambiamento nell’apprezzamento delle criptovalute da parte di società come BlackRock che in passato le evitavano. Già il settore della gestione degli asset finanziari sta aspettando l’approvazione della SEC di diversi ETF bitcoin.</p>
<h2 id="h2-Domande20frequenti20sugli20ETF20Bitcoin183554"><a name="Domande frequenti sugli ETF Bitcoin" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Domande frequenti sugli ETF Bitcoin</h2><h3 id="h3-Bitcoin20verr20approvato220619"><a name="Bitcoin verrà approvato?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Bitcoin verrà approvato?</h3><p>Molti esperti ritengono che la SEC degli Stati Uniti approverà diversi ETF di bitcoin entro i prossimi tre mesi. La SEC ha ritardato la sua decisione sugli ETF di bitcoin perché vuole effettuare ulteriori valutazioni per garantire che non vi siano pratiche manipolative di mercato.</p>
<h3 id="h3-BlackRock20offre20criptovalute135245"><a name="BlackRock offre criptovalute?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>BlackRock offre criptovalute?</h3><p>BlackRock non offre prodotti o servizi cripto. È una tradizionale società di gestione del patrimonio che offre strumenti di investimento finanziario tradizionali. Recentemente, BlackRock ha presentato domanda per offrire un ETF di bitcoin.</p>
<h3 id="h3-BlackRock20possiede20XRP713936"><a name="BlackRock possiede XRP?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>BlackRock possiede XRP?</h3><p>Attualmente, BlackRock non possiede <a href="/price/xrp-xrp" rel="nofollow noopener noreferrer" target="_blank">XRP</a> coins. Il suo ruolo principale è quello di offrire tradizionali asset finanziari che includono servizi di consulenza, iShares ETF e tecnologia di gestione degli investimenti.</p>
<h3 id="h3-Cosa20supporta20BlackRock73780"><a name="Cosa supporta BlackRock?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Cosa supporta BlackRock?</h3><p>BlackRock è una società di gestione patrimoniale che offre vari prodotti e servizi di investimento tradizionali come servizi di consulenza, iShares ETF e tecnologia di gestione degli investimenti. Sia gli investitori istituzionali che quelli al dettaglio possono accedere ai suoi prodotti e servizi.</p>
<h3 id="h3-Come20influenzer20BlackRock20le20criptovalute182697"><a name="Come influenzerà BlackRock le criptovalute?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Come influenzerà BlackRock le criptovalute?</h3><p>BlackRock intende introdurre fondi negoziati in borsa cripto come Bitcoin ETF. Se la SEC approva la sua richiesta di ETF BTC, darà agli investitori l’opportunità di investire indirectamente in bitcoin. Ciò potrebbe comportare un aumento del prezzo del bitcoin.</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. Sarà consentito il riutilizzo dell'articolo a condizione che venga citato Gate.io. In tutti i casi, saranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div>