SWwgbnVvdm8gcHJlc2lkZW50ZSBkZWxsYSBTRUMgcHJlbmRlIHNlcnZpemlvLCBjb21wcmVuZGUgbW9sdGUgcG9saXRpY2hlIHJlY2VudGkgYW1pY2hldm9saSBpbiB1biBhcnRpY29sbw==

2025-04-17, 07:23

<p><img src="https://gimg2.gateimg.com/image/article/1744873960INDUSTRYANALYSIS.png" alt=""></p>
<h2 id="h2-TLDR413172"><a name="[TL;DR]:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL;DR]:</h2><p>Il 9 aprile, il Senato degli Stati Uniti ha confermato l’ex commissario della SEC Paul Atkins come nuovo presidente della SEC con 52 voti contro 44. Il nuovo presidente, Paul Atkins, noto per la sua filosofia di “libero mercato”, ha dichiarato che farà dello sviluppo di un quadro normativo per gli asset digitali una “priorità assoluta”, segnando un importante cambiamento nell’atteggiamento della SEC nei confronti della regolamentazione delle criptovalute.</p>
<p>La posizione amichevole e rilassata di Paul Atkins è strettamente legata alla sua educazione e carriera. Durante il suo mandato come Commissario della SEC dal 2002 al 2008, è stato noto per il suo sostegno ai principi del libero mercato e alla riduzione degli oneri regolamentari.</p>
<p>La nomina di Paul Atkins fa parte della politica complessivamente cripto-friendly dell’amministrazione Trump. Si prevede che aderisca alla filosofia politica di riduzione della regolamentazione e promozione dell’innovazione, ma ci sono ancora sfide.</p>
<h2 id="h2-Introduzione33679"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>Mentre tutti sono concentrati sull’attuale tumulto nel <a href="/price" rel="nofollow noopener noreferrer" target="_blank">mercato crittografico</a> sotto l’estrema politica tariffaria di Trump, si sta silenziosamente verificando un’iniziativa per rilanciare il mercato: il nuovo presidente della Commissione per i titoli e gli scambi degli Stati Uniti (SEC), Paul Atkins, ha recentemente assunto l’incarico e si sta presentando come una persona amichevole, portando nuova vitalità al settore.</p>
<h2 id="h2-Paul20Atkins20Takes20Over20the20SEC20e20la20nuova20politica20amichevole20porta20speranza721328"><a name="Paul Atkins Takes Over the SEC, e la nuova politica amichevole porta speranza" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Paul Atkins Takes Over the SEC, e la nuova politica amichevole porta speranza</h2><p>Recentemente, i rischi macroeconomici rappresentati dalla guerra commerciale tra Sino-USA hanno continuato ad aumentare, e lo shock della catena di approvvigionamento globale è stato trasmesso al mercato finanziario. Il prezzo di <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> è anche sceso al di sotto dei $75,000. Molti degli ultimi post del blog dell’autore hanno discusso dello sfondo generale della vendita di asset crittografici. Alla data di scrittura, il sentiment di mercato è ancora in discesa.</p>
<p>Tuttavia, un punto di svolta è silenziosamente arrivato. Il 9 aprile, il Senato degli Stati Uniti ha confermato l’ex commissario della SEC Paul Atkins come nuovo presidente della SEC con 52 voti a 44, sostituendo il predecessore Gary Gensler. Gensler è noto per l’applicazione rigorosa della legge, mentre il nuovo presidente, Paul Atkins, noto per la sua filosofia del “libero mercato”, ha dichiarato che farà dello sviluppo di un quadro normativo per gli asset digitali una “priorità assoluta”, segnando un cambiamento significativo nell’atteggiamento della SEC nei confronti della regolamentazione delle criptovalute.<img src="https://gimg2.gateimg.com/image/article/17448743661.jpeg" alt=""><br>Origine: @EleanorTerrett</p>
<p>Paul Atkins ha promosso una serie di politiche e attività favorevoli sin dal suo insediamento:</p>
<p>10 aprile: La SEC ha approvato diversi <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> applicazioni di trading di opzioni di fondi negoziati in borsa (ETF) da BlackRock, Bitwise e altri attraverso una procedura di ‘approvazione accelerata’.</p>
<p>11 aprile: La divisione finanziaria della SEC ha rilasciato una dichiarazione fornendo riferimenti normativi per l’emissione e la registrazione di titoli nel mercato degli asset crittografici. La dichiarazione spiega l’applicabilità delle leggi federali sui titoli agli asset crittografici e elenca le informazioni che gli emittenti potrebbero dover considerare, tra cui descrizioni aziendali, fattori di rischio, caratteristiche di sicurezza e informazioni sulla gestione, segnando un passaggio dalla “vigilanza dell’applicazione della legge” alla “vigilanza guida”. Lo stesso giorno, la SEC e Ripple hanno raggiunto un accordo transattivo. Le due parti hanno presentato congiuntamente una richiesta di sospensione dell’appello e hanno ufficialmente ritirato la causa legale contro Nova Labs (sviluppatore del <a href="/price/helium-hnt" rel="nofollow noopener noreferrer" target="_blank">Elio</a> rete), mostrando un atteggiamento più morbido.</p>
<p>12 aprile: i vertici della SEC hanno dichiarato venerdì che avrebbero valutato la possibilità di istituire una sandbox regolamentare per gli asset digitali, consentendo agli scambi di criptovalute di sperimentare liberamente in nuovi settori, compresa la possibile apertura del trading in titoli tokenizzati.</p>
<p>16 aprile: La SEC ha concluso la sua indagine sulle comunicazioni finanziarie del progetto NFT CyberKongz e Coinbase; inoltre, il ricorso congiunto per una sospensione dell’appello precedentemente depositato con Ripple è stato approvato.<br>17 aprile: La SEC ha annunciato che terrà il suo terzo tavolo rotondo sulla politica cripto il 25 aprile, con un focus sulla custodia cripto. La riunione prevede due panel — uno sui broker e la custodia del portafoglio, e un altro sugli advisor e la custodia delle società di investimento.<br><img src="https://gimg2.gateimg.com/image/article/17448744012.jpeg" alt=""><br>Source: Bloomberg</p>
<p>Ancora più importante, la nomina di Atkins ha accelerato la risoluzione dei casi legacy passati. Ad esempio, la causa contro lo sviluppatore della rete <a href="/price/helium-hnt" target="_blank" class="blog_inner_link">Helium</a>, Nova Labs, menzionata in precedenza, è stata risolta silenziosamente, e la disputa di lunga data di Ripple con la SEC è stata risolta. Queste azioni stabiliscono un precedente positivo per progetti simili e permettono al mercato di vedere la possibilità di un rilassamento normativo. Come spesso sottolineo nei miei precedenti post sul blog, spostamenti di politica sono spesso un preludio ai punti di svolta di mercato, e i segnali rilasciati dalla SEC non sembrano essere stati completamente scontati dal mercato, quindi è più importante discuterne.</p>
<h2 id="h2-Curriculum20di20Paul20Atkins20da20un20candidato20di20una20piccola20citt20a20un20pioniere20della20regolamentazione202733"><a name="Curriculum di Paul Atkins: da un candidato di una piccola città a un pioniere della regolamentazione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Curriculum di Paul Atkins: da un candidato di una piccola città a un pioniere della regolamentazione</h2><p>Paul Atkins assume una posizione amichevole e rilassata, strettamente legata alla sua educazione e carriera.</p>
<p>Secondo le informazioni pubbliche, Atkins è nato in una piccola città della Carolina del Nord, USA, e ha trascorso gli anni dell’adolescenza a Tampa, Florida. Dopo aver conseguito una laurea in Arti presso il Wofford College, ha frequentato la Facoltà di Giurisprudenza dell’Università di Vanderbilt per ulteriori studi. È diventato un senior student writing editor della Vanderbilt Law Review. Questa esperienza ha coltivato la sua attenzione ai dettagli legali e al pensiero rigoroso.<br><img src="https://gimg2.gateimg.com/image/article/17448744273.jpeg" alt=""><br>Fonte: @realDonaldTrump</p>
<p>Dopo essersi laureato alla Harvard Law School, Atkins ha servito come Commissario della SEC dal 2002 al 2008, quando era conosciuto per il suo sostegno al libero mercato. Ad esempio, nel 2005, si oppose all’aumento della regolamentazione degli hedge fund, sottolineando che una regolamentazione eccessiva avrebbe influenzato la liquidità del mercato. Durante questo periodo, era noto per il suo sostegno ai principi del libero mercato e alla sua posizione sulla riduzione degli oneri regolamentari, e una volta dichiarò pubblicamente: “La SEC non deve spremere gli investitori dal mercato attraverso una regolamentazione onerosa.”</p>
<p>Questa filosofia permea l’intera sua carriera. Dopo aver lasciato la SEC, ha fondato Patomak Global Partners per fornire servizi di consulenza a società di criptovalute, come ad esempio l’assistenza a Ripple nel rispondere alle cause legali. Atkins guida anche la Token Alliance, impegnata nello sviluppo delle migliori pratiche per gli asset digitali.<img src="https://gimg2.gateimg.com/image/article/17448744474.jpeg" alt=""><br>Source: Atkins</p>
<p>Vale la pena sottolineare che Atkins stesso è anche un partecipante attivo nell’industria delle criptovalute. Secondo la rivista Fortune, possiede fino a $6 milioni in asset correlati alle criptovalute, tra cui azioni in Anchorage e Securitize. Anche se questo investimento ha suscitato domande dalla senatrice Elizabeth Warren riguardo al suo potenziale conflitto di interessi, ha risposto che questi asset riflettono il suo <a href="/price/optimism-op" rel="nofollow noopener noreferrer" target="_blank">ottimismo</a> sulla potenziale della tecnologia piuttosto che sui tentativi speculativi. A mio parere, questa identità di un “detentore di monete” potrebbe essere una delle ragioni per cui può veramente comprendere le esigenze dell’industria crittografica.</p>
<p>Non è difficile vedere dal precedente che lo sfondo di Atkins mostra che non solo supporta la criptovaluta in teoria, ma partecipa anche nella pratica, ponendo le basi per la promozione di politiche amichevoli. L’autore ha menzionato in “ <a href="https://www.gate.io/blog/4765/gary-gensler-may-resign-analyze-secs-approach-to-crypto-regulation" target="_blank">Gary Gensler May Resign, Analizzare l’Approccio della SEC alla Regolamentazione delle Criptovalute</a> che l’esperienza personale dei regolatori influisce spesso profondamente sulle loro politiche, e Atkins è un caso tipico.</p>
<h2 id="h2-Nellera20di20Trump20quali20saranno20le20tendenze20normative20future483976"><a name="Nell’era di Trump, quali saranno le tendenze normative future?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Nell’era di Trump, quali saranno le tendenze normative future?</h2><p>Da un punto di vista più ampio, la nomina di Paul Atkins fa parte della politica complessivamente favorevole alle criptovalute dell’amministrazione Trump. Se non accadranno imprevisti, la SEC continuerà con questo approccio regolatorio amichevole e rilassato.</p>
<p>In realtà, già lo scorso anno durante la campagna, Trump ha ripetutamente espresso il suo sostegno a <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> e alla tecnologia blockchain come manifestazione della sua strategia politica di nazionalismo economico e competizione tecnologica. Dopo aver assunto la presidenza, ha rapidamente abolito le regole del broker dell’IRS per le piattaforme DeFi, approvato il Stablecoin Act, proposto un piano di riserva strategica di <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> e tenuto il primo Vertice sulla Criptovaluta della Casa Bianca.<img src="https://gimg2.gateimg.com/image/article/17448745145.jpeg" alt=""><br>Fonte: @NaeemAslam23</p>
<p>In questo contesto, il controllo di Atkins sulla SEC deve naturalmente essere adattato alla strategia di governo dell’amministrazione Trump. Allentare le regolamentazioni è favorevole al raggiungimento:</p>
<p>Domanda di rimpatrio di capitale: La guerra dei dazi ha portato al ritiro di capitali stranieri dagli Stati Uniti. Una regolamentazione delle criptovalute più rilassata può attrarre aziende globali di blockchain, come ad esempio collaborare con D.O.G.E., guidata da Musk, per ridurre l’onere sulle aziende di criptovaluta e promuovere la crescita.</p>
<p>Lotta per la sovranità tecnologica: l’amministrazione Trump considera il blockchain come la “prossima generazione di infrastrutture finanziarie.” L’avanzamento dei piani strategici di riserva di Bitcoin e altre criptovalute richiede la cooperazione della SEC per chiarire gli attributi del token.</p>
<p>Gioco politico elettorale: Fortezze repubblicane tradizionali come il Texas e la Florida hanno approvato leggi favorevoli alle criptovalute, e il rilassamento della politica a livello federale consoliderà il sostegno locale.</p>
<p>Ripensando al curriculum di Paul Atkins e alle recenti tendenze politiche, non è difficile trovare che Atkins abbia proseguito la politica coerente dell’amministrazione Trump, che è quella di enfatizzare la riduzione della regolamentazione e la promozione dell’innovazione. La sua nomina segna una trasformazione importante della SEC da un approccio a ‘pugno di ferro’ a uno di ‘inclusione’, e disegnerà anche un percorso chiaro per l’industria delle criptovalute.<img src="https://gimg2.gateimg.com/image/article/17448745476.jpeg" alt=""><br>Origine: @SECGov</p>
<p>Tuttavia, rimangono sfide. Da un lato, le tendenze filo-industria di Atkins potrebbero indebolire la protezione degli investitori e destare dubbi pubblici. Dopotutto, l’esplosione di FTX nel 2022 è ancora ben impressa nella mente delle persone. Dall’altro lato, la variabilità delle politiche di Trump potrebbe limitare anche il suo margine di manovra.</p>
<p>In breve, nell’intreccio di guerre tariffarie e rivoluzioni tecnologiche, il rilassamento della politica della SEC potrebbe essere il “primo domino” della ripresa del mercato. L’autore ritiene che con il cambiamento di molteplici sentimenti negativi sul mercato, il “fondo politico” della serie di azioni amichevoli della SEC è emerso, e il cambiamento positivo del mercato delle criptovalute da ribassista a rialzista è dietro l’angolo.</p>
<div class="blog-details-info"><br><div>Autore:<strong>Charle Y.</strong>, Ricercatore di Gate.io<br><div>Traduttore: Joy Z.<br><div class="info-tips"><em>Questo articolo rappresenta solo le opinioni del ricercatore e non costituisce suggerimenti di investimento. Tutti gli investimenti comportano rischi intrinseci; è essenziale prendere decisioni oculate.<br></em><div><em></em>Gate.io si riserva tutti i diritti su questo articolo. La ripubblicazione dell'articolo sarà consentita 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></div>