R2Vuc2xlciBkZWxsYSBTRUMgc3VpICQ1IG1pbGlhcmRpIGRpIHNhbnppb25pIGUgc3VsIGNhbWJpYW1lbnRvIGRlbCBwYW5vcmFtYSBkZWxsZSBjcmlwdG92YWx1dGU=

<p><img src="https://gimg2.gateimg.com/image/article/1690791857hotspot.jpeg" alt=""></p>
<h2 id="h2-TL20DR773448"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p>La SEC ha presentato più di 780 azioni di esecuzione e oltre 500 casi autonomi nel 2023.</p>
<p>Gary Gensler, il presidente della SEC, ha affermato che l’autorità di regolamentazione è in fase di revisione di 8-10 spot <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Applicazioni ETF.</p>
<p>La SEC ha multato BlackRock con 2,5 milioni di dollari per informazioni inaccurate.</p>
<h2 id="h2-Introduzione341281"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>Il settore della criptovaluta, essendo una nuova industria, sta ancora affrontando incertezze normative. D’altra parte, le autorità di regolamentazione come la Securities and Exchange Commission degli Stati Uniti stanno lavorando duramente per affermare la propria autorità nel settore e creare una legislazione chiara sulle criptovalute.</p>
<p>Sebbene la supervisione normativa sia fondamentale per proteggere il pubblico e gli investitori, dovrebbe essere equa e trasparente per promuovere l’innovazione e la creatività che spingono l’economia in avanti. Oggi, diamo uno sguardo a <a href="https://www.gate.io/learn/articles/the-wild-west-of-the-crypto-world/670" target="_blank">Gli ultimi guadagni della SEC</a> nella supervisione del settore cripto e del futuro della regolamentazione del mercato cripto.</p>
<h2 id="h2-Applicazione20della20legge20della20SEC20nel20settore20criptato20degli20Stati20Uniti282092"><a name="Applicazione della legge della SEC nel settore criptato degli Stati Uniti" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Applicazione della legge della SEC nel settore criptato degli Stati Uniti</h2><p>Nel rivolgere il 2023 Securities Enforcement Forum il 25 ottobre, il presidente della Securities and Exchange Commission (SEC) degli Stati Uniti, Gary Gensler, ha sottolineato le azioni di contrasto legale di successo della SEC durante gli ultimi anni.</p>
<p>Gensler ha dichiarato che la SEC ha presentato più di 780 azioni di contrasto e oltre 500 casi autonomi nel 2023 da sola. Di conseguenza, attraverso queste sentenze e ordinanze, la SEC ha raccolto 5 miliardi di dollari. Già ha distribuito 930 milioni di dollari agli investitori interessati.</p>
<p>Il presidente della SEC ha affermato che da dicembre 2021 l’agenzia ha intentato cause contro 40 società che hanno violato diverse normative del mercato criptato. Inoltre, nello stesso periodo la SEC ha risolto le questioni relative alla tenuta dei registri con 23 aziende, dimostrando il suo impegno a instillare disciplina e ordine nel settore.</p>
<p>In primo luogo, la SEC presenta cause legali per impedire alle aziende e alle persone di violare le leggi sui valori mobiliari degli Stati Uniti. Durante il processo, recupera i fondi che alcune aziende e persone ottengono da comportamenti illegali. Inoltre, impone sanzioni civili alle aziende in violazione come mezzo per costringerle a conformarsi alle leggi sui valori mobiliari.</p>
<p><a href="https://www.coindesk.com/policy/2023/02/21/secs-shadow-crypto-rule-taking-shape-as-enforcement-cases-mount/" rel="nofollow noopener noreferrer" target="_blank">Secondo CoinDesk</a> Finora, le azioni di contrasto della SEC hanno creato una ‘regola cripto ombra’ che definisce ciò che l’organo di regolamentazione vede come regolamentazione del mercato cripto. Finora, le azioni di contrasto legate alle cripto che la SEC ha istituito coprono una vasta gamma di settori, tra cui la manipolazione di mercato, le violazioni della sicurezza informatica, il trading interno, i tweet falsi e le violazioni delle comunicazioni delle società quotate pubblichemente.</p>
<p>In relazione a ciò che l’agenzia di regolamentazione ha fatto finora, il presidente della SEC <a href="https://docketevents.com/live/71/page/854" rel="nofollow noopener noreferrer" target="_blank">detto</a>“Non iniziate nemmeno a parlarmi di criptovalute. Non nomino nemmeno tutte le persone che abbiamo incriminato in questo settore altamente non conforme.”</p>
<h2 id="h2-Il20presidente20della20SEC20Gensler20parla20degli20ETF20Bitcoin20spot483200"><a name="Il presidente della SEC, Gensler, parla degli ETF Bitcoin spot" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Il presidente della SEC, Gensler, parla degli ETF <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> spot</h2><p>Il presidente della SEC, Gensler, ha confermato anche che la Securities and Exchange Commission è attualmente <a href="https://www.gate.io/uk/blog_detail/3289/sec-postpones-decision-on-spot-bitcoin-etfs-from-blackrock-and-others" target="_blank">revisione di 8 a 10 domande di ETF bitcoin spot</a>. È importante notare che la SEC sta gestendo 12 richieste di ETF spot su BTC, tra cui quelle per Bitwise, WisdomTree, Grayscale, <a href="https://www.gate.io/blog_detail/1643/blackrock-launches-blockchain-related-etf-for-european-markets." target="_blank">BlackRock</a>, Invesco e Fidelity.</p>
<p>Nel frattempo, il presidente Gensler ha sottolineato che le domande ETF per BTC potrebbero presto arrivare davanti alla commissione composta da cinque membri. Tuttavia, ha rifiutato di fornire date specifiche per questo. Nel chiarire la situazione lui <a href="https://www.youtube.com/watch?v=TV2-UJWwMiE" rel="nofollow noopener noreferrer" target="_blank">detto</a>, “Hanno tutte scadenze diverse per l’applicazione.”</p>
<p><a href="https://www.youtube.com/watch?v=TV2-UJWwMiE" rel="nofollow noopener noreferrer" target="_blank">In un’intervista con Bloomberg Gensler ha aggiunto</a>, “Quello che abbiamo di fronte, affinché il pubblico capisca, non abbiamo uno, ma più; penso che siano otto o dieci depositi che lo staff, e in definitiva la commissione, sta considerando.”</p>
<p>L’attesa dell’approvazione da parte della SEC di diverse applicazioni spot bitcoin ETF è aumentata quando il regolatore ha deciso di non appellarsi contro l’ordinanza del tribunale di riesaminare l’applicazione Grayscale spot bitcoin ETF.</p>
<p>Leggi anche: <a href="https://www.gate.io/blog_detail/3289/sec-postpones-decision-on-spot-bitcoin-etfs-from-blackrock-and-others" target="_blank">La SEC rimanda la decisione sugli ETF Bitcoin spot di BlackRock</a></p>
<h2 id="h2-La20SEC20presenta20una20causa20contro20BlackRock204408"><a name="La SEC presenta una causa contro BlackRock" class="reference-link"></a><span class="header-link octicon octicon-link"></span>La SEC presenta una causa contro BlackRock</h2><p>In un contesto correlato, la SEC ha intentato una causa contro BlackRock, accusandola di non aver reso noti gli investimenti in una società che stava consulenzando. Secondo la causa della SEC, tra il 2015 e il 2019 il BlackRock Multi-Sector Income Trust (BIT) ha effettuato un investimento in Aviron Group, LLC tramite un finanziamento.</p>
<p>Tuttavia, BIT non è riuscita a fare divulgazioni accurate nei suoi rapporti annuali e semestrali quando ha descritto Aviron come una società di ‘Servizi Finanziari Diversificati’. Tale informazione era inesatta poiché Aviron sviluppa piani di stampa e pubblicità per i film. Pertanto, la SEC sostiene che BlackRock abbia fornito informazioni errate agli investitori al dettaglio e istituzionali.</p>
<p>A tal fine, <a href="https://www.sec.gov/news/press-release/2023-226#:~:text=%E2%80%9CRetail%20and%20institutional%20investors%20rely,Enforcement%20Division" rel="nofollow noopener noreferrer" target="_blank">Andrew Dean, il Co-Capo dell’Unità di Gestione degli Asset dell’Enforcement Division, ha detto</a>, “I investitori al dettaglio e istituzionali si affidano a divulgazioni accurate delle aziende che compongono il portafoglio di un fondo chiuso o di investimento collettivo per valutare un investimento attuale o potenziale nel fondo.”</p>
<p>Ha aggiunto: “Gli advisor di investimento hanno la responsabilità di fornire queste informazioni vitali, e BlackRock non è riuscita a farlo con l’investimento in Aviron”. Inoltre, BlackRock ha falsamente riportato che Aviron pagasse un tasso di interesse più elevato rispetto a quello effettivo.</p>
<p>Per tale falsa rappresentazione dei fatti, la SEC ha multato BlackRock per 2,5 milioni di dollari. Sebbene BlackRock non abbia ammesso o negato le accuse, ha risolto l’accordo. Questa causa arriva in un momento in cui la SEC sta esaminando la domanda di Grayscale per un ETF spot su bitcoin.</p>
<h2 id="h2-La20prospettiva20di20Gary20Gensler20sulla20regolamentazione20delle20criptovalute597462"><a name="La prospettiva di Gary Gensler sulla regolamentazione delle criptovalute" class="reference-link"></a><span class="header-link octicon octicon-link"></span>La prospettiva di Gary Gensler sulla regolamentazione delle criptovalute</h2><p>Il presidente della SEC, Gensler, non ha modificato la sua opinione sulle criptovalute nel corso degli anni. Egli ritiene che la maggior parte delle criptovalute siano titoli che la SEC dovrebbe regolamentare. In un’occasione, ha spiegato il concetto di contratto di investimento e ha affermato che la maggior parte delle criptovalute rientra in questa definizione, superando così il test del contratto di investimento.</p>
<p>Inoltre, Gensler ha paragonato l’attuale ambiente delle criptovalute al mercato finanziario non regolamentato degli anni ‘20. Tuttavia, il presidente della SEC ritiene che bitcoin ed ETH siano diversi dalle altre criptovalute. Egli sostiene che bitcoin è una merce e un deposito di valore proprio come l’oro. Tuttavia, Gensler non ha chiarito se ETH è considerata un titolo.</p>
<p>La visione di Gensler è che vi sia la necessità di classificare tutte le criptovalute al fine di avere chiarezza sulle regole che le governano. D’altra parte, la SEC sostiene che le attuali leggi finanziarie e di sicurezza sono chiare e possono essere applicate alle criptovalute senza ulteriori chiarimenti legali.</p>
<p>Attualmente, la SEC utilizza il ‘Test di Howey’ nelle sue azioni di applicazione. <a href="https://www.youtube.com/watch?v=h_oAr4wn7M4" rel="nofollow noopener noreferrer" target="_blank">Secondo l’interpretazione di Gensler</a>, “questi token sono titoli perché c’è un gruppo al centro e il pubblico si aspetta profitti basati su quel gruppo.”</p>
<p>Egli sostiene inoltre che il mercato ha molte ‘non conformità’, motivo per cui la SEC ha il diritto e la responsabilità legale di proteggere gli investitori utilizzando gli standard applicabili al settore finanziario tradizionale.</p>
<p>Leggi anche: <a href="https://www.gate.io/blog_detail/3357" target="_blank">Appello della SEC e il suo impatto sulla decisione del Grayscale Bitcoin ETF</a></p>
<h2 id="h2-Implicazioni20della20posizione20regolamentare20di20Gensler20e20delle20azioni20di20applicazione20della20SEC20sul20futuro20del20mercato20delle20criptovalute273137"><a name="Implicazioni della posizione regolamentare di Gensler e delle azioni di applicazione della SEC sul futuro del mercato delle criptovalute" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Implicazioni della posizione regolamentare di Gensler e delle azioni di applicazione della SEC sul futuro del mercato delle criptovalute</h2><p>In sostanza, la posizione regolamentare di Gensler e le recenti azioni di applicazione della SEC probabilmente soffocheranno l’innovazione, la ricerca e la creatività nel settore. Ciò significa che poche aziende cripto saranno disposte a operare negli Stati Uniti.</p>
<p>Anche alcune aziende internazionali che offrono prodotti crypto eviteranno di stabilire business unit negli Stati Uniti. Pertanto, potrebbero non consentire ai cittadini degli Stati Uniti di accedere ai loro prodotti e servizi.</p>
<h2 id="h2-Conclusione838472"><a name="Conclusione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusione</h2><p>Durante il 2023, la SEC degli Stati Uniti ha presentato oltre 700 cause penali contro i criminali crittografici. Da tali azioni di applicazione della legge, l’organo di regolamentazione è riuscito a raccogliere oltre 5 miliardi di dollari in sanzioni. Il presidente della SEC, Gensler, ritiene che tutte le criptovalute, tranne il bitcoin, siano titoli perché hanno squadre che le sviluppano e le “gestiscono”. D’altra parte, gli individui o le istituzioni che investono in criptovalute si aspettano di generare profitti.</p>
<h2 id="h2-Domande20frequenti20sulla20SEC795763"><a name="Domande frequenti sulla SEC" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Domande frequenti sulla SEC</h2><h3 id="h3-Cosa20ha20detto20Gensler20riguardo20alle20criptovalute424425"><a name="Cosa ha detto Gensler riguardo alle criptovalute?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Cosa ha detto Gensler riguardo alle criptovalute?</h3><p>Il <a href="https://www.gate.io/bitwiki/detail/875" target="_blank">Il presidente della Securities and Exchange Commission degli Stati Uniti, Gary Gensler</a>, ha detto che la maggior parte delle criptovalute sono titoli poiché hanno team che le creano e le gestiscono. Ha definito il bitcoin come una merce. La SEC utilizza il Test di Howey per determinare se una criptovaluta è un titolo o meno.</p>
<h3 id="h3-Chi2020Gary20Gensler20capo20della20SEC964229"><a name="Chi è Gary Gensler, capo della SEC?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Chi è Gary Gensler, capo della SEC?</h3><p>Gary Gensler, ex <a href="https://www.gate.io/blog_detail/907/gate.io-futures-rebate-rewards-150-000-twitter-accepts-musk-s-buyout-goldman-sachs-launches-lending-service-for-bitcoin-central-african-republic-sees-bitcoin-as-fiat-currency" target="_blank">Goldman Sachs</a> L’investment banker Gary Gensler è attualmente il presidente della Securities and Exchange Commission degli Stati Uniti. Nato nel 1957, Gensler ha ricoperto diverse cariche nei dipartimenti governativi negli ultimi anni. Ad esempio, è stato presidente della Commodity Futures Trading Commission durante il mandato dell’ex presidente Barack Obama.</p>
<h3 id="h3-Quanto20guadagna20Gary20Gensler855551"><a name="Quanto guadagna Gary Gensler?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Quanto guadagna Gary Gensler?</h3><p>Per il suo ruolo di presidente della Securities and Exchange Commission degli Stati Uniti, Gary Gensler riceve uno stipendio di circa $32.000 al mese. D’altra parte, il patrimonio netto di Gensler si aggira tra i $41 milioni e i $119 milioni.</p>
<h3 id="h3-Quando20si2020dimesso20Gary20Gensler568020"><a name="Quando si è dimesso Gary Gensler?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Quando si è dimesso Gary Gensler?</h3><p>Gary Gensler è ancora il presidente della Securities and Exchange Commission degli Stati Uniti. È stato nominato presidente nel 2018. È responsabile della supervisione della regolamentazione dei mercati finanziari e della protezione degli investitori.</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 suggerimenti di investimento.<br></em><div><em></em>Gate.io si riserva tutti i diritti su questo articolo. Sarà consentito il ri-pubblicare dell'articolo 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>