TGEgcHJvcG9zdGEgZGkgR3JheXNjYWxlIHNvbGxlY2l0YSBsYSByaXZhbHV0YXppb25lIGRlbGxhIFNFQyBkZWdsaSBFVEYgZGkgQml0Y29pbg==

2023-12-29, 08:46

<p><img src="https://gimg2.gateimg.com/image/article/1703838812RDZZ 1.jpeg" alt=""></p>
<h2 id="h2-TL20DR639809"><a name="TL; DR" class="reference-link"></a><span class="header-link octicon octicon-link"></span>TL; DR</h2><p>È probabile che la SEC assuma una posizione più accomodante nei confronti dello spot <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Alessio</a> ETF a seguito della recente sentenza del tribunale.</p>
<p>Attualmente, la SEC sta valutando tra 8 e 12 ETF di <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">bitcoin</a> spot.</p>
<p>È probabile che la SEC possa approvare diversi ETF bitcoin spot a gennaio 2024.</p>
<h2 id="h2-Introduzione88129"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>Sebbene molti analisti si aspettino che <a href="https://www.gate.io/blog_detail/3611/daily-news-the-sec-announced-the-deadline-for-bitcoin-spot-etfs-application-solana-s-network-activity-data-achieved-a-record-high-bitcoin-halving-time-is-less-than-120-days" target="_blank">La SEC probabilmente approverà gli ETF di bitcoin spot durante il primo trimestre del 2024</a> Non c’è garanzia in merito. Sembra che la SEC degli Stati Uniti rimanga rigorosa nelle sue richieste per l’approvazione degli ETF BTC spot. La SEC ha tenuto incontri con i potenziali <a href="https://www.gate.io/bitwiki/detail/731/bitcoin-etfs" target="_blank">ETF su Bitcoin</a> emittenti.</p>
<p>Oggi analizziamo la posizione attuale della SEC sul bitcoin spot dopo la decisione della corte di Grayscale che ha costretto l’autorità di regolamentazione a riconsiderare le sue richieste sull’approvazione degli ETF BTC spot.</p>
<p>Leggi anche: <a href="https://www.gate.io/blog_detail/3555/grayscale-pushes-spot-btc-etf" target="_blank">Grayscale continua con l’avanzamento dell’ETF Bitcoin spot</a></p>
<h2 id="h2-Posizione20della20SEC20sulla20decisione20del20tribunale20postGrayscale20sullapprovazione20di20un20ETF20Bitcoin20spot125398"><a name="Posizione della SEC sulla decisione del tribunale post-Grayscale sull’approvazione di un ETF Bitcoin spot" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Posizione della SEC sulla decisione del tribunale post-Grayscale sull’approvazione di un ETF Bitcoin spot</h2><p>Gary Gensler, presidente della Securities and Exchange Commission (SEC) degli Stati Uniti, ha accennato a un cambiamento nella sua posizione verso gli ETF spot su bitcoin a seguito della sentenza del tribunale sull’applicazione dell’ETF Grayscale.</p>
<p>È molto probabile che la SEC adotti una posizione più morbida sugli ETF bitcoin spot rispetto al passato. Tuttavia, non ha confermato la direzione che prenderà in futuro. In un’intervista con CNBC il 14 dicembre <a href="https://www.cnbc.com/video/2023/12/14/sec-chair-gary-gensler-ai-is-the-most-transformative-technology-of-our-time.html" rel="nofollow noopener noreferrer" target="_blank">Gensler ha detto</a> che la SEC attualmente sta gestendo tra otto e una dozzina di depositi.</p>
<p>Gensler ha rivelato che in passato l’autorità di regolamentazione aveva respinto le domande di ETF, ma i tribunali sono intervenuti. Ha detto: “In passato abbiamo respinto un certo numero di queste domande. Quindi, stiamo riconsiderando la questione in base a tali sentenze dei tribunali.”</p>
<p>Come hai notato, le sue parole suggeriscono un cambio di focus. Tuttavia, <a href="https://www.cnbc.com/video/2023/12/14/sec-chair-gary-gensler-ai-is-the-most-transformative-technology-of-our-time.html" rel="nofollow noopener noreferrer" target="_blank">ha sottolineato</a> ciò che l’agenzia di regolamentazione ha fatto è guidato dalle leggi che il Congresso ha promulgato e da come i tribunali le interpretano.</p>
<p>Qualcosa di unico riguardo a Gensler, il presidente della SEC, è che spesso ignora di rispondere in modo diretto a determinate domande. Ad esempio, in un’intervista con Kailey Leinz di Bloomberg il 14 dicembre, ha evitato di rispondere a una domanda sul numero di depositi per gli ETF bitcoin spot.</p>
<p>Leggi anche: <a href="https://www.gate.io/blog_detail/3076/can-spot-bitcoin-etfs-become-market-catalysts-if-approved" target="_blank">Possono gli ETF Bitcoin spot diventare catalizzatori di mercato se approvati?</a></p>
<p>Di conseguenza, Bryan Steil ha dato un commento sincero su X riguardo alla risposta di solito di Gensler alle domande. <a href="https://twitter.com/RepBryanSteil/status/1735032072425676838" rel="nofollow noopener noreferrer" target="_blank">Steil postato</a> Il presidente Gary Gensler oscura le criptovalute con la stampa come fa durante le audizioni del comitato. Non vuole spiegare l’approccio regolamentare aggressivo della sua agenzia che sta spingendo le criptovalute all’estero.</p>
<h2 id="h2-Domande20respinte20per20ETF20Bitcoin20spot588622"><a name="Domande respinte per ETF Bitcoin spot" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Domande respinte per ETF Bitcoin spot</h2><p>La SEC ha respinto le varie richieste di spot bitcoin ETF ricevute in passato, compresa l’offerta di Grayscale Investment tramite il suo Bitcoin Trust. In particolare, la SEC ha negato la richiesta di Grayscale di spot bitcoin basandosi sul fatto che non ha indicato in modo sufficiente come proteggerà gli investitori dalla manipolazione di mercato.</p>
<p>Notizie correlate: <a href="https://www.gate.io/blog_detail/3461" target="_blank">Punto di luce sugli Spot Bitcoin ETF e il loro impatto</a></p>
<p>Dopo la decisione della SEC di respingere la sua richiesta, Grayscale ha citato in giudizio l’autorità di regolamentazione sulla base del fatto che in passato ha approvato ETF basati su futures che si basano anche sul prezzo del bitcoin.</p>
<p>Alla fine, il tribunale ha stabilito che la SEC ha arbitrariamente respinto la richiesta di Grayscale per un fondo negoziato in borsa di scambio bitcoin al contante poiché non è riuscita a spiegare come l’ETF basato sui futures e l’ETF Spot BTC siano materialmente diversi.</p>
<p>Il caso Grayscale SEC è diventato interessante quando l’agenzia di regolamentazione ha declinato di appellarsi contro quella sentenza. Pertanto, il mercato crittografico aspetta di vedere la prossima mossa della SEC considerando che ci sono oltre 8 domande ETF, tra cui quelle di BlackRock, Invesco, Galaxy, VanEck, Valkyrie e Fidelity. Tuttavia, la SEC non ha preso una decisione sulle domande di questi gestori patrimoniali.</p>
<h2 id="h2-La20SEC20incontra20gli20emittenti20di20Spot20Bitcoin20ETF20per20tracciare20una20via20avanti975212"><a name="La SEC incontra gli emittenti di Spot Bitcoin ETF per tracciare una via avanti" class="reference-link"></a><span class="header-link octicon octicon-link"></span>La SEC incontra gli emittenti di Spot Bitcoin ETF per tracciare una via avanti</h2><p>Negli ultimi due mesi la Securities and Exchange Commission degli Stati Uniti ha incontrato diversi potenziali emittenti di ETF spot su bitcoin, tra cui Blackrock, Fidelity, Franklin Templeton e Grayscale per discutere di questioni relative a “<br><strong>SEC approva ETF Bitcoin spot.</strong>”</p>
<p>Recentemente, la SEC ha incontrato Grayscale e Franklin Templeton l’8 dicembre. Inoltre, ha avuto incontri con Fidelity Investments e BlackRock rispettivamente il 7 e l’11 dicembre. Ecco perché Eric Balchunas, un analista senior ETF di Bloomberg, ha commentato che la SEC è stata occupata.</p>
<p><a href="https://twitter.com/EricBalchunas/status/1734688272293789759" rel="nofollow noopener noreferrer" target="_blank">Ha scritto</a>, “La SEC è più occupata degli elfi di Babbo Natale. Il terzo incontro di Blackrock con loro ieri è il più notevole secondo me, poiché tutti stanno aspettando di vedere se riescono a convincere la SEC a consentire creazioni in natura nella prima serie di approvazioni.</p>
<p>Niente di rivoluzionario da segnalare, ma 4 diversi emittenti si sono incontrati con la SEC riguardo le loro presentazioni di Bitcoin ETF.</p>
<p><a href="https://twitter.com/JSeyff/status/1734679896746758219?ref_src=twsrc%5Etfw" rel="nofollow noopener noreferrer" target="_blank">James Seyffart, un altro analista ETF di Bloomberg ha detto</a>, “Sia la Divisione del Commercio e dei Mercati della [SEC] che la Divisione della Finanza Aziendale erano presenti in ciascuno di questi incontri. Sono le due divisioni che alla fine decideranno se e quando i 19b-4 e gli S-1 saranno approvati o respinti.”</p>
<h2 id="h2-Trattative20SEC20Grayscale187798"><a name="Trattative SEC Grayscale" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Trattative SEC Grayscale</h2><p>Anche se sembra che ci siano ritardi nelle approvazioni degli ETF di bitcoin, la speculazione sta crescendo nel settore crittografico che la SEC è probabile che li approvi già a gennaio 2024. Quello che sembra essere il punto fermo è il modello da utilizzare.</p>
<p>La SEC preferisce il modello di creazione di contanti mentre la maggior parte dei potenziali emittenti di bitcoin spot preferisce il modello di creazione in natura per gli ETF di bitcoin spot. Alcuni emittenti di ETF spot BTC come BlackRock sono disposti a rivedere il loro modello in natura.</p>
<h2 id="h2-Conclusion208300"><a name="Conclusion" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusion</h2><p>La SEC ha dichiarato di essere disposta a rivalutare la sua posizione sulle richieste di ETF bitcoin spot alla luce della recente decisione della corte di Grayscale. Finora, la SEC sta considerando tra 8 e una dozzina di richieste di ETF. Nel frattempo, il mercato prevede che la SEC possa approvare diversi ETF bitcoin spot all’inizio di gennaio 2024.</p>
<h2 id="h2-Domande20frequenti20sugli20ETF20Bitcoin20Spot854102"><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-Cos20Grayscale858743"><a name="Cos’è Grayscale?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Cos’è Grayscale?</h3><p>Grayscale è una delle principali società di gestione di asset di criptovalute con sede negli Stati Uniti. Offre asset di investimento che offrono esposizione a asset digitali come criptovalute. Recentemente, <a href="https://www.gate.io/blog_detail/3357/analyzing-the-sec-s-appeal-and-its-impact-on-grayscale-bitcoin-etf-ruling &quot;Grayscale filed an application for the launch of a spot bitcoin exchange traded fund (ETF" rel="nofollow noopener noreferrer" target="_blank">Grayscale ha presentato una domanda per il lancio di un fondo negoziato in borsa (ETF) bitcoin spot.</a>“).</p>
<h3 id="h3-Cos20lo20spot20bitcoin20ETF570015"><a name="Cos’è lo spot bitcoin ETF?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Cos’è lo spot bitcoin ETF?</h3><p>Un ETF spot bitcoin è un derivato crittografico che tiene traccia del prezzo del bitcoin. Consente agli investitori di ottenere esposizione al bitcoin senza possederlo. Attualmente, non ci sono ETF spot bitcoin negli Stati Uniti.</p>
<h3 id="h3-Cosa20sono20gli20ETF20criptovaluta308424"><a name="Cosa sono gli ETF criptovaluta?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Cosa sono gli ETF criptovaluta?</h3><p>Gli ETF criptati sono strumenti di investimento che danno agli investitori l’esposizione alle criptovalute senza possederle. Le azioni degli ETF criptati vengono scambiate sui tradizionali mercati azionari.</p>
<h3 id="h3-Battaglie20SEC20vs20Crypto20ETFs2020Chi20vince779133"><a name="Battaglie SEC vs Crypto ETFs - Chi vince?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Battaglie SEC vs Crypto ETFs - Chi vince?</h3><p>La SEC sta prendendo il suo tempo per valutare l’adeguatezza degli ETF cripto. È stata impegnata in discussioni con i potenziali emittenti di spot bitcoin durante l’ultimo trimestre del 2023. Al momento, è molto probabile che la SEC degli Stati Uniti approverà diversi ETF cripto all’inizio del 2024.</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 ripostaggio dell'articolo a condizione che venga fatto riferimento a Gate.io. In tutti i casi, verranno intraprese azioni legali a causa di violazioni del copyright.<br></div><p></p><br></div></div></div>