R3JheXNjYWxlIHZhIGF2YW50aSBjb24gU3BvdCBCaXRjb2luIEVURiwgc2kgaW1wZWduYSBpbiBkaXNjdXNzaW9uaSBpbiBjb3JzbyBjb24gbGEgU0VD

2023-12-13, 02:56

<p><img src="https://gimg2.gateimg.com/image/article/1700024128RDZZ 1.jpeg" alt=""><br>La SEC potrebbe approvare diversi spot <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Applicazioni ETF tra il 5 e il 10 gennaio 2024.</p>
<p>Recentemente, la SEC ha tenuto incontri con potenziali emittenti di ETF <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> spot.</p>
<p>Finora, 12 gestori di asset hanno presentato domanda per gli ETF di bitcoin spot.</p>
<p>Parole chiave: Spot Bitcoin ETF, Grayscale spot bitcoin ETF, approvazione di un ETF bitcoin spot, approvazione SEC di un ETF bitcoin spot, BTC ETF, crypto ETF</p>
<h2 id="h2-Introduzione680672"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>C’è stato molto parlare nel mercato crittografico sul possibile lancio di fondi negoziati in borsa (ETF) bitcoin spot. Molti analisti ritengono che l’approvazione degli ETF crittografici è probabile che aumenti l’adozione e la domanda di criptovalute. Grayscale, BlackRock, WisdomTree, Fidelity e Valkyrie sono alcune delle società di gestione patrimoniale che hanno <a href="https://www.gate.io/de/blog_detail/3479/daily-news-czs-confession-boosts-the-approval-of-bitcoin-spot-etfs-multiple-defi-platforms-funds-stolen-accumulated-losses-exceeding-dollar150-million" target="_blank">richiesti ETF Bitcoin spot</a>.</p>
<p>In questo post, approfondiamo i progressi compiuti da Grayscale nel convincere la Securities and Exchange Commission degli Stati Uniti ad approvare il suo spot bitcoin ETF. Discuteremo anche il possibile periodo di tempo per l’approvazione degli spot bitcoin ETF da parte della SEC.</p>
<h2 id="h2-Avanzamento20nei20piani20dellETF20Bitcoin20spot384888"><a name="Avanzamento nei piani dell’ETF Bitcoin spot" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Avanzamento nei piani dell’ETF Bitcoin spot</h2><p>Il 22 novembre, Grayscale ha presentato il suo prospetto modificato per un ETF spot su bitcoin presso la SEC. Lo scopo è quello di convertire il suo fondo GBTC in un ETF spot su BTC. Nel suo ultimo deposito, Grayscale probabilmente ha cambiato dal suo modello in natura al modello “Cash”, che è un modello più sicuro, per affrontare le principali preoccupazioni della SEC. <a href="https://www.gate.io/blog_detail/3076/can-spot-bitcoin-etfs-become-market-catalysts-if-approved" target="_blank">preoccupazione sulle domande di ETF Bitcoin spot</a>.</p>
<p>Già, <a href="https://www.sec.gov/comments/sr-nysearca-2021-90/srnysearca202190-305159-785022.pdf" rel="nofollow noopener noreferrer" target="_blank">Grayscale ha</a> ha incontrato la SEC per discutere della sua proposta <a href="https://www.gate.io/bitwiki/detail/731/bitcoin-etfs" target="_blank">bitcoin ETF</a>. È importante notare che nel corso degli anni Grayscale ha mantenuto una relazione sana con la SEC grazie al suo Grayscale Bitcoin Trust (GBTC), ora mira a convertirsi in un ETF criptovalutario spot.</p>
<p>Tuttavia, la SEC ha respinto la prima domanda di ETF BTC spot di Grayscale, costringendo la società di gestione patrimoniale a rivolgersi a un tribunale federale per assistenza legale. Di conseguenza, un panel di giudici federali ha concluso che la SEC era “arbitraria e capricciosa” nel respingere la domanda di ETF bitcoin spot di Grayscale.</p>
<p>Con questo, il tribunale ha ordinato alla SEC di esaminare la domanda di Grayscale. Una fonte citata da CoinDesk ha detto che Grayscale ha recentemente aperto negoziati con la SEC. Secondo CoinDesk, <a href="https://www.coindesk.com/policy/2023/11/08/us-sec-said-to-open-talks-with-grayscale-on-spot-bitcoin-etf-push/#:~:text=The%20U.S.%20Securities%20and%20Exchange%20Commission%20(SEC" rel="nofollow noopener noreferrer" target="_blank">Craig Salm, un rappresentante di Grayscale, ha detto</a>%20ha%20aperto%20i%20negoziati,20potrebbe%20avere%20implicazioni%20momentous%20per%20“Craig%20Salm,%20un%20rappresentante%20di%20Grayscale%20ha%20detto”),%20“Al%20momento%20siamo%20solo%20concentrati%20sul%20riprendere%20costruttivamente%20i%20rapporti%20con%20Trading%20e%20Markets.”</p>
<p>Ha aggiunto: “Ci sono ancora cose che devono essere risolte. Nel complesso, è stato un buon coinvolgimento, ed è una questione di quando, non più di se.”</p>
<p>Anche se Salm non ha fornito dettagli più precisi delle loro trattative o conversazioni, il suo feedback ha creato un sentimento positivo all’interno del mercato che la SEC potrebbe approvare la domanda di Grayscale. Oltre a Grayscale, la SEC sta coinvolgendo altri gestori di asset riguardo alle loro domande di spot crypto ETF.</p>
<p><strong>Leggi anche: </strong><br><a href="https://www.gate.io/blog_detail/3479/daily-news-czs-confession-boosts-the-approval-of-bitcoin-spot-etfs-multiple-defi-platforms-funds-stolen-accumulated-losses-exceeding-dollar150-million" target="_blank">La confessione di CZ stimola l’approvazione degli ETF Bitcoin Spot</a> <a href="https://www.gate.io/blog_detail/3317/blackrock-sees-shift-spot-btc-etf" target="_blank">Ex MD di BlackRock Vede un Cambiamento di Sentimento verso Spot Bitcoin ETF</a></p>
<p>In sostanza, il settore delle criptovalute sta aspettando l’approvazione della SEC di un ETF bitcoin spot che contribuirà ad attirare molti investimenti per l’industria. Si prevede che investitori istituzionali e al dettaglio verseranno più di 3 miliardi di dollari nel settore nei primi mesi dopo il lancio di un ETF crypto spot. L’approvazione da parte della SEC di più ETF BTC genererà probabilmente molto più denaro per l’industria.</p>
<p>Nel frattempo, ci sono molti grandi operatori nel settore della gestione patrimoniale come Amplify Investments, ProShares e Roundhill che non hanno ancora intrapreso la corsa per lanciare i loro ETF cripto spot.</p>
<p>Queste organizzazioni ritengono che il mercato sia saturo, i costi di marketing siano elevati e i prodotti siano altamente regolamentati. Allo stesso tempo, non sono certe se ci sarà una domanda sufficiente per questi veicoli di investimento.</p>
<h2 id="h2-La20finestra20di20approvazione20potenziale20dellETF20Bitcoin20Spot425189"><a name="La finestra di approvazione potenziale dell’ETF Bitcoin Spot" class="reference-link"></a><span class="header-link octicon octicon-link"></span>La finestra di approvazione potenziale dell’ETF Bitcoin Spot</h2><p>L’approvazione dell’ETF bitcoin spot è probabile che avvenga tra il 5 e il 10 gennaio 2024. Dal momento che il 6 e il 7 cadono nel fine settimana, l’approvazione dovrebbe avvenire durante la settimana che inizia l’8 gennaio. La previsione di James Seyffart, analista di Bloomberg, si basa sul fatto che la scadenza della decisione di ARK è il 10 gennaio.</p>
<p>Seyffart ha pubblicato la sua previsione su X. <a href="https://twitter.com/JSeyff/status/1730327792066195501" rel="nofollow noopener noreferrer" target="_blank">Ha scritto</a>, “Okay la finestra <a href="https://www.gate.io/blog_detail/3434/bitcoin-etf-approval-potential-catalyst-for-historic-crypto-bull-run" target="_blank">per potenziale approvazione ETF Bitcoin spot</a> sembra che sarà tra il 5 gennaio e il 10 gennaio 2024.</p>
<p>Un altro analista, Scott Johnsson, concorda con Seyffart. <a href="https://twitter.com/JSeyff/status/1730327792066195501" rel="nofollow noopener noreferrer" target="_blank">Ha detto</a>, “La SEC pubblicherà domani nel registro federale (12⁄1) i ritardi di Franklin/Hashdex. Un tempo di risposta più rapido del solito indica nuovamente che si tratta di allineare potenziali approvazioni.</p>
<p>Pertanto, si aspetta anche che le approvazioni avvengano tra il 5 e il 10 gennaio. La sua ragione per questo si basa sulla rapida risposta della SEC alla presentazione di Franklin. <a href="https://twitter.com/JSeyff/status/1730327792066195501" rel="nofollow noopener noreferrer" target="_blank">Seyffart ha commentato</a>, “Wow. La SEC è stata molto tempestiva con Franklin. Non dovevano prendere una decisione fino al 1 ° gennaio. Da notare che Franklin è l’unico emittente che non ha ancora presentato un modulo S-1 aggiornato. Chissà.” <a href="https://www.gate.io/blog_detail/3461/glassnode-insights-finance-bridge-spotlight-on-spot-bitcoin-etfs-and-their-impact" target="_blank">se questo ha qualche impatto qui</a>.</p>
<p>Secondo Bloomberg, la prima scadenza per Franklin e HashDex è il 5 gennaio, come mostra la seguente tabella.</p>
<p><img src="https://gimg2.gateimg.com/image/article/17024354331.png" alt=""><br>Stime e scadenze per l’approvazione dell’ETF Bitcoin spot - Seyff (X)</p>
<p>La tabella mostra 12 domande di ETF bitcoin spot, alcune delle quali potrebbero essere approvate tra il 5 e il 10 gennaio 2024. Poiché alcune di queste domande hanno finestre di approvazione precedenti, è molto probabile che saranno approvate questa volta.</p>
<p>Inoltre, il fatto che Grayscale abbia assunto John Hoffman, un ex dirigente di Invesco ETF, come direttore generale mostra la fiducia dell’azienda nell’approvazione probabile della SEC del suo ETF spot BTC. Hoffman è destinato a diventare responsabile della distribuzione e delle partnership strategiche.</p>
<h2 id="h2-Ritardo20della20SEC20nella20riunione20di20Hashdex20segnala20una20prospettiva20positiva20per20lapprovazione20potenziale20dellETF20Bitcoin891006"><a name="Ritardo della SEC nella riunione di Hashdex segnala una prospettiva positiva per l’approvazione potenziale dell’ETF Bitcoin" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Ritardo della SEC nella riunione di Hashdex segnala una prospettiva positiva per l’approvazione potenziale dell’ETF Bitcoin</h2><p>Seyffart ha anche fornito un’ulteriore possibile indicazione della disponibilità della SEC ad approvare diversi ETF bitcoin spot nel prossimo futuro. Secondo lui, la SEC ha incontrato Hashdex il 27 novembre, segno del suo impegno continuo con i vari gestori di asset che hanno presentato richiesta per ETF BTC spot.</p>
<p><a href="https://twitter.com/JSeyff/status/1730236396428816528" rel="nofollow noopener noreferrer" target="_blank">Seyffart ha pubblicato</a>, ““” <a href="https://twitter.com/JSeyff/status/1730236396428816528/photo/1" rel="nofollow noopener noreferrer" target="_blank">La SEC si è incontrata con Hashdex</a> lunedì 27 e poi la SEC ha emesso un ordine di ritardo il giorno successivo sulla loro domanda. Questo è un altro episodio di una serie in corso <a href="/price/flow-flow" rel="nofollow noopener noreferrer" target="_blank">Flusso</a> di indicazioni che la SEC sta lavorando duramente con potenziali emittenti di ETF Bitcoin sui dettagli di backend e impianti idraulici.</p>
<p>L’incontro della SEC con Hashdex arriva circa una settimana dopo aver incontrato i rappresentanti di BlackRock, anche per discutere dei loro ETF crypto. Tutto ciò ha aumentato l’attesa del mercato che la SEC possa approvare più di un ETF spot su bitcoin nel gennaio 2024.</p>
<h2 id="h2-Conclusion665016"><a name="Conclusion" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusion</h2><p>Diversi potenziali emittenti di ETF bitcoin spot si sono recentemente incontrati con la SEC per discutere questioni legate alle loro domande. A causa di tali incontri e altre indicazioni, alcuni analisti di investimento hanno previsto che la SEC potrebbe approvare diverse domande di ETF bitcoin spot nel gennaio 2024.</p>
<h2 id="h2-Domande20frequenti20sugli20ETF20Bitcoin20Spot183121"><a name="Domande frequenti sugli ETF Bitcoin Spot" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Domande frequenti sugli ETF Bitcoin Spot</h2><h3 id="h3-Sar20approvato20lETF20spot20di20Bitcoin546978"><a name="Sarà approvato l’ETF spot di Bitcoin?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Sarà approvato l’ETF spot di Bitcoin?</h3><p>La SEC probabilmente approverà uno o più ETF spot di bitcoin tra il 5 e il 10 gennaio 2024. Attualmente, sta coinvolgendo i vari potenziali emittenti di ETF spot di bitcoin.</p>
<h3 id="h3-Cos20un20ETF20Bitcoin20con20leva203x690721"><a name="Cos’è un ETF Bitcoin con leva 3x?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Cos’è un ETF Bitcoin con leva 3x?</h3><p>Un ETF bitcoin a leva 3X è un fondo negoziato in borsa che cerca di restituire tre volte il valore dell’indice utilizzato. Sebbene tali ETF abbiano rendimenti elevati, hanno anche rischi elevati.</p>
<h3 id="h3-Esiste20un20ETF20short20per20Bitcoin298988"><a name="Esiste un ETF short per Bitcoin?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Esiste un ETF short per Bitcoin?</h3><p>Un ETF short per il bitcoin consente agli investitori di beneficiare quando il prezzo del bitcoin sta diminuendo. Il ProShares Short Bitcoin Strategy ETF (BITI) è un esempio di un ETF short per il 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. La ripubblicazione dell'articolo sarà consentita a condizione che si faccia riferimento a Gate.io. In tutti i casi, verranno intraprese azioni legali a causa della violazione del copyright.<br></div><p></p><br></div></div></div>