Q0ZUQyB2YSBjb250cm8gdHJlIHByb3RvY29sbGkgRGVGaQ==

<p><img src="https://gimg2.gateimg.com/image/article/1690791857hotspot.jpeg" alt=""><br>La CFTC ha dato un ordine a OPYN, ZeroEX e Deridex di interrompere le loro attività di trading di derivati.</p>
<p>I tre progetti DeFi, OPYN, ZeroEX e Deridex, hanno ottemperato all’ordine della CFTC.</p>
<p>C’è stata cooperazione tra CFTC e le tre aziende DeFi, OPYN, ZeroEX e Deridex.</p>
<p>Parole chiave: Mercato DeFi, Protocolli DeFi, Emissioni CFTC, Comunità DeFi, CFTC contro DeFi, Commodity Futures Trading Commission degli Stati Uniti, trading di derivati su asset digitali, leggi federali, derivati crypto, derivati DeFi</p>
<h2 id="h2-Introduzione223109"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>Gli Stati Uniti sono un paese con vari organismi di regolamentazione delle criptovalute, tra cui il <a href="https://www.gate.io/blog_detail/3194/crypto-influencers-fuel-speculation-sec" target="_blank">Securities and Exchange Commission (SEC)</a>) Dipartimento di Giustizia (DOJ), Financial Crimes Enforcement Network (FinCEN) del Dipartimento del Tesoro e Commodity Futures Trading Commission (CTFC).</p>
<p>In questo articolo discutiamo del ruolo della Commodity Futures Trading Commission (CTFC) degli Stati Uniti nel supervisionare le attività criptate negli Stati Uniti. Analizzeremo anche l’ordine della CFTC contro tre protocolli DeFi, vale a dire OPYN, ZeroEX e Deridex.</p>
<p>Leggi anche: <a href="https://www.gate.io/blog_detail/3018/new-crypto-bill-cftc-and-sec-collaboration" target="_blank">Nuova legge cripto: collaborazione CFTC &amp; SEC</a></p>
<h2 id="h2-La20Commodity20Futures20Trading20Commission20CTFC20emette20ordini20contro20tre20protocolli20DeFi951494"><a name="La Commodity Futures Trading Commission (CTFC) emette ordini contro tre protocolli DeFi" class="reference-link"></a><span class="header-link octicon octicon-link"></span>La Commodity Futures Trading Commission (CTFC) emette ordini contro tre protocolli DeFi</h2><p>Recentemente, la Commodity Futures Trading Commission (CTFC) ha emesso ordini contro tre protocolli DeFi, OPYN, ZeroEX e Deridex, per offrire trading di derivati senza licenza. La CFTC afferma che le tre aziende operano come piattaforme di trading basate su blockchain che offrono derivati.</p>
<p>Poiché queste piattaforme di trading non sono autorizzate, la CFTC ha ordinato ai tre protocolli DeFi di interrompere le loro operazioni. Inoltre, i tre progetti DeFi, <a href="https://www.gate.io/learn/articles/everything-you-need-to-know-about-opyn/577" target="_blank">OPYN</a>, ZeroEX e Deridex, pagheranno multe rispettivamente di $250.000, $200.000 e $100.000.</p>
<p>Ian McGinley, il Direttore dell’Applicazione della CFTC, ha fatto un commento incauto sui comportamenti di vari protocolli DeFi, tra cui OPYN, ZeroEX e Deridex, sulla loro mancanza di volontà di conformarsi alle leggi nazionali, cosa che li rende soggetti a cause legali e a enormi sanzioni finanziarie.</p>
<p>Ha detto: “Da qualche parte lungo la strada, gli operatori di DeFi hanno avuto l’idea che le transazioni illegali diventino lecite quando facilitate dai contratti intelligenti. Non lo fanno.”</p>
<p>Tuttavia, gli ordini contro OPYN, ZeroEX e Deridex non implicano che le tre società abbiano appropriato indebitamente i fondi dei clienti. In relazione a ciò, il Commissario Summer Mersinger ha dichiarato: “Gli ordini della Commissione in questi casi non danno alcuna indicazione che i fondi dei clienti siano stati appropriati indebitamente o che i partecipanti al mercato siano stati vittime dei protocolli DeFi su cui la Commissione ha scatenato i suoi poteri di applicazione della legge.”</p>
<p>Solo per aggiungere ulteriori dettagli alle accuse, OPYN è stato incriminato per non aver registrato la propria piattaforma come strumento di esecuzione dello swap, nonché per non essersi registrato come commerciante della Futures Commission. Ha anche mancato di rispettare le disposizioni del programma di conformità al Bank Secrecy Act che richiedono alle piattaforme di trading di istituire programmi di identificazione dei clienti.</p>
<p>OPYN, un’azienda con sede in California, offre un derivato chiamato oSQTH che deriva il suo prezzo da un indice che tiene traccia del valore di ‘ether al quadrato rispetto alla stablecoin USDC’.</p>
<p>Come tale, l’autorità di regolamentazione ha dichiarato: “L’ordine stabilisce che i token oSQTH sono swap e transazioni su materie prime al dettaglio con leva o margine e pertanto possono essere offerti solo agli utenti al dettaglio su una borsa registrata in conformità alle normative CEA e CFTC.”</p>
<p>La CFTC ha accusato ZeroEX di offrire esposizione con leva 2:1 agli asset digitali come ether e <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a>.” Matcha, un’applicazione front-end, consente ai suoi utenti di scambiare diversi asset digitali basati su varie blockchain. Secondo le normative CEA e CFTC, tali prodotti possono essere scambiati solo su exchange registrati.</p>
<p>Allo stesso modo, Deridex, una società con sede nella Carolina del Nord la cui piattaforma di trading esiste sul <a href="/price/algorand-algo" rel="nofollow noopener noreferrer" target="_blank">Algorand</a> blockchain, offre diversi derivati DeFi.</p>
<p>Leggi anche: <a href="https://www.gate.io/de/learn/articles/what-is-defi-2/121" target="_blank">Cos’è DeFi 2.0 e perché è importante?</a></p>
<h2 id="h2-CFTC20contro20i20protocolli20DeFi20cooperazione20esemplare384606"><a name="CFTC contro i protocolli DeFi: cooperazione esemplare" class="reference-link"></a><span class="header-link octicon octicon-link"></span>CFTC contro i protocolli DeFi: cooperazione esemplare</h2><p>In sostanza, i tre protocolli DeFi hanno ammesso di aver commesso il suddetto reato, ovvero offrire servizi di trading di derivati su asset digitali senza registrarsi presso le autorità competenti. La CFTC ha elogiato le tre società per la loro cooperazione e volontà di risolvere i problemi in sospeso.</p>
<p>ZeroEx, attraverso il suo account Matcha X, ha ammesso di aver cooperato con la CFTC. <a href="https://twitter.com/matchaxyz/status/1699919425225523352" rel="nofollow noopener noreferrer" target="_blank">Ha detto</a>, “<br><strong><a href="/price/0x-zrx" rel="nofollow noopener noreferrer" target="_blank">0x</a> Il team di sviluppo del DEX aggregator Matcha ha recentemente collaborato con la CFTC per risolvere un’indagine riguardante i token costituenti meno dello 0,1% del volume di scambio di Matcha sin dalla sua nascita.</strong>”</p>
<p>Ha aggiunto: “A 0x, le decisioni strategiche sono prese con il contributo di consulenti legali esterni. In questo caso, stiamo implementando processi aggiuntivi dopo un dialogo costruttivo con l’agenzia regolamentare.”</p>
<p>Leggi anche: <a href="https://www.gate.io/learn/articles/the-wild-west-of-the-crypto-world/670" target="_blank">Il selvaggio West del mondo delle criptovalute? Le ragioni dietro le cause legali della SEC degli Stati Uniti</a></p>
<h2 id="h2-Fondamento20giuridico20per20il20coinvolgimento20della20CFTC20in20DeFi562220"><a name="Fondamento giuridico per il coinvolgimento della CFTC in DeFi" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Fondamento giuridico per il coinvolgimento della CFTC in DeFi</h2><p>Non c’è dubbio che la CFTC, un organo regolatore federale che regola i mercati delle materie prime e dei derivati negli Stati Uniti, abbia intrapreso forti iniziative per stampare la propria autorità e influenza sulla DeFi.</p>
<p>Ad esempio, nel marzo 2021 ha spiegato che la sua giurisdizione include le criptovalute che ritiene essere merci. La sua recente azione contro OPYN, ZeroEX e Deridex indica la sua volontà di monitorare il mercato DeFi. Per farlo, utilizza le leggi federali esistenti e le leggi dei tribunali, qualcosa di cui la comunità DeFi dovrebbe essere consapevole.</p>
<p>Ora è chiaro che la CFTC ha giurisdizione in DeFi fintanto che i protocolli decentralizzati offrono asset digitali e servizi che sono classificati come materie prime o derivati. Ad esempio, la CFTC ha dichiarato apertamente che <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">bitcoin</a> ed Ether (ETH) sono materie prime. Pertanto, avrà il controllo su tutti i prodotti digitali, in particolare derivati e contratti futures, legati a queste blockchain.</p>
<p>La richiesta della CFTC è stata confermata dalla sentenza del tribunale federale di New York del 6 marzo 2018, che ha dichiarato che la CFTC può regolare gli asset virtuali che rientrano nella categoria delle materie prime. Pertanto, la <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">Commissione per il commercio di future su materie prime contro McDonnell</a>(6 marzo 2018 E.D.N.Y.) ha approvato la CFTC come autorità di regolamentazione per determinati asset digitali.</p>
<p>Leggi anche: <a href="https://www.gate.io/blog_detail/1672/10-best-defi-protocols-to-invest-during-bear-markets" target="_blank">I 10 migliori protocolli DeFi in cui investire durante i mercati orsi</a></p>
<h2 id="h2-Implicazioni20dellOrdine20della20CFTC20sulla20Comunit20di20DeFi588508"><a name="Implicazioni dell’Ordine della CFTC sulla Comunità di DeFi" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Implicazioni dell’Ordine della CFTC sulla Comunità di DeFi</h2><p>Finora, molte persone e organizzazioni hanno sollevato preoccupazione per la recente repressione delle criptovalute negli Stati Uniti. Credono che tali azioni possano soffocare l’innovazione.</p>
<p>Non c’è dubbio che la regolamentazione e la supervisione delle criptovalute siano essenziali per lo sviluppo del mercato DeFi. Tuttavia, troppe restrizioni eccessive possono comportare una crescita ridotta del settore DeFi negli Stati Uniti.</p>
<p>Pertanto, fare affidamento eccessivo sulle azioni punitive regolamentari, come hanno fatto la CFTC e la SEC, potrebbe spingere gli sviluppatori di DeFi a trasferirsi in altri paesi per sfuggire all’incertezza regolamentare e alle difficoltà negli Stati Uniti. Se ciò accade, potrebbe portare alla perdita di competenze e innovazione nel settore della blockchain e delle criptovalute negli Stati Uniti.</p>
<p>La crescita sostenibile nel settore DeFi può esistere se le autorità regolatorie collaborano, hanno conversazioni aperte e negoziano con i diversi attori del settore blockchain anziché adottare un approccio di rigore nei loro confronti.</p>
<p>Leggi anche su altri protocolli DeFi come <a href="https://www.gate.io/learn/articles/what-is-venus/736" target="_blank">Venere</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-Conclusion135746"><a name="Conclusion" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusion</h2><p>Di recente, la Commodity Futures Trading Commission (CTFC) ha emesso un ordine contro OPYN, ZeroEX e Deridex per fermare le operazioni in quanto non hanno registrato i loro derivati DeFi presso le autorità regolatorie competenti. Tuttavia, i tre protocolli DeFi hanno ottemperato all’ordine della CFTC e promesso di pagare le sanzioni stabilite.</p>
<h2 id="h2-Domande20frequenti20sulla20DeFi593176"><a name="Domande frequenti sulla DeFi" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Domande frequenti sulla DeFi</h2><h3 id="h3-Quanti20protocolli20DeFi20ci20sono533662"><a name="Quanti protocolli DeFi ci sono?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Quanti protocolli DeFi ci sono?</h3><p>Ci sono oltre 17.000 protocolli DeFi. Questi protocolli DeFi sono composti da codici, standard e procedure che controllano le applicazioni finanziarie. Inoltre, essi esistono su diverse blockchain, incluso <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> e <a href="https://www.gate.io/bitwiki/detail/160/algorand-algo" target="_blank">Algorand</a>.</p>
<h3 id="h3-Quali20sono20i20principali20protocolli20DeFi147200"><a name="Quali sono i principali protocolli DeFi?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Quali sono i principali protocolli DeFi?</h3><p>Ci sono oltre 17.000 protocolli DeFi che svolgono varie funzioni. Esempi dei principali protocolli decentralizzati sono <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>, Protocollo Ren e <a href="https://www.gate.io/price/balancer-bal/usd" target="_blank">Balancer</a>.</p>
<h3 id="h3-Cosa20fa20la20Commodity20Futures20Trading20Commission50207"><a name="Cosa fa la Commodity Futures Trading Commission?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Cosa fa la Commodity Futures Trading Commission?</h3><p>La Commodity Futures Trading Commission è un’agenzia regolamentare degli Stati Uniti che controlla e supervisiona merci e prodotti e mercati derivati, costituiti da contratti futures, opzioni e swap. È composta da un panel di commissari che monitora le attività di varie organizzazioni che offrono derivati e materie prime.</p>
<div class="blog-details-info"><br><div>Autore:<strong> Mashell C.</strong>, Ricercatore di Gate.io<br><div class="info-tips"><em>Questo articolo rappresenta solo le opinioni del ricercatore e non costituisce alcun suggerimento di investimento.<br></em><div><em></em>Gate.io si riserva tutti i diritti su questo articolo. Sarà consentito il ripostaggio dell'articolo a condizione che venga citato Gate.io. In tutti i casi, saranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div>