SWwgdGVudGF0aXZvIGRlbGxhIFNFQyBkaSBhcHBlbGxhcnNpIGFsbGEgcGVyZGl0YSBkZWwgY2FzbyBSaXBwbGUgw6ggc3RhdG8gcmVzcGludG8=

2023-10-18, 08:33

<p><img src="https://gimg2.gateimg.com/image/article/1690791857hotspot.jpeg" alt=""></p>
<h2 id="h2-TL20DR378875"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p>Di recente la giudice distrettuale Analisa Torres ha respinto il tentativo della SEC di appellarsi contro la sentenza del caso Ripple.</p>
<p>La SEC ha sostenuto che la sentenza del tribunale potrebbe influire sulle altre cause correlate.</p>
<p>Il processo completo della SEC vs. Ripple inizierà ad aprile 2024.</p>
<h2 id="h2-Introduzione711708"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>Il caso della Securities and Exchange Commission (SEC) degli Stati Uniti contro Ripple Labs (Ripple) è diventato la causa SEC più prolungata nella storia delle criptovalute e della blockchain. Si protrae dal dicembre 2020 ed è probabile che continui fino al 2024.</p>
<p>Questo post copre lo sfondo del <a href="https://www.gate.io/blog_detail/2960/xrp-climbs-on-the-4th-spot-among-cryptocurrencies-following-ripple-s-sec-triumph" target="_blank">Cause legale SEC vs. Ripple</a> nonché le ragioni dell’impugnazione della SEC contro la sua sconfitta.</p>
<h2 id="h2-Azione20della20SEC20contro20la20causa20di20Ripple956184"><a name="Azione della SEC contro la causa di Ripple" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Azione della SEC contro la causa di Ripple</h2><p>Di recente, il giudice distrettuale Analisa Torres ha respinto il tentativo della Security and Exchange Commission degli Stati Uniti di appellare la sua sconfitta contro Ripple Labs, l’azienda di criptovalute che possiede Ripple (XRP). <a href="/price/xrp-xrp" rel="nofollow noopener noreferrer" target="_blank">XRP</a>). La giudice Analisa Torres ha stabilito che la SEC non è riuscita a dimostrare che ci fossero motivi sostanziali di differenze o questioni di diritto convincenti e vincolanti.</p>
<p>Fondamentalmente, il <a href="https://www.gate.io/article/25653/gate.io-blog-behind-the-scene-sec-vs.-ripple-lawsuit" target="_blank">reiezione dell’appello SEC vs. Ripple</a> è un altro duro colpo per la Securities and Exchange Commission degli Stati Uniti e un’altra grande vittoria per Ripple e per l’intero settore delle criptovalute. Secondo l’ordinanza, la SEC avrebbe dovuto presentare ricorso contro le conclusioni del giudice Torres sulle vendite programmatiche di <a href="/price/xrp-xrp" target="_blank" class="blog_inner_link">XRP</a> e altre distribuzioni, in cui Ripple ha utilizzato la criptovaluta per effettuare diversi pagamenti per i servizi offerti.</p>
<p>Inoltre, il giudice ha sostenuto che l’appello della SEC non aiuterebbe ad avanzare il caso verso una conclusione. L’ordine legge, “La richiesta della SEC di certificazione dell’appello interlocutorio è respinta”.</p>
<p>Tuttavia, l’ordine del giudice di distretto Torres contro l’appello della SEC non significa che Ripple abbia vinto la causa. Secondo la legge cripto degli Stati Uniti, è probabile che il caso SEC contro Ripple sia concluso nel 2024 dopo ulteriori sessioni di tribunale. In effetti, il giudice Torres ha fissato il 23 aprile 2024 come data per il processo finale.</p>
<p>Tuttavia, la SEC avrà un’altra possibilità di appellarsi contro la decisione complessiva nel caso in cui dovesse perdere contro Ripple.</p>
<p>Leggi anche: <a href="https://www.gate.io/blog_detail/1374/why-people-think-sec-is-indecisive-on-which-crypto-assets-are-securities" target="_blank">Perché le persone pensano che la SEC sia indecisa su quali cripto-attività siano titoli</a></p>
<h2 id="h2-Contesto20sulla20battaglia20di20Ripple803414"><a name="Contesto sulla battaglia di Ripple" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Contesto sulla battaglia di Ripple</h2><p>Nel dicembre 2020, la SEC ha intentato una causa contro Ripple, sostenendo che ha effettuato una vendita di titoli non registrati. <a href="https://www.gate.io/learn/articles/what-is-xrp/225" target="_blank">XRP</a>. Secondo la causa, Ripple Labs ha violato le sezioni 5(a) e 5(c) del Securities Act del 1933 vendendo Ripple crypto che è stato considerato un titolo che avrebbe dovuto essere registrato prima di essere venduto agli investitori e al pubblico.</p>
<p>Quella causa legale ha avuto un impatto significativo sul valore della moneta XRP, che era uno dei principali asset crittografici dell’epoca. La sua capitalizzazione di mercato, che era di circa 27 miliardi di dollari, è scesa a circa 16 miliardi di dollari. Tuttavia, subito dopo la causa legale della SEC, Ripple ha annunciato che avrebbe combattuto.</p>
<p>La controversia riguardava se Ripple (XRP) dovesse essere considerato un contratto di investimento. Tuttavia, non vi è alcuna definizione di contratto di investimento nelle normative federali sui titoli. Invece, il tribunale utilizza i criteri del Test di Howey, stabiliti nel 1946, per valutare se uno strumento di investimento è un titolo o meno.</p>
<p>La SEC ha sostenuto che le persone che hanno acquistato XRP si aspettavano di ottenere un rendimento da esso. Afferma che i rendimenti che gli investitori avrebbero ottenuto dipendevano dalle attività promozionali di Ripple Labs.</p>
<p>Ha inoltre sostenuto che Ripple ha pubblicizzato che gli investitori potessero vendere l’attività crittografica sui mercati secondari per generare profitto. Sulla base di tali motivi, la SEC ritiene che XRP sia un titolo.</p>
<h2 id="h2-Sentenza20del20tribunale50097"><a name="Sentenza del tribunale" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Sentenza del tribunale</h2><p>Il 13 luglio 2023, il giudice distrettuale degli Stati Uniti Analisa Torres ha annunciato una sentenza contro Ripple Labs e i suoi due dirigenti senior Christian A. Larsen (co-fondatore di Ripple, ex CEO e attuale presidente esecutivo) e Bradley Garlinghouse (attuale CEO di Ripple). La corte ha affermato che se XRP è o meno una criptovaluta sicura dipende dal modo in cui gli investitori l’hanno acquisita.</p>
<p>Ha dichiarato che le vendite programmatiche di XRP e altre distribuzioni non rendono la criptovaluta Ripple un titolo, poiché non soddisfano i criteri del test di Howey. Con la vendita programmata di XRP, Ripple Labs non conosceva le persone che stavano acquistando la sua criptovaluta. Questo perché sono state vendute al pubblico attraverso gli exchange. D’altra parte, il <a href="https://www.gate.io/how-to-buy/xrp-xrp" target="_blank">Acquirenti di XRP</a> non aveva conoscenza completa dell’azienda o dell’individuo che lo vendeva.</p>
<p>Nel caso di Ripple, l’altro caso si riferiva alle monete XRP che sono state date ai dipendenti per i loro servizi. Secondo la sentenza del tribunale, tali pagamenti non rendono XRP un titolo perché i dipendenti non hanno pagato alcun denaro per acquistarli. Pertanto, non costituiscono un contratto di investimento.</p>
<p>Tuttavia, la vendita di XRP agli investitori istituzionali rende XRP un titolo. Ciò perché gli investitori hanno pagato la criptovaluta Ripple utilizzando varie valute legali, che soddisfa i criteri di investimento del test di Howey. Inoltre, la fortuna degli investitori individuali era legata al successo di Ripple.</p>
<h2 id="h2-La20decisione20della20SEC20di20appellarsi20alla20sentenza20del20tribunale606811"><a name="La decisione della SEC di appellarsi alla sentenza del tribunale" class="reference-link"></a><span class="header-link octicon octicon-link"></span>La decisione della SEC di appellarsi alla sentenza del tribunale</h2><p>La SEC aveva le sue ragioni per appellarsi alla sentenza del tribunale della battaglia SEC vs. Ripple. In primo luogo, la SEC ha detto che la questione richiedeva un’attenzione immediata perché influisce sugli esiti di altri casi, compresi quelli contro Coinbase Global Inc. e Binance Holdings Ltd.</p>
<p>Ha anche sottolineato che c’era un’incoerenza da parte del tribunale su ciò che costituisce una cripto sicurezza. Ciò è dovuto al fatto che la visione del giudice federale di Manhattan Jed Rakoff contrasta con quella di 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">riflesso nel caso SEC contro Terraform Labs</a>.</p>
<p>L’altro argomento della SEC è che la sentenza del tribunale nel caso Ripple crea una “distinzione artificiale” tra gli investitori al dettaglio e quelli istituzionali. In altre parole, la sentenza crea standard diversi per gli investitori istituzionali e quelli al dettaglio. Di conseguenza, sostiene che la sentenza “trasforma impropriamente l’indagine dell’investitore ragionevole di Howey in una soggettiva e ribalta il ragionamento alla base di Howey e altri casi.</p>
<p>Secondo la SEC, a causa delle suddette differenze diventa difficile conciliare con le disposizioni fondamentali della legge sui titoli. A riguardo, la SEC ha affermato: “Infine, la logica sottostante alla decisione su Ripple si discosta dai principi di base di Howey e delle leggi federali sui titoli in modo più ampio.”</p>
<p>Notizie correlate: <a href="https://www.gate.io/blog_detail/3287/catalysts-that-could-propel-ripple-xrp-to-new-heights-in-2023" target="_blank">Catalizzatori che potrebbero spingere Ripple (XRP) verso nuove vette nel 2023</a></p>
<h2 id="h2-Cronologia20della20controversia20legale20tra20Ripple20e20la20SEC232492"><a name="Cronologia della controversia legale tra Ripple e la SEC" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Cronologia della controversia legale tra Ripple e la SEC</h2><p>Molti esperti di criptovalute e analisti ritengono che Ripple non abbia ancora vinto la causa poiché ci saranno altre udienze in aprile 2024. Preston Byrne, imprenditore e socio commerciale presso Brown Rudnick, ha detto che la SEC sta ancora esaminando il caso e ha ancora una possibilità di vincere contro Ripple Labs.</p>
<p>Preston Byrne ha detto “La sentenza di sintesi di Ripple ovviamente non è l’ultima parola sulla questione. Anche se il caso finisce così, Ripple ha ancora “miliardi di dollari di vendite istituzionali per cui sono responsabili.”</p>
<p>La battaglia SEC vs. Ripple avrà termine nell’aprile 2024 quando ci si aspetta che il tribunale emetta la sua sentenza definitiva. Nel frattempo, la SEC sta ancora valutando la propria posizione e potrebbe presentare altri argomenti convincenti per vincere la causa.</p>
<p>Secondo alcuni analisti come Yassin Mobarak, imprenditore, la SEC potrebbe ritirare la sua causa contro Ripple prima della sessione finale del tribunale. Di recente ha detto: “Ora si muoveranno per chiudere questo caso il prima possibile in modo da poter fare appello al secondo circuito e continuare a sostenere questa nube di incertezza nell’intera industria. La causa legale, di per sé, indipendentemente dall’esito, è l’arma.”</p>
<h2 id="h2-Conclusion949421"><a name="Conclusion" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusion</h2><p>La Securities and Exchange Commission degli Stati Uniti (SEC) ha perso il suo tentativo di appellarsi contro la sentenza del caso SEC vs. Ripple. Il giudice distrettuale Analisa Torres ha stabilito che la SEC non è riuscita a dimostrare fondamenti sostanziali di differenze. Nel frattempo, il giudice Torres ha fissato il 23 aprile 2024 come data di inizio del processo SEC vs. Ripple.</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 suggerimenti di investimento.<br></em><div><em></em>Gate.io si riserva tutti i diritti su questo articolo. Sarà consentito il ripostaggio dell'articolo a condizione che venga citato Gate.io. In tutti i casi, saranno intraprese azioni legali a causa della violazione del copyright.<br></div><p></p><br></div></div></div>