SGVlZnQgQmluYW5jZSB2cyBTRUMgRXJpYyB6aWpuIGhvb2d0ZXB1bnQgYmVyZWlrdD8gSGV0IE1hdGNodXBzIE5pZXV3cyB2YW4gZGUgV2Vlaw==

2023-06-28, 09:25
<p><img src="https://gimg2.gateimg.com/blog/1679447253500249423shendu.jpeg" alt=""></p>
<h2 id="h2-TL20DR890728"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p>SEC heeft Binance aangeklaagd omdat het effectengerelateerde diensten verleent zonder zich bij hen te registreren.</p>
<p>De SEC beweert dat Binance en Changpeng Zhao de fondsen die door zijn burgers zijn geïnvesteerd in gevaar hebben gebracht door ze aan een derde partij te geven.</p>
<p>De waarde van <a href="/price/bnb-bnb" rel="nofollow noopener noreferrer" target="_blank">BNB</a> viel nadat de SEC Binance aanklaagde. Sommige marktanalisten geloven dat de prijs van <a href="/price/bnb-bnb" target="_blank" class="blog_inner_link">BNB</a> kan dalen naar zijn 2022 dieptepunt van $180.</p>
<h2 id="h2-Inleiding255165"><a name="Inleiding" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Inleiding</h2><p>De aanpak van de Verenigde Staten van crypto-activiteiten lijkt door te gaan, aangezien het rechtszaken heeft aangespannen tegen grote cryptocurrency-beurzen die in het land actief zijn, Binance en Coinbase. De Securities and Exchange Commission (SEC) heeft de twee beurzen aangeklaagd wegens het overtreden van de effectenwetten van de Verenigde Staten.</p>
<p>Vandaag richten we ons op de SEC tegen Binance-rechtszaak. We zullen ook bespreken hoe Binance heeft gereageerd op deze juridische ontwikkeling.</p>
<h2 id="h2-SECs20Rechtszaken20tegen20Crypto20Beurzen281963"><a name="SEC’s Rechtszaken tegen Crypto Beurzen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>SEC’s Rechtszaken tegen Crypto Beurzen</h2><p>Op 5 en 6 juni heeft de Securities and Exchange Commission (SEC) haar juridische aanklachten ingediend tegen Binance, de grootste cryptobeurs die actief is in de Verenigde Staten. Deze stap toont de vastberadenheid van de Verenigde Staten om haar gezag te laten gelden op het gebied van cryptogeldkwesties.</p>
<p>De ineenstorting van FTX-beurs gaf de SEC extra prikkels om crypto-activiteiten te reguleren ter bescherming van de consumenten. Ondanks dat de zaken van de SEC tegen Coinbase en Binance iets verschillend zijn, hebben ze iets gemeen.<br><img src="https://gimg2.gateimg.com/image/article/16879439514171687943937_.pic_hd.jpg" alt=""><br>Binance CEO - Changpeng Zhao</p>
<p>De SEC beschuldigt beide beurzen ervan dat ze nagelaten hebben om sommige cryptocurrencies te registreren als effecten, volgend op de recente aanwijzing van 68 crypto-activa in die categorie. Volgens de wetten van de Verenigde Staten moeten alle bedrijven die met effecten te maken hebben, dergelijke beleggingsactiva eerst registreren voordat ze het publiek toestaan om ze te kopen.</p>
<p>In een <a href="https://www.sec.gov/news/press-release/2023-101" rel="nofollow noopener noreferrer" target="_blank">persbericht, gedateerd 5 juni, beschuldigt de SEC “Binance</a> en BAM Trading van het exploiteren van niet-geregistreerde nationale effectenbeurzen, effectenmakelaars en clearinginstellingen.</p>
<p>Het beschuldigt verder Binance en BAM Trading van niet-geregistreerde aanbieding en verkoop van Binance’s eigen crypto-activa, waaronder een zogenaamde uitwisselingstoken, BNB, een zogenaamde stabiele munt. <a href="/price/binance-usd-busd" rel="nofollow noopener noreferrer" target="_blank">Binance USD</a> (BUSD), bepaalde crypto-uitleenproducten en een staking-als-een-service programma.”</p>
<p>Opvallend is dat de SEC onder leiding van voorzitter Gensler vastbesloten is om veel cryptocurrencies aan te wijzen als effecten. Sterker nog, Gensler zei onlangs dat bijna alle cryptocurrencies effecten zijn. Desalniettemin zal de tijd uitwijzen of de SEC al dan niet alle crypto-activa als effecten zal aanwijzen.</p>
<p>Lees ook: <a href="https://www.gate.io/ru/blog_detail/2448/cz-sued-by-cftu-another-turn-of-the-crypto-saga" target="_blank">CZ aangeklaagd door CFTU: weer een wending in het crypto-saga</a></p>
<h2 id="h2-De20Aanklachten20Tegen20Binance103428"><a name="De Aanklachten Tegen Binance" class="reference-link"></a><span class="header-link octicon octicon-link"></span>De Aanklachten Tegen Binance</h2><p>Laten we kort de aanklachten bespreken die de SEC heeft ingediend tegen Binance. Op 5 juni dit jaar heeft de SEC 13 aanklachten ingediend tegen Binance Holdings Ltd, Binance Exchange-oprichter en CEO Changpeng Zhao en BAM Trading Services Inc. (“BAM Trading”)- dat samenwerkt met Binance om het cryptovermogenhandelsplatform te exploiteren.</p>
<p>De SEC heeft aangeklaagd dat hoewel Binance beweert dat het de handel van Amerikaanse inwoners op zijn platform beperkt, het heimelijk toestaat dat zijn burgers met een hoog vermogen met hen handelen.</p>
<p>Het beweert ook dat hoewel Binance.US beweert onafhankelijk te zijn van Binance Global Unit, het onder haar controle en toezicht valt.</p>
<p>Een andere beschuldiging is dat Binance veel controle uitoefent op de activa van zijn klanten, in die mate dat ze vermengd worden en worden omgeleid naar andere doeleinden en entiteiten zoals Sigma Chain, die onder controle staat van Zhao.</p>
<p>De SEC is ook van mening dat Binance en/of Zhao manipulatieve activiteiten hebben uitgevoerd. In een <a href="https://www.sec.gov/news/press-release/2023-101" rel="nofollow noopener noreferrer" target="_blank">in het persbericht stond</a> De klacht van de SEC beweert verder dat BAM Trading en BAM Management US Holdings, Inc. (“BAM Management”) investeerders hebben misleid over niet-bestaande handelscontroles op het Binance.US-platform, terwijl Sigma Chain zich bezighield met manipulatieve handel die het handelsvolume van het platform kunstmatig opdreef.</p>
<p>De beschuldigingen tegen Binance CEO Zhao zijn gebaseerd op het feit dat hij degene is die de activiteiten van Binance en BAM Trading controleert. Verder beschouwt de SEC de twee entiteiten als ‘niet-geregistreerde nationale effectenbeurzen, effectenmakelaars en clearinginstellingen’.</p>
<p>De verklaring van SEC-voorzitter Gary Gensler vat duidelijk de beschuldigingen samen tegen Binance, BAM Trading en CEO Changpeng Zhao. Hij zei: ‘Via dertien aanklachten beweren we dat Zhao en Binance-entiteiten betrokken waren bij een uitgebreid web van bedrog, belangenconflicten, gebrek aan openbaarmaking en berekende ontduiking van de wet.’</p>
<p>Lees ook: <a href="https://www.gate.io/blog_detail/2238/do-kwon-reaches-5-star-wanted-level-as-sec-brings-more-fraud-charges" target="_blank">SEC klaagt Terraform Labs en Do Kwon aan voor het orchestreren van een multi-miljard crypto-activa effecten</a></p>
<h2 id="h2-Potentile20risicos20van20de20activiteiten20van20Binance20op20investeringsfondsen20SEC685734"><a name="Potentiële risico’s van de activiteiten van Binance op investeringsfondsen: SEC" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Potentiële risico’s van de activiteiten van Binance op investeringsfondsen: SEC</h2><p>Een van de klachten in de SEC-rechtszaak tegen Binance is dat Zhao en Binance de fondsen van de investeerders in gevaar hebben gebracht. Er werd kort gezegd gesteld dat de fondsen van de klant afhankelijk zijn van Binance en Zhao, die zichzelf “verrijkt hebben met miljarden Amerikaanse dollars.”</p>
<p>Het ondersteunde zijn standpunt door te beweren dat Binance en BAM Trading opzettelijk het toezicht van de Verenigde Staten hebben omzeild door niet-geregistreerde effecten gerelateerde diensten aan te bieden aan zijn burgers. Het zei: “[Dit] brengt de veiligheid van miljarden dollars aan kapitaal van Amerikaanse investeerders in gevaar en in de genade van Binance en Zhao.”</p>
<p>Volgens de SEC komen de risico’s voort uit het vermengen van Binance en Binance.US klantenfondsen op een rekening die wordt gecontroleerd door Merit Peak Limited, een entiteit die eigendom is van en wordt gecontroleerd door Zhao. Als zodanig stort Binance normaal gesproken zijn Amerikaanse klantenfondsen over naar een derde partij met als doel het kopen en verkopen van cryptocurrencies.</p>
<p>Bovendien zijn de toezichthouders van mening dat deze regeling Zhao de vrijheid heeft gegeven om de miljarden dollars die door Amerikaanse beleggers zijn gestort, te gebruiken zonder toezicht van de relevante autoriteiten. Als gevolg hiervan hebben de Amerikaanse toezichthouders op 6 juni een verzoek tot een straatverbod ingediend tegen Binance omdat het zonder vergunning opereert en verkeerd omgaat met de geïnvesteerde fondsen van zijn burgers. Ze hebben ook verzocht om het bevriezen van Binance.US-fondsen.</p>
<p>Lees ook: <a href="https://www.gate.io/blog_detail/2763/amended-class-action-against-elon-musk" target="_blank">Gewijzigde class-action-rechtszaak beweert dat Elon Musk insiderhandel pleegt in Dogecoin</a></p>
<h2 id="h2-Binance20heeft20mogelijk20Amerikaanse20wetgevers20misleid20met20zijn20verklaring924815"><a name="Binance heeft mogelijk Amerikaanse wetgevers misleid met zijn verklaring." class="reference-link"></a><span class="header-link octicon octicon-link"></span>Binance heeft mogelijk Amerikaanse wetgevers misleid met zijn verklaring.</h2><p>Een van de klachten van Amerikaanse toezichthouders tegen Binance is dat het hen mogelijk misleidende verklaringen heeft gegeven met betrekking tot haar zakelijke activiteiten in de Verenigde Staten. Zo heeft Binance eerder dit jaar bijvoorbeeld verklaard dat Binance US onafhankelijk is van haar wereldwijde entiteit. De Securities and Exchange Commission gelooft echter dat Binance US en de wereldwijde entiteit van Binance vermengd zijn.</p>
<p>Als gevolg van deze verdenking hebben de Amerikaanse senatoren het ministerie van Justitie gevraagd te onderzoeken of Binance al dan niet een onjuiste voorstelling van zaken heeft gegeven aan het Congres via haar verklaring. De senatoren denken dat Binance mogelijk haar relatie met haar lokale eenheid heeft verkeerd voorgesteld om sancties te ontwijken, toezicht van Amerikaanse regelgevers te ontduiken en om het witwassen van geld te vergemakkelijken.</p>
<p>Jack Graves, een rechtenprofessor aan de Syracuse University, vertelde aan Cointelegraph dat als Binance een sterke financiële relatie heeft of controle heeft over de Amerikaanse eenheid, er duidelijke juridische implicaties zijn.</p>
<p>Hij zei: “Als je ze niet onafhankelijk houdt, zullen de Amerikaanse regelgevers achter Binance International aangaan en zeggen dat we jurisdictie hebben omdat je via de Amerikaanse entiteit handelt. En eigenlijk denk ik dat de SEC daar naar kijkt.”</p>
<p>De SEC wil misschien duidelijkheid over de relatie tussen de twee entiteiten, aangezien dit juridische implicaties heeft als de Amerikaanse eenheid failliet gaat. Als de twee entiteiten fondsen vermengen, betekent dit dat Binance Global Unit verplicht is om de schulden van Binance US te betalen in g van faillissement.</p>
<p>Volgens Graves is Binance International echter niet verplicht om de schulden van Binance.US te betalen als “Binance.US volledig onafhankelijk is en failliet gaat.” Deze scenario’s zouden de reden kunnen zijn waarom Amerikaanse senatoren duidelijkheid willen over de kwestie.</p>
<p>Lees ook: <a href="https://www.gate.io/blog_detail/2285/new-york-regulators-probes-stablecoin-issuer-paxos" target="_blank">New York Regulators onderzoekt Stablecoin-uitgever, Paxos</a></p>
<h2 id="h2-Binance20US20zet20Amerikaanse20stortingen20on20hold343966"><a name="Binance US zet Amerikaanse stortingen on hold" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Binance US zet Amerikaanse stortingen on hold</h2><p>Als reactie op de rechtszaak en Amerikaanse onderzoeken heeft Binance met ingang van 13 juni alle Amerikaanse dollar-stortingen en -opnames opgeschort. Daarnaast heeft het zijn klanten aangemoedigd om USD op te nemen via bankoverschrijvingen. Volgens Binance is dit omdat de situatie ernstig is.</p>
<p>Het verklaarde: “De SEC heeft zich toegelegd op het gebruik van uiterst agressieve en intimiderende tactieken in haar streven naar een ideologische campagne tegen de Amerikaanse digitale activabranche. Binance.US en onze zakenpartners zijn niet gespaard gebleven bij het gebruik van deze tactieken, wat uitdagingen heeft gecreëerd voor de banken waarmee we samenwerken.”</p>
<h2 id="h2-Binance20vs20SEC20De20neerwaartse20koers20van20BNB20en20de20mogelijke20limiet20ervan702978"><a name="Binance vs SEC: De neerwaartse koers van BNB en de mogelijke limiet ervan" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Binance vs SEC: De neerwaartse koers van BNB en de mogelijke limiet ervan</h2><p>Ondanks zijn bullish momentum in juni gaf BNB toe aan de druk die de SEC uitoefende tegen Binance. Al in de tweede week van juni was de prijs van BNB met 15% gedaald. Opmerkelijk genoeg stopte Binance tijdens dezelfde periode met de handel in verschillende paren, waaronder <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a>.</p>
<p>De huidige rechtszaken tegen cryptobeurzen, waaronder Binance, hebben geleid tot een afname van de vraag naar Binance Coin. Sommige technische indicatoren toonden echter aan dat BNB nog steeds bullish was tijdens de tweede week van juni, ondanks het verlies van momentum. In het bijzonder toonde het BNB/USD-paar een mogelijkheid van een kortetermijnherstel. Die mogelijkheid werd ondersteund door het feit dat de Relative Strength Index (RSI) het oversold-gebied betrad, onder 30.</p>
<p>Desalniettemin voorspellen sommige analisten dat de waarde van BNB binnen de komende maanden zal dalen. Bijvoorbeeld, TraderSZ, een onafhankelijke <a href="https://twitter.com/trader1sz/status/1666473070867914752" rel="nofollow noopener noreferrer" target="_blank">marktonderzoeker denkt</a> dat de prijs van BNB kan dalen naar $180 als gevolg van lopende rechtszaken tegen cryptobeurzen, waaronder Binance.</p>
<p>Op het moment van schrijven, 18 juni, bedraagt de prijs van BNB $246.94 na een stijging van 4.5% in de afgelopen 7 dagen. Over het geheel genomen is het echter met 20.1% gedaald in de afgelopen 30 dagen. De onderstaande diagram geeft een samenvatting van de belangrijke statistieken.<br><img src="https://gimg2.gateimg.com/image/article/16879442474181687944231_.pic.jpg" alt=""><br>Prijsbewegingen van BNB binnen de laatste 30 dagen- Coingecko</p>
<p>Zoals de diagram aangeeft, is de prijs van BNB aanzienlijk gedaald van $300,85 op 5 juni naar $224,47 op 12 juni. Echter, sinds 15 juni is het aan het herstellen.</p>
<h2 id="h2-Conclusie190716"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>Binance US heeft de storting van USD stopgezet na de klacht van de SEC tegen hen. Tegelijkertijd adviseerden ze onlangs hun klanten om hun USD via bankoverschrijving op te nemen. De SEC klaagt Binance voornamelijk aan omdat ze effecten gerelateerde diensten aanbieden zonder ze bij hen te registreren. Ook heeft het lopende onderzoek naar Binance en de handhaving van de effectenwetten door de SEC tegen crypto-uitwisselingen die in de Verenigde Staten opereren geleid tot een afname in de vraag naar crypto-activa zoals BNB.</p>
<p>Lees ook: <a href="https://www.gate.io/blog_detail/2708/sec-labels-37-cryptocurrencies-as-securities-implications-for-trading" target="_blank">SEC Labelt 37 Cryptocurrencies als Effecten: Implicaties voor Handel</a></p>
<h3 id="h3-Is20er20een20rechtszaak20tegen20Binance707746"><a name="Is er een rechtszaak tegen Binance?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Is er een rechtszaak tegen Binance?</h3><p>Op 5 juni heeft de Securities and Exchange Commission (SEC) een rechtszaak aangespannen tegen Binance waarin zij ervan beschuldigd worden ongeregistreerde effectendiensten aan het publiek aan te bieden. In totaal heeft Binance dertien aanklachten van de SEC aan zijn broek.</p>
<h3 id="h3-Waarom20heeft20de20SEC20Binance20aangeklaagd289113"><a name="Waarom heeft de SEC Binance aangeklaagd?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Waarom heeft de SEC Binance aangeklaagd?</h3><p>De SEC klaagde Binance aan voor het aanbieden van niet-geregistreerde cryptowaarden aan het publiek. Dit volgt op de aanwijzing van de SEC van 68 cryptocurrencies als effecten.</p>
<h3 id="h3-Is20mijn20geld20veilig20bij20Binance11189"><a name="Is mijn geld veilig bij Binance?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Is mijn geld veilig bij Binance?</h3><p>De fondsen van investeerders, inclusief cryptocurrencies en USD, zijn veilig bij Binance ondanks de recente rechtszaken. Er is geen teken dat ze hun vermogen zullen verliezen, aangezien de SEC tot doel heeft de investeringen van haar burgers te beschermen.</p>
<h3 id="h3-Wat20is20er20aan20de20hand20met20Binance285280"><a name="Wat is er aan de hand met Binance?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wat is er aan de hand met Binance?</h3><p>De Securities and Exchange Commission (SEC) heeft Binance aangeklaagd op 5 juni 2023, omdat het ervan wordt beschuldigd ongeregistreerde effectendiensten te verkopen. Dit komt nadat de SEC 68 cryptocurrencies heeft aangewezen als effecten.</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 visie van de onderzoeker en vormt geen enkele beleggingssuggestie.<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 schending van het auteursrecht.<br></div><p></p><br></div></div></div>
Share
Content
gate logo
Gate
Trade Now
Join Gate to Win Rewards