U0VDIHZzIFVuaXN3YXA6IHVuYSBiYXR0YWdsaWEgbGVnYWxlIGNoZSBwb3RyZWJiZSByaWRlZmluaXJlIGlsIGZ1dHVybyBkaSBEZUZp

2024-04-24, 03:51

<p><img src="https://gimg2.gateimg.com/image/article/1692587449analysis.jpeg" alt=""></p>
<h2 id="h2-TL20DR155790"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p>La Securities and Exchange Commission degli Stati Uniti (SEC) ha servito <a href="/price/uniswap-uni" rel="nofollow noopener noreferrer" target="_blank">Uniswap</a> con un avviso Wells di cui i dettagli non sono ancora noti al pubblico.</p>
<p>Alcuni analisti ritengono che la SEC intenda addebitare a <a href="/price/uniswap-uni" target="_blank" class="blog_inner_link">Uniswap</a> l’operatività di un broker o exchange di criptovalute non autorizzato.</p>
<p>La battaglia legale SEC vs. Uniswap potrebbe creare un precedente che probabilmente plasmerà il futuro del settore DeFi.</p>
<h2 id="h2-Introduzione111019"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>La Securities and Exchange Commission degli Stati Uniti (SEC) continua la sua crociata contro le principali borse crittografiche. Le sue principali accuse contro di loro sono la mancata conformità alle leggi sui valori mobiliari degli Stati Uniti attraverso l’offerta di titoli non registrati o l’operazione di scambi non autorizzati.</p>
<p>L’obiettivo di questo articolo è discutere della recente comunicazione di avviso Wells della SEC <a href="https://www.gate.io/blog_detail/4024/daily-news-bitcoin-ignored-inflation-and-rebounded-dollar70k-uniswap-has-a-firm-attitude-towards-sec-complaints-jupiter-co-founder-announced-network-upgrade" target="_blank">contro Hayden Adams e Uniswap</a>. Guarderemo anche l’impatto della causa SEC sul futuro di DeFi. Infine, valuteremo le prestazioni del prezzo di UNI a seguito della notizia del Wells Notice di Uniswap.</p>
<h2 id="h2-Esame20della20SEC20su20Uniswap20avviso20Wells20a20Hayden20Adams258118"><a name="Esame della SEC su Uniswap: avviso Wells a Hayden Adams" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Esame della SEC su Uniswap: avviso Wells a Hayden Adams</h2><p>L’ecosistema DeFi potrebbe assistere a un altro intervento di controllo delle criptovalute da parte della SEC a seguito della sua intenzione di citare in giudizio Uniswap, un exchange di criptovalute decentralizzato. Secondo il blog di Uniswap, la Securities and Exchange Commission degli Stati Uniti (SEC) ha emesso un avviso Wells a Hayden Adams, CEO di Uniswap, segnalando una possibile attenzione alla piattaforma DeFi.</p>
<p>Attualmente, non c’è chiarezza sul motivo dell’eventuale azione di applicazione della legge SEC contro Uniswap Labs, lo sviluppatore di Uniswap, un importante fornitore di servizi tecnologici. Tuttavia, la questione dovrebbe ruotare attorno alla violazione della legge sulla tecnologia finanziaria degli Stati Uniti, in particolare l’offerta di titoli non registrati o l’operazione di uno scambio non registrato.</p>
<p>Già sul suo blog Uniswap ha affermato che il token UNI, la sua criptovaluta nativa, non è una security. <a href="https://blog.uniswap.org/fighting-for-defi" rel="nofollow noopener noreferrer" target="_blank">Si è detto</a>, “Il token UNI non è un titolo perché non soddisfa la definizione legale di nessun tipo di titolo, incluso non soddisfa la definizione di un ‘contratto di investimento.’</p>
<p>“Non esiste alcun contratto o promessa tra Uniswap Labs e i oltre 300.000 detentori del token. Non c’è un’impresa comune e il valore del token non dipende unicamente dagli sforzi di Uniswap Labs.”</p>
<p>Sulla base dei dettagli sopra riportati di Uniswap, si deduce che la SEC mira ad applicare la legge sulle criptovalute per garantire la protezione dei consumatori. In passato, la SEC ha intrapreso azioni simili contro importanti exchange di criptovalute come Coinbase, Kraken e Binance.</p>
<p>Se le questioni legali del SEC DeFi riguardo a Uniswap sono simili a quelle di Coinbase, saranno legate alla classificazione del token UNI e alla conformità normativa della criptovaluta. Alla fine, queste sfide legali sulle criptovalute contribuiranno a chiarire se gli asset digitali come UNI ed ETH siano contratti di investimento come obbligazioni e azioni che la SEC dovrebbe regolamentare. Ciò che Uniswap, altre piattaforme di scambio decentralizzate (DEX) e piattaforme di scambio centralizzate vogliono è chiarezza sullo status legale delle criptovalute.</p>
<p>Attraverso il post del blog citato, Uniswap ha aggiunto: ‘Tenendo conto delle cause in corso della SEC contro Coinbase e altri, nonché della loro completa riluttanza a fornire chiarezza o un percorso per la registrazione a coloro che operano legalmente negli Stati Uniti, possiamo solo concludere che questo è l’ultimo sforzo politico per colpire anche i migliori attori che costruiscono tecnologia su blockchain.’</p>
<p>Uniswap crede fortemente che i suoi prodotti digitali siano conformi al quadro normativo per DeFi negli Stati Uniti. Lo ha sottolineato nel post in cui ha detto: “Siamo fiduciosi che i nostri prodotti siano dalla parte della legge e che il nostro lavoro sia dalla parte della storia. Mentre il nostro team legale affronta questa battaglia, continueremo a fare ciò che sappiamo fare meglio: costruire.”</p>
<p>Infine, Uniswap ha anche avvertito che gli Stati Uniti potrebbero essere in ritardo nelle innovazioni dei prodotti blockchain se non riesce a trovare un equilibrio tra le innovazioni delle criptovalute e la regolamentazione. La sua avvertenza afferma: “Se la SEC protegge i sistemi opachi e attacca le nuove tecnologie trasparenti che possono aprire opportunità e ridurre i costi per gli americani, gli Stati Uniti rimarranno indietro nell’innovazione che può alimentare la scelta e la libertà dei consumatori.”</p>
<h2 id="h2-Il20Significato20della20Battaglia87680"><a name="Il Significato della Battaglia" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Il Significato della Battaglia</h2><p>L’esito dell’imminente causa SEC vs. Uniswap avrà un impatto significativo sul mercato DeFi, in modo positivo o negativo. In primo luogo, l’esito della causa legale della SEC contro Uniswap potrebbe portare all’instaurazione di uno status legale chiaro delle piattaforme DeFi e delle criptovalute. Imporrà anche il precedente che potrebbe ostacolare l’innovazione nel settore DeFi sotto il pretesto di migliorare l’integrità del mercato e la protezione dei consumatori.</p>
<p>Ad esempio, se Uniswap vince la causa contro la SEC, è probabile che scateni la crescita e la prosperità del settore DeFi. Con ciò, molte aziende criptografiche simili funzioneranno correttamente senza temere ripercussioni legali da parte del regolatore. Un tale precedente instillerà fiducia nel settore e promuoverà l’innovazione.</p>
<p>Al contrario, se <a href="https://www.gate.io/learn/articles/what-is-uniswap/91" target="_blank">Uniswap</a> Se perde la causa, diventerà estremamente difficile per le aziende che forniscono prodotti basati su blockchain operare senza rispettare la conformità alla regolamentazione finanziaria decentralizzata. Ad esempio, tali aziende potrebbero dover rispettare i requisiti KYC, le disposizioni per le licenze e la registrazione del prodotto.</p>
<h2 id="h2-Impatto20della20causa20sul20futuro20di20DeFi646474"><a name="Impatto della causa sul futuro di DeFi" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Impatto della causa sul futuro di DeFi</h2><p>Un aspetto positivo di un caso del genere è che il governo degli Stati Uniti, attraverso la SEC, chiarirà come funzionerà il settore. Inoltre, attraverso tali azioni, il governo degli Stati Uniti legittimerà il settore delle criptovalute, i prodotti digitali e le aziende che operano nell’industria. Ciò favorirà ulteriormente l’innovazione e la crescita <a href="https://www.gate.io/learn/articles/defi-eco-2024-preview-key-trends-and-direction-predictions-for-the-industry/1387" target="_blank">a causa di una regolamentazione DeFi precisa</a>.</p>
<h2 id="h2-Commenti20di20Nicola20Massella20sulla20situazione736409"><a name="Commenti di Nicola Massella sulla situazione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Commenti di Nicola Massella sulla situazione</h2><p>Nicola Massella, socio legale di STORM Partners, ritiene che ciò che sta vivendo Uniswap abbia già interessato altre entità cripto come Coinbase e Binance. Spetta a ciascuna di queste aziende restare forti e difendersi. Massela pensa anche che la SEC stia utilizzando le stesse accuse secondo cui Uniswap opera come broker o exchange di titoli non registrato.</p>
<p>In <a href="https://beincrypto.com/sec-vs-uniswap-define-defi-future/" rel="nofollow noopener noreferrer" target="_blank">una dichiarazione pubblicata da BeInCrypto</a> Massella ha detto: “Questa azione contro Uniswap segna il primo passo aggressivo della SEC verso un’entità di spicco nel settore DeFi.” Pensa anche che l’esito del caso darà forma ai confini legali delle operazioni DeFi negli Stati Uniti e aiuterà a riclassificare gli asset digitali.</p>
<p>Di conseguenza, la SEC potrebbe lavorare per costringere le aziende DeFi a conformarsi al quadro giuridico finanziario cui aderiscono i broker di titoli e altre entità finanziarie del settore finanziario tradizionale. Come previsto, ciò potrebbe costringere le aziende crypto a smettere di considerarsi meri fornitori di servizi tecnologici che facilitano transazioni indipendenti di cripto-attività con limitate obbligazioni di conformità alla regolamentazione esistente sulle attività digitali.</p>
<h2 id="h2-Variazioni20di20prezzo20e20volume20di20trading20di20UNI204201"><a name="Variazioni di prezzo e volume di trading di UNI" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Variazioni di prezzo e volume di trading di UNI</h2><p>Lo stallo attuale tra Uniswap e la SEC degli Stati Uniti potrebbe avere un forte impatto sul mercato DeFi, specialmente sul prezzo del token UNI. Ad esempio, dopo l’annuncio di Uniswap del SEC Wells Notice <a href="https://www.gate.io/how-to-buy/uniswap-uni" target="_blank">Il prezzo di UNI è crollato</a> a causa della FUD nel mercato, il token è sceso a un minimo di sei settimane di $10. Da allora, il valore è gradualmente diminuito. Al momento della scrittura, il token veniva scambiato a $7.80, come mostra il grafico successivo.<br><img src="https://gimg2.gateimg.com/image/article/17139305421.jpg" alt=""><br>Movimento del prezzo del token UNI - CoinGecko</p>
<p>L’area tra la linea nera e la fine <a href="/price/the-graph-grt" rel="nofollow noopener noreferrer" target="_blank">The Graph</a> indica la performance del prezzo del token UNI dopo che Uniswap ha annunciato di aver ricevuto un avviso Wells dalla SEC. In pratica, il prezzo è sceso di circa il 30% dalla notizia dell’avviso arrivata sul mercato.</p>
<p>Inoltre, Uniswap ha aumentato le sue commissioni di transazione da $0,15 a $0,25. Il mercato specula che lo scambio abbia fatto ciò per raccogliere più fondi in preparazione alla sua battaglia legale contro la SEC. Leggi anche il <a href="https://www.gate.io/price-prediction/uniswap-uni" target="_blank">Previsioni del prezzo UNI</a> dalle analisi di Gate.io.<br><img src="https://gimg2.gateimg.com/image/article/17139306061.jpg" alt=""><br>Fonte: x.com</p>
<p>Nonostante questi cambiamenti il volume degli scambi sulla piattaforma è aumentato a $2.92 miliardi. Entro il 5 aprile il volume degli scambi cumulativo era salito a $2 trilioni. Ora, l’intero mercato è in attesa di scoprire se l’esito del caso legale potrebbe portare nuove regolamentazioni per il trading di criptovalute.</p>
<h2 id="h2-Conclusione84007"><a name="Conclusione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusione</h2><p>Recentemente, la SEC ha notificato a Uniswap un avviso di Wells mentre l’autorità di regolamentazione continua a colpire i progetti DeFi. Non c’è conferma delle accuse che la SEC ha mosso contro lo scambio decentralizzato. Tuttavia, gli analisti ritengono che l’agenzia possa addebitare a Uniswap l’operatività di uno scambio o broker di criptovalute non autorizzato.</p>
<div class="blog-details-info"><br><div>Autore: <strong>Mashell C.</strong>, Ricercatore 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 re-post dell'articolo a condizione che venga citato Gate.io. In tutti i casi, verranno intraprese azioni legali a causa della violazione del copyright.<br></div><p></p><br></div></div></div>