U0VDIHp1aXZlcnQgUmlwcGxlIENFTyBHYXJsaW5naG91c2UgZW4gdm9vcnppdHRlciBMYXJzZW4gdmFuIGFhbmtsYWNodGVu

2023-10-31, 06:16

<p><img src="https://gimg2.gateimg.com/image/article/1690791857hotspot.jpeg" alt=""><br>De Amerikaanse SEC heeft de aanklachten tegen Garlinghouse en Larsen laten vallen.</p>
<p>De SEC heeft Ripple Labs uitgenodigd om te onderhandelen over een schikking over haar institutionele verkoop van <a href="/price/xrp-xrp" rel="nofollow noopener noreferrer" target="_blank">XRP</a>.</p>
<p>90% van de activiteiten van Ripple bevindt zich buiten de Verenigde Staten.</p>
<p>Trefwoorden: SEC-zaken tegen Ripple, SEC-rechtszaak, Ripple Labs, Ripple-munt, koop Ripple, <a href="/how-to-buy/xrp-xrp" rel="nofollow noopener noreferrer" target="_blank">koop XRP</a>, SEC vs. Ripple, SEC strijd</p>
<h2 id="h2-Introductie458483"><a name="Introductie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introductie</h2><p>De zaak van de SEC tegen Ripple loopt sinds 2020, toen de Securities and Exchange Commission een rechtszaak heeft aangespannen tegen Ripple Labs en zijn leidinggevenden, Brad Garlinghouse, de CEO van Ripple en Chris Larsen, de uitvoerend voorzitter.</p>
<p>Ripple Labs heeft al gescoord <a href="https://www.gate.io/blog_detail/3315/ripple-scores-big-win-against-sec-2024-looks-bullish-for-xrp" target="_blank">“drie overwinningen” tegen de SEC</a>. Dit artikel gaat in op de meest recente overwinning van Ripple tegen de SEC: het intrekken van de aanklachten tegen Ripple-utives.</p>
<h2 id="h2-SEC20laat20aanklachten20vallen20tegen20Garlinghouse20Larsen347115"><a name="SEC laat aanklachten vallen tegen Garlinghouse Larsen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>SEC laat aanklachten vallen tegen Garlinghouse Larsen</h2><p>De SEC heeft twee Ripple Labs utives Brad Garlinghouse, CEO van Ripple, en Chris Larsen, de uitvoerend voorzitter, vrijgepleit van enig wangedrag in de lopende juridische strijd tussen de twee organisaties.</p>
<p>Volgens de SEC-rechtszaak hebben Garlinghouse en Larsen Ripple Labs geholpen bij het overtreden van de Amerikaanse effectenwet. Daarom heeft de SEC hen samen met hun bedrijf, Ripple Labs, als verdachten opgenomen.</p>
<p>Lees ook: <a href="https://www.gate.io/blog_detail/3319" target="_blank">Poging van de SEC om het verlies in de Ripple-zaak aan te vechten afgewezen</a></p>
<p>Desalniettemin heeft de SEC op donderdag 19 oktober de aanklachten tegen de twee Ripple Labs utives laten vallen via gerechtelijke documenten. Sterker nog, de toezichthouder heeft vrijwillig de beschuldigingen van hulp en medeplichtigheid tegen hen ingetrokken. De SEC zal echter doorgaan met de juridische strijd tegen Ripple Labs.</p>
<p>De recente verklaring van de SEC markeert de derde overwinning van Ripple Labs tegen de federale toezichthouder. De eerste gedeeltelijke overwinning van Ripple in de <a href="https://www.gate.io/br/article/25653/gate.io-blog-behind-the-scene-sec-vs.-ripple-lawsuit" target="_blank">De SEC-strijd was op 13 juli</a> toen de Amerikaanse districtsrechter Analisa Torres oordeelde dat de Ripple-munt geen effect is wanneer deze op beurzen wordt verhandeld.</p>
<p>Voor de tweede keer ook Ripple Labs <a href="https://www.gate.io/blog_detail/3315/ripple-scores-big-win-against-sec-2024-looks-bullish-for-xrp" target="_blank">gewonnen in de SEC vs. Ripple zaak</a> toen rechter Torres het tussenberoep van de Securities and Exchange Commission tegen de uitspraak van 13 juli verwierp. Deze keer heeft de SEC vrijwillig de aanklachten tegen Garlinghouse en Larsen ingetrokken.</p>
<p>Het intrekken van de aanklachten van de SEC tegen Garlinghouse en Larsen bracht opluchting voor hen. In dat verband zei Garlinghouse,<br><strong>“Al bijna drie jaar zijn Chris en ik het onderwerp geweest van ongegronde beschuldigingen van een losgeslagen toezichthouder met een politieke agenda.”</strong></p>
<p>Hij voegde eraan toe: ‘In plaats van op zoek te gaan naar criminelen die klantfondsen stelen op offshore-beurzen die politieke steun zoeken, richtte de SEC zich op de goede mensen - samen met ons hele bedrijf van vernieuwers en ondernemers - die een gereguleerde onderneming opbouwen op basis van de VS.’</p>
<p>Intussen streven zowel de SEC als Ripple naar een vriendschappelijke schikking. Inderdaad, de SEC heeft verklaard dat het van plan is om Ripple Labs te ontmoeten en een open discussie te voeren naar een schikking over zijn institutionele <a href="https://www.gate.io/blog_detail/3195/ripple-xrp-poised-for-a-20-price-surge-key-indicators-suggest-breakout" target="_blank">verkoop van XRP</a>.</p>
<p>In zijn recente gerechtelijke indiening zei de SEC: “De SEC en Ripple zijn van plan om bijeen te komen en te overleggen over een mogelijke briefingplanning met betrekking tot het hangende probleem in de zaak - welke remedies passend zijn tegen Ripple voor zijn schendingen van artikel 5 met betrekking tot zijn Institutionele verkoop van XRP.”</p>
<h2 id="h2-SECzaak20tegen20Ripple241430"><a name="SEC-zaak tegen Ripple" class="reference-link"></a><span class="header-link octicon octicon-link"></span>SEC-zaak tegen Ripple</h2><p>Laten we kort kijken naar de zaak SEC vs. Ripple. De strijd van de SEC tegen Ripple Labs begon in december 2020 toen de toezichthouder een rechtszaak tegen laatstgenoemde indiende. De SEC beweerde dat Ripple Labs de Amerikaanse effectenwetten had geschonden door <a href="/price/xrp-xrp" target="_blank" class="blog_inner_link">XRP</a> te verkopen zonder het als effect te registreren.</p>
<p>Sindsdien heeft de SEC haar standpunt gehandhaafd en beweerd dat de Ripple-munt aan de criteria van de Howey-test voldoet. Ripples Labs heeft echter altijd de beschuldigingen ontkend. Daarom heeft het op 29 januari 2022 een verzoek ingediend om de aanklachten te laten vallen. Het argument van Ripple is dat de Ripple-munt een valuta is, omdat het fungeert als een ruilmiddel.</p>
<h2 id="h2-Hoe20de20SECstrijd20Ripple20en20XRP20Coin20heeft20benvloed900505"><a name="Hoe de SEC-strijd Ripple en XRP Coin heeft beïnvloed?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Hoe de SEC-strijd Ripple en XRP Coin heeft beïnvloed?</h2><p>De zaak SEC vs. Ripple heeft geleid tot een daling van de adoptie van XRP in de Verenigde Staten om verschillende redenen. Ten eerste hebben grote beurzen zoals Coinbase, OKCoin en Crypto.com XRP uit de handel genomen, wat betekent dat het minder toegankelijk werd voor mensen dan voorheen. Echter, met de tijd hebben sommige crypto-beurzen zoals Crypto.com het weer op de lijst gezet.</p>
<p>Ten tweede heeft de rechtszaak van de SEC tegen Ripple het vertrouwen dat investeerders hadden in de XRP-munt doen afnemen. Dat leidde tot een afname van de vraag en de waarde ervan. Kortom, de rechtszaak resulteerde in een negatief sentiment tegen de munt onder sommige sectoren.</p>
<p>Helaas werden sommige bedrijven, zoals MoneyGram, die begonnen waren met het gebruik van XRP voor het afhandelen van financiële transacties, ook getroffen. Aan de andere kant werd het ontwikkelingsprogramma van Ripple Labs met betrekking tot het XRP grootboek beïnvloed doordat het bedrijf veel van zijn inspanningen richtte op de afhandeling van de SEC vs. Ripple-kwestie.</p>
<p>Lees ook: <a href="https://www.gate.io/price-prediction/xrp-xrp" target="_blank">XRP Prijsvoorspelling &amp; Prognose voor 2023, 2025, 2030</a></p>
<h2 id="h2-Wereldwijde20uitbreiding20van20Ripple20meer20dan209020van20de20zaken20buiten20de20Verenigde20Staten60189"><a name="Wereldwijde uitbreiding van Ripple: meer dan 90% van de zaken buiten de Verenigde Staten" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wereldwijde uitbreiding van Ripple: meer dan 90% van de zaken buiten de Verenigde Staten</h2><p>De onzekerheid die de crypto-crackdown in de Verenigde Staten heeft veroorzaakt, heeft veel cryptocurrency-bedrijven gedwongen hun investeringen in andere regio’s van de wereld te verhogen. Een goed voorbeeld hiervan is Ripple, dat meer dan 90% van zijn zaken buiten de VS heeft.</p>
<p>Ripple heeft al kantoren en operationele eenheden opgezet in andere landen, vooral in Azië en het Midden-Oosten. Zo heeft het kantoren in Dubai, gevestigd in het Dubai International Financial Centre (DIFC).</p>
<p>Het heeft ook bedrijfseenheden in de<br><strong>Het Midden-Oosten en Noord-Afrika (MENA) waar 20% van de RippleNet-klanten, zoals Lulu Financial Holdings, Al-Ansari Exchange SABB RAK Bank en Qatar National Bank, zich bevinden</strong> zijn gebaseerd. Deze partners zorgen voor financiële overboekingen naar landen als Saudi-Arabië, India, de VAE en Bahrein.</p>
<p>Onlangs heeft het ook een vergunning voor een betalingsinstelling verworven in Singapore, waardoor het de Aziatisch-Pacifische regio kan bedienen. Bovendien zal Ripple gereguleerde betalingsdiensten aanbieden in Singapore, een van de crypto-hubs van Azië.</p>
<p>In dit opzicht zei Garlinghouse, de CEO van Ripple: “Sinds de oprichting van Singapore als ons hoofdkantoor voor de regio Azië-Pacific in 2017, is het land cruciaal geweest voor de wereldwijde activiteiten van Ripple. We zijn van plan onze aanwezigheid uit te breiden in een progressieve jurisdictie zoals Singapore.”</p>
<h2 id="h2-Conclusie314437"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>De SEC heeft twee leidinggevenden van Ripple Labs vrijgesproken van enige misdrijven bij de verkoop van XRP zonder registratie. Het Ripple vs. SEC-zaak is echter nog steeds gaande en beide partijen willen een vriendschappelijke schikking bereiken. Ondertussen heeft Ripple verklaard dat 90% van haar bedrijfsactiviteiten buiten de Verenigde Staten plaatsvindt.</p>
<h2 id="h2-Veelgestelde20vragen20over20Ripple610149"><a name="Veelgestelde vragen over Ripple" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Veelgestelde vragen over Ripple</h2><h3 id="h3-Heeft20de20SEC20de20zaak20tegen20Ripple20laten20vallen323366"><a name="Heeft de SEC de zaak tegen Ripple laten vallen?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Heeft de SEC de zaak tegen Ripple laten vallen?</h3><p>De SEC heeft zijn zaak tegen Ripple Labs niet laten vallen. Het heeft alleen zijn beschuldigingen tegen de twee leidinggevenden van Ripple Labs, Brad Garlinghouse, CEO van Ripple, en Chris Larsen, de uitvoerend voorzitter, ingetrokken. De SEC zal verder gaan met zijn zaak tegen Ripple Labs, waarvan het beschuldigt van de verkoop van een niet-geregistreerde effect, XRP.</p>
<h3 id="h3-Wie20zit20er20achter20XRP20Ripple779217"><a name="Wie zit er achter XRP Ripple?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wie zit er achter XRP Ripple?</h3><p>In 2012 begonnen Jed McCaleb, een programmeur, en Chris Larsen, een ondernemer, Ripple Labs, een bedrijf dat achter Ripple crypto (XRP) staat. Brad Garlinghouse, CEO van Ripple Labs, en Chris Larsen, de voorzitter, beheren Ripple Labs en zijn verantwoordelijk voor de XRP-munt. Lees ook: <a href="https://www.gate.io/blog_detail/3287/catalysts-that-could-propel-ripple-xrp-to-new-heights-in-2023" target="_blank">Katalysatoren die Ripple (XRP) naar nieuwe hoogten kunnen brengen</a></p>
<h3 id="h3-Hoeveel20is20Chris20Larsen20waard387695"><a name="Hoeveel is Chris Larsen waard?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Hoeveel is Chris Larsen waard?</h3><p>Volgens Forbes is Chris Larsen, voorzitter van Ripple Labs en een Amerikaanse zakenman, momenteel ongeveer $2,6 miljard waard. In 2012 mede-oprichtte Larsen Ripple, wat zijn waarde heeft verhoogd. Echter, Larsen bezit ook andere ondernemingen zoals E-Loan en Prosper Marketplace.</p>
<h3 id="h3-Is20Brad20Garlinghouse20nog20steeds20de20CEO20van20Ripple754252"><a name="Is Brad Garlinghouse nog steeds de CEO van Ripple?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Is Brad Garlinghouse nog steeds de CEO van Ripple?</h3><p>Brad Garlinghouse is nog steeds de CEO van Ripple. Sinds 2020 heeft de SEC Garlinghouse samen met Chris Larsen beschuldigd van het schenden van de Amerikaanse effectenwetgeving door de verkoop van een niet-geregistreerde beveiliging XRP. Onlangs heeft de SEC echter de aanklachten tegen hen laten vallen.</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 mening van de onderzoeker en vormt geen enkele beleggingssuggestie.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het opnieuw plaatsen van het artikel is toegestaan op voorwaarde dat Gate.io wordt vermeld. In alle glen zal er juridische actie worden ondernomen wegens inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div>