U0VDIExhYmVsdCAzNyBDcnlwdG9jdXJyZW5jaWVzIGFscyBlZmZlY3RlbjogSW1wbGljYXRpZXMgdm9vciBIYW5kZWw=

2023-06-01, 03:43

<p><img src="https://gimg2.gateimg.com/blog/1679447253155655279redian.jpeg" alt=""></p>
<h2 id="h2-TL20DR247172"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p>De SEC heeft 37 cryptocurrencies ingedeeld, waaronder <a href="/price/decentraland-mana" rel="nofollow noopener noreferrer" target="_blank">Decentraland</a> (MANA), <a href="/price/dash-dash" target="_blank" class="blog_inner_link">DASH</a> (DASH) <a href="/price/algorand-algo" rel="nofollow noopener noreferrer" target="_blank">Algorand</a> (ALGO), <a href="/price/terra-luna" rel="nofollow noopener noreferrer" target="_blank">Terra</a> USD (UST) en <a href="/price/tron-trx" target="_blank" class="blog_inner_link">Tron</a> (TRX), als effecten.</p>
<p>Alle crypto-beurzen die actief zijn in de Verenigde Staten moeten de 37 crypto-effecten registreren bij de SEC voordat ze het publiek toestaan om te handelen.</p>
<p>Het bestempelen van sommige cryptocurrencies als effecten zal de groei van de blockchainsector en de cryptobranche belemmeren.<br>Crypto handelaren moeten het juiste type cryptocurrencies kennen voordat ze erin investeren om de bijbehorende veiligheidsrisico’s te vermijden.</p>
<h2 id="h2-Introductie208548"><a name="Introductie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introductie</h2><p>Veel regeringen over de hele wereld hebben nog geen definitieve wetgeving inzake crypto. Desalniettemin gebruiken sommige landen de bestaande financiële regelgeving om crypto-activiteiten te monitoren. Een van de grootste debatten die wereldwijd woeden, gaat over de vraag hoe cryptocurrencies moeten worden ingedeeld: moeten ze worden gecategoriseerd als grondstoffen zoals goud of als effecten zoals aandelen. Dit artikel bespreekt de recente classificatie van 37 cryptocurrencies als effecten in de Verenigde Staten en de implicaties daarvan.</p>
<h2 id="h2-Standpunt20van20de20SEC20over20cryptocurrencies573027"><a name="Standpunt van de SEC over cryptocurrencies" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Standpunt van de SEC over cryptocurrencies</h2><p>In haar streven om crypto-activa te reguleren, heeft de Amerikaanse Securities and Exchange Commission (SEC) 37 cryptocurrencies geclassificeerd als effecten, wat veel implicaties heeft voor investeerders, crypto-beurzen en de bredere blockchainsector.</p>
<p>De SEC heeft deze cryptocurrencies gecategoriseerd als effecten op basis van de normen van de Securities Act van 1933 en de gerelateerde gerechtelijke beslissingen over crypto-activa. De prominente zaak van SEC v. W. J. Howey Co heeft de Howey Test-criteria vastgesteld die bepalen of een beleggingsinstrument al dan niet een effect is.</p>
<p><img src="https://gimg2.gateimg.com/image/article/16855908512981685590831_.pic_hd.jpg" alt=""><br>SEC - Verenigde Staten - Fibogroep</p>
<p>De criteria van de Howey-test beoordelen of een investering in een onderneming wordt uitgevoerd met als voornaamste doel het genereren van winst uit de inspanningen van een derde partij of de promotor. Met andere woorden, als beleggers winst realiseren uit de verkoop van een beleggingsinstrument of door het innen van dividenden of rente die op dat beleggingsinstrument is opgebouwd, is dat beleggingsinstrument een effect.</p>
<p>Lees ook: <a href="https://www.gate.io/blog_detail/1689/the-sec-took-action-against-kim-kardashian-for-endorsing-ethereum-max-emax" target="_blank">De SEC heeft actie ondernomen tegen Kim Kardashian omdat ze Ethereum max EMAX heeft gepromoot</a></p>
<p>In eenvoudige bewoordingen is een effect een beleggingsinstrument dat een vordering op de uitgever vertegenwoordigt. Met andere woorden geeft een effect de belegger het recht om toekomstige kasstromen van een derde partij te ontvangen. Voorbeelden van effecten zijn aandelen, obligaties en derivaten die zijn <a href="https://www.gate.io/blog_detail/384/" target="_blank">gereguleerd door de SEC in de Verenigde Staten</a>.</p>
<p>Daarom heeft de SEC verschillende cryptocurrencies geïdentificeerd die voldoen aan de criteria van de Howey Test.</p>
<h2 id="h2-De20volgende20zijn20cryptoeffecten565389"><a name="De volgende zijn crypto-effecten:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>De volgende zijn crypto-effecten:</h2><p><a href="/price/xrp-xrp" rel="nofollow noopener noreferrer" target="_blank">XRP</a> (XRP), Telegram Gram Token (TON), LBRY Credits (LBC), <a href="/price/decentraland-mana" target="_blank" class="blog_inner_link">Decentraland</a> (MANA), DASH (DASH), Power Ledger (POWR), OmiseGo (OMG), <a href="/price/algorand-algo" target="_blank" class="blog_inner_link">Algorand</a> (ALGO), Naga (NGC), TokenCard (TKN), IHT Real Estate (IHT), Kik (KIN), Salt Lending (SALT), Beaxy Token (BXY), DragonChain (DRGN), Tron (TRX), <a href="/price/bittorrent-btt" rel="nofollow noopener noreferrer" target="_blank">BitTorrent</a>(BTT), <a href="/price/terra-luna" target="_blank" class="blog_inner_link">Terra</a> USD (UST), Luna (LUNA), Mirror Protocol mAssets (Meerdere Symbolen), Mirror Protocol (MIR), Mango (MNGO), Ducat (DUCAT), Locke (LOCKE), EthereumMax (EMAX), Hydro (HYDRO), BitConnect (BCC), Meta 1 Coin (META1), Rally (RLY), DerivaDAO (DDX), XYO Network (XYO), Rari (RGT), Liechtenstein Cryptoasset Exchange (LCX), DFX Finance (DFX), Kromatica (KROM), FlexaCoin (AMP) en <a href="/price/filecoin-fil" rel="nofollow noopener noreferrer" target="_blank">Filecoin</a> (FIL).</p>
<h2 id="h2-Juridische20gevolgen20van20de20beveiliging20van20cryptohandel431795"><a name="Juridische gevolgen van de beveiliging van cryptohandel" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Juridische gevolgen van de beveiliging van cryptohandel</h2><p>Gezien de classificatie van de bovenstaande cryptocurrencies als effecten is het belangrijk om de juridische implicaties daarvan te begrijpen. Zo wordt het bijvoorbeeld illegaal voor Amerikaanse beurzen om niet-geregistreerde crypto-effecten te verkopen. Daarom moeten beurzen alle cryptocurrencies die als effecten zijn geclassificeerd, registreren bij de SEC voordat ze deze openbaar te koop aanbieden.</p>
<p>Volgens de vastgestelde crypto-regelgeving in de Verenigde Staten kunnen zware straffen worden opgelegd voor de verkoop van niet-geregistreerde cryptowaarden, waaronder winstverbeurdverklaring of boetes. Daarom zullen beurzen die deze cryptocurrencies verhandelen een verhoogd toezicht van de autoriteiten ondervinden. Wat we weten is dat de meeste crypto-beurzen in de Verenigde Staten verschillende van deze cryptowaarden verkopen.</p>
<p>Lees ook: <a href="https://www.gate.io/th/blog_detail/2564/g7-sets-out-to-strengthen-crypto-regulations" target="_blank">G7 streeft ernaar om de regelgeving voor cryptovaluta te versterken</a></p>
<p>Zelfs nadat deze cryptocurrencies zijn geregistreerd, moeten de beurzen nog veel meer doen. Er zijn andere SEC-cryptoregels en openbaarmakingsvereisten waar ze zich aan moeten houden. Bijvoorbeeld, ze moeten investeerdersbescherming, handels- en rapportageregels in acht nemen.</p>
<p>De classificatie van sommige cryptocurrencies als effecten betekent dat hun uitgevers zich moeten houden aan de Amerikaanse crypto-regelgeving bij crowdfunding. Zo moeten ze hun crypto-activa registreren voordat ze Initial Coin Offerings (ICO’s) gebruiken om geld in te zamelen voor hun projecten. Aangezien veel ICO’s gebrek hebben aan transparantie en verantwoordingsplicht, kan de toezichthoudende autoriteit zoals de SEC bepaalde maatregelen tegen hen afdwingen.</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">Do Kwon bereikt 5-sterren Wanted level terwijl SEC meer fraude-aanklachten brengt</a></p>
<p>De classificatie van de geïdentificeerde cryptocurrencies als effecten heeft directe of indirecte juridische implicaties voor de investeerders. Voordat een investeerder in cryptohandel beveiliging moet hij/zij ervoor zorgen dat de digitale activa volgens de wet zijn geregistreerd. Dit komt doordat er gevaar bestaat dat het vermogen waarin hij/zij investeert in de toekomst van verschillende beurzen wordt gehaald, wat de liquiditeit en marktbelichting vermindert.</p>
<p>Desalniettemin kan dit goed nieuws zijn voor sommige risicomijdende crypto-investeerders. Dit komt omdat de federale wetten hen beschermen tegen wanpraktijken die sommige crypto-uitwisselingen en -projecten uitvoeren. Nogmaals, de investeerders krijgen vertrouwen in cryptocurrencies, waardoor ze er meer in kunnen investeren.</p>
<h2 id="h2-Effecten20van20het20classificeren20van20cryptocurrencies20als20effecten20op20de20blockchain374941"><a name="Effecten van het classificeren van cryptocurrencies als effecten op de blockchain" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Effecten van het classificeren van cryptocurrencies als effecten op de blockchain</h2><p>Er bestaat geen twijfel over dat het classificeren van sommige cryptocurrencies als effecten de ontwikkeling en uitbreiding van de blockchainsector en de cryptobranche zal belemmeren. Het zal bijvoorbeeld moeilijker zijn dan voorheen voor sommige cryptoprojecten om geld in te zamelen via ICO’s.</p>
<p>Lees ook: <a href="https://www.gate.io/blog_detail/2664/historic-florida-enacts-groundbreaking-legislation-cbdcs" target="_blank">Historisch: Florida voert baanbrekende wetgeving in tegen CBDC’s</a></p>
<p>Ook zal het moeilijk zijn voor sommige op de VS gebaseerde cryptoprojecten en startups om te investeren in sommige cryptoprojecten. Bijvoorbeeld kunnen sommige op blockchain gebaseerde projecten buiten de Verenigde Staten IP-adressen van Amerikaanse individuen of startups blokkeren.</p>
<p>Daarnaast zullen juridische kosten waarmee sommige crypto-projecten te maken krijgen vanwege schending van Amerikaanse crypto-regelgeving een negatieve invloed hebben op hun kasstroom. <a href="/price/flow-flow" rel="nofollow noopener noreferrer" target="_blank">Stroming</a> en financiële stabiliteit. Dit kan leiden tot sluitingen van sommige op blockchain gebaseerde projecten.</p>
<p>Bovendien zal de markt voor crypto-effecten krimpen. We weten al dat de Verenigde Staten het land is met het hoogste aantal crypto-investeerders. Wat dit betekent is dat deze individuen waarschijnlijk hun investeringen in activa die door hun land als illegaal worden verklaard, zullen verminderen.</p>
<h2 id="h2-Naar20regelgevende20transparantie858163"><a name="Naar regelgevende transparantie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Naar regelgevende transparantie</h2><p>Elke regelgevende instantie zoals de SEC zou transparante regelgeving moeten creëren die consumenten beschermt en innovatie in de sector bevordert. Zo zouden ze bijvoorbeeld duidelijke richtlijnen moeten geven voor de registratie van cryptocurrencies, evenals rapportage- en openbaarmakingsvereisten.</p>
<p>Alle betrokken partijen, zoals muntuitgevers en andere DeFi-projecten, moeten de regels kennen die van toepassing zijn in de crypto-ruimte, zodat ze de beste bedrijfsbeleid en -praktijken kunnen aannemen. Bijvoorbeeld, als de autoriteiten de beurzen reguleren, kunnen financiële instellingen zoals banken hun diensten aanbieden om de sector te ondersteunen.</p>
<p>Tot slot moeten de regelgevende autoriteiten specifiek zijn over belastingvereisten voor crypto-activa. Bijvoorbeeld, ze moeten aangeven welke belastingen beurzen en andere crypto-projecten moeten betalen. Landen die cryptocurrencies behandelen als grondstoffen kunnen vereisen dat cryptohouders onroerendgoedwinstbelasting betalen.</p>
<h2 id="h2-Conclusie14978"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>De Amerikaanse Securities and Exchange Commission (SEC) heeft 37 cryptocurrencies geclassificeerd als effecten, wat van invloed kan zijn op de omvang van hun markt en hun liquiditeit. Decentraland (MANA), DASH (DASH) Algorand (ALGO), Terra USD (UST) en Tron (TRX) zijn voorbeelden van cryptocurrencies die door de SEC zijn aangemerkt 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 beleggingsaanbevelingen.<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 juridische actie worden ondernomen wegens inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div>