Q29zJ8OoIFhSUCBlIGNvbWUgZnVuemlvbmE/

<p><img src="https://gimg2.gateimg.com/image/article/1675160629WhatisXRPandhowdoesitwork_web.jpg" alt=""></p>
<p><strong>[TL; DR]</strong><br>🔹 Jed McCaleb ha iniziato a sviluppare la criptovaluta <a href="/price/xrp-xrp" target="_blank" class="blog_inner_link">XRP</a> e il registro pubblico XRP nel 2011.</p>
<p>🔹 XRP è più veloce, più scalabile e più efficiente dal punto di vista energetico di <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> che utilizza il meccanismo di consenso della prova del lavoro.</p>
<p>🔹 Lo scopo di XRP è consentire alle banche e ad altre istituzioni finanziarie di inviare e ricevere fondi in tutto il mondo.</p>
<p>🔹 XRP ha un’offerta preminata di 100 miliardi di monete.</p>
<h2 id="h2-Introduzione47310"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>La storia delle criptovalute è lunga, con migliaia di monete e token sul mercato. Ripple (XRP), che è presente sul mercato dal 2012, è una delle principali criptovalute.</p>
<p>Sviluppato da Ripple Labs, XRP è stato una delle prime criptovalute, creata alcuni anni dopo il lancio di <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a>. Attualmente, XRP è la sesta criptovaluta più grande con una capitalizzazione di mercato di oltre 19 miliardi di dollari. In questo articolo, copriamo la storia di XRP, per cosa viene utilizzato e come funziona.</p>
<h2 id="h2-La20storia20di20Ripple520104"><a name="La storia di Ripple" class="reference-link"></a><span class="header-link octicon octicon-link"></span>La storia di Ripple</h2><p>La storia della criptovaluta Ripple (XRP) è affascinante poiché la sua fondazione risale al 2004, ben prima che Satoshi Nakamoto sviluppasse e lanciasse <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a>. In particolare, XRP non è stato creato allo stesso modo di altre criptovalute come <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> e ETH, dove i fondatori hanno avviato i progetti da zero.</p>
<p>Il concetto di XRP è nato tra il 2004 e il 2005 quando il fondatore di Ripple, Ryan Fugger, un programmatore informatico canadese, ha sviluppato Ripple con la visione di fornire un sistema di pagamento sicuro che soddisfi le esigenze della comunità online. A tal fine, ha sviluppato Ripple Pay per facilitare il trasferimento internazionale di fondi.</p>
<p>L’avvento delle criptovalute ha creato un’opportunità per Ripple di realizzare la sua visione di essere un fornitore globale di trasferimenti di fondi veloci, sicuri e senza soluzione di continuità. Tuttavia, quella visione è stata perseguite dai rinomati imprenditori, Arthur Britto, Jed McCaleb e David Schwartz, che hanno identificato le criptovalute come un mezzo per porre fine alle inefficienze che esistono nei tradizionali sistemi di bonifico e pagamento internazionali.</p>
<p>Nel 2011 un programmatore, Jed McCaleb, ha iniziato a sviluppare il registro pubblico XRP e la criptovaluta XRP prima di reclutare un team che includeva altri investitori. È importante sottolineare che nel 2012 si è rivolto a Fugger, allora proprietario di Ripple, chiedendo di utilizzare la rete RipplePay. Fugger ha accettato il piano e ha consegnato la rete a McCaleb e al suo team.</p>
<p>In seguito, nel 2012, McCaleb e la sua squadra lanciarono il protocollo di transazione Ripple (RTXP) prima di rinominare l’azienda in Ripple Labs nel 2013. Originariamente, avevano chiamato l’azienda NewCoin prima di ribattezzarla OpenCoin e infine adottare il nome Ripple.</p>
<p>I tre ingegneri, Britto, McCaleb e Schwartz, hanno creato XRP con l’obiettivo di superare le limitazioni di <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a>. Come tale, volevano creare una criptovaluta sostenibile che fungesse da affidabile sistema di pagamento internazionale. Uno dei membri del team, Chris Larsen, si è unito al progetto nel 2012.</p>
<p>In seguito, mentre la crittografia Ripple guadagnava slancio, l’azienda ha stretto partnership con istituti finanziari. Entro il 2019, Ripple aveva collaborato con oltre 300 istituti finanziari in più di 45 paesi. Purtroppo, nel 2020 la SEC ha intentato una causa contro Ripple per la violazione della legge sulle securities degli Stati Uniti. La SEC sostiene che Ripple abbia venduto titoli non registrati quando ha messo Ripple XRP sul mercato.</p>
<h2 id="h2-Come20funziona20Ripple20XRP20Crypto186176"><a name="Come funziona Ripple XRP Crypto?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Come funziona Ripple XRP Crypto?</h2><p>La criptovaluta Ripple XRP è una criptovaluta nativa del registro pubblico XRP che utilizza l’algoritmo del consenso federato. È importante notare che Ripple non è una blockchain ma un albero hash che opera in modo simile a una blockchain poiché ha nodi che verificano le transazioni.</p>
<p>In primo luogo, le persone possono trasferire la criptovaluta XRP allo stesso modo in cui lo fanno con tutti gli altri token che possono inviare a portafogli digitali. Come previsto, le transazioni XRP sono trasparenti, permanenti, sicure e immutabili. Questo perché esistono su un registro elettronico pubblico.</p>
<h2 id="h2-Meccanismo20di20consenso20di20Ripple20XRP482166"><a name="Meccanismo di consenso di Ripple (XRP)" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Meccanismo di consenso di Ripple (XRP)</h2><p>Ripple utilizza un meccanismo di consenso basato su quorum che chiama Ripple Protocol Consensus Algorithm (RPCA) in cui i validatori selezionati devono accordarsi per verificare le transazioni. Fondamentalmente, i validatori confrontano le voci del registro e i blocchi entro 3-6 secondi. Se l’80% dei validatori raggiunge un accordo sulle transazioni, le verificano.</p>
<p>Tuttavia, se meno dell’80% dei validatori è d’accordo sulle transazioni che devono effettuare nuove proposte fino a raggiungere un consenso. Per cominciare, Ripple seleziona 35 validatori in base alle loro prestazioni precedenti. A loro volta, ciascuno dei 35 validatori seleziona un elenco di altri nodi per partecipare al processo di verifica. Questo elenco di validatori aggiuntivi è chiamato Unique Node List (UNL).</p>
<h2 id="h2-Per20cosa20viene20utilizzato20XRP822570"><a name="Per cosa viene utilizzato XRP?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Per cosa viene utilizzato XRP?</h2><p>Lo scopo principale di Ripple (XRP) è quello di consentire pagamenti in tempo reale e supportare rimesse transfrontaliere rapide ed efficienti. Infatti, il team ha creato XRP come criptovaluta per istituzioni finanziarie come le banche.</p>
<p>Utilizzando XRP, queste istituzioni sono in grado di effettuare transazioni più rapide collegate ai sistemi di denaro e di cambio di valuta estera. Pertanto, il team non prevede che le persone utilizzino XRP come mezzo di scambio per commerciare beni e servizi. Piuttosto, XRP facilita transazioni efficienti tra grandi istituzioni finanziarie.<br><img src="https://gimg2.gateimg.com/image/article/1675160787111.png" alt=""><br>XRP supporta i pagamenti internazionali- Forexlive</p>
<p>Per questo motivo, XRP migliora le transazioni veloci tra le parti. È per questo che elabora fino a 1.500 transazioni al secondo. Inoltre, queste transazioni vengono approvate entro 3-5 secondi, rendendolo uno dei registri pubblici più veloci.</p>
<p>XRP è decentralizzato e si integra bene con le applicazioni di finanza decentralizzata (DeFi). Poiché è decentralizzato, le transazioni sono garantite, standardizzate e vengono eseguite quasi istantaneamente. Questo è il motivo per cui la criptovaluta XRP ha rivoluzionato il settore finanziario.</p>
<h2 id="h2-Gli20altri20vantaggi20della20criptovaluta20Ripple287471"><a name="Gli altri vantaggi della criptovaluta Ripple" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Gli altri vantaggi della criptovaluta Ripple</h2><p>Oltre alla velocità e alla decentralizzazione, la criptovaluta XRP ha una commissione di transazione molto bassa.</p>
<p>Inoltre, gli utenti del registro Ripple possono denominare le loro transazioni in qualsiasi valuta fiat principale a loro scelta. Ad esempio, possono utilizzare il dollaro statunitense o la sterlina britannica. Questo perché il registro XRP offre un servizio di autobridging che identifica il miglior tasso di cambio in qualsiasi momento.</p>
<p>Ha anche una vasta base clienti che comprende grandi istituzioni finanziarie come Axis Bank.</p>
<h2 id="h2-XRP2020preminato281656"><a name="XRP è preminato" class="reference-link"></a><span class="header-link octicon octicon-link"></span>XRP è preminato</h2><p>Un altro fatto eccezionale sulla criptovaluta XRP è che è preminata. XRP, con un’offerta totale di 100 miliardi di monete, è stato preminato al momento del lancio. Di queste, la Ripple Lab Foundation, responsabile della rete Ripple, possiede 80 miliardi di monete che vende per finanziare ulteriori sviluppi dell’ecosistema XRP.</p>
<p>20 miliardi di criptovaluta XRP sono stati distribuiti ai fondatori del progetto. Inoltre, una piccola quantità di criptovaluta viene bruciata ogni volta che una transazione riesce. Attualmente, oltre 45 miliardi di criptovaluta XRP sono in circolazione.</p>
<h2 id="h2-Qual2020la20differenza20tra20Ripple20e20XRP7757"><a name="Qual è la differenza tra Ripple e XRP?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Qual è la differenza tra Ripple e XRP?</h2><p>Nella maggior parte dei casi, usiamo Ripple e XRP in modo intercambiabile, ma c’è una differenza. Ripple è un’azienda che ha sviluppato il registro pubblico XRP e la criptovaluta XRP. È un’azienda orientata al profitto che gestisce altri progetti oltre al registro pubblico XRP. Al contrario, XRP è una criptovaluta che supporta un sistema finanziario internazionale composto da banche e altre istituzioni correlate.</p>
<h2 id="h2-Un20confronto20di202020Bitcoin2020e20XRP618459"><a name="Un confronto di   Bitcoin  e XRP" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Un confronto di <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> e XRP</h2><p>La maggior parte delle persone è interessata a conoscere la differenza tra la criptovaluta numero uno, <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a>, e XRP. <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> utilizza il meccanismo di consenso proof-of-stake mentre XRP utilizza un algoritmo di consenso basato su Quorum.</p>
<p>Con <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a>, il primo validatore a risolvere un’equazione crittografica complessa verifica le transazioni e aggiunge il blocco alla blockchain. Tuttavia, per il registro pubblico XRP, l’80% dei validatori deve essere d’accordo per verificare una transazione.</p>
<p>Inoltre, il <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> La blockchain ricompensa il nodo che convalida e aggiunge un blocco alla rete. Al contrario, il registro XRP non ricompensa i nodi che verificano le transazioni. Il motivo per i validatori è garantire la stabilità e l’integrità della rete.</p>
<p>In secondo luogo, il libro mastro pubblico XRP è conveniente, più efficiente e più ecologico del <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> blockchain. Questo perché la rete XRP è in grado di elaborare molte transazioni al secondo con meno energia di <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> D’altra parte, il meccanismo di proof-of-work, che <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> consuma molta energia elettrica. Inoltre, poiché il libro mastro XRP elabora circa 1.500 transazioni al secondo, è più scalabile di <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Alessio</a>.<br>XRP ha un’offerta molto più elevata di <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a>. L’offerta massima di BTC è di 21 milioni, mentre XRP ha 100 miliardi di monete preminate.</p>
<h2 id="h2-Conclusione601050"><a name="Conclusione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusione</h2><p>XRP è una criptovaluta creata sul registro pubblico XRP il cui scopo principale è promuovere e sostenere un sistema finanziario globale. La criptovaluta è utilizzata dalle banche e da altre istituzioni finanziarie per inviare e ricevere fondi a livello globale. La criptovaluta XRP è più efficiente, più economica, più veloce e più ecologica di <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a>.</p>
<h2 id="h2-Domande20frequenti20su20Ripple20XRP121437"><a name="Domande frequenti su Ripple XRP" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Domande frequenti su Ripple XRP</h2><h3 id="h3-Ripple20e20XRP20sono20la20stessa20cosa826078"><a name="Ripple e XRP sono la stessa cosa?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Ripple e XRP sono la stessa cosa?</h3><p>Ripple e XRP sono differenti. Ripple è un’azienda che mira a generare profitto da diversi progetti che includono la criptovaluta XRP. D’altra parte, XRP è la criptovaluta nativa del registro pubblico XRP che è sotto la responsabilità di Ripple. L’offerta massima di XRP è di 100 miliardi.</p>
<h3 id="h3-Dove20posso20comprare20XRP34151"><a name="Dove posso comprare XRP?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Dove posso comprare XRP?</h3><p>Puoi acquistare XRP presso scambi e broker di criptovalute. Ad esempio, molti investitori lo acquistano su Gate.io, un exchange centralizzato, utilizzando P2P, carta di credito o bonifico bancario. Tuttavia, puoi anche acquistarlo dai tuoi colleghi.</p>
<h3 id="h3-Quanto2020sicuro20XRP715845"><a name="Quanto è sicuro XRP?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Quanto è sicuro XRP?</h3><p>Il registro pubblico XRP utilizza l’algoritmo di consenso basato su Quorum, in cui l’80% dei validatori deve essere d’accordo su una transazione. Poiché la rete Ripple è quasi centralizzata, i validatori vengono selezionati dai suoi clienti affidabili come banche e altre rinomate istituzioni finanziarie. L’obiettivo principale dei validatori è proteggere la rete come mezzo per proteggere i loro investimenti.</p>
<h3 id="h3-20XRP20un20buon20investimento519163"><a name="È XRP un buon investimento?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>È XRP un buon investimento?</h3><p>Nonostante XRP stia affrontando una causa legale dalla SEC, ha il potenziale per sperimentare una corsa al toro se vince la causa. Il suo attuale prezzo di mercato basso può portare a profitti elevati se il suo valore aumenta in futuro. Inoltre, oltre 300 banche accettano XRP e possono influenzare una crescita della domanda in futuro. Inoltre, la rete XRP è scalabile, veloce e sicura, il che attira gli investimenti.</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 ripostaggio 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>