QW5hbGlzaSBkZWxsJ2FwcGVsbG8gZGVsbGEgU0VDIGUgZGVsIHN1byBpbXBhdHRvIHN1bGxhIGRlY2lzaW9uZSBkZWxsJ0VURiBkaSBHcmF5c2NhbGUgQml0Y29pbg==

2023-10-26, 17:16
<p><img src="https://gimg2.gateimg.com/image/article/1698340134SDFX 1.jpeg" alt=""></p>
<h2 id="h2-In20poche20parole928651"><a name="In poche parole" class="reference-link"></a><span class="header-link octicon octicon-link"></span>In poche parole</h2><p>Il 13 ottobre 2023 è l’ultima data entro cui la SEC può appellarsi contro Grayscale Vs SEC <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Sentenza della Corte ETF.</p>
<p>La Company Act del 1940 e il Securities Act del 1933 che regolano gli ETF criptati impongono alla SEC di approvare o respingere le domande di ETF <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">bitcoin</a> spot.</p>
<p>La SEC ha il diritto di regolare i titoli, compresi gli ETF bitcoin spot.</p>
<h2 id="h2-Introduzione37353"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>Il 2023 è stato un anno molto frenetico per la Securities and Exchange Commission degli Stati Uniti (SEC) poiché si è occupata di diverse cause legali legate al settore delle criptovalute. Ad esempio, è stata coinvolta in battaglie legali con Grayscale, Coinbase, Binance e Ripple.</p>
<p>In particolare, la SEC ha perso due casi essenziali al momento. Non è riuscito a presentare ricorso sul caso SEC vs Ripple, anche se ha ancora la possibilità di presentare ricorso contro la recente sentenza sugli Exchange Traded Funds (ETF) di bitcoin in scala di grigi.</p>
<p>Questo post spiega la possibilità della SEC di fare appello alla decisione di Grayscale. Ci concentreremo anche sul quadro giuridico che regola gli ETF criptovalutari negli Stati Uniti. Infine, valuteremo il ruolo della SEC nell’approvazione o disapprovazione degli ETF criptovalutari e di altri titoli.</p>
<p>Leggi anche: <a href="https://www.gate.io/blog_detail/3194/crypto-influencers-fuel-speculation-sec" target="_blank">Gli influencer della criptovaluta alimentano le speculazioni mentre la SEC rimanda la decisione sull’ETF Bitcoin</a></p>
<h2 id="h2-Cos20un20ETF20Bitcoin20spot445110"><a name="Cos’è un ETF Bitcoin spot?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Cos’è un ETF Bitcoin spot?</h2><p>Iniziamo definendo un ETF bitcoin spot. Si tratta di un asset di investimento che segue il prezzo del bitcoin. Questo significa che se il prezzo del bitcoin aumenta, il valore dell’ETF aumenta in maniera proporzionale.</p>
<p>D’altra parte, il suo prezzo diminuisce quando il valore di Bitcoin scende. Tuttavia, l’ETF Bitcoin spot viene scambiato sulle borse valori, non sugli scambi di criptovaluta. Grayscale ha l’intenzione di <a href="https://www.gate.io/blog_detail/3312/what-are-bitcoin-etfs-and-why-investors-are-lining-up-gate-learn-offer-insight" target="_blank">introdurre un ETF bitcoin in contanti</a> non appena la SEC lo approva.</p>
<h2 id="h2-Possibilit20di20appello20della20SEC20sulla20sentenza20del20tribunale20di20Grayscale496903"><a name="Possibilità di appello della SEC sulla sentenza del tribunale di Grayscale" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Possibilità di appello della SEC sulla sentenza del tribunale di Grayscale</h2><p>La SEC dovrebbe prendere una decisione importante se appellarsi o meno contro la sentenza del tribunale della SEC sul Bitcoin ETF. Legalmente, la SEC dovrebbe presentare appello entro il 13 ottobre 2023. Il fatto che la SEC non presenti appello contro la sentenza del tribunale potrebbe aumentare le sue possibilità di <a href="https://www.gate.io/blog_detail/3265/daily-news-grayscale-applied-to-convert-its-ethereum-trust-fund-into-a-spot-etf-bitcoin-wallets-holding-100-000-10-000-coins-have-accumulated-a-total-of-1.17-billion-since-september-1" target="_blank">approvazione dell’ETF su bitcoin Grayscale</a>.</p>
<p>Lo scorso agosto, la Corte d’Appello del Circuito di Washington ha stabilito che la SEC dovesse esaminare la richiesta di Grayscale di convertire il suo trust Bitcoin in un ETF BTC. La corte ha stabilito che la SEC è stata arbitraria e capricciosa nella sua decisione di respingere l’ETF spot Bitcoin di Grayscale. La corte ha concluso che la SEC non ha spiegato perché ha trattato prodotti simili, <a href="https://www.gate.io/learn/articles/what-is-a-bitcoin-etf/218" target="_blank">ETF su bitcoin</a> e i futures su bitcoin, in modo diverso.</p>
<p>Giudice <a href="/price/tether-usdt" rel="nofollow noopener noreferrer" target="_blank">Tether</a> Rao ha detto: “Il diniego della proposta di Grayscale è stato arbitrario e capriccioso perché la Commissione non è riuscita a spiegare il diverso trattamento di prodotti simili.”</p>
<p>Il giudice Rao ha aggiunto: “Nonostante queste somiglianze salienti, la Commissione ha respinto l’ETP proposto da Grayscale e ha approvato due ETP futures su bitcoin.”</p>
<p>In altre parole, la SEC non è riuscita a spiegare chiaramente come l’ETF Bitcoin sia meno sicuro dei fondi basati sui futures che ha approvato in passato. Storicamente, nel 2021 Grayscale ha presentato domanda per convertire il suo trust Bitcoin in un ETF BTC.</p>
<p>Tuttavia, la SEC respinge l’ETF Grayscale sulla base del fatto che la società di gestione patrimoniale non ha implementato misure sufficienti per proteggere gli investitori dalle manipolazioni del mercato. Tuttavia, Grayscale ha presentato ricorso contro la sentenza della SEC con l’intenzione di combattere <a href="https://www.gate.io/blog_detail/3289/sec-desicion-spot-btc-etf-blackrock" target="_blank">fino all’approvazione dell’ETF bitcoin da parte della SEC</a>.</p>
<p>La SEC sostiene che l’ETF su bitcoin rifiutato è suscettibile di molte manipolazioni di mercato poiché l’asset sottostante, bitcoin, non è regolamentato. Ha difeso la sua decisione di approvare gli ETF sui futures su Bitcoin affermando che il Chicago Mercantile Exchange è regolamentato e dispone di misure sufficienti e comprovate per salvaguardare i suddetti asset contro la manipolazione del mercato e le frodi.</p>
<p>Leggi anche: <a href="https://www.gate.io/learn/articles/what-are-leveraged-etf-tokens/21" target="_blank">Cosa sono i token ETF con leva?</a></p>
<h2 id="h2-C20qualche20possibilit20di20approvazione20dellETF20Bitcoin20spot352308"><a name="C’è qualche possibilità di approvazione dell’ETF Bitcoin spot?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>C’è qualche possibilità di approvazione dell’ETF Bitcoin spot?</h2><p>Molte persone si chiedono ancora se vedranno un ETF Bitcoin approvato negli Stati Uniti. In primo luogo, alcuni analisti credono che sebbene la SEC potrebbe non fare appello contro la sentenza del tribunale Grayscale vs SEC, essa presenterà comunque, <a href="https://www.gate.io/blog_detail/511/sec-delays-on-grayscale-s-bitcoin-etf-proposal" target="_blank">modi per ritardare l’approvazione dell’ETF Bitcoin spot di Grayscale</a>.</p>
<p>Anche se non è specifico, Eric Balchunas, un analista ETF di Bloomberg, ha detto che anche se la Securities and Exchange Commission degli Stati Uniti non fa appello alla decisione del tribunale SEC Grayscale, troverà un modo per ritardare l’approvazione di qualsiasi ETF bitcoin spot.</p>
<p>Balchunas ha detto: “Pensiamo che un ricorso sia un’ipotesi remota […] Ma c’è sempre la possibilità che accada qualcos’altro.” Tuttavia, James Seyffart, un altro analista ETF di Bloomberg, contraddice la posizione di Balchunas. Ha detto che anche se non c’è una data di decisione della SEC sul bitcoin ETF, alla fine approverà il Grayscale bitcoin ETF. L’ultimo sondaggio mostra una probabilità del 95% che la Securities and Exchange Commission degli Stati Uniti possa approvare il Grayscale SEC ETF nel 2024.</p>
<p>Leggi anche: <a href="https://www.gate.io/blog_detail/3135/sec-approves-eth-futures" target="_blank">La SEC approva i Future ETFS di Ethereum</a></p>
<h2 id="h2-Il20quadro20normativo20per20gli20ETF20sulle20criptovalute473607"><a name="Il quadro normativo per gli ETF sulle criptovalute" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Il quadro normativo per gli ETF sulle criptovalute</h2><p>Anche se non esistono leggi specifiche che trattino in modo specifico gli ETF sulle criptovalute, le leggi esistenti li accolgono. Ci sono diverse disposizioni nel Investment Company Act del 1940 che sono applicabili agli ETF sulle criptovalute.</p>
<p>Secondo la legge sia la Securities and Exchange Commission degli Stati Uniti che la Commodity Futures Trading Commission hanno il mandato di regolare i prodotti di investimento correlati alla crittografia a seconda della loro natura.</p>
<p>Il Securities Exchange Act del 1934 impone anche alla SEC di regolamentare tutti i titoli. Ciò significa che ha l’autorità di governare gli ETF crittografici. Questo perché gli ETF crittografici sono cesti di titoli correlati alle criptovalute. In particolare, il Securities Act del 1933 stabilisce che la SEC ha il diritto e l’obbligo di approvare o disapprovare i titoli indipendentemente dalle loro specifiche categorie.</p>
<h2 id="h2-Ruolo20della20SEC20nellapprovazione20e20disapprovazione20degli20ETF20criptovalutari84109"><a name="Ruolo della SEC nell’approvazione e disapprovazione degli ETF criptovalutari" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Ruolo della SEC nell’approvazione e disapprovazione degli ETF criptovalutari</h2><p>Come detto sopra, sia il Company Act del 1940 che il Securities Act del 1933 obbligano la SEC a regolare tutti i titoli, una classe di attività in cui rientrano gli ETF criptati. Pertanto, la SEC regola la creazione e la negoziazione degli ETF criptati. Lo scopo principale della SEC è proteggere gli investitori dalle manipolazioni di mercato e dalle frodi.</p>
<p>Uno dei ruoli chiave della SEC è approvare o respingere qualsiasi domanda di titoli, compresi gli ETF criptovalutari. Inoltre, la SEC fa rispettare la conformità legale alle leggi sui titoli esistenti.</p>
<h2 id="h2-Cosa20succede20se20viene20approvato20il20Bitcoin20ETF227720"><a name="Cosa succede se viene approvato il Bitcoin ETF?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Cosa succede se viene approvato il Bitcoin ETF?</h2><p>Una volta approvato un ETF bitcoin spot, la SEC garantirà che l’emittente aderisca ai requisiti di reporting come mezzo per aumentare la trasparenza e la supervisione.</p>
<p>Sicuramente, l’ETF aumenterà la liquidità del mercato del bitcoin e aumenterà anche il suo volume di scambi. Di conseguenza, il <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Prezzo del Bitcoin</a> probabilmente aumenterà sia nel breve termine che nel lungo termine. Ciò significherà anche un’accettazione delle criptovalute da parte delle autorità di regolamentazione, il che potrebbe portare a un aumento dell’adozione.</p>
<h2 id="h2-Conclusione880213"><a name="Conclusione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusione</h2><p>C’è una forte probabilità che la SEC non presenti appello contro la decisione della SEC su Grayscale ETF. Se ciò accade, la possibilità di approvazione dell’ETF su spot bitcoin di Grayscale diventa più alta rispetto a prima. La SEC utilizza il Company Act del 1940 e il Securities Act del 1933 nella regolamentazione degli ETF criptati e altri titoli.</p>
<h2 id="h2-Domande20frequenti20sugli20ETF20Bitcoin20Spot978612"><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-La20vittoria20in20tribunale20di20Grayscale20sulla20SEC20solleva20la20speranza20per20lapprovazione20dellETF20Bitcoin657503"><a name="La vittoria in tribunale di Grayscale sulla SEC solleva la speranza per l’approvazione dell’ETF Bitcoin?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>La vittoria in tribunale di Grayscale sulla SEC solleva la speranza per l’approvazione dell’ETF Bitcoin?</h3><p>La vittoria in tribunale di Grayscale sulla SEC ha dato al mercato delle criptovalute la speranza che il suo bitcoin spot venga approvato. Tuttavia, c’è stata la possibilità che la SEC possa impugnare la sentenza entro il 13 ottobre.</p>
<h3 id="h3-Pu20la20SEC20fare20appello20a20Grayscale8492"><a name="Può la SEC fare appello a Grayscale?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Può la SEC fare appello a Grayscale?</h3><p>La SEC ha il diritto di appellarsi contro la sentenza del tribunale su Grayscale spot bitcoin entro il 13 ottobre 2023. Tuttavia, c’è una alta possibilità che la SEC possa scegliere di non appellarsi contro la sentenza.</p>
<h3 id="h3-La20SEC20approver20gli20ETF20bitcoin158066"><a name="La SEC approverà gli ETF bitcoin?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>La SEC approverà gli ETF bitcoin?</h3><p>C’è una alta possibilità che la SEC possa approvare diversi ETF Bitcoin nel 2024. Attualmente, sta valutando le possibilità di manipolazione del mercato e frode nel mercato degli ETF Bitcoin.</p>
<h3 id="h3-Qual2020la20decisione20della20SEC20sullETF20Bitcoin507551"><a name="Qual è la decisione della SEC sull’ETF Bitcoin?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Qual è la decisione della SEC sull’ETF Bitcoin?</h3><p>La SEC ha rinviato la sua decisione su varie richieste di ETF di bitcoin. Questo perché sta ancora valutando la fattibilità degli ETF cripto. La SEC darà la sua decisione finale sugli ETF di bitcoin nel 2024.</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 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 ripubblicare l'articolo 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>
Share
Content
gate logo
Gate
Trade Now
Join Gate to Win Rewards