TGEgcHJlc2VudGF6aW9uZSBkZWdsaSBFVEYgZGkgQmxhY2tSb2NrIHN1c2NpdGEgc2VudGltZW50aSByaWFsemlzdGksIG1lbnRyZSBpIEJpdGNvaW4gU2hvcnRzIHBlcmRvbm8gJDE2IE0=

2023-07-03, 04:13

<p><img src="https://gimg2.gateimg.com/image/article/1688357190RDZZ.jpeg" alt=""></p>
<h2 id="h2-TL20DR343612"><a name="TL; DR" class="reference-link"></a><span class="header-link octicon octicon-link"></span>TL; DR</h2><p>BlackRock ha presentato una domanda per un <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> fondo negoziato in borsa che sarà quotato su Nasdaq.</p>
<p>La Securities and Exchange Commission (SEC) non ha ancora indicato se approverà o meno l’ETF criptato.</p>
<p>In passato, la SEC ha disapprovato gli ETF BTC <a href="https://www.gate.io/uk/blog_detail/158/the-1st-cryptocurrency-investments-grayscale-what-is-gbtc" target="_blank">per Grayscale</a>, Valkyrie Investments, NYDIG, SkyBridge, ARK Invest, Fidelity, Galaxy Digital, VanEck e WisdomTree.</p>
<p>La notizia di un possibile lancio di ETF BTC ha portato a un’ottica di mercato rialzista.</p>
<h2 id="h2-Introduzione665692"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>Negli anni sono stati introdotti nuovi prodotti e servizi nel settore delle criptovalute e hanno influenzato la loro adozione e riconoscimento internazionale. La nuova ondata di regolamentazioni criptografiche, ad esempio, è un riconoscimento del potenziale degli asset crittografici. I derivati come i futures delle criptovalute sono tra gli asset digitali che stanno guidando l’adozione delle criptovalute.</p>
<p>I futures e le opzioni su <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> sono popolari attività digitali in cui singoli e aziende possono investire senza possedere direttamente criptovalute. In questo articolo discutiamo del recentemente proposto Bitcoin Exchange Traded Fund (ETF). Inoltre, il mercato crittografico attende di vedere se la SEC approverà il di BlackRock. <a href="https://www.gate.io/blog_detail/379/what-are-bitcoin-etfs-bitcoin-etfs-explained" target="_blank">Bitcoin ETF</a>.</p>
<h2 id="h2-Piano20ETF20di20Bitcoin20di20BlackRock699517"><a name="Piano ETF di Bitcoin di BlackRock" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Piano ETF di Bitcoin di BlackRock</h2><p>BlackRock, la più grande società di gestione patrimoniale al mondo che gestisce oltre 10 trilioni di dollari, ha pianificato di lanciare il suo mercato pubblico quotato <a href="https://www.gate.io/learn/articles/what-is-a-bitcoin-etf/218 &quot;Bitcoin exchange-traded fund (ETF" rel="nofollow noopener noreferrer" target="_blank">Fondo negoziato in borsa di Bitcoin (ETF)</a>”) negli Stati Uniti dopo aver presentato la sua domanda giovedì 15 giugno 2023.</p>
<p>Nel deposito presso la Securities and Exchange Commission (SEC), la società ha dichiarato di avere l’intenzione di vendere gli asset di investimento come iShares Bitcoin Trust con Coinbase Custody Trust Co come custode per il Bitcoin.</p>
<p>BlackRock ha dichiarato che se l’ETF verrà approvato, sarà quotato sul Nasdaq. Inoltre, il Nasdaq supervisionerà la determinazione del prezzo dell’ETF, un fattore critico che potrebbe influenzare l’approvazione da parte della SEC. In precedenza, la SEC ha respinto le richieste di lancio di ETF BTC temendo che il mercato potesse manipolarne i prezzi.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1688357357unnamed (2" alt="">BlackRock Applica per Bitcoin ETF - .png)<br><a href="https://th.bing.com/th/id/OIF.YxntBf1fKwIeWH9ctVOaEw?pid=ImgDet&amp;rs=1" rel="nofollow noopener noreferrer" target="_blank">Watcherguru</a></p>
<p>Se la SEC approverà questo ETF, sarà una mossa positiva poiché BlackRock ha una vasta portata che consentirà agli investitori cripto al dettaglio di investire in Bitcoin attraverso queste azioni. <a href="https://www.gate.io/blog_detail/1685/how-are-institutional-investors-participating-in-crypto" target="_blank">Gli investitori istituzionali come i fondi pensione</a> probabilmente conserverà quell’asset.</p>
<h2 id="h2-Perch20il20mercato20supporta20il20lancio20dellETF20Bitcoin20di20BlackRock793659"><a name="Perché il mercato supporta il lancio dell’ETF Bitcoin di BlackRock?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Perché il mercato supporta il lancio dell’ETF Bitcoin di BlackRock?</h2><p>La presentazione dell’ETF di BlackRock è stata accolta positivamente dal mercato. Attualmente, gli investitori di criptovalute non possono acquisire Bitcoin sotto forma di azioni, ad eccezione di Grayscale Bitcoin Trust che non è disponibile su molte borse valori. Questo è contrario al modo in cui le persone possono facilmente acquisire Bitcoin su diverse piattaforme come Gate.io, Coinbase e Binance, tra gli altri.</p>
<p>Leggi anche: <a href="https://www.gate.io/blog_detail/1479/blackrock-launches-bitcoin-private-trust" target="_blank">BlackRock lancia il primo Bitcoin Private Trust</a></p>
<p>Purtroppo, Grayscale addebita anche una commissione elevata del 2% che ne ostacola l’accettazione. Al contrario, BlackRock mira a offrire il suo ETF a una commissione inferiore a 0,5%.</p>
<p>Mike Novogratz, CEO di Galaxy Digital, ha detto che se la SEC approva la presentazione dell’ETF di BlackRock, sarà “la cosa migliore che potrebbe accadere a $BTC”.</p>
<p>Un altro analista di criptovalute, Steven Lubka, direttore generale di Swan Bitcoin, ritiene che se la SEC approverà il BTC ETF di BlackRock, il valore del Bitcoin potrebbe raggiungere 1 milione di dollari. Tuttavia, la cosa triste è che alcuni ricchi investitori istituzionali come BlackRock, Goldman Sachs e altri emittenti di ETF probabilmente trarranno beneficio da tale situazione in quanto investiranno molto in essi.</p>
<h2 id="h2-La20SEC20approver20la20domanda20di20BlackRock474331"><a name="La SEC approverà la domanda di BlackRock?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>La SEC approverà la domanda di BlackRock?</h2><p>Secondo Eric Balchunas, un analista senior di ETF presso Bloomberg, è improbabile che la SEC approvi la richiesta per l’ETF BTC. Ha detto: “Non ci sono stati segnali che la SEC sia disposta ad approvare, ma BlackRock è molto connessa, quindi forse sanno qualcosa?”</p>
<p>Diversi analisti di mercato condividono lo stesso sentimento basato sulla precedente posizione della SEC contro il BTC ETF. In precedenza, la SEC ha respinto le richieste di numerose società di gestione del patrimonio che volevano lanciare spot BTC ETF. Grayscale, Valkyrie Investments, NYDIG, SkyBridge, ARK Invest, Fidelity, Galaxy Digital, VanEck e WisdomTree hanno presentato domanda per spot BTC ETF, ma le loro richieste sono state respinte.</p>
<p>A giugno 2022, Grayscale ha citato in giudizio la SEC per la sua posizione rigida sull’ETF spot BTC. Ha sostenuto che la SEC è stata inconsistente nel trattamento di asset di investimento simili. Tuttavia, la SEC ha approvato diversi ETF basati su future di Bitcoin che sono più complicati e più costosi rispetto agli ETF crypto spot.</p>
<h2 id="h2-Lentusiasmo20attorno20alla20spinta20di20BlackRock20per20lETF20BTC20fa20salire20i20prezzi20delle20criptovalute970808"><a name="L’entusiasmo attorno alla spinta di BlackRock per l’ETF BTC fa salire i prezzi delle criptovalute" class="reference-link"></a><span class="header-link octicon octicon-link"></span>L’entusiasmo attorno alla spinta di BlackRock per l’ETF BTC fa salire i prezzi delle criptovalute</h2><p>L’entusiasmo che circonda il lancio previsto del BTC EFT di BlackRock ha spinto verso l’alto i prezzi di diverse criptovalute principali. Venerdì 16 giugno, il <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">prezzo di Bitcoin</a> ha riguadagnato il livello di $25.500 dopo la sua caduta nei due giorni precedenti fino a $24.860. <a href="https://www.gate.io/learn/articles/what-is-polygon/73" target="_blank">I valori di Polygon</a> MATIC della rete e <a href="/price/cardano-ada" rel="nofollow noopener noreferrer" target="_blank">Cardano</a> Anche l’ADA di Gate.io è salito al di sopra dei livelli dei due giorni precedenti.</p>
<p>Tuttavia, <a href="/price/dogecoin-doge" rel="nofollow noopener noreferrer" target="_blank">Dogecoin</a> (DOGE) e <a href="/price/litecoin-ltc" rel="nofollow noopener noreferrer" target="_blank">Litecoin</a>(LTC) sono stati i maggiori protagonisti nelle ultime 24 ore, guadagnando rispettivamente il 4% e il 3,3%. La recente posizione stabile di Bitcoin sul mercato ha avuto un impatto negativo sugli short di BTC che sono stati liquidati, causando così una perdita di circa 16 milioni di dollari.</p>
<p>In generale, c’era un’ottica rialzista nel mercato, come indicato dall’indice Fear &amp; Greed Crypto che è salito da 41 a 47. Di conseguenza, il mercato delle criptovalute è passato dalla paura alla speranza.</p>
<h2 id="h2-Conclusione611655"><a name="Conclusione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusione</h2><p>Recentemente, <a href="https://www.gate.io/bitwiki/detail/809" target="_blank">BlackRock</a> Un’azienda di gestione del patrimonio ha presentato una domanda per una<br><strong>Fondo negoziato in borsa di Bitcoin (ETF BTC)</strong> Tuttavia, la SEC non ha ancora indicato se approverà o meno le domande. Tuttavia, quella mossa ha alimentato la speranza all’interno del mercato crittografico, come dimostrato dal sentimento di mercato rialzista associato che ha pompatole quotazioni di diverse criptovalute, tra cui BTC, ADA, LTC e Doge.</p>
<div class="blog-details-info"><br><div>Autore: <strong>Mashell C.</strong>, Ricercatore Gate.io<br><div class="info-tips"><em>Questo articolo rappresenta solo i punti 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 venga fatto riferimento a Gate.io. In tutti i casi, saranno intraprese azioni legali a causa di violazioni del copyright.<br></div><p></p><br></div></div></div>