R2Vuc2xlciB2YW4gZGUgU0VDIG92ZXIgJDUgbWlsamFyZCBoYW5kaGF2aW5nIGVuIHZlcmFuZGVyZW5kIGNyeXB0b2xhbmRzY2hhcA==

2023-11-08, 07:23

<p><img src="https://gimg2.gateimg.com/image/article/1690791857hotspot.jpeg" alt=""></p>
<h2 id="h2-TL20DR306810"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p>De SEC heeft in 2023 meer dan 780 handhavingsmaatregelen en meer dan 500 op zichzelf staande glen ingediend.</p>
<p>Gary Gensler, de voorzitter van de SEC, zei dat de toezichthoudende autoriteit bezig is met het beoordelen van 8 tot 10 spot <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> ETF-aanvragen.</p>
<p>De SEC heeft BlackRock een boete van 2,5 miljoen dollar opgelegd voor onnauwkeurige openbaarmakingen.</p>
<h2 id="h2-Inleiding80508"><a name="Inleiding" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Inleiding</h2><p>De cryptosector is als nieuwe industrie nog steeds geconfronteerd met regelgevende onzekerheid. Aan de andere kant werken regelgevende autoriteiten zoals de Securities and Exchange Commission van de Verenigde Staten hard om hun gezag in de sector te vestigen en duidelijke wetgeving voor crypto te creëren.</p>
<p>Hoewel toezicht door regelgevende instanties essentieel is om het publiek en investeerders te beschermen, moet het eerlijk en transparant zijn om innovatie en creativiteit te bevorderen, die de economie vooruit stuwen. Vandaag bekijken we de <a href="https://www.gate.io/learn/articles/the-wild-west-of-the-crypto-world/670" target="_blank">Recente winsten van de SEC</a> bij het toezicht houden op de cryptosector, evenals de toekomst van regulering van de cryptomarkt.</p>
<h2 id="h2-Handhaving20van20de20SEC20in20de20Amerikaanse20cryptosector863494"><a name="Handhaving van de SEC in de Amerikaanse cryptosector" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Handhaving van de SEC in de Amerikaanse cryptosector</h2><p>Tijdens het toespreken van het 2023 Securities Enforcement Forum op 25 oktober, benadrukte de voorzitter van de Amerikaanse Securities and Exchange Commission (SEC), Gary Gensler, de succesvolle juridische handhavingsacties van de SEC in de afgelopen jaren.</p>
<p>Gensler zei dat de SEC alleen al in 2023 meer dan 780 handhavingsmaatregelen en meer dan 500 afzonderlijke zaken heeft ingediend. Als gevolg hiervan heeft de SEC via deze vonnissen en bevelen 5 miljard dollar opgehaald. Er is al 930 miljoen dollar uitbetaald aan getroffen investeerders.</p>
<p>De SEC-voorzitter zei dat het bureau sinds december 2021 rechtszaken heeft aangespannen tegen 40 bedrijven die verschillende cryptomarktregels hadden overtreden. Ook heeft de SEC in dezelfde periode problemen met de registratie van 23 bedrijven geregeld, waaruit blijkt dat zij zich inzet om discipline en orde in de sector bij te brengen.</p>
<p>In de eerste plaats dient de SEC rechtszaken in om te voorkomen dat bedrijven en personen de Amerikaanse effectenwetten overtreden. In het proces haalt het fondsen terug die sommige bedrijven en personen verkrijgen uit illegaal gedrag. Het legt ook civiele boetes op aan overtredende bedrijven als middel om hen te dwingen zich te houden aan effectenwetten.</p>
<p><a href="https://www.coindesk.com/policy/2023/02/21/secs-shadow-crypto-rule-taking-shape-as-enforcement-cases-mount/" rel="nofollow noopener noreferrer" target="_blank">Volgens CoinDesk</a>, de handhavingsacties van de SEC hebben een ‘schaduw cryptoregel’ gecreëerd die definieert wat de toezichthoudende instantie ziet als regulering van de cryptomarkt. Tot nu toe bestrijken de <a href="/price/optimism-op" target="_blank" class="blog_inner_link">op crypto</a> gerelateerde handhavingsacties die de SEC heeft ingesteld een breed scala aan gebieden, waaronder marktmanipulatie, cyberbeveiligingsinbreuken, handel met voorkennis, valse tweets en mislukkingen in de openbaarmaking van bedrijven.</p>
<p>Met betrekking tot wat de regelgevende instantie tot nu toe heeft gedaan, de voorzitter van de SEC <a href="https://docketevents.com/live/71/page/854" rel="nofollow noopener noreferrer" target="_blank">zei</a>, “Begin me niet over crypto. Ik zal zelfs niet alle individuen noemen die we hebben aangeklaagd in dit zeer niet-nalevende veld.”</p>
<h2 id="h2-SECvoorzitter20Gensler20spreekt20over20spot20Bitcoin20ETFs248658"><a name="SEC-voorzitter Gensler spreekt over spot Bitcoin ETF’s" class="reference-link"></a><span class="header-link octicon octicon-link"></span>SEC-voorzitter Gensler spreekt over spot <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> ETF’s</h2><p>SEC-voorzitter Gensler heeft ook bevestigd dat de Securities and Exchange Commission momenteel <a href="https://www.gate.io/uk/blog_detail/3289/sec-postpones-decision-on-spot-bitcoin-etfs-from-blackrock-and-others" target="_blank">beoordelen van 8 tot 10 aanvragen voor spot bitcoin ETF’s</a> Het is belangrijk op te merken dat de SEC 12 spot BTC ETF-aanvragen in behandeling heeft, waaronder die voor Bitwise, WisdomTree, Grayscale, <a href="https://www.gate.io/blog_detail/1643/blackrock-launches-blockchain-related-etf-for-european-markets." target="_blank">Zwart-Brabant</a>, Invesco en Fidelity.</p>
<p>Ondertussen benadrukte voorzitter Gensler dat de aanvragen voor BTC ETF’s binnenkort voor de commissie met vijf leden kunnen komen. Hij weigerde echter specifieke data te geven. Bij het verduidelijken van de situatie zei hij <a href="https://www.youtube.com/watch?v=TV2-UJWwMiE" rel="nofollow noopener noreferrer" target="_blank">zei</a>, ‘Ze hebben allemaal verschillende aanmeldingstermijnen.’</p>
<p><a href="https://www.youtube.com/watch?v=TV2-UJWwMiE" rel="nofollow noopener noreferrer" target="_blank">In een interview met Bloomberg voegde Gensler toe</a>, “Wat we hier voor ons hebben liggen, zodat het kijkerspubliek begrijpt, zijn niet één, maar meerdere indieningen die het personeel, en uiteindelijk de commissie, overweegt. Ik denk dat het er acht of tien zijn.”</p>
<p>De anticipatie op goedkeuring van verschillende spot bitcoin ETF-aanvragen door de SEC nam toe toen de toezichthouder ervoor koos om niet in beroep te gaan tegen het bevel van de rechtbank om de aanvraag voor de Grayscale spot bitcoin ETF te herzien.</p>
<p>Lees ook: <a href="https://www.gate.io/blog_detail/3289/sec-postpones-decision-on-spot-bitcoin-etfs-from-blackrock-and-others" target="_blank">SEC stelt beslissing over spot Bitcoin ETF’s van BlackRock uit</a></p>
<h2 id="h2-SEC20dient20rechtszaak20in20tegen20BlackRock96679"><a name="SEC dient rechtszaak in tegen BlackRock" class="reference-link"></a><span class="header-link octicon octicon-link"></span>SEC dient rechtszaak in tegen BlackRock</h2><p>In een gerelateerde ontwikkeling heeft de SEC een rechtszaak aangespannen tegen BlackRock waarvan het beschuldigd wordt van het niet bekendmaken van investeringen in een bedrijf waar het advies aan gaf. Volgens de rechtszaak van de SEC heeft de BlackRock Multi-Sector Income Trust (BIT) tussen 2015 en 2019 een investering gedaan in Aviron Group, LLC via een leningfaciliteit.</p>
<p>Desondanks slaagde BIT er niet in om accurate openbaarmakingen te doen in zijn jaarlijkse en halfjaarlijkse rapporten toen het Aviron beschreef als een ‘gediversifieerd financieel dienstenbedrijf’. Deze informatie was onnauwkeurig omdat Aviron print- en advertentieplannen ontwikkelt voor films. Daarom beweert de SEC dat BlackRock informatie heeft verkeerd voorgesteld aan particuliere en institutionele beleggers.</p>
<p>In dit verband, <a href="https://www.sec.gov/news/press-release/2023-226#:~:text=%E2%80%9CRetail%20and%20institutional%20investors%20rely,Enforcement%20Division" rel="nofollow noopener noreferrer" target="_blank">Andrew Dean, de mede-chef van de Asset Management Unit van de handhavingsafdeling zei</a>“Retail- en institutionele beleggers vertrouwen op nauwkeurige openbaarmakingen van de bedrijven die deel uitmaken van de portefeuille van een closed-end of beleggingsfonds om een huidige of potentiële investering in het fonds te ueren.”</p>
<p>Hij voegde eraan toe: “Beleggingsadviseurs hebben de verantwoordelijkheid om deze essentiële informatie te verstrekken, en BlackRock heeft dit nagelaten bij de investering in Aviron.” Bovendien heeft BlackRock ten onrechte gerapporteerd dat Aviron een hogere rente heeft betaald dan de werkelijke rente.</p>
<p>Voor dergelijke verkeerde voorstelling van feiten heeft de SEC BlackRock een boete opgelegd van $2,5 miljoen. Hoewel BlackRock de beschuldigingen niet heeft toegegeven of ontkend, heeft het de overeenkomst gesloten. Deze rechtszaak komt op een moment dat de SEC de aanvraag van Grayscale voor een spot bitcoin ETF aan het beoordelen is.</p>
<h2 id="h2-Gary20Genslers20perspectief20op20cryptoregulering126698"><a name="Gary Gensler’s perspectief op crypto-regulering" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Gary Gensler’s perspectief op crypto-regulering</h2><p>De opvatting van Gensler, voorzitter van de SEC, over cryptocurrencies is in de loop der jaren niet veranderd. Hij gelooft dat de meeste cryptocurrencies effecten zijn waarop de SEC toezicht zou moeten houden. Op een gegeven moment legde hij het concept van investeringsovereenkomst uit en beweerde dat de meeste cryptocurrencies aan die definitie voldoen en dus de investeringsovereenkomsttest doorstaan.</p>
<p>Bovendien heeft Gensler de bestaande cryptocurrency-omgeving vergeleken met de ongereguleerde financiële markt van de jaren 1920. De voorzitter van de SEC is echter van mening dat bitcoin en ETH verschillen van andere cryptocurrencies. Hij beweert dat bitcoin een grondstof is en een waardeopslag, net als goud. Desalniettemin heeft Gensler niet verduidelijkt of ETH al dan niet als effect wordt beschouwd.</p>
<p>Gensler’s opvatting is dat er een behoefte is om alle cryptocurrencies te classificeren om duidelijkheid te hebben over de regelgeving die ze beheerst. Aan de andere kant is de SEC van mening dat de bestaande financiële en effectenwetgeving duidelijk is en kan worden toegepast op cryptocurrencies zonder verdere juridische verduidelijking.</p>
<p>Op dit moment gebruikt de SEC de “Howey-test” in haar handhavingsmaatregelen. <a href="https://www.youtube.com/watch?v=h_oAr4wn7M4" rel="nofollow noopener noreferrer" target="_blank">Volgens Gensler’s interpretatie</a>“Deze tokens worden als effecten beschouwd omdat er een groep in het midden is en het publiek winst verwacht op basis van die groep.”</p>
<p>Hij beweert ook dat de markt veel ‘incompliances’ heeft, een reden waarom de SEC het wettelijke recht en de verantwoordelijkheid heeft om investeerders te beschermen met behulp van de normen die van toepassing zijn op de traditionele financiële sector.</p>
<p>Lees ook: <a href="https://www.gate.io/blog_detail/3357" target="_blank">Het hoger beroep van de SEC en de impact ervan op de uitspraak van de Grayscale Bitcoin ETF</a></p>
<h2 id="h2-Implicaties20van20Genslers20regulatoire20standpunt20en20de20handhavingsacties20van20de20SEC20op20de20toekomstige20cryptomarkt451523"><a name="Implicaties van Genslers regulatoire standpunt en de handhavingsacties van de SEC op de toekomstige cryptomarkt" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Implicaties van Genslers regulatoire standpunt en de handhavingsacties van de SEC op de toekomstige cryptomarkt</h2><p>In feite zal de regelgevende standpunten van Gensler en de recente handhavingsmaatregelen van de SEC waarschijnlijk innovatie, onderzoek en creativiteit in de sector belemmeren. Dit betekent dat maar heel weinig cryptobedrijven bereid zullen zijn om in de Verenigde Staten te opereren.</p>
<p>Zelfs sommige internationale bedrijven die cryptoproducten aanbieden, zullen vermijden om bedrijfseenheden in de Verenigde Staten op te richten. Hierdoor kunnen zij het mogelijk niet toestaan dat Amerikaanse burgers toegang hebben tot hun producten en diensten.</p>
<h2 id="h2-Conclusie221238"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>In 2023 heeft de Amerikaanse SEC meer dan 700 rechtszaken aangespannen tegen crypto-overtreders. Uit dergelijke handhavingsacties wist het regelgevende orgaan meer dan $5 miljard aan boetes op te leggen. SEC-voorzitter Gensler is van mening dat alle cryptocurrencies, behalve bitcoin, effecten zijn omdat ze teams hebben die ze ontwikkelen en “beheren”. Aan de andere kant verwachten individuen of instellingen die investeren in cryptocurrencies winst te genereren.</p>
<h2 id="h2-Veelgestelde20vragen20over20de20SEC614342"><a name="Veelgestelde vragen over de SEC" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Veelgestelde vragen over de SEC</h2><h3 id="h3-Wat20zei20Gensler20over20crypto682506"><a name="Wat zei Gensler over crypto?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wat zei Gensler over crypto?</h3><p>De <a href="https://www.gate.io/bitwiki/detail/875" target="_blank">Voorzitter van de Securities and Exchange Commission van de Verenigde Staten, Gary Gensler</a> zei dat de meeste cryptocurrencies effecten zijn omdat ze teams hebben die ze creëren en beheren. Hij wees bitcoin aan als een grondstof. De SEC gebruikt de Howey-test om te bepalen of een cryptocurrency al dan niet een effect is.</p>
<h3 id="h3-Wie20is20Gary20Gensler20de20voorzitter20van20de20SEC431429"><a name="Wie is Gary Gensler, de voorzitter van de SEC?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wie is Gary Gensler, de voorzitter van de SEC?</h3><p>Gary Gensler, een voormalig <a href="https://www.gate.io/blog_detail/907/gate.io-futures-rebate-rewards-150-000-twitter-accepts-musk-s-buyout-goldman-sachs-launches-lending-service-for-bitcoin-central-african-republic-sees-bitcoin-as-fiat-currency" target="_blank">Goldman Sachs</a> Investmentbankier, is momenteel voorzitter van de Securities and Exchange Commission van de Verenigde Staten. Gensler, geboren in 1957, heeft de afgelopen jaren in verschillende overheidsafdelingen gewerkt. Zo was hij voorzitter van de Commodity Futures Trading Commission tijdens het presidentschap van voormalig president Barack Obama.</p>
<h3 id="h3-Hoeveel20verdient20Gary20Gensler857598"><a name="Hoeveel verdient Gary Gensler?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Hoeveel verdient Gary Gensler?</h3><p>Voor zijn rol als voorzitter van de Securities and Exchange Commission van de Verenigde Staten ontvangt Gary Gensler een salaris van ongeveer $ 32,000 per maand. Aan de andere kant ligt het vermogen van Gensler tussen $ 41 miljoen en $ 119 miljoen.</p>
<h3 id="h3-Wanneer20heeft20Gary20Gensler20ontslag20genomen360983"><a name="Wanneer heeft Gary Gensler ontslag genomen?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wanneer heeft Gary Gensler ontslag genomen?</h3><p>Gary Gensler is nog steeds voorzitter van de United States Securities and Exchange Commission. Hij werd in 2018 benoemd tot voorzitter. Hij is verantwoordelijk voor het toezicht op de regulering van financiële markten en het beschermen van beleggers.</p>
<div class="blog-details-info"><br><div>Auteur:<strong> Mashell C.</strong>, Gate.io-onderzoeker<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de mening van de onderzoeker en vormt geen beleggingsadvies.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het opnieuw plaatsen van het artikel is toegestaan mits Gate.io wordt vermeld. In alle glen zal juridische actie worden ondernomen vanwege schending van het auteursrecht.<br></div><p></p><br></div></div></div>