TmlldXdlIHZvb3J6aXR0ZXIgdmFuIGRlIFNFQyBuZWVtdCB6aWpuIGZ1bmN0aWUgb3AgemljaCwgYmVncmlqcHQgdmVsZSByZWNlbnRlIHZyaWVuZGVsaWprZSBiZWxlaWRzbWFhdHJlZ2VsZW4gaW4gw6nDqW4gYXJ0aWtlbA==

2025-04-17, 07:23

<p><img src="https://gimg2.gateimg.com/image/article/1744873960INDUSTRYANALYSIS.png" alt=""></p>
<h2 id="h2-TLDR926716"><a name="[TL;DR]:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL;DR]:</h2><p>Op 9 april bevestigde de Amerikaanse Senaat voormalig SEC-commissaris Paul Atkins als de nieuwe voorzitter van de SEC met 52 stemmen tegen 44. De nieuwe voorzitter, Paul Atkins, die bekend staat om zijn ‘vrijemarkt’-filosofie, zei dat hij de ontwikkeling van een regelgevend kader voor digitale activa tot een ‘topprioriteit’ zou maken, wat een belangrijke verschuiving markeert in de houding van de SEC ten opzichte van cryptoregulering.</p>
<p>Paul Atkins’ vriendelijke en ontspannen houding staat nauw in verband met zijn opvoeding en carrière. Tijdens zijn ambtstermijn als SEC-commissaris van 2002 tot 2008 stond hij bekend om zijn steun voor vrije marktprincipes en het verminderen van regelgevende lasten.</p>
<p>De benoeming van Paul Atkins maakt deel uit van het algehele crypto-vriendelijke beleid van de Trump-regering. Men verwacht dat het zich zal houden aan de beleidsfilosofie van het verminderen van regulering en het bevorderen van innovatie, maar er zijn nog steeds uitdagingen.</p>
<h2 id="h2-Kennismaking376517"><a name="Kennismaking" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Kennismaking</h2><p>Terwijl iedereen nauwlettend let op de recente onrust in de <a href="/price" rel="nofollow noopener noreferrer" target="_blank">crypto markt</a> Onder het extreme tariefbeleid van Trump vindt er stilletjes een beweging plaats om de markt te stimuleren - de nieuwe voorzitter van de U.S. Securities and Exchange Commission (SEC), Paul Atkins, heeft onlangs zijn functie aanvaard en treedt op als een vriendelijk persoon, die nieuwe vitaliteit brengt in de industrie.</p>
<h2 id="h2-Paul20Atkins20neemt20de20leiding20over20de20SEC20en20het20vriendelijke20nieuwe20beleid20brengt20hoop599562"><a name="Paul Atkins neemt de leiding over de SEC en het vriendelijke nieuwe beleid brengt hoop" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Paul Atkins neemt de leiding over de SEC en het vriendelijke nieuwe beleid brengt hoop</h2><p>Onlangs zijn de macro-economische risico’s vertegenwoordigd door de Sino-Amerikaanse tariefhandelsoorlog blijven escaleren, en de schok van de mondiale toeleveringsketen is overgebracht naar de financiële markt. De prijs van <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> is ook onder de $75,000 gezakt. Veel van de recente blogberichten van de auteur hebben ook de algemene achtergrond van de verkoop van crypto-activa besproken. Op de datum van schrijven is het marktsentiment nog steeds in een neerwaartse spiraal.</p>
<p>Echter is er een keerpunt stilzwijgend aangekomen. Op 9 april bevestigde de Amerikaanse Senaat voormalig SEC commissaris Paul Atkins als de nieuwe SEC voorzitter met 52 stemmen voor en 44 tegen, ter vervanging van voorganger Gary Gensler. Gensler staat bekend om strenge handhaving van de wet, terwijl de nieuwe voorzitter, Paul Atkins, die bekend staat om zijn ‘vrije markt’ filosofie, zei dat hij de ontwikkeling van een regelgevend kader voor digitale activa tot een ‘topprioriteit’ zou maken, wat een belangrijke verschuiving markeert in de houding van de SEC ten opzichte van cryptoregulering.<br><img src="https://gimg2.gateimg.com/image/article/17448743661.jpeg" alt=""><br>Bron: @EleanorTerrett</p>
<p>Paul Atkins heeft sinds zijn aantreden een aantal gunstige beleidsmaatregelen en activiteiten gepromoot:</p>
<p>10 april: De SEC heeft verschillende goedgekeurd <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> handelsapplicaties voor exchange-traded fund (ETF) opties van BlackRock, Bitwise en anderen via een procedure voor ‘versnelde goedkeuring’.</p>
<p>11 april: De financiële afdeling van de SEC heeft een verklaring uitgegeven met regelgevingsverwijzingen voor het uitgeven en registreren van effecten op de cryptomarkt. De verklaring legt uit hoe federale effectenwetten van toepassing zijn <a href="/price/optimism-op" target="_blank" class="blog_inner_link">op crypto</a>-activa en somt openbaarmakingsvereisten op die emittenten in overweging kunnen nemen, waaronder bedrijfsbeschrijvingen, risicofactoren, beveiligingskenmerken en managementinformatie, wat een verschuiving markeert van ‘handhavingstoezicht’ naar ‘begeleidingstoezicht.’ Op dezelfde dag hebben de SEC en Ripple een schikkingsovereenkomst bereikt. De twee partijen hebben gezamenlijk een verzoek ingediend voor uitstel van beroep en hebben de rechtszaak tegen Nova Labs (ontwikkelaar van de <a href="/price/helium-hnt" rel="nofollow noopener noreferrer" target="_blank">Helium</a> netwerk), waarbij een zachtere houding wordt getoond.</p>
<p>12 april: SEC-leiderschap zei op vrijdag dat het zou overwegen om een regelgevende sandbox voor digitale activa op te zetten, waardoor cryptobeurzen vrij kunnen experimenteren op nieuwe gebieden, inclusief mogelijk het openen van de handel in getokeniseerde effecten.</p>
<p>16 april: De SEC heeft haar onderzoek naar de financiële openbaarmakingen van NFT-project CyberKongz en Coinbase afgerond; bovendien werd het gezamenlijke verzoek tot uitstel van hoger beroep dat eerder was ingediend bij Ripple, goedgekeurd.<br>17 april: De SEC zei dat zij op 25 april haar derde crypto-beleidsronde tafel zal houden, met de focus op cryptobewaring. De vergadering omvat twee panelen — één over effectenmakelaars en portefeuillebewaring, en een ander over beleggingsadviseurs en beleggingsmaatschappijbewaring.<br><img src="https://gimg2.gateimg.com/image/article/17448744012.jpeg" alt=""><br>Bron: Bloomberg</p>
<p>Belangrijker nog versnelde de benoeming van Atkins de oplossing van eerdere legacy-glen. Zo eindigde de rechtszaak tegen <a href="/price/helium-hnt" target="_blank" class="blog_inner_link">Helium</a>-netwerkontwikkelaar Nova Labs zoals hierboven vermeld geruisloos, en werd het langlopende geschil van Ripple met de SEC geschikt. Deze acties stellen een positief precedent voor soortgelijke projecten en laten de markt zien dat er mogelijkheden zijn voor regelgevende versoepeling. Zoals ik vaak benadruk in eerdere blogposts, zijn beleidswijzigingen vaak een voorbode van keerpunten op de markt, en de signalen die door de SEC worden vrijgegeven lijken nog niet volledig in de markt te zijn verwerkt, dus is het belangrijker om hierover te discussiëren.</p>
<h2 id="h2-Paul20Atkins20CV20Van20een20student20uit20een20kleine20stad20tot20een20pionier20op20het20gebied20van20regelgeving676493"><a name="Paul Atkins’ CV: Van een student uit een kleine stad tot een pionier op het gebied van regelgeving" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Paul Atkins’ CV: Van een student uit een kleine stad tot een pionier op het gebied van regelgeving</h2><p>Paul Atkins neemt een vriendelijke en ontspannen houding aan, nauw verbonden met zijn opvoeding en carrière.</p>
<p>Volgens openbare informatie werd Atkins geboren in een klein stadje in North Carolina, VS, en bracht vervolgens zijn tienerjaren door in Tampa, Florida. Na het behalen van een Bachelor of Arts-diploma van het Wofford College, ging hij naar de rechtenfaculteit van de Vanderbilt University voor verdere studies. Hij werd een senior student schrijvende redacteur van de Vanderbilt Law Review. Deze ervaring heeft zijn aandacht voor juridische details en rigoureus denken gekweekt.<br><img src="https://gimg2.gateimg.com/image/article/17448744273.jpeg" alt=""><br>Bron: @realDonaldTrump</p>
<p>Na zijn afstuderen aan de Harvard Law School diende Atkins als commissaris van de SEC van 2002 tot 2008, toen hij bekend stond om zijn steun voor de vrije markt. Zo verzette hij zich in 2005 tegen een toename van de regulering van hedgefondsen, waarbij hij benadrukte dat overmatige regulering de marktliquiditeit zou beïnvloeden. In die periode stond hij bekend om zijn steun voor principes van de vrije markt en zijn standpunt over het verminderen van regelgevingslasten, en hij verklaarde eens publiekelijk: “De SEC mag investeerders niet uit de markt drukken door zware regulering.”</p>
<p>Deze filosofie loopt door zijn hele carrière heen. Na het verlaten van de SEC richtte hij Patomak Global Partners op om adviesdiensten te verlenen aan cryptobedrijven, zoals het helpen van Ripple bij het reageren op rechtszaken. Atkins leidt ook de Token Alliance, die zich inzet voor het ontwikkelen van best practices voor digitale activa.<img src="https://gimg2.gateimg.com/image/article/17448744474.jpeg" alt=""><br>Bron: Atkins</p>
<p>Het is vermeldenswaard dat Atkins zelf ook een actieve deelnemer is in de crypto-industrie. Volgens het tijdschrift Fortune heeft hij tot wel $6 miljoen aan crypto-gerelateerde activa, waaronder aandelen in Anchorage en Securitize. Hoewel deze investering vragen heeft opgeroepen van Senator Elizabeth Warren over zijn mogelijke belangenconflict, reageerde hij dat deze activa zijn <a href="/price/optimism-op" rel="nofollow noopener noreferrer" target="_blank">optimisme</a> over de potentie van de technologie in plaats van speculatieve pogingen. Naar mijn mening kan deze identiteit van een ‘muntbezitter’ een van de redenen zijn waarom hij echt de behoeften van de cryptobranche kan begrijpen.</p>
<p>Het is niet moeilijk om uit het bovenstaande te zien dat de achtergrond van Atkins laat zien dat hij niet alleen cryptocurrency in theorie ondersteunt, maar ook in de praktijk deelneemt, waardoor hij de basis legt voor de bevordering van vriendelijk beleid. De auteur noemde in “Gate <a href="https://www.gate.io/blog/4765/gary-gensler-may-resign-analyze-secs-approach-to-crypto-regulation" target="_blank">Gary Gensler May aftreden, Analyseer de aanpak van de SEC ten aanzien van cryptoregulering</a> Dat de persoonlijke ervaring van toezichthouders vaak een diepgaande invloed heeft op hun beleid, en Atkins is een typisch g.</p>
<h2 id="h2-In20het20Trumptijdperk20Welke20regelgevingstrends20zullen20er20in20de20toekomst20zijn88907"><a name="In het Trump-tijdperk, Welke regelgevingstrends zullen er in de toekomst zijn?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>In het Trump-tijdperk, Welke regelgevingstrends zullen er in de toekomst zijn?</h2><p>Vanuit een breder perspectief maakt de benoeming van Paul Atkins deel uit van het algehele crypto-vriendelijke beleid van de Trump-regering. Als er niets onverwachts gebeurt, zal de SEC deze vriendelijke, ontspannen regelgevende aanpak voortzetten.</p>
<p>In feite heeft Trump al vorig jaar tijdens de campagne herhaaldelijk zijn steun uitgesproken voor <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> en blockchaintechnologie als een manifestatie van zijn beleidsstrategie van economisch nationalisme en technologische concurrentie. Nadat Trump aantrad, schafte hij snel de IRS-makelaarsregels voor DeFi-platforms af, keurde de Stablecoin Act goed, stelde een <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> strategisch reserveplan voor en organiseerde de eerste White House Cryptocurrency Summit.<img src="https://gimg2.gateimg.com/image/article/17448745145.jpeg" alt=""><br>Bron: @NaeemAslam23</p>
<p>In deze context moet de controle van Atkins over de SEC natuurlijk aansluiten bij de bestuursstrategie van de Trump-regering. Het versoepelen van regelgeving draagt bij aan het bereiken van:</p>
<p>Vraag naar kapitaalrepatriëring: De tariefoorlog heeft geleid tot de terugtrekking van buitenlands kapitaal uit de Verenigde Staten. Een versoepeling van de crypto-regelgeving kan wereldwijde blockchainbedrijven aantrekken om zich te vestigen, zoals samenwerken met D.O.G.E., geleid door Musk, om de last voor cryptobedrijven te verminderen en de groei te bevorderen.</p>
<p>Strijd om technologische soevereiniteit: De regering-Trump beschouwt blockchain als de ‘volgende generatie financiële infrastructuur.’ Vooruitgang van strategische Bitcoin en andere cryptoreserveplannen vereist de medewerking van de SEC om tokenkenmerken te verduidelijken.</p>
<p>Electoraal politiek spel: Traditionele Republikeinse bolwerken zoals Texas en Florida hebben crypto-vriendelijke wetten aangenomen, en beleidsversoepeling op federaal niveau zal lokale steun consolideren.</p>
<p>Terugkijkend op het cv van Paul Atkins en recente beleidstrends is het niet moeilijk te vinden dat Atkins het consistente beleid van de Trump-regering heeft voortgezet, namelijk het benadrukken van deregulering en het bevorderen van innovatie. Zijn benoeming markeert een grote transformatie van de SEC van ‘ijzeren vuist’ naar ‘inclusiviteit’, en zal ook een duidelijk pad uitstippelen voor de cryptobranche.<img src="https://gimg2.gateimg.com/image/article/17448745476.jpeg" alt=""><br>Bron: @SECGov</p>
<p>Echter, er blijven uitdagingen bestaan. Enerzijds kunnen de pro-industrie neigingen van Atkins de bescherming van investeerders verzwakken en publieke twijfels opwekken. Immers, de FTX-explosie in 2022 staat nog vers in het geheugen van mensen. Anderzijds kan de beleidsvariatie van Trump ook zijn speelruimte beperken.</p>
<p>Kortom, in het verweven van tariefoorlogen en technologische revoluties kan de beleidsversoepeling van de SEC de “ eerste dominosteen ” van marktherstel zijn. De auteur is van mening dat met de verandering van meerdere negatieve sentimenten op de markt, de “ beleidsbodem ” van de reeks vriendelijke acties van de SEC is opgekomen, en de positieve verandering van de cryptomarkt van dalend naar stijgend staat voor de deur.</p>
<div class="blog-details-info"><br><div>Auteur:<strong>Charle Y.</strong>, Gate.io onderzoeker<br><div>Vertaler: Joy Z.<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de standpunten van de onderzoeker en vormt geen enkele beleggingsaanbeveling. Alle investeringen brengen inherente risico's met zich mee; verstandige besluitvorming is essentieel.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het opnieuw plaatsen van het artikel zal worden toegestaan mits Gate.io wordt vermeld. In alle glen zullen juridische stappen worden ondernomen vanwege inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div></div>