U0VDIGNhbmNlbGxhIGxlIGFjY3VzZSBjb250cm8gaWwgQ0VPIGRpIFJpcHBsZSBHYXJsaW5naG91c2UgZSBpbCBQcmVzaWRlbnRlIExhcnNlbg==

2023-10-31, 06:16

<p><img src="https://gimg2.gateimg.com/image/article/1690791857hotspot.jpeg" alt=""><br>La SEC degli Stati Uniti ha ritirato le accuse contro Garlinghouse e Larsen.</p>
<p>La SEC ha invitato Ripple Labs a negoziare un accordo sulla sua vendita istituzionale di <a href="/price/xrp-xrp" rel="nofollow noopener noreferrer" target="_blank">XRP</a>.</p>
<p>Il 90% delle attività di Ripple si svolge al di fuori degli Stati Uniti.</p>
<p>Parole chiave: casi SEC contro Ripple, causa SEC, Ripple Labs, Ripple coin, acquista Ripple, <a href="/how-to-buy/xrp-xrp" rel="nofollow noopener noreferrer" target="_blank">acquista XRP</a>, SEC vs. Ripple, la battaglia della SEC</p>
<h2 id="h2-Introduzione732031"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>Il caso della SEC contro Ripple è in corso dal 2020, quando la Security and Exchange Commission ha intentato una causa contro Ripple Labs e i suoi dirigenti, Brad Garlinghouse, CEO di Ripple, e Chris Larsen, il Presidente esecutivo.</p>
<p>Ripple Labs ha già segnato <a href="https://www.gate.io/blog_detail/3315/ripple-scores-big-win-against-sec-2024-looks-bullish-for-xrp" target="_blank">“tre vittorie” contro la SEC</a>. Questo articolo verte sulla più recente vittoria di Ripple contro la SEC: il ritiro delle accuse dell’agenzia federale contro gli esecutivi di Ripple.</p>
<h2 id="h2-La20SEC20ritira20le20accuse20contro20Garlinghouse20Larsen987429"><a name="La SEC ritira le accuse contro Garlinghouse Larsen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>La SEC ritira le accuse contro Garlinghouse Larsen</h2><p>La SEC ha scagionato due dirigenti di Ripple Labs, Brad Garlinghouse, CEO di Ripple, e Chris Larsen, Presidente Esecutivo, da qualsiasi illecito nella battaglia legale in corso tra le due organizzazioni.</p>
<p>Secondo la denuncia della SEC, Garlinghouse e Larsen hanno aiutato Ripple Labs a violare la legge federale statunitense sui titoli. Pertanto, la SEC li ha inclusi come imputati insieme alla loro azienda, Ripple Labs.</p>
<p>Leggi anche: <a href="https://www.gate.io/blog_detail/3319" target="_blank">Il tentativo della SEC di appellare la perdita del caso Ripple è stato respinto</a></p>
<p>Tuttavia, giovedì 19 ottobre, la SEC, attraverso i suoi documenti depositati in tribunale, ha ritirato le accuse contro i due dirigenti di Ripple Labs. In effetti, il regolatore ha volontariamente respinto le accuse di favoreggiamento mosse contro di loro. Tuttavia, la SEC continuerà la sua battaglia legale contro Ripple Labs.</p>
<p>La recente dichiarazione della SEC segna la terza vittoria di Ripple Labs contro l’autorità regolatoria federale. La prima vittoria parziale di Ripple nella <a href="https://www.gate.io/br/article/25653/gate.io-blog-behind-the-scene-sec-vs.-ripple-lawsuit" target="_blank">La battaglia della SEC è avvenuta il 13 luglio</a> quando il giudice distrettuale degli Stati Uniti Analisa Torres ha stabilito che la moneta Ripple non è un titolo quando viene scambiata sulle borse.</p>
<p>Per la seconda volta, anche Ripple Labs <a href="https://www.gate.io/blog_detail/3315/ripple-scores-big-win-against-sec-2024-looks-bullish-for-xrp" target="_blank">vinto nel caso SEC vs. Ripple</a> quando il giudice Torres ha respinto l’appello interlocutorio della Securities and Exchange Commission contro la sentenza del tribunale del 13 luglio. Questa volta, la SEC ha ritirato volontariamente le accuse contro Garlinghouse e Larsen.</p>
<p>Il ritiro delle accuse della SEC contro Garlinghouse e Larsen ha portato sollievo su di loro. A riguardo, Garlinghouse ha detto,<br><strong>“Da quasi tre anni, io e Chris siamo stati oggetto di accuse infondate da un regolatore fuorilegge con un’agenda politica.”</strong></p>
<p>Ha aggiunto: ‘Invece di cercare i criminali che rubano i fondi dei clienti su scambi offshore che cercavano favori politici, la SEC si è rivolta ai bravi ragazzi - insieme a tutta la nostra azienda di innovatori e imprenditori - che stanno costruendo un’attività regolamentata basata negli Stati Uniti’.</p>
<p>Nel frattempo, sia la SEC che Ripple mirano a raggiungere un accordo amichevole. Infatti, la SEC ha dichiarato la sua intenzione di incontrare Ripple Labs e avere una discussione aperta verso un accordo sul suo istituzionale <a href="https://www.gate.io/blog_detail/3195/ripple-xrp-poised-for-a-20-price-surge-key-indicators-suggest-breakout" target="_blank">vendita di XRP</a>.</p>
<p>Nel suo recente deposito in tribunale, la SEC ha dichiarato: “La SEC e Ripple intendono incontrarsi e confrontarsi su un potenziale calendario per le memorie con riguardo alla questione pendente nel caso – quali rimedi sono appropriati contro Ripple per le sue violazioni della Sezione 5 con riguardo alle sue vendite istituzionali di XRP.”</p>
<h2 id="h2-Caso20SEC20contro20Ripple445809"><a name="Caso SEC contro Ripple" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Caso SEC contro Ripple</h2><p>Diamo brevemente un’occhiata al caso SEC vs Ripple. La battaglia della SEC contro Ripple Labs è iniziata nel dicembre 2020, quando il regolatore ha intentato una causa contro quest’ultima. La SEC ha sostenuto che Ripple Labs ha violato le leggi sulla sicurezza degli Stati Uniti vendendo <a href="/price/xrp-xrp" target="_blank" class="blog_inner_link">XRP</a> senza registrarla come titolo di sicurezza.</p>
<p>Da allora, la SEC ha mantenuto la sua posizione, affermando che la moneta Ripple soddisfa i criteri del test di Howey. Tuttavia, Ripples Labs ha sempre negato le accuse. Ecco perché, il 29 gennaio 2022, ha presentato una mozione per respingere le accuse. L’argomento di Ripple è che la moneta Ripple è una valuta in quanto funziona come mezzo di scambio.</p>
<h2 id="h2-Come20la20battaglia20della20SEC20ha20influenzato20Ripple20e20la20moneta20XRP520149"><a name="Come la battaglia della SEC ha influenzato Ripple e la moneta XRP?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Come la battaglia della SEC ha influenzato Ripple e la moneta XRP?</h2><p>La causa SEC vs. Ripple ha portato a una diminuzione dell’adozione di XRP negli Stati Uniti per diversi motivi. In primo luogo, importanti exchange come Coinbase, OKCoin e Crypto.com hanno rimosso XRP dalla loro lista, il che significa che è diventato meno accessibile alle persone rispetto a prima. Tuttavia, nel tempo alcuni exchange di criptovalute come Crypto.com lo hanno ripristinato.</p>
<p>In secondo luogo, la causa della SEC contro Ripple ha smorzato la fiducia che gli investitori avevano nella moneta XRP. Ciò ha portato a una diminuzione della sua domanda e del suo valore. Fondamentalmente, la causa legale ha generato un sentimento negativo nei confronti della moneta in alcuni settori.</p>
<p>Purtroppo, alcune aziende come MoneyGram, che avevano iniziato a utilizzare XRP per regolare transazioni finanziarie, sono state anch’esse colpite. D’altro canto, l’agenda di sviluppo di Ripple Labs legata al registro XRP è stata influenzata poiché la società ha dedicato gran parte dei suoi sforzi a gestire la questione SEC vs. Ripple.</p>
<p>Leggi anche: <a href="https://www.gate.io/price-prediction/xrp-xrp" target="_blank">Previsione del prezzo di XRP &amp; Forecast per il 2023, 2025, 2030</a></p>
<h2 id="h2-Espansione20globale20di20Ripple20oltre20il209020delle20attivit20al20di20fuori20degli20Stati20Uniti61166"><a name="Espansione globale di Ripple: oltre il 90% delle attività al di fuori degli Stati Uniti" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Espansione globale di Ripple: oltre il 90% delle attività al di fuori degli Stati Uniti</h2><p>L’incertezza causata dalla repressione delle criptovalute negli Stati Uniti ha costretto molte aziende di criptovalute ad aumentare i loro investimenti in altre regioni del mondo. Un buon esempio è quello di Ripple, che ha oltre il 90% dei suoi affari al di fuori degli Stati Uniti.</p>
<p>Già, Ripple ha stabilito sedi e unità operative in altri paesi, specialmente in Asia e nel Medio Oriente. Ad esempio, ha sedi a Dubai situate nel Dubai International Financial Centre (DIFC).</p>
<p>Dispone inoltre di unità aziendali nel<br><strong>Medio Oriente e Nord Africa (MENA), dove il 20% dei clienti di RippleNet, come Lulu Financial Holdings, Al-Ansari Exchange SABB RAK Bank e Qatar National Bank</strong> sono basati. Questi partner supervisionano i trasferimenti finanziari verso paesi come l’Arabia Saudita, l’India, gli Emirati Arabi Uniti e il Bahrain.</p>
<p>Recentemente, ha acquisito anche una licenza di istituto di pagamento a Singapore che gli consente di servire la regione Asia-Pacifico. Inoltre, Ripple offrirà servizi di pagamento regolamentati a Singapore, uno dei centri crittografici dell’Asia.</p>
<p>Riguardo a questo, Garlinghouse, CEO di Ripple, ha dichiarato: “Dal momento in cui abbiamo stabilito Singapore come nostra sede per l’Asia Pacifico nel 2017, il paese è stato fondamentale per il business globale di Ripple. Abbiamo intenzione di continuare a crescere la nostra presenza in una giurisdizione progressista come Singapore.”</p>
<h2 id="h2-Conclusione88036"><a name="Conclusione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusione</h2><p>La SEC ha scagionato due dirigenti di Ripple Labs da ogni accusa per la vendita di XRP senza registrazione. Tuttavia, la causa Ripple vs. SEC è ancora in corso e le due parti desiderano trovare un accordo amichevole. Nel frattempo, Ripple ha dichiarato che il 90% delle sue operazioni commerciali si svolge al di fuori degli Stati Uniti.</p>
<h2 id="h2-Domande20frequenti20su20Ripple691975"><a name="Domande frequenti su Ripple" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Domande frequenti su Ripple</h2><h3 id="h3-La20SEC20ha20ritirato20il20caso20contro20Ripple443884"><a name="La SEC ha ritirato il caso contro Ripple?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>La SEC ha ritirato il caso contro Ripple?</h3><p>La SEC non ha abbandonato la sua causa contro Ripple Labs. Ha solo ritirato le accuse contro i due dirigenti di Ripple Labs, Brad Garlinghouse, CEO di Ripple, e Chris Larsen, Presidente Esecutivo. La SEC proseguirà la sua causa contro Ripple Labs, accusandolo di vendere un titolo non registrato, XRP.</p>
<h3 id="h3-Chi20c20dietro20a20XRP20Ripple32258"><a name="Chi c’è dietro a XRP Ripple?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Chi c’è dietro a XRP Ripple?</h3><p>Nel 2012 Jed McCaleb, un programmatore, e Chris Larsen, un imprenditore, hanno fondato Ripple Labs, un’azienda che è dietro la criptovaluta Ripple (XRP). Brad Garlinghouse, CEO di Ripple Labs, e Chris Larsen, il presidente, gestiscono Ripple Labs e sono responsabili della moneta XRP. Leggi anche: <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">Catalizzatori che potrebbero spingere Ripple (XRP) a nuove altezze</a> a nuove altezze”)</p>
<h3 id="h3-Quanto20vale20Chris20Larsen709298"><a name="Quanto vale Chris Larsen?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Quanto vale Chris Larsen?</h3><p>Secondo Forbes, Chris Larsen, presidente di Ripple Labs e uomo d’affari americano, vale attualmente circa 2,6 miliardi di dollari. Nel 2012 Larsen ha cofondato Ripple, il che ha aumentato il suo valore. Tuttavia, Larsen possiede altre aziende come E-Loan e Prosper Marketplace.</p>
<h3 id="h3-Brad20Garlinghouse2020ancora20il20CEO20di20Ripple362429"><a name="Brad Garlinghouse è ancora il CEO di Ripple?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Brad Garlinghouse è ancora il CEO di Ripple?</h3><p>Brad Garlinghouse è ancora il CEO di Ripple. Dal 2020 la SEC ha accusato Garlinghouse insieme a Chris Larsen di aver violato la legge federale statunitense sulla sicurezza vendendo un titolo non registrato XRP. Tuttavia, di recente la SEC ha ritirato le accuse contro di loro.</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 riposting dell'articolo a condizione che si faccia riferimento a Gate.io. In tutti i casi, saranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div>