Q0ZUQyBnYWF0IGFjaHRlciBkcmllIERlRmktcHJvdG9jb2xsZW4gYWFu

2023-09-19, 08:59

<p><img src="https://gimg2.gateimg.com/image/article/1690791857hotspot.jpeg" alt=""><br>De CFTC gaf een bevel aan OPYN, ZeroEX en Deridex om hun derivatenhandelsactiviteiten te stoppen.</p>
<p>De drie DeFi-projecten, OPYN, ZeroEX en Deridex, hebben voldaan aan de CFTC-order.</p>
<p>Er was samenwerking tussen CFTC en de drie DeFi-bedrijven, OPYN, ZeroEX en Deridex.</p>
<p>Trefwoorden: DeFi-markt, DeFi-protocollen, CFTC-problemen, DeFi-gemeenschap, CFTC tegen DeFi, US Commodity Futures Trading Commission, handel in digitale activaderivaten, federale wetten, crypto-derivaten, DeFi-derivaten</p>
<h2 id="h2-Introductie941112"><a name="Introductie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introductie</h2><p>De Verenigde Staten is één land met verschillende cryptoregulerende instanties, waaronder de <a href="https://www.gate.io/blog_detail/3194/crypto-influencers-fuel-speculation-sec" target="_blank">Securities and Exchange Commission (SEC)</a>), Department of Justice (DOJ), het Financial Crimes Enforcement Network (FinCEN) van het Ministerie van Financiën en de Commodity Futures Trading Commission (CTFC).</p>
<p>In dit artikel bespreken we de rol van de U.S. Commodity Futures Trading Commission (CTFC) bij het toezicht houden op crypto-activiteiten in de Verenigde Staten. We zullen ook de order van de CFTC tegen drie DeFi-protocollen, namelijk OPYN, ZeroEX en Deridex, analyseren.</p>
<p>Lees ook: <a href="https://www.gate.io/blog_detail/3018/new-crypto-bill-cftc-and-sec-collaboration" target="_blank">Nieuw Crypto-wetsvoorstel: Samenwerking tussen CFTC &amp; SEC</a></p>
<h2 id="h2-De20Commodity20Futures20Trading20Commission20CTFC20vaardigt20orders20uit20tegen20drie20DeFiprotocollen478248"><a name="De Commodity Futures Trading Commission (CTFC) vaardigt orders uit tegen drie DeFi-protocollen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>De Commodity Futures Trading Commission (CTFC) vaardigt orders uit tegen drie DeFi-protocollen</h2><p>Onlangs heeft de Commodity Futures Trading Commission (CTFC) bevelen uitgevaardigd tegen drie DeFi-protocollen, OPYN, ZeroEX en Deridex, omdat ze ongelicentieerde derivatenhandel aanbieden. CFTC zegt dat de drie bedrijven blockchain-gebaseerde protocollen exploiteren als handelsplatforms die derivaten aanbieden.</p>
<p>Aangezien deze handelsplatforms geen vergunning hebben, heeft de CFTC de drie DeFi-protocollen bevolen om hun activiteiten te stoppen. Bovendien, de drie DeFi-projecten, <a href="https://www.gate.io/learn/articles/everything-you-need-to-know-about-opyn/577" target="_blank">OPYN</a>, ZeroEX en Deridex zullen respectievelijk boetes betalen van $250.000, $200.000 en $100.000.</p>
<p>Ian McGinley, de directeur van handhaving van de CFTC, maakte een terloopse opmerking over het gedrag van verschillende DeFi-protocollen, waaronder OPYN, ZeroEX en Deridex, over hun onwil om te voldoen aan nationale wetten, iets dat hen vatbaar maakt voor rechtszaken en enorme financiële boetes.</p>
<p>Hij zei: ‘Op een of andere manier hebben DeFi-operators het idee gekregen dat onwettige transacties wettig worden wanneer ze worden vergemakkelijkt door slimme contracten. Dat is niet het g.’</p>
<p>Desalniettemin betekenen de orders tegen OPYN, ZeroEX en Deridex niet dat de drie bedrijven klantenfondsen hebben verduisterd. In verband met deze zaak zei commissaris Summer Mersinger: ‘De orders van de Commissie in deze zaken geven geen indicatie dat klantenfondsen zijn verduisterd of dat enige marktdeelnemers het slachtoffer zijn geworden van de DeFi-protocollen waarop de Commissie haar handhavingsbevoegdheden heeft losgelaten.’</p>
<p>Om de beschuldigingen verder te versterken, werd OPYN aangeklaagd omdat het zijn platform niet had geregistreerd als een ruiluitvoerfaciliteit en omdat het zich niet had geregistreerd als handelaar van de Futures Commission. Het heeft ook nagelaten zich te houden aan de bepalingen van het nalevingsprogramma van de Bank Secrecy Act, die vereisen dat handelsplatforms klantidentificatieprogramma’s instellen.</p>
<p>OPYN, een in Californië gevestigd bedrijf, biedt een derivaat aan genaamd oSQTH dat zijn prijs ontleent aan een index die de waarde van “ether gekwadrateerd ten opzichte van de USDC-stablecoin” volgt.</p>
<p>De toezichthouder zei daarom: “Het besluit stelt vast dat oSQTH-tokens swaps zijn en gehefboomde of marginale detailhandelgoederentransacties zijn en daarom alleen aan detailhandelaren kunnen worden aangeboden op een geregistreerde beurs in overeenstemming met de CEA- en CFTC-voorschriften. “</p>
<p>De CFTC heeft ZeroEX aangeklaagd voor het aanbieden van ‘2:1 geheven blootstelling aan digitale activa zoals ether en <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a>.” Het is Matcha, een front-end applicatie, waarmee gebruikers verschillende digitale activa kunnen verhandelen op basis van verschillende blockchains. Volgens de voorschriften van de CEA en CFTC kunnen dergelijke producten alleen worden verhandeld op geregistreerde beurzen.</p>
<p>Evenzo, Deridex, een bedrijf gevestigd in North Carolina, wiens handelsplatform bestaat op de <a href="/price/algorand-algo" rel="nofollow noopener noreferrer" target="_blank">Algorand</a> blockchain biedt verschillende DeFi-derivaten.</p>
<p>Lees ook: <a href="https://www.gate.io/de/learn/articles/what-is-defi-2/121" target="_blank">Wat is DeFi 2.0 en waarom is het belangrijk?</a></p>
<h2 id="h2-CFTC20tegen20DeFi20Protocollen20Voorbeeldige20Samenwerking171596"><a name="CFTC tegen DeFi Protocollen: Voorbeeldige Samenwerking" class="reference-link"></a><span class="header-link octicon octicon-link"></span>CFTC tegen DeFi Protocollen: Voorbeeldige Samenwerking</h2><p>In feite hebben de drie DeFi protocollen toegegeven dat zij de genoemde overtreding hebben begaan, namelijk het aanbieden van handelsdiensten voor digitale activa-derivaten zonder zich te registreren bij de relevante autoriteiten. De CFTC prees de drie bedrijven voor hun medewerking en bereidheid om de problemen op te lossen.</p>
<p>ZeroEx, via zijn Matcha X-account, heeft toegegeven dat het heeft samengewerkt met de CFTC. <a href="https://twitter.com/matchaxyz/status/1699919425225523352" rel="nofollow noopener noreferrer" target="_blank">Het zei</a>, “<br><strong><a href="/price/0x-zrx" rel="nofollow noopener noreferrer" target="_blank">0x</a>, de ontwikkelaar van DEX-aggregator Matcha, heeft onlangs samengewerkt met de CFTC om een onderzoek naar tokens die minder dan 0,1% van het handelsvolume van Matcha vertegenwoordigen sinds de oprichting op te lossen.</strong>”</p>
<p>Het voegde eraan toe: “Bij <a href="/price/0x-zrx" target="_blank" class="blog_inner_link">0x</a> worden strategische beslissingen genomen met inbreng van externe juridisch adviseurs. In dit g implementeren we extra processen na constructieve dialoog met de toezichthoudende instantie.”</p>
<p>Lees ook: <a href="https://www.gate.io/learn/articles/the-wild-west-of-the-crypto-world/670" target="_blank">Het Wilde Westen van de cryptowereld? Redenen achter de rechtszaken van de Amerikaanse SEC</a></p>
<h2 id="h2-Wettelijke20basis20voor20de20betrokkenheid20van20de20CFTC20bij20DeFi891443"><a name="Wettelijke basis voor de betrokkenheid van de CFTC bij DeFi" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wettelijke basis voor de betrokkenheid van de CFTC bij DeFi</h2><p>Er bestaat geen twijfel over dat de CFTC, een federale regelgevende instantie die grondstoffen- en derivatenmarkten reguleert in de Verenigde Staten, sterke initiatieven heeft genomen om haar autoriteit en invloed op DeFi te laten gelden.</p>
<p>Bijvoorbeeld, in maart 2021 legde het uit dat zijn rechtsgebied cryptocurrencies omvat die het als grondstoffen beschouwt. Zijn recente actie tegen OPYN, ZeroEX en Deridex geeft aan dat het bereid is om de DeFi-markt te volgen. Dit doet hij door gebruik te maken van de bestaande federale wetten en gerechtelijke wetten, iets waar de DeFi-gemeenschap zich bewust van moet zijn.</p>
<p>Nu is het duidelijk dat de CFTC jurisdictie heeft in DeFi zolang gedecentraliseerde protocollen digitale activa en diensten aanbieden die zijn geclassificeerd als grondstoffen of derivaten. Bijvoorbeeld, de CFTC heeft openlijk gezegd dat <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">bitcoin</a> en Ether (ETH) grondstoffen zijn. Daarom zal het controle hebben over alle digitale producten, vooral derivaten en futures contracten, die verband houden met deze blockchains.</p>
<p>De claim van de CFTC werd bevestigd door de uitspraak van de federale rechtbank in New York op 6 maart 2018, waarin werd verklaard dat de CFTC virtuele activa kan reguleren die onder de categorie grondstoffen vallen. Daarom, <a href="https://www.nortonrosefulbright.com/en/knowledge/publications/6c7bcc30/federal-court-holds-that-cftc-can-regulate-virtual-currencies-as-commodities#_ftn1" rel="nofollow noopener noreferrer" target="_blank">Commodity Futures Trading Commission v. McDonnell</a> (E.D.N.Y. 6 maart 2018) heeft CFTC aanbevolen als regelgevende autoriteit voor gespecificeerde digitale activa.</p>
<p>Lees ook: <a href="https://www.gate.io/blog_detail/1672/10-best-defi-protocols-to-invest-during-bear-markets" target="_blank">10 Beste DeFi-protocollen om te investeren tijdens berenmarkten</a></p>
<h2 id="h2-Implicaties20van20CFTCorder20voor20de20DeFigemeenschap976969"><a name="Implicaties van CFTC-order voor de DeFi-gemeenschap" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Implicaties van CFTC-order voor de DeFi-gemeenschap</h2><p>Tot nu toe hebben veel individuen en organisaties bezorgdheid geuit over de huidige crypto-campagne in de Verenigde Staten. Ze geloven dat dergelijke acties innovatie kunnen verstikken.</p>
<p>Het staat buiten kijf dat crypto-regelgeving en toezicht essentieel zijn voor de ontwikkeling van de DeFi-markt. Echter, te veel strenge beperkingen kunnen leiden tot een lage groei van de DeFi-sector in de Verenigde Staten.</p>
<p>Daarom kan het te veel vertrouwen op regulerende strafmaatregelen, zoals de CFTC en de SEC hebben gedaan, ertoe leiden dat DeFi-ontwikkelaars zich verplaatsen naar andere landen om te ontsnappen aan regelgevingsonzekerheid en moeilijkheden in de VS. Als dat gebeurt, kan dit leiden tot verlies van expertise en innovatie in de blockchain- en cryptosector in de Verenigde Staten.</p>
<p>Duurzame groei in de DeFi-sector kan bestaan als regelgevende instanties samenwerken, open gesprekken voeren en onderhandelen met de verschillende spelers in de blockchainsector in plaats van een harde aanpak tegen hen te hanteren.</p>
<p>Lees ook over andere DeFi-protocollen zoals <a href="https://www.gate.io/learn/articles/what-is-venus/736" target="_blank">Venus</a>, <a href="https://www.gate.io/learn/articles/what-is-pendle1/610" target="_blank">Pendle</a>, <a href="https://www.gate.io/learn/articles/what-is-stafi/680" target="_blank">StaFi</a>.</p>
<h2 id="h2-Conclusie824985"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>Onlangs heeft de Commodity Futures Trading Commission (CTFC) een bevel uitgevaardigd tegen OPYN, ZeroEX en Deridex om hun activiteiten stop te zetten, omdat ze hun DeFi-derivaten niet hebben geregistreerd bij de relevante toezichthoudende autoriteiten. Desondanks hebben de drie DeFi-protocollen voldaan aan het bevel van de CFTC en beloofd de vastgestelde boetes te betalen.</p>
<h2 id="h2-Veelgestelde20vragen20over20DeFi665643"><a name="Veelgestelde vragen over DeFi" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Veelgestelde vragen over DeFi</h2><h3 id="h3-Hoeveel20DeFiprotocollen20zijn20er309780"><a name="Hoeveel DeFi-protocollen zijn er?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Hoeveel DeFi-protocollen zijn er?</h3><p>Er zijn meer dan 17.000 DeFi-protocollen. Deze DeFi-protocollen bestaan uit codes, standaarden en procedures die financiële toepassingen aansturen. Ze bestaan ook op verschillende blockchains, waaronder <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> en <a href="https://www.gate.io/bitwiki/detail/160/algorand-algo" target="_blank">Algorand</a>.</p>
<h3 id="h3-Wat20zijn20de20belangrijkste20DeFiprotocollen31914"><a name="Wat zijn de belangrijkste DeFi-protocollen?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wat zijn de belangrijkste DeFi-protocollen?</h3><p>Er zijn meer dan 17.000 DeFi-protocollen die verschillende functies vervullen. Voorbeelden van belangrijke gedecentraliseerde protocollen zijn <a href="/price/compound-comp" rel="nofollow noopener noreferrer" target="_blank">Compound</a>, <a href="https://www.gate.io/price/aave-aave/usd" target="_blank">Aave</a>, <a href="https://www.gate.io/price/uniswap-uni" target="_blank">Uniswap</a>, <a href="https://www.gate.io/how-to-buy/sushi-sushi" target="_blank">Sushiswap</a>, <a href="https://www.gate.io/price/kyber-network-crystal-knc/ars" target="_blank">Kyber Network</a>, yEarn, MakerDAO, Synthetix, <a href="https://www.gate.io/price/curve-dao-crv" target="_blank">CurveDAO</a>, Ren Protocol en <a href="https://www.gate.io/price/balancer-bal/usd" target="_blank">Balancer</a>.</p>
<h3 id="h3-Wat20doet20de20Commodity20Futures20Trading20Commission482297"><a name="Wat doet de Commodity Futures Trading Commission?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wat doet de Commodity Futures Trading Commission?</h3><p>De Commodity Futures Trading Commission is een regulatorische instantie van de Verenigde Staten die grondstoffen en derivaatproducten en markten controleert en superviseert, bestaande uit termijncontracten, opties en swaps. Het bestaat uit een panel van commissarissen dat de activiteiten van verschillende organisaties die derivaten en grondstoffen aanbieden, controleert.</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 standpunten van de onderzoeker en vormt geen enkele beleggingssuggestie.<br></em><div><em></em>Gate.io behoudt zich alle rechten op dit artikel voor. Herplaatsing van het artikel is toegestaan, op voorwaarde dat Gate.io wordt vermeld. In alle glen zullen juridische stappen worden ondernomen vanwege inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div>