U0VDIENyeXB0byBSb3VuZHRhYmxlIFVpdGxlZzogQmVsYW5ncmlqa2UgU2lnbmFsZXJlbiB2YW4gZWVuIEFtZXJpa2FhbnNlIFJlZ2VsZ2V2aW5nc3ZlcnNjaHVpdmluZw==

2025-06-20, 09:38

<p><img src="https://gimg2.gateimg.com/image/sec202506201737025064687108.png" alt="">
</p><p>In januari 2025 heeft de SEC de Crypto Task Force opgericht, geleid door de hervormingsgezinde commissaris Hester Peirce, gericht op “het definiëren van duidelijke regulatoire grenzen en het opstellen van een redelijke openbaarmakingskader” voor encryptie-activa. Deze actie pakt rechtstreeks de langdurige pijnpunten van de sector aan: de afgelopen tien jaar heeft de SEC voornamelijk op handhavingsacties vertrouwd in plaats van op regelgeving, wat ertoe heeft geleid dat de markt “worstelt met juridische onzekerheid en fragmentatie.”</p>
<p>Voorzitter Mark Uyeda bekritiseerde de eerdere strategieën van de SEC scherp - “struisvogelbeleid” en “schiet eerst, stel later vragen handhaving” - tijdens de eerste ronde tafelbijeenkomst op 21 maart en kondigde het einde aan van het “improviserende handhavingsmodel”, met de overstap naar formele regelgevingsprocessen, inclusief vrijstellingsmechanismen en veilige havens. Deze verschuiving werd door Forbes beschreven als een “belangrijk signaal van de overgang van handhaving naar communicatie.”</p>
<h2 id="h2-Serie20Rondetafelgesprekken20Focus20op20Vier20Kernkwesties493812"><a name="Serie Rondetafelgesprekken: Focus op Vier Kernkwesties" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Serie Rondetafelgesprekken: Focus op Vier Kernkwesties</h2><p>De SEC hield van maart tot juni vijf intensieve rondetafelbijeenkomsten, waarin de meest urgente regelgevende uitdagingen van de sector werden besproken:</p>
<ol>
<li>Compliance Pad voor Handelsplatforms (11 april): Bespreking of gedecentraliseerde handelsplatforms kunnen voldoen zonder hun architectuur te veranderen, met directe aandacht voor DeFi-pijnpunten;</li><li>Nieuwe bewaarregelingen geïmplementeerd (25 april): Na de intrekking van het controversiële document SAB 121 zijn de normen voor zelfbewaring en gekwalificeerde bewaarders verduidelijkt.</li><li>Tokenisatiepraktijken en -uitdagingen (12 mei): Debat over de technische haalbaarheid en de regelgevende aanpasbaarheid van effecten op de blockchain;</li><li>DeFi en de Balans van Innovatie (9 juni): Onderzoeken hoe gedecentraliseerde financiën compatibel zijn met de “Amerikaanse geest”.</li></ol>
<p>Elke vergadering is openbaar voor live-uitzending en nodigt vertegenwoordigers uit de sector uit om deel te nemen aan discussies, wat de acceptatie van diverse stemmen door de SEC weerspiegelt.</p>
<h2 id="h2-Tokenisatie20De20Controversile20Focus20van20de20Rondetafelgesprek704481"><a name="Tokenisatie: De Controversiële Focus van de Rondetafelgesprek" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Tokenisatie: De Controversiële Focus van de Rondetafelgesprek</h2><p>De speciale sessie over tokenisatie in mei veroorzaakte intense debatten. SEC-voorzitter Paul Atkins vergeleek on-chain effecten met de “transformatie van de muziekindustrie van vinyl naar het digitale tijdperk,” en betoogde dat het potentieel zou kunnen ontketenen voor automatische dividenden en verbeterde liquiditeit. Echter, commissaris Caroline Crenshaw betwijfelde de praktische haalbaarheid, en wees op problemen zoals de onvoldoende schaalbaarheid van openbare permissionless blockchains en de nadelen van directe afwikkeling—bijvoorbeeld, T+0 afwikkeling zou het netto-afwikkelingsmechanisme (dat momenteel 98% van het handelsvolume elimineert) kunnen ondermijnen en de betalingsflexibiliteit voor particuliere beleggers kunnen verzwakken.</p>
<p>De diepere contradictie ligt in de regelgevende logica: Moet de SEC actief specifieke technologieën bevorderen? Crenshaw waarschuwt dat het focussen op blockchain terwijl andere gedistribueerde grootboektechnologieën genegeerd worden, gelijkstaat aan “de overheid die winnaars kiest.”</p>
<h2 id="h2-De20mondiale20regelgevingstructuur20dwingt20de20VS20om20te20handelen384936"><a name="De mondiale regelgevingstructuur dwingt de VS om te handelen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>De mondiale regelgevingstructuur dwingt de VS om te handelen</h2><p>De transformatie van de SEC wordt deels gedreven door wereldwijde concurrentiedruk:</p>
<ul>
<li>De EU MiCA en het Hongkong VASP-systeem hebben een uitgebreid kader vastgesteld, waardoor kapitaal en talent uit de Verenigde Staten worden aangetrokken.</li><li>Canada keurt de wereld’s eerste staking-gebaseerde goed <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> ETF, leidend in innovatie van spotproducten;</li><li>Opkomende markten zoals Panama drijven overheidsinstanties ertoe om encryptiebetalingen te accepteren en soevereine gebruikstoepassingen te verkennen.</li></ul>
<p>Tegelijkertijd waarschuwt de zaak van de “Bitcoin-wet” van El Salvador, die een afkoeling ondervindt (met slechts 11% van de geregistreerde bedrijven die actief zijn), dat beleidsmaatregelen moeten aansluiten bij de marktrealiteit. Peirce pleit daarom sterk voor een “regulatory sandbox” die uitwisselingen in staat stelt om te experimenteren met getokeniseerde effecten in een gecontroleerde omgeving, waarbij innovatie en risico in balans worden gehouden.</p>
<h2 id="h2-Toekomstige20Vooruitzichten20Regelimplementatie20en20Wereldwijde20Cordinatie364021"><a name="Toekomstige Vooruitzichten: Regelimplementatie en Wereldwijde Coördinatie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Toekomstige Vooruitzichten: Regelimplementatie en Wereldwijde Coördinatie</h2><p>De reeks rondetafelgesprekken van de SEC, hoewel niet direct leidend tot regels, legt een cruciale basis voor beleidsvorming:</p>
<ol>
<li>Uitgiftezijde: Herziening van het S-1 formulier om niet-typische openbaarmakingsclausules voor cryptovaluta uit te sluiten (zoals uitvoerderscompensatie);</li><li>Handelszijde: Herziening van de ATS-regels ter ondersteuning van “hedgingtransacties” tussen effecten en niet-effecten;</li><li>Bewaringszijde: Herstructurering van het kader voor “special purpose broker-dealers” om de impasse van slechts twee goedgekeurde instellingen te doorbreken.</li></ol>
<p>Deze maatregelen weerspiegelen de visie van de Trump-administratie om de Verenigde Staten de wereldwijde hoofdstad van encryptie te maken, maar succes hangt af van de vraag of de SEC in staat is om de open dialoog van de ronde tafel om te zetten in duidelijke, uitvoerbare regels, en te voorkomen dat het terugvalt in de “handhaving-eerst” val.</p>
<p>Beleidsmakers en industrieoprichters zitten rond een tafel, met de lichten gericht op de federale effectenwet die aan het hoofdkantoor van de SEC hangt. Wanneer de <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> het white paper is zeventien jaar geleden geboren, deze wet bestond al een halve eeuw; de discussie aan de ronde tafel van vandaag herstructureert stilletjes de manier waarop de twee partijen met elkaar communiceren.</p>
<p>De reeks rondetafelgesprekken van de SEC markeert een belangrijk keerpunt in de Amerikaanse encryptieregulering, van confrontatie naar constructieve dialoog. Naarmate de kernproblemen verschuiven van theoretische debatten naar regelgeving, kan 2025 het vertrekpunt worden voor de VS om weer leiderschap te heroveren in de encryptieregulering - op voorwaarde dat deze discussies de gangen van Washington overstijgen en zich vertalen in regels die de markt echt nodig heeft.</p>
<div class="blog-details-info"><br><div>Auteur: <strong>Blogteam</strong><br><div class="info-tips"><em>De inhoud hierin vormt geen aanbod, sollicitatie of aanbeveling. U dient altijd onafhankelijk professioneel advies in te winnen voordat u enige investeringsbeslissingen neemt.<br><div></div>Houd er rekening mee dat Gate het gebruik van alle of een deel van de Diensten vanuit Beperkte Locaties kan beperken of verbieden. Voor meer informatie, lees de Gebruikersovereenkomst via <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>