U0VDJ3MgcG9naW5nIG9tIGJlcm9lcCBhYW4gdGUgdGVrZW5lbiB0ZWdlbiB2ZXJsaWVzIHZhbiBkZSBSaXBwbGUtemFhayBpcyBhZmdld2V6ZW4=

2023-10-18, 08:33

<p><img src="https://gimg2.gateimg.com/image/article/1690791857hotspot.jpeg" alt=""></p>
<h2 id="h2-TL20DR579207"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p>Recentelijk heeft districtsrechter Analisa Torres de poging van de SEC om in beroep te gaan tegen de uitspraak in de Ripple-zaak afgewezen.</p>
<p>De SEC betoogde dat de uitspraak van de rechtbank invloed kan hebben op de andere gerelateerde zaken.</p>
<p>Het volledige proces SEC vs. Ripple zal beginnen in april 2024.</p>
<h2 id="h2-Kennismaking373720"><a name="Kennismaking" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Kennismaking</h2><p>De zaak van de U.S. Securities and Exchange Commission (SEC) tegen Ripple Labs (Ripple) is de langstdurende SEC-rechtszaak in de geschiedenis van cryptocurrency en blockchain geworden. Het sleept al voort sinds december 2020 en zal waarschijnlijk doorgaan tot 2024.</p>
<p>Deze post behandelt de achtergrond van de <a href="https://www.gate.io/blog_detail/2960/xrp-climbs-on-the-4th-spot-among-cryptocurrencies-following-ripple-s-sec-triumph" target="_blank">SEC vs. Ripple rechtszaak</a> evenals de redenen voor het beroep van de SEC tegen haar verlies.</p>
<h2 id="h2-SEC20tegen20Ripplerechtszaak273597"><a name="SEC tegen Ripple-rechtszaak" class="reference-link"></a><span class="header-link octicon octicon-link"></span>SEC tegen Ripple-rechtszaak</h2><p>Onlangs heeft rechter Analisa Torres het verzoek van de Amerikaanse Securities and Exchange Commission om in beroep te gaan tegen haar verlies tegen Ripple Labs, het cryptobedrijf dat Ripple bezit, afgewezen. <a href="/price/xrp-xrp" rel="nofollow noopener noreferrer" target="_blank">XRP</a> Rechter Analisa Torres oordeelde dat de SEC niet heeft kunnen aantonen dat er substantiële gronden van verschil waren of dwingende en bindende rechtsvragen.</p>
<p>Eigenlijk, de <a href="https://www.gate.io/article/25653/gate.io-blog-behind-the-scene-sec-vs.-ripple-lawsuit" target="_blank">afwijzing van het hoger beroep SEC tegen Ripple</a> is opnieuw een grote klap voor de Amerikaanse Securities and Exchange Commission en opnieuw een grote overwinning voor Ripple en de hele cryptosector. Volgens de uitspraak was de SEC van plan om in beroep te gaan tegen de bevindingen van rechter Torres over XRP-programmatische verkopen en andere distributies, waarbij Ripple de cryptocurrency gebruikte om verschillende betalingen te doen voor aangeboden diensten.</p>
<p>Ook betoogde de rechter dat het beroep van de SEC niet zou helpen bij het bevorderen van de zaak naar een conclusie. De uitspraak luidde: ‘Het verzoek van de SEC voor certificering van interlocutoir hoger beroep wordt afgewezen.’</p>
<p>De uitspraak van rechter Torres tegen het beroep van de SEC betekent echter niet dat Ripple de zaak heeft gewonnen. Volgens de Amerikaanse cryptowetgeving zal de zaak van de SEC tegen Ripple waarschijnlijk worden afgerond in 2024 na extra rechtbankzittingen. Rechter Torres heeft zelfs 23 april 2024 vastgesteld als de datum voor het definitieve proces.</p>
<p>Niettemin zal de SEC nog een kans krijgen om in hoger beroep te gaan tegen de algehele beslissing als het verliest van Ripple.</p>
<p>Lees ook: <a href="https://www.gate.io/blog_detail/1374/why-people-think-sec-is-indecisive-on-which-crypto-assets-are-securities" target="_blank">Waarom mensen denken dat de SEC onbeslist is over welke crypto-activa effecten zijn</a></p>
<h2 id="h2-Achtergrond20over20de20Ripple20Battle43529"><a name="Achtergrond over de Ripple Battle" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Achtergrond over de Ripple Battle</h2><p>In december 2020 diende de SEC een rechtszaak in tegen Ripple, waarin werd beweerd dat het een verkoop van niet-geregistreerde effecten had uitgevoerd, <a href="https://www.gate.io/learn/articles/what-is-xrp/225" target="_blank">XRP</a>. Volgens de rechtszaak heeft Ripple Labs artikel 5(a) en 5(c) van de Securities Act van 1933 overtreden door Ripple crypto te verkopen die als effecten worden beschouwd en die voorafgaand aan de verkoop aan investeerders en het publiek geregistreerd hadden moeten worden.</p>
<p>Die rechtszaak had aanzienlijke invloed op de waarde van de XRP-munt, die destijds een van de belangrijkste crypto-activa was. De marktkapitalisatie, die ongeveer $27 miljard bedroeg, daalde naar ongeveer $16 miljard. Desalniettemin kondigde Ripple direct na de rechtszaak van de SEC aan dat het zich zou verzetten.</p>
<p>Het geschil ging over de vraag of Ripple (XRP) al dan niet als een investeringscontract moet worden beschouwd. Desalniettemin is er geen definitie van een investeringscontract in de federale effectenregelgeving. In plaats daarvan gebruikt de rechtbank de Howey-testcriteria, die in 1946 zijn vastgesteld om te beoordelen of een beleggingsinstrument al dan niet als effect wordt beschouwd.</p>
<p>De SEC heeft betoogd dat de mensen die <a href="/price/xrp-xrp" target="_blank" class="blog_inner_link">XRP</a> hebben gekocht, verwachtten daarvan rendement te krijgen. Het beweert dat de rendementen die de investeerders zouden krijgen, afhankelijk waren van de promotieactiviteiten van Ripple Labs.</p>
<p>Het voegde verder toe dat Ripple adverteerde dat de investeerders de crypto-activa op secundaire markten konden verkopen om winst te genereren. Op basis van dergelijke gronden beschouwt de SEC XRP als een effect.</p>
<h2 id="h2-Uitspraak20van20de20rechtbank40874"><a name="Uitspraak van de rechtbank" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Uitspraak van de rechtbank</h2><p>Op 13 juli 2023 heeft rechter Analisa Torres van de Amerikaanse districtsrechtbank een uitspraak gedaan tegen Ripple Labs en zijn twee topfunctionarissen Christian A. Larsen (mede-oprichter, voormalig CEO en huidig uitvoerend voorzitter van Ripple) en Bradley Garlinghouse (huidige CEO van Ripple). De rechtbank zei dat de vraag of XRP al dan niet een crypto-effect is afhangt van hoe investeerders het hebben verkregen.</p>
<p>Het verklaarde dat Programmatic Sales van XRP en andere distributies Ripple crypto niet als een beveiliging maken omdat ze niet aan de criteria van de Howey Test voldoen. Met de programmatische verkoop van XRP wist Ripple Labs niet wie haar cryptocurrency kocht. Dit komt omdat ze aan het publiek werden verkocht via beurzen. Aan de andere kant, <a href="https://www.gate.io/how-to-buy/xrp-xrp" target="_blank">XRP kopers</a> had geen volledige kennis van het bedrijf of de persoon die het verkoopt.</p>
<p>In het g van Ripple verwijst de andere verkoop naar de XRP-munten die aan de werknemers werden gegeven voor hun diensten. Volgens de uitspraak van de rechtbank maken dergelijke betalingen XRP niet tot een effect omdat de werknemers geen geld hebben betaald om ze te verwerven. Als zodanig vormen ze geen beleggingsovereenkomst.</p>
<p>Desalniettemin maakt de verkoop van XRP aan institutionele beleggers XRP tot een effect. Dit komt doordat de investeerders betaalden voor de Ripple-crypto met verschillende fiatvaluta’s die voldoen aan de investeringsgeldcriteria van de Howey-test. Ook waren de fortuinen van de individuele investeerders verbonden met het succes van Ripple.</p>
<h2 id="h2-Besluit20van20de20SEC20om20in20beroep20te20gaan20tegen20de20uitspraak20van20de20rechtbank324261"><a name="Besluit van de SEC om in beroep te gaan tegen de uitspraak van de rechtbank" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Besluit van de SEC om in beroep te gaan tegen de uitspraak van de rechtbank</h2><p>De SEC had zijn redenen om in beroep te gaan tegen de uitspraak van de rechtbank in de zaak SEC vs. Ripple. Ten eerste zei de SEC dat de zaak onmiddellijke aandacht vereiste omdat het gevolgen heeft voor de uitkomst van andere zaken, waaronder die tegen Coinbase Global Inc. en Binance Holdings Ltd.</p>
<p>Het wees er ook op dat er inconsistentie was aan de kant van de rechtbank over wat een crypto-beveiliging vormt. Dat komt doordat het standpunt van Jed Rakoff, een federale rechter in Manhattan, in contrast staat met dat van Torres. <a href="https://www.gate.io/blog_detail/2238/do-kwon-reaches-5-star-wanted-level-as-sec-brings-more-fraud-charges" target="_blank">weerspiegeld in de SEC tegen Terraform Labs zaak</a>.</p>
<p>Het andere argument van de SEC is dat de uitspraak van de rechtbank in de Ripple-zaak een “kunstmatig onderscheid” creëert tussen particuliere beleggers en institutionele beleggers. Met andere woorden, de uitspraak creëert verschillende normen voor institutionele beleggers en particuliere beleggers. Als gevolg daarvan betoogt het dat de uitspraak “op onjuiste wijze van Howey’s redelijke belegger onderzoek een subjectief onderzoek maakt en de redenering achter Howey en andere zaken op zijn kop zet.”</p>
<p>Volgens de SEC wordt het als gevolg van het bovenstaande verschil moeilijk om in overeenstemming te komen met de fundamentele bepalingen van de effectenwetgeving. Hierover zei de SEC: ‘Uiteindelijk staat de onderliggende logica van de Ripple-uitspraak los van de basisprincipes achter Howey en de federale effectenwetten in het algemeen.’</p>
<p>Gerelateerd nieuws: <a href="https://www.gate.io/blog_detail/3287/catalysts-that-could-propel-ripple-xrp-to-new-heights-in-2023 &quot;Catalysts that Could Propel Ripple (XRP" rel="nofollow noopener noreferrer" target="_blank">Katalysatoren die Ripple (XRP) in 2023 naar nieuwe hoogten zouden kunnen stuwen</a> naar nieuwe hoogten in 2023”)</p>
<h2 id="h2-Tijdlijn20van20het20juridische20geschil20tussen20Ripple20en20de20SEC34568"><a name="Tijdlijn van het juridische geschil tussen Ripple en de SEC" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Tijdlijn van het juridische geschil tussen Ripple en de SEC</h2><p>Veel crypto-experts en analisten geloven dat Ripple de zaak nog niet heeft gewonnen, aangezien er andere gerechtelijke zittingen zullen plaatsvinden in april 2024. Preston Byrne, een ondernemer en een zakenpartner bij Brown Rudnick, zei dat de SEC de zaak nog steeds onderzoekt en nog steeds kans maakt om te winnen van Ripple Labs.</p>
<p>Preston Byrne zei: “Het samenvattende oordeel inzake Ripple is uiteraard niet het laatste woord over de kwestie. Zelfs als de zaak eindigt zoals nu, heeft Ripple nog steeds “meerdere miljarden dollars aan institutionele verkopen waar ze verantwoordelijk voor zijn.”</p>
<p>De strijd tussen de SEC en Ripple zal in april 2024 tot een einde komen wanneer de rechtbank naar verwachting haar definitieve uitspraak zal doen. Ondertussen bekijkt de SEC haar positie nog steeds en kan zij andere sterke argumenten bedenken om de zaak te winnen.</p>
<p>Volgens sommige analisten, zoals Yassin Mobarak, een ondernemer, kan de SEC haar rechtszaak tegen Ripple intrekken vóór de laatste zitting. Hij zei onlangs: ‘Ze zullen nu proberen deze zaak zo snel mogelijk te beëindigen, zodat ze in beroep kunnen gaan bij het 2e circuit en deze onzekerheid in de hele industrie kunnen voortzetten. Litigatie op zichzelf, ongeacht de uitkomst, is het wapen.’</p>
<h2 id="h2-Conclusie273300"><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 zijn poging om in beroep te gaan tegen het gerechtelijk vonnis in de zaak SEC vs Ripple verloren. Rechter Analisa Torres oordeelde dat de SEC er niet in geslaagd is om substantiële verschillen aan te tonen. Ondertussen heeft rechter Torres 23 april 2024 vastgesteld als de datum voor de start van het proces in de zaak SEC vs Ripple.</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 beleggingsaanbeveling.<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>