U0VDIHZzIFVuaXN3YXA6IEVlbiBKdXJpZGlzY2ggR2V2ZWNodCBEYXQgRGUgVG9la29tc3QgdmFuIERlRmkgWm91IEt1bm5lbiBIZXJkZWZpbmnDq3Jlbg==

2024-04-24, 03:51

<p><img src="https://gimg2.gateimg.com/image/article/1692587449analysis.jpeg" alt=""></p>
<h2 id="h2-TL20DR974039"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p>De Amerikaanse Securities and Exchange Commission (SEC) heeft gediend <a href="/price/uniswap-uni" rel="nofollow noopener noreferrer" target="_blank">Uniswap</a> met een Wells Notice waarvan de details nog niet bekend zijn bij het publiek.</p>
<p>Sommige analisten geloven dat de SEC van plan is om <a href="/price/uniswap-uni" target="_blank" class="blog_inner_link">Uniswap</a> te vervolgen voor het exploiteren van een niet-gecertificeerde crypto-makelaar of -beurs.</p>
<p>De juridische strijd tussen de SEC en Uniswap kan een precedent scheppen dat waarschijnlijk de toekomst van de DeFi-sector zal vormgeven.</p>
<h2 id="h2-Introductie112991"><a name="Introductie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introductie</h2><p>De Amerikaanse Securities and Exchange Commission (SEC) zet zijn aanval voort tegen toonaangevende crypto-beurzen. De belangrijkste beschuldigingen tegen hen zijn het niet naleven van de Amerikaanse effectenwetten door het aanbieden van niet-geregistreerde effecten of het exploiteren van niet-vergunde beurzen.</p>
<p>Het doel van dit artikel is om de recente Wells Notice van de SEC te bespreken <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">tegen Hayden Adams en Uniswap</a>. We zullen ook kijken naar de impact van de SEC-rechtszaak op de toekomst van DeFi. Ten slotte zullen we de prijsprestaties van UNI ueren na het nieuws over de Uniswap Wells Notice.</p>
<h2 id="h2-SECs20Onderzoek20naar20Uniswap20Wells20Notice20aan20Hayden20Adams117170"><a name="SEC’s Onderzoek naar Uniswap: Wells Notice aan Hayden Adams" class="reference-link"></a><span class="header-link octicon octicon-link"></span>SEC’s Onderzoek naar Uniswap: Wells Notice aan Hayden Adams</h2><p>Het DeFi-ecosysteem zou mogelijk nog een SEC-cryptocrackdown kunnen meemaken na zijn voornemen om Uniswap, een gedecentraliseerde cryptocurrency-uitwisseling, aan te klagen. Volgens de Uniswap-blog heeft de Amerikaanse Securities and Exchange Commission (SEC) een wells-mededeling uitgegeven aan Hayden Adams, CEO van Uniswap, wat wijst op mogelijke controle van het DeFi-platform.</p>
<p>Op dit moment is er onduidelijkheid over het motief voor de mogelijke handhavingsactie van de SEC tegen Uniswap Labs, de ontwikkelaar van Uniswap, een prominente technologische dienstverlener. Desalniettemin zou het probleem moeten draaien om de schending van de Amerikaanse financiële technologiewet, met name het aanbieden van niet-geregistreerde effecten of de exploitatie van een niet-geregistreerde beurs.</p>
<p>Op zijn blog heeft Uniswap al beweerd dat de UNI-token, zijn eigen cryptocurrency, geen effect is. <a href="https://blog.uniswap.org/fighting-for-defi" rel="nofollow noopener noreferrer" target="_blank">Het zei</a> De UNI-token is geen effect omdat deze niet voldoet aan de wettelijke definitie van een soort effect, inclusief de definitie van een ‘beleggingscontract’.</p>
<p>Er is geen contract of belofte tussen Uniswap Labs en de meer dan 300.000 houders van het token. Er is geen gemeenschappelijke onderneming en de waarde van het token is niet uitsluitend afhankelijk van de inspanningen van Uniswap Labs.</p>
<p>Op basis van de bovenstaande details van Uniswap blijkt dat de SEC streeft naar handhaving van de wetgeving inzake cryptowaarden ter bescherming van de consument. In het verleden heeft de SEC soortgelijke stappen ondernomen tegen toonaangevende cryptocurrency-beurzen zoals Coinbase, Kraken en Binance.</p>
<p>Als de juridische problemen van de SEC met betrekking tot DeFi tegen Uniswap vergelijkbaar zijn met die van Coinbase, zullen ze betrekking hebben op de classificatie van de UNI-token en de naleving van de regelgeving voor crypto. Uiteindelijk zullen deze juridische uitdagingen met betrekking tot cryptocurrencies helpen verduidelijken of digitale activa zoals UNI en ETH beleggingscontracten zijn zoals obligaties en aandelen waar de SEC toezicht op moet houden. Wat Uniswap, andere gedecentraliseerde beurzen (DEX) en gecentraliseerde beurzen willen, is duidelijkheid over de juridische status van cryptocurrencies.</p>
<p>Via het aangehaalde blogbericht voegde Uniswap eraan toe: ‘Rekening houdend met de lopende rechtszaken van de SEC tegen Coinbase en anderen, evenals hun volledige onwil om duidelijkheid te verschaffen of een pad naar registratie aan te bieden aan degenen die wettelijk opereren binnen de VS, kunnen we alleen maar concluderen dat dit de nieuwste politieke inspanning is om zelfs de beste actoren die technologie op blockchains bouwen, te targeten.’</p>
<p>Al met al is Uniswap er sterk van overtuigd dat haar digitale producten voldoen aan het regelgevend kader voor DeFi in de Verenigde Staten. Dit heeft het benadrukt in de post waarin het zei: ‘We zijn ervan overtuigd dat onze producten aan de juiste kant van de wet staan en dat ons werk aan de juiste kant van de geschiedenis staat. Terwijl ons juridische team deze strijd aangaat, zullen we blijven doen waar we goed in zijn: bouwen.’</p>
<p>Ten slotte heeft Uniswap ook gewaarschuwd dat de Verenigde Staten achter kunnen blijven bij blockchain-productinnovaties als het geen evenwicht vindt tussen cryptocurrency-innovaties en regulering. De waarschuwing luidt als volgt: ‘Als de SEC ondoorzichtige en beschermt en nieuwe, transparante technologie aanvalt die kansen kan bieden en kosten kan verlagen voor Amerikanen, zal de VS achterblijven op het gebied van innovatie die consumentenkeuze en vrijheid kan stimuleren’.</p>
<h2 id="h2-De20Betekenis20van20de20Strijd235336"><a name="De Betekenis van de Strijd" class="reference-link"></a><span class="header-link octicon octicon-link"></span>De Betekenis van de Strijd</h2><p>De uitkomst van de aanstaande rechtszaak SEC vs. Uniswap zal een aanzienlijke impact hebben op de DeFi-markt, hetzij positief hetzij negatief. Ten eerste kan de uitkomst van de juridische zaak van de SEC tegen Uniswap leiden tot de vaststelling van de duidelijke juridische status van DeFi-platforms en cryptocurrencies. Het zal ook het precedent scheppen dat innovatie in de DeFi-sector kan ontsporen onder het voorwendsel van het bevorderen van marktintegriteit en consumentenbescherming.</p>
<p>Bijvoorbeeld, als Uniswap de zaak tegen de SEC wint, zal dit waarschijnlijk de groei en bloei van de DeFi-sector in gang zetten. Hierdoor zullen veel vergelijkbare crypto-bedrijven normaal kunnen functioneren zonder juridische gevolgen van de toezichthouder te vrezen. Een dergelijk precedent zal het vertrouwen in de sector versterken en innovatie bevorderen.</p>
<p>Integendeel, als <a href="https://www.gate.io/learn/articles/what-is-uniswap/91" target="_blank">Uniswap</a> als het de zaak verliest, wordt het uiterst moeilijk voor bedrijven die blockchain-gebaseerde producten aanbieden om te opereren zonder compliance met decentrale financiële regelgeving. Bijvoorbeeld, dergelijke bedrijven moeten mogelijk voldoen aan KYC-vereisten, vergunningen en productregistratie.</p>
<h2 id="h2-Impact20van20de20rechtszaak20op20de20toekomst20van20DeFi966661"><a name="Impact van de rechtszaak op de toekomst van DeFi" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Impact van de rechtszaak op de toekomst van DeFi</h2><p>Een positief aspect van een dergelijk g is dat de regering van de Verenigde Staten, via de SEC, zal verduidelijken hoe de sector zal functioneren. Ook zal de Amerikaanse overheid door dergelijke acties de crypto-sector, digitale producten en bedrijven die in de branche opereren, legitimeren. Dit zal verdere innovatie en groei bevorderen. <a href="https://www.gate.io/learn/articles/defi-eco-2024-preview-key-trends-and-direction-predictions-for-the-industry/1387" target="_blank">vanwege nauwkeurige DeFi-regulering</a>.</p>
<h2 id="h2-Reacties20van20Nicola20Massella20over20de20situatie437935"><a name="Reacties van Nicola Massella over de situatie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Reacties van Nicola Massella over de situatie</h2><p>Nicola Massella, Legal Partner bij STORM Partners, is van mening dat wat Uniswap meemaakt al andere crypto-entiteiten zoals Coinbase en Binance heeft beïnvloed. Het is aan elk van deze bedrijven om sterk te staan en zichzelf te verdedigen. Massela denkt ook dat de SEC dezelfde beschuldigingen gebruikt dat Uniswap een niet-geregistreerde effectenmakelaar of beurs exploiteert.</p>
<p>In <a href="https://beincrypto.com/sec-vs-uniswap-define-defi-future/" rel="nofollow noopener noreferrer" target="_blank">een verklaring gepubliceerd door BeInCrypto</a>, Massella zei: “Deze actie tegen Uniswap markeert de eerste agressieve zet van de SEC tegen een toonaangevende entiteit in de DeFi-sector.” Ze denkt ook dat de uitkomst van de zaak de juridische grenzen van DeFi-operaties in de Verenigde Staten zal vormen en zal helpen bij het herclassificeren van digitale activa.</p>
<p>Als gevolg hiervan zou de SEC kunnen proberen om DeFi-bedrijven te dwingen te voldoen aan het financiële wettelijke kader waar effectenmakelaars en andere financiële entiteiten in de traditionele financiële sector zich aan houden. Zoals verwacht kan dit ertoe leiden dat crypto-bedrijven stoppen met het beschouwen van zichzelf als louter technologieleveranciers die onafhankelijke crypto-activatransacties vergemakkelijken met beperkte verplichting om te voldoen aan de bestaande regelgeving voor digitale activa.</p>
<h2 id="h2-UNI20Prijsprestaties20en20veranderingen20in20het20handelsvolume830440"><a name="UNI Prijsprestaties en veranderingen in het handelsvolume" class="reference-link"></a><span class="header-link octicon octicon-link"></span>UNI Prijsprestaties en veranderingen in het handelsvolume</h2><p>De huidige impasse tussen Uniswap en de Amerikaanse SEC kan een sterke impact hebben op de DeFi-markt, vooral op de prijs van de UNI-token. Na de aankondiging van de SEC Wells Notice door Uniswap bijvoorbeeld, <a href="https://www.gate.io/how-to-buy/uniswap-uni" target="_blank">UNI prijs is gekelderd</a> tot een zes weken laagtepunt van $10 als gevolg van de FUD op de markt. Sindsdien is de waarde geleidelijk gedaald. Op het moment van schrijven werd de token verhandeld voor $7.80, zoals de volgende grafiek laat zien.<br><img src="https://gimg2.gateimg.com/image/article/17139305421.jpg" alt=""><br>UNI Token Prijsbeweging - CoinGecko</p>
<p>Het gebied tussen de zwarte lijn en het einde van <a href="/price/the-graph-grt" rel="nofollow noopener noreferrer" target="_blank">De Grafiek</a> geeft de prijsprestaties van UNI-token aan nadat Uniswap heeft aangekondigd dat het een SEC Wells Notice heeft ontvangen. Kort gezegd is de prijs met ongeveer 30% gedaald sinds het nieuws over de kennisgeving naar de markt kwam.</p>
<p>Ook heeft Uniswap zijn transactiekosten verhoogd van $0.15 naar $0.25. De markt speculeert dat de beurs dit heeft gedaan om meer fondsen te werven ter voorbereiding op de juridische strijd tegen de SEC. Lees ook de <a href="https://www.gate.io/price-prediction/uniswap-uni" target="_blank">UNI prijsvoorspellingen</a> van Gate.io analytics.<br><img src="https://gimg2.gateimg.com/image/article/17139306061.jpg" alt=""><br>Bron: x.com</p>
<p>Ondanks deze veranderingen steeg het handelsvolume op het platform naar $2,92 miljard. Tegen 5 april was het cumulatieve handelsvolume gestegen tot $2 biljoen. Nu wacht de hele markt af om te ontdekken of de uitkomst van de rechtszaak mogelijk nieuwe crypto-handelsregels met zich meebrengt.</p>
<h2 id="h2-Conclusie340875"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>Onlangs heeft de SEC Uniswap een Wells Notice gestuurd, terwijl de regelgevende autoriteit blijft optreden tegen DeFi-projecten. Er is nog geen bevestiging van de aanklachten die de SEC heeft ingediend tegen de gedecentraliseerde exchange. Deskundigen geloven echter dat de instantie Uniswap kan aanklagen wegens het exploiteren van een niet-gelicentieerde exchange of cryptomakelaar.</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 opvattingen van de onderzoeker en vormt geen enkele beleggingsaanbeveling.<br></em><div><em></em>Gate.io behoudt alle rechten voor op dit artikel. Het is toegestaan om het artikel opnieuw te plaatsen op voorwaarde dat 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>