R2FyeSBHZW5zbGVyIGthbiBhZnRyZWRlbiwgQW5hbHlzZSB2YW4gZGUgYWFucGFrIHZhbiBkZSBTRUMgdGVuIGFhbnppZW4gdmFuIGNyeXB0b3JlZ3VsZXJpbmc=

2024-11-19, 07:15

<p><img src="https://gimg2.gateimg.com/image/article/17319993841690791857hotspot.jpeg" alt=""></p>
<h2 id="h2-TLDR624043"><a name="[TL;DR]:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL;DR]:</h2><p>Vanaf de eerste verkenning en testen, tot de geleidelijke standaardisatie nu, wordt het cryptoreguleringskader van de SEC steeds duidelijker.</p>
<p>Het leiderschap van Gary Gensler bij regulerende acties onder de SEC heeft op korte termijn marktturbulentie en bezorgdheid onder investeerders veroorzaakt, maar op de lange termijn heeft het ook geholpen bij het bevorderen van de standaardisatie en mainstreaming van de crypto-industrie.</p>
<p>De directe interventie en hoogspanningsreguleringsstrategie van Gensler hebben geleid tot een situatie waarin de uatie ervan in het <a href="/price" rel="nofollow noopener noreferrer" target="_blank">crypto markt</a> is meer negatief dan positief.</p>
<h2 id="h2-Introductie72736"><a name="Introductie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introductie</h2><p>In de afgelopen jaren heeft de Amerikaanse Securities and Exchange Commission (SEC) voortdurend haar regelgevende inspanningen op het gebied van cryptocurrency versterkt. Als de regulerende “peetvader” van dit gebied heeft SEC-voorzitter Gary Gensler meerdere malen toespraken en verklaringen afgelegd over regelgevingskwesties op de cryptomarkt, waarbij hij streeft naar het waarborgen van markteerlijkheid en transparantie door de openbaarmakingsregels en strafrechtelijke procedures te versterken. Echter, met de steeds complexere regelgevende omgeving en de voortdurend veranderende markt, met name de verklaring van Trump dat hij hem onmiddellijk zou “ontslaan” zodra hij president wordt, staan de regelgevende beleidslijnen van Gensler ook voor toenemende controverse en uitdagingen.</p>
<h2 id="h2-De20intensiteit20van20de20handhaving20van20de20wet20is20jaar20na20jaar20toegenomen20en20Gensler20reguleert20de20cryptomarkt20stevig858604"><a name="De intensiteit van de handhaving van de wet is jaar na jaar toegenomen, en Gensler reguleert de cryptomarkt stevig." class="reference-link"></a><span class="header-link octicon octicon-link"></span>De intensiteit van de handhaving van de wet is jaar na jaar toegenomen, en Gensler reguleert de cryptomarkt stevig.</h2><p>Sinds 2020 heeft de Amerikaanse Securities and Exchange Commission (SEC) een reeks belangrijke maatregelen genomen in de crypto-regelgeving. Haar beslissingen hebben niet alleen een diepgaande invloed gehad op de binnenlandse markt in de Verenigde Staten, maar ook een brede en verstrekkende impact gehad op de wereldwijde crypto-industrie.</p>
<p>In 2020 heeft de SEC het basisframework voor cryptoregulering vastgesteld. Aan het begin van dat jaar heeft de SEC richtlijnen uitgegeven over het bepalen of digitale activa als effecten worden beschouwd, waarbij duidelijke nalevingsnormen voor de sector worden geboden. In december van dat jaar heeft de SEC een rechtszaak aangespannen tegen Ripple Labs, waarin zij worden beschuldigd van het illegaal verkopen van niet-geregistreerde effecten. <a href="/price/xrp-xrp" rel="nofollow noopener noreferrer" target="_blank">XRP</a>. Deze zaak werd al snel een van de meest spraakmakende juridische geschillen in de cryptosector en trok veel aandacht voor de regelgevende kracht van de SEC binnen en buiten de sector.<br><img src="https://gimg2.gateimg.com/image/article/17320002041.jpeg" alt=""><br>Bron: Bloomberg Law Nieuws</p>
<p>Bij het betreden van 2021 zijn de regelgevende inspanningen van de SEC verder versterkt. Hoewel meerdere bedrijven hebben geprobeerd op de lijst te staan <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> ETF’s in de Verenigde Staten, de meeste aanvragen zijn afgewezen. Echter, de erkenning van Grayscale <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> Trust (GBTC) toont indirect de open houding van de SEC ten opzichte van cryptoproducten aan. Tegelijkertijd heeft de SEC haar onderzoeks- en handhavingsinspanningen met betrekking tot cryptoprojecten opgevoerd, meerdere onderzoeken gestart naar projecten die verdacht worden van het schenden van effectenwetten, en met succes enkele belangrijke bedrijven aangeklaagd, waaruit haar vastberadenheid blijkt om markttoezicht te versterken.</p>
<p>In 2022 zal de regelgevende reikwijdte van de SEC verder worden uitgebreid. De SEC is begonnen haar focus te verleggen naar gedecentraliseerde financiële (DeFi) platforms en waarschuwt dat gerelateerde projecten in strijd kunnen zijn met de effectenregelgeving, waardoor de nalevingsdruk op het DeFi-ecosysteem toeneemt. Tegelijkertijd heeft de SEC haar toezicht op uitgevers van stablecoins en gecentraliseerde crypto-handelsplatforms versterkt, met bijzondere aandacht voor transparantie en reservekwesties achter grote stablecoins zoals USDT en USDC. Bovendien, nadat FTX failliet ging als gevolg van chaotisch management en betrokkenheid bij criminele activiteiten, heeft de SEC haar regelgevende inspanningen op de crypto-industrie opgevoerd, deze beschouwd als een industrie vol met “oplichters, fraudeurs en fraudeurs” en strengere regelgevende maatregelen genomen.</p>
<p>Tegen 2023 zal de regelgevende kracht van de SEC aanzienlijk toenemen. Aan het begin van het nieuwe jaar heeft de SEC aanklachten ingediend tegen Genesis, een crypto-uitleningsbedrijf, en Gemini, een crypto-uitwisseling, wat het begin markeert van de jaarlijkse regelgevende strijd. Vervolgens beschuldigde de SEC het crypto-uitleningsbedrijf <a href="/price/nexo-nexo" rel="nofollow noopener noreferrer" target="_blank">Nexo</a> van het classificeren van zijn leningproducten als niet-geregistreerde effecten en heeft een schikking getroffen met Nexo, die een enorme boete heeft betaald. Daarnaast heeft de SEC rechtszaken aangespannen of waarschuwingen uitgegeven tegen verschillende bekende crypto-bedrijven, waarbij zij hen beschuldigen van verschillende overtredingen. Sommige bedrijven kiezen er zelfs voor om te verhuizen, hun activiteiten in de VS te sluiten of schikkingen te zoeken om verdere juridische geschillen te voorkomen.<img src="https://gimg2.gateimg.com/image/article/17320002292.jpeg" alt=""><br>Bron: pixelplex.io</p>
<p>Wat betreft dit jaar, is de meest bekende dat de SEC eindelijk spot ETF’s voor Bitcoin heeft goedgekeurd en <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a>, wat dit jaar sterk heeft bijgedragen aan de prijsontdekking van Bitcoin. Bovendien heeft de SEC in het midden van dit jaar een voorlopige conceptregelgeving vrijgegeven, specifiek voor gedecentraliseerde financiering (DeFi) en niet-fungibele tokens (NFT). Onlangs heeft het de bestaande registratiesysteem uitgebreid naar alle platforms die betrokken zijn bij de handel in cryptovaluta, waarbij cryptovalutawissels en walletserviceproviders verplicht zijn zich te registreren als formele effectenbeurzen of makelaars-dealers, en de controle op de circulatie van cryptocurrencies versterkt.</p>
<h2 id="h2-Genslers20Sterk20Toezicht20van20Potentile20Bondgenoten20tot20Openlijke20Vijanden304348"><a name="Gensler’s Sterk Toezicht, van Potentiële Bondgenoten tot Openlijke Vijanden" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Gensler’s Sterk Toezicht, van Potentiële Bondgenoten tot Openlijke Vijanden</h2><p>Gary Gensler is sinds april 2021 voorzitter van de Amerikaanse Securities and Exchange Commission (SEC). Zijn carrière heeft meerdere belangrijke terreinen bestreken, waaronder Goldman Sachs, het Amerikaanse ministerie van Financiën, de Commodity Futures Trading Commission (CFTC) en het Massachusetts Institute of Technology (MIT).</p>
<p>Hij gaf ooit de cursus ‘Blockchain en Valuta’ aan MIT, had een positieve houding ten opzichte van blockchaintechnologie en moedigde studenten aan om deel te nemen aan de industrie. Hij werd ooit beschouwd als een vriendelijke persoon in de crypto-industrie.</p>
<p>Echter, toen Gensler door Biden werd genomineerd als voorzitter van de SEC, veroorzaakte zijn strenge regulerende stijl enorme controverse in de crypto-industrie. Hij maakt vaak serieuze regulerende opmerkingen, waarbij hij beweert dat de meeste tokens op de cryptomarkt effecten zijn en onderhevig zouden moeten zijn aan effectenwetgeving, en heeft zaken aangespannen tegen veel bekende cryptobedrijven, waaronder Ripple, Coinbase, Kraken, FTX, Binance, enz.<img src="https://gimg2.gateimg.com/image/article/17320002553.jpeg" alt=""><br>Bron: CNBC</p>
<p>Hoewel Gensler’s regulerende acties in de cryptobranche controversieel zijn en zelfs door sommigen worden gezien als de ‘vijand van de cryptowereld’, hebben zijn maatregelen objectief gezien ook de integratie van de cryptobranche in de reguliere financiële sector bevorderd.</p>
<p>Gedurende zijn ambtsperiode heeft de SEC achtereenvolgens de notering van futures ETF’s en spot ETF’s voor Bitcoin en <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> goedgekeurd. De goedkeuring van deze ETF’s biedt een formele identiteit voor de crypto-industrie en markeert een mijlpaal voor verdere groei in de mainstream wereld.</p>
<p>Ondertussen heeft Gensler’s regelgevende optreden ook de cryptosector aangespoord om meer nadruk te leggen op naleving. Sommige bedrijven zoeken samenwerking met regelgevende instanties om de wettigheid van hun bedrijf te waarborgen en het interne nalevingsmanagement te versterken om mogelijke juridische geschillen te voorkomen. Dit verhoogt uiteraard de nalevingskosten voor ondernemingen, en excessieve handhavingsmaatregelen beperken ook de innovatie en vooruitgang in de sector.<img src="https://gimg2.gateimg.com/image/article/17320002734.jpeg" alt=""><br>Bron: @EleanorTerrett</p>
<p>Over het algemeen hebben de reguleringsacties van Gary Gensler gezorgd voor marktturbulentie en zorgen bij investeerders op korte termijn, maar op de lange termijn zullen ze ook bijdragen aan het bevorderen van het standaardisatie- en mainstreamingsproces van de crypto-industrie.</p>
<h2 id="h2-Hoe20zal20de20Cryptoregelgeving20van20de20SEC20veranderen20nadat20Trump20aan20de20macht20komt893038"><a name="Hoe zal de Crypto-regelgeving van de SEC veranderen nadat Trump aan de macht komt?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Hoe zal de Crypto-regelgeving van de SEC veranderen nadat Trump aan de macht komt?</h2><p>Vanuit het bovenstaande is het niet moeilijk om te zien dat Gensler’s directe interventie en op hoge druk gebaseerde reguleringsstrategie hebben geleid tot een situatie waarin de uatie in de cryptomarkt meer negatief dan positief is. Gensler zei tijdens de recente jaarlijkse vergadering van de Bar Association: ‘Ik ben vereerd om met hen samen te werken, de mensen te dienen en ervoor te zorgen dat onze kapitaalmarkten blijven voldoen aan de beste wereldwijde normen.’ Deze vriendelijke opmerking heeft de ontevredenheid van de industrie over zijn reguleringsstrategie echter niet getemperd.</p>
<p>Nu Trump volgend jaar het Witte Huis betreedt, heeft de markt opnieuw zijn lof geuit voor zijn verklaring op de Bitcoin-conferentie dat hij Gary Gensler op zijn eerste dag in functie zou ontslaan. Trumps belofte heeft ongetwijfeld de moeilijkheden van Gensler vergroot om met waardigheid bij de SEC te vertrekken. Het ontslaan van de voorzitter van de SEC is echter geen gemakkelijke taak, omdat Trump legitieme redenen moet geven voor het ontslag en een juridische toetsing en administratieve overgang moet ondergaan, een proces dat meer dan een jaar kan duren.</p>
<p>Het is vermeldenswaard dat Gary Gensler vorige week een verklaring aflegde waarin hij suggereerde dat hij de SEC zou kunnen verlaten, en Ripple (XRP), dat al vele jaren worstelt met de SEC, steeg snel met 20% op deze positieve noot en bereikte een nieuw hoogtepunt van zes maanden.<br><img src="https://gimg2.gateimg.com/image/article/17320003095.jpeg" alt=""><br>Bron: Gate.io</p>
<p>Volgens de toespraak van Gensler kan de toekomstige cryptoreguleringsstrategie van de SEC de volgende nieuwe trends bevatten:</p>
<p>Tijdelijk opschorten van handhavingsmaatregelen tegen registratieovertredingen: De nieuwe voorzitter van de SEC kan handhavingsmaatregelen tegen crypto bedrijven die alleen in strijd zijn met registratieregels tijdelijk opschorten in afwachting van een duidelijker regelgevend kader.</p>
<p>Publiceer de nieuwste richtlijnen: De SEC kan haar richtlijnen bijwerken over wanneer digitale activa worden verkocht als effecten om veranderingen in de branche van de afgelopen vijf jaar te weerspiegelen en kwesties zoals door activa gedekte stablecoins aan te pakken.</p>
<p>Voorstel crypto-regels: Gezien de verschillen tussen crypto-activa en traditionele effecten, kan de SEC op maat gemaakte regels voorstellen om dit opkomende gebied nauwkeuriger te reguleren.</p>
<p>Gebruik immuniteit: De SEC kan gebruik maken van haar immuniteit om op maat gemaakte oplossingen te bieden voor deelnemers aan de cryptomarkt om mogelijke uitdagingen aan te pakken die traditionele effectenregels met zich meebrengen.</p>
<p>Updateverklaring voor speciale brokerage-dealers: De SEC kan haar richtlijnen voor speciale brokerage-dealers bijwerken om deze meer van toepassing te maken op de huidige crypto-industrie en gerelateerde deadlines te verlengen.</p>
<p>Bovendien heeft het Congres met de Republikeinse Partij die de Senaat en mogelijk het Huis van Afgevaardigden controleert, ook de mogelijkheid om crypto-wetgeving aan te nemen. Desalniettemin zal de SEC nog steeds een belangrijke rol spelen bij de regulering van cryptovaluta. De onlangs aangenomen ‘21st Century Financial Innovation and Technology Act’ en ‘Lummis Gillibrand Responsible Financial Innovation Act’ met bipartijdse steun hebben ruimte gecreëerd voor de SEC om digitale activa te reguleren.</p>
<p>Over het algemeen kan het grote waarschijnlijkheid van het vertrek van Gary Gensler en het gat in de regulering dat hij achterlaat, nieuwe positieve ontwikkelingen brengen voor de cryptoregulering van de SEC. In de toekomst moet de SEC ervoor zorgen dat de perspectieven van de industrie volledig worden overwogen, technologische innovatie en marktstandaardisatieprocessen bevorderen, en evenwicht vinden tussen het beschermen van investeerders en het ondersteunen van marktinnovatie.</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 mening van de onderzoeker en vormt geen enkele beleggingssuggestie. Alle beleggingen brengen inherente risico's met zich mee; verstandig 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 zal er juridische actie worden ondernomen vanwege inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div></div>