U0VDIENyeXB0byBSb3VuZHRhYmxlIHNwaWVnYXRvOiBzZWduYWxpIGNoaWF2ZSBkaSB1biBjYW1iaWFtZW50byBub3JtYXRpdm8gbmVnbGkgU3RhdGkgVW5pdGk=

2025-06-20, 09:38

<p><img src="https://gimg2.gateimg.com/image/sec202506201737025064687108.png" alt="">
</p><p>Nel gennaio 2025, la SEC ha istituito il Crypto Task Force, guidato dalla commissaria riformista Hester Peirce, con l’obiettivo di “definire chiari confini regolatori e stabilire un ragionevole quadro di divulgazione” per gli asset crittografici. Questa azione affronta direttamente i punti dolenti di lunga data del settore: nell’ultimo decennio, la SEC ha principalmente fatto affidamento su azioni di enforcement piuttosto che sulla creazione di regole, portando il mercato a “lottare con l’incertezza legale e la frammentazione.”</p>
<p>Il presidente ad interim Mark Uyeda ha criticato aspramente le strategie passate della SEC—“politica da struzzo” e “sparare prima, fare domande dopo”—durante il primo incontro del tavolo rotondo il 21 marzo, e ha annunciato la fine del modello di “applicazione improvvisata”, spostandosi verso la creazione di regole formali, comprese le meccanismi di esenzione e le disposizioni di safe harbor. Questo cambiamento è stato descritto da Forbes come un “segnale chiave di passaggio dall’applicazione alla comunicazione.”</p>
<h2 id="h2-Discussioni20di20Tavolo20Rotondo20della20Serie20Focalizzandosi20su20Quattro20Questioni20Fondamentali683754"><a name="Discussioni di Tavolo Rotondo della Serie: Focalizzandosi su Quattro Questioni Fondamentali" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Discussioni di Tavolo Rotondo della Serie: Focalizzandosi su Quattro Questioni Fondamentali</h2><p>La SEC ha tenuto cinque incontri intensivi a tavola rotonda da marzo a giugno, coprendo le sfide regolatorie più pressanti dell’industria:</p>
<ol>
<li>Percorso di conformità per le piattaforme di trading (11 aprile): Discussione su se le piattaforme di trading decentralizzate possono conformarsi senza modificare la loro architettura, affrontando direttamente i punti critici del DeFi.</li><li>Nuove normative di custodia implementate (25 aprile): Dopo la revoca del controverso documento SAB 121, sono stati chiariti gli standard per la custodia autonoma e i custodi qualificati.</li><li>Pratiche e sfide della tokenizzazione (12 maggio): Dibattito sulla fattibilità tecnica e sull’adattabilità normativa dei titoli sulla blockchain;</li><li>DeFi e l’equilibrio dell’innovazione (9 Giugno): Esplorare come la finanza decentralizzata sia compatibile con lo “spirito americano”.</li></ol>
<p>Ogni incontro è aperto al pubblico per la trasmissione in diretta e invita i rappresentanti del settore a partecipare alle discussioni, riflettendo l’accettazione da parte della SEC di voci diverse.</p>
<h2 id="h2-Tokenizzazione20Il20Focus20Controverso20della20Discussione20del20Tavolo20Rotondo48909"><a name="Tokenizzazione: Il Focus Controverso della Discussione del Tavolo Rotondo" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Tokenizzazione: Il Focus Controverso della Discussione del Tavolo Rotondo</h2><p>La sessione speciale sulla tokenizzazione di maggio ha suscitato un intenso dibattito. Il presidente della SEC Paul Atkins ha paragonato i titoli on-chain alla “trasformazione dell’industria musicale dal vinile all’era digitale”, sostenendo che potrebbe liberare il potenziale per dividendi automatici e liquidità migliorata. Tuttavia, la commissaria Caroline Crenshaw ha messo in discussione la sua fattibilità pratica, sottolineando problemi come la scalabilità insufficiente delle blockchain pubbliche permissionless e gli svantaggi del regolamento istantaneo— per esempio, il regolamento T+0 potrebbe compromettere il meccanismo di regolamento netto (che attualmente elimina il 98% del volume degli scambi) e indebolire la flessibilità dei pagamenti per gli investitori al dettaglio.</p>
<p>La contraddizione più profonda risiede nella logica regolamentare: Dovrebbe la SEC promuovere attivamente tecnologie specifiche? Crenshaw avverte che concentrarsi sulla blockchain ignorando altre tecnologie di registro distribuito è simile a “il governo che sceglie i vincitori.”</p>
<h2 id="h2-La20Ristrutturazione20del20Panorama20Normativo20Globale20Costringe20gli20Stati20Uniti20ad20Agire89424"><a name="La Ristrutturazione del Panorama Normativo Globale Costringe gli Stati Uniti ad Agire" class="reference-link"></a><span class="header-link octicon octicon-link"></span>La Ristrutturazione del Panorama Normativo Globale Costringe gli Stati Uniti ad Agire</h2><p>La trasformazione della SEC è parzialmente guidata da pressioni competitive globali:</p>
<ul>
<li>I sistemi EU MiCA e VASP di Hong Kong hanno stabilito un quadro completo, attirando capitale e talenti lontano dagli Stati Uniti.</li><li>Il Canada approva il primo sistema di staking al mondo <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> ETF, leader nell’innovazione dei prodotti spot;</li><li>I mercati emergenti come Panama stanno spingendo le agenzie governative ad accettare pagamenti in criptovaluta ed esplorare casi d’uso a livello sovrano.</li></ul>
<p>Allo stesso tempo, il caso della “Legge sul Bitcoin” di El Salvador che affronta un raffreddamento (con solo l’11% delle imprese registrate operative) avverte anche che le politiche devono allinearsi con le realtà di mercato. Peirce quindi sostiene fermamente un “sandbox normativo” che consenta agli scambi di sperimentare con titoli tokenizzati in un ambiente controllato, bilanciando innovazione e rischio.</p>
<h2 id="h2-Prospettive20future20attuazione20delle20regole20e20coordinamento20globale710579"><a name="Prospettive future: attuazione delle regole e coordinamento globale" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Prospettive future: attuazione delle regole e coordinamento globale</h2><p>La serie di tavole rotonde della SEC, pur non producendo direttamente regole, getta una base cruciale per la formulazione delle politiche:</p>
<ol>
<li>Lato emissione: Rivisitazione del modulo S-1 per esentare le clausole di divulgazione delle attività di crittografia non tipiche (come la compensazione dei dirigenti);</li><li>Lato trading: Revisione delle regole ATS per supportare le “transazioni di copertura” tra titoli e non-titoli;</li><li>Lato custodia: Ristrutturazione del framework del “broker-dealer a scopo speciale” per sbloccare il blocco dell’approvazione di sole due istituzioni.</li></ol>
<p>Queste misure rispecchiano la visione dell’amministrazione Trump di rendere gli Stati Uniti la capitale globale della crittografia, ma il successo dipende dal fatto che la SEC possa trasformare il dialogo aperto del tavolo rotondo in regole chiare e attuabili, evitando di ricadere nella trappola del “primo l’applicazione”.</p>
<p>I responsabili delle politiche e i costruttori dell’industria sono seduti attorno a un tavolo, con le luci concentrate sulla legge federale sulle securities che pende presso la sede della SEC. Quando il <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> il white paper è nato diciassette anni fa, questa legge esisteva già da mezzo secolo; la discussione del tavolo rotondo di oggi sta silenziosamente rimodellando il modo in cui i due lati conversano.</p>
<p>La serie di tavole rotonde della SEC segna un punto di svolta chiave nella regolamentazione della crittografia negli Stati Uniti, passando da un confronto a un dialogo costruttivo. Poiché le questioni centrali si spostano da dibattiti teorici a creazione di regole, il 2025 potrebbe diventare il punto di partenza per gli Stati Uniti per riconquistare la leadership nella regolamentazione della crittografia, a condizione che questi dibattiti possano trascendere i corridoi di Washington e tradursi in regole di cui il mercato ha veramente bisogno.</p>
<div class="blog-details-info"><br><div>Autore: <strong>Team del Blog</strong><br><div class="info-tips"><em>Il contenuto qui non costituisce alcuna offerta, sollecitazione o raccomandazione. Dovresti sempre cercare un consiglio professionale indipendente prima di prendere qualsiasi decisione di investimento.<br><div></div>Si prega di notare che Gate potrebbe limitare o vietare l'uso di tutti o parte dei Servizi da Località Riservate. Per ulteriori informazioni, si prega di leggere il Contratto dell'Utente tramite <a href="https://www.gate.com/legal/user-agreement" data-index="3">https://www.gate.com/legal/user-agreement</a>.<br><p></p><br></em></div></div></div>