WFJQIHNhbGUgYWwgNMKwIHBvc3RvIHRyYSBsZSBjcmlwdG92YWx1dGUgZG9wbyBpbCB0cmlvbmZvIGRlbGxhIFNFQyBkaSBSaXBwbGU=

2023-07-25, 08:08

<p><img src="https://gimg2.gateimg.com/blog/1679447253155655279redian.jpeg" alt=""></p>
<h2 id="h2-TL20DR406905"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p>La sentenza del tribunale degli Stati Uniti su <a href="/price/xrp-xrp" rel="nofollow noopener noreferrer" target="_blank">XRP</a> creato molto <a href="/price/optimism-op" rel="nofollow noopener noreferrer" target="_blank">Ottimismo</a> nel mercato delle criptovalute che ha portato all’impennata dei prezzi di diverse delle principali criptovalute.</p>
<p>Dopo la sentenza del tribunale, <a href="/price/xrp-xrp" target="_blank" class="blog_inner_link">XRP</a> è passato dalla 7ª posizione alla 4ª posizione nella classifica delle criptovalute.</p>
<p>Diverse criptovalute, tra cui Gemini, Coinbase, Bitstamp e Kraken, hanno promesso di ri-elencare XRP.</p>
<h2 id="h2-Introduzione188061"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>Ripple’s <a href="https://www.gate.io/blog_detail/2927/ripple-price-after-victory" target="_blank">vincere contro la causa della SEC</a> ha portato ad un aumento astronomico del valore del <a href="/price/xrp-xrp" rel="nofollow noopener noreferrer" target="_blank">criptovaluta XRP</a>. Ciò segue la battaglia legale tra la SEC e Ripple che si è protratta dal 2020 al 2023. Nel 2020 la SEC ha citato in giudizio Ripple accusando la sua criptovaluta, XRP, di essere una sicurezza crittografica. In questa analisi, discutiamo come il parziale trionfo di Ripple contro la SEC abbia portato alla <a href="/price/xrp-xrp" rel="nofollow noopener noreferrer" target="_blank">Prezzo XRP</a> surge.</p>
<h2 id="h2-XRP20Occupato20il2042020posto20nelle20classifiche20globali20delle20criptovalute961394"><a name="XRP Occupato il 4 ° posto nelle classifiche globali delle criptovalute" class="reference-link"></a><span class="header-link octicon octicon-link"></span>XRP Occupato il 4 ° posto nelle classifiche globali delle criptovalute</h2><p>La criptovaluta focalizzata sui pagamenti, Ripple (XRP), ha superato <a href="/price/bnb-bnb" rel="nofollow noopener noreferrer" target="_blank">BNB</a> in termini di capitalizzazione di mercato occupare la 4a posizione nelle classifiche mondiali delle criptovalute. In realtà, la capitalizzazione di mercato di XRP è aumentata di $21,2 miliardi a un nuovo massimo di $46,1 miliardi. Con un tale aumento della capitalizzazione di mercato, ha superato sia Circle’s <a href="/price/usd-coin-usdc" rel="nofollow noopener noreferrer" target="_blank">USD Coin</a>(USDC) e Binance’s <a href="/price/bnb-bnb" target="_blank" class="blog_inner_link">BNB</a> (BNB) diventeranno la nuova criptovaluta classificata al 4° posto.</p>
<p>Di fatto, la capitalizzazione di mercato di XRP è cresciuta del 84% a seguito della parziale vittoria di Ripple Labs contro la Securities and Exchange Commission il 13 luglio. Al 14 luglio, XRP aveva una capitalizzazione di mercato di $42.5 miliardi.</p>
<h2 id="h2-XRP2020un20Crypto20Security482009"><a name="XRP è un Crypto Security" class="reference-link"></a><span class="header-link octicon octicon-link"></span>XRP è un Crypto Security</h2><p><a href="https://www.gate.io/price-prediction/xrp-xrp" target="_blank">Il prezzo di XRP</a> è aumentato rapidamente dopo che Analisa Torres, il giudice del Tribunale distrettuale per il Distretto meridionale di New York, ha stabilito che la vendita di criptovalute Ripple su scambi di criptovalute non ne fa un contratto di investimento o una sicurezza crittografica.</p>
<p>Il tribunale ha dichiarato che XRP diventa una security solo quando viene venduto a investitori istituzionali, caso in cui soddisfa i criteri del test di Howey. Questa decisione del tribunale era contraria alla causa intentata dalla SEC che cercava di costringere Ripple Labs a smettere di offrire il suo token XRP senza registrazione poiché lo considerava una criptovaluta di sicurezza.</p>
<p>Poiché la sentenza del tribunale specifica chiaramente che XRP non è un titolo crittografico se viene scambiato su scambi crittografici e tramite algoritmi, diversi scambi crittografici come Gemini, Kraken e Bitstamp hanno annunciato la loro intenzione di rilistarlo.</p>
<p>A tal proposito, Coinbase non ha perso molto tempo annunciando che presto riincluderà XRP una volta che ci sarà liquidità. Ha intenzione di avere diverse coppie tra cui XRP-USD, XRP-EUR e XRP-USDT.</p>
<p>Un’altra importante borsa di criptovalute, Gemini, mira a sfruttare la chiarezza emersa dalla sentenza per elencare XRP sia per il trading spot che per il trading derivato.</p>
<p>Kraken, un’altra importante cripto-borsa, ha reso disponibile il trading di XRP ai suoi clienti con sede negli Stati Uniti con effetto immediato. Ciò dimostra che Kraken ha fiducia nella recente sentenza del tribunale.</p>
<p>Un’altra exchange di criptovalute affidabile, Bitstamp, ha espresso il suo interesse a rilistare XRP il prima possibile. Poiché Ripple Labs, l’azienda proprietaria di XRP, ha una quota in Bitstamp, la quotazione del token XRP ha molta importanza per l’exchange di criptovalute.</p>
<p>Leggi anche: <a href="https://www.gate.io/blog_detail/2101/bitcoin-vs.-ripple-what-s-the-difference" target="_blank">Bitcoin vs. Ripple: Qual è la differenza?</a></p>
<h2 id="h2-Movimento20del20prezzo20di20XRP20dopo20la20sentenza20del20tribunale587553"><a name="Movimento del prezzo di XRP dopo la sentenza del tribunale" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Movimento del prezzo di XRP dopo la sentenza del tribunale</h2><p>Secondo TradingView <a href="https://www.gate.io/price/xrp-xrp" target="_blank">valore di XRP</a> è aumentato di circa il 98% poche ore dopo la sentenza del tribunale per essere scambiato a $0,93. In realtà, c’è stata molta fretta di acquistare Ripple che ha causato un ingorgo sullo scambio di criptovalute statunitense Uphold. Di conseguenza, lo scambio è stato bloccato per un breve periodo a causa dell’“aumento di volume del 50x.”</p>
<p>Non c’è dubbio che ci sia stata molta attività di trading su Uphold, considerando che era uno degli ultimi scambi con sede negli Stati Uniti che continuava a offrire XRP al pubblico.</p>
<p>È importante notare che l’aumento del valore di XRP ha influenzato i prezzi di altre criptovalute, inclusa BNB. L’aumento di XRP’s <a href="/price/theta-network-theta" rel="nofollow noopener noreferrer" target="_blank">Prezzo della rete Theta</a> coinciso con una diminuzione del valore di BNB. Non è chiaro se ci fosse o meno una relazione diretta tra i due. Tuttavia, è importante notare anche che prima della sentenza del tribunale XRP la capitalizzazione di mercato di BNB era il doppio di quella di XRP.</p>
<p>Nel frattempo, diversi rappresentanti di Ripple hanno accolto la decisione come positiva e conforme alle loro aspettative. Ad esempio, Garlinghouse <a href="https://twitter.com/bgarlinghouse/status/1679520607837253639?s=20" rel="nofollow noopener noreferrer" target="_blank">tweetato</a> <em>“Abbiamo detto a dicembre 2020 che eravamo dalla parte della legge, e saremo dalla parte della storia. Grati a tutti coloro che ci hanno aiutato ad arrivare alla decisione di oggi - una decisione che riguarda tutta l’innovazione criptografica negli Stati Uniti. Ci saranno altre novità.”</em></p>
<h2 id="h2-Conclusione876860"><a name="Conclusione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusione</h2><p>La notizia della vittoria parziale di XRP contro la SEC statunitense ha fatto aumentare il valore di diverse criptovalute di cifre doppie. In particolare, il prezzo di XRP è aumentato di circa il 98% portando a una capitalizzazione di mercato di 46,1 miliardi di dollari. Nel frattempo, diverse criptovalute hanno promesso di rimettere in lista XRP in seguito alla chiarificazione della regolamentazione criptata in materia di titoli emessa dalla sentenza del tribunale.</p>
<h2 id="h2-Domande20frequenti20su20XRP632865"><a name="Domande frequenti su XRP" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Domande frequenti su XRP</h2><h3 id="h3-Ripple20ha20vinto20la20causa20della20SEC912269"><a name="Ripple ha vinto la causa della SEC?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Ripple ha vinto la causa della SEC?</h3><p><a href="https://www.gate.io/blog_detail/601/behind-the-scene-sec-vs.-ripple-lawsuit" target="_blank">Ripple ha avuto una vittoria parziale contro la SEC</a> dal momento che la sentenza del tribunale ha dichiarato che le monete XRP scambiate su scambi di criptovalute e tramite algoritmi non costituiscono titoli. Tuttavia, ha stabilito che quando le monete XRP vengono vendute direttamente a investitori istituzionali loro <a href="https://www.gate.io/uk/blog_detail/2708/sec-labels-37-cryptocurrencies-as-securities-implications-for-trading" target="_blank">diventare titoli</a>.</p>
<h3 id="h3-Perch20XRP20non2020considerato20un20titolo978522"><a name="Perché XRP non è considerato un titolo?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Perché XRP non è considerato un titolo?</h3><p>Le monete XRP offerte attraverso scambi di criptovalute e algoritmi non sono contratti di investimento. Pertanto, non sono titoli crittografici. Solo le monete XRP vendute direttamente agli investitori sono titoli.</p>
<h3 id="h3-Qual2020il20caso20Ripple20con20la20SEC379260"><a name="Qual è il caso Ripple con la SEC?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Qual è il caso Ripple con la SEC?</h3><p>La SEC ha citato in giudizio Ripple con il pretesto che ha venduto XRP senza registrarla come titolo. Secondo Ripple, la maggior parte delle altcoin sono titoli in base ai criteri del Test di Howey. Tuttavia, un tribunale statunitense ha stabilito che le monete XRP vendute sugli scambi di criptovalute non sono titoli.</p>
<h3 id="h3-Perch20Ripple2020salito20oggi275433"><a name="Perché Ripple è salito oggi?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Perché Ripple è salito oggi?</h3><p>La parziale vittoria di Ripple contro la SEC statunitense ha portato al suo forte aumento di prezzo il 14 luglio 2023. Quando diversi exchange di criptovalute hanno promesso di rimettere in vendita <a href="https://www.gate.io/price/xrp-xrp" target="_blank">XRP, il suo prezzo</a> ha continuato a salire.</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 ripubblicare l'articolo a condizione che venga citato Gate.io. In tutti i casi, verranno intraprese azioni legali a causa della violazione del copyright.<br></div><p></p><br></div></div></div>