QmFuY2EgY2VudHJhbGUgaW5kaWFuYSBlc3Bsb3JhIGwnSUEgcGVyIGkgcGFnYW1lbnRpIGlzdGFudGFuZWk=

2023-08-22, 13:04

<p><img src="https://gimg2.gateimg.com/image/article/1692709194RDZZ 1.jpeg" alt=""></p>
<h2 id="h2-In20poche20parole656756"><a name="In poche parole" class="reference-link"></a><span class="header-link octicon octicon-link"></span>In poche parole</h2><p>La banca centrale dell’India sta lavorando per integrare un impianto di pagamento conversazionale basato sull’IA con UPI.</p>
<p>L’India sta conducendo un programma pilota della sua valuta digitale della banca centrale (CBDC).</p>
<p>In India non esiste un divieto legale sulle criptovalute, anche se non esiste una regolamentazione per governarle.</p>
<h2 id="h2-Introduzione94909"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>Il ruolo dell’intelligenza artificiale nelle imprese è aumentato dal 2021. In passato recente, l’IA è stata introdotta nel settore delle criptovalute, dove diverse blockchain la utilizzano per migliorare la sicurezza e offrire prodotti unici.</p>
<p>Di conseguenza, esiste una nuova categoria di cripto-attività chiamate criptovalute AI, fornite da blockchain che utilizzano l’intelligenza artificiale. Questo articolo discute come la Banca Centrale Indiana mira a integrare l’IA nell’interfaccia di pagamenti unificata (UPI).</p>
<h2 id="h2-La20Reserve20Bank20of20India20utilizzer20lintelligenza20artificiale20per20i20pagamenti20UPI635310"><a name="La Reserve Bank of India utilizzerà l’intelligenza artificiale per i pagamenti UPI" class="reference-link"></a><span class="header-link octicon octicon-link"></span>La Reserve Bank of India utilizzerà l’intelligenza artificiale per i pagamenti UPI</h2><p>La Reserve Bank of India ha annunciato la sua intenzione di utilizzare l’intelligenza artificiale per l’interfaccia di pagamento unificata (UPI). Shaktikanta Das, il governatore della RBI, ha dichiarato che la banca presto lancerà i “Pagamenti Conversazionali” su UPI. Quel sistema alimentato dall’IA porterà a transazioni sicure e convenienti.</p>
<p>La RBI mira a introdurre nuove funzionalità all’UPI dopo aver realizzato che ha trasformato il sistema di pagamenti digitali poiché è sicuro, protetto e facile da usare. Attraverso l’introduzione di nuove funzionalità come i pagamenti conversazionali, la RBI desidera soddisfare le diverse esigenze dell’economia indiana.</p>
<p>L’obiettivo della RBI è creare un sistema basato sull’IA che avvierà e completerà le transazioni attraverso una conversazione. Tuttavia, il sistema di pagamento conversazionale basato sull’IA sarà disponibile solo su smartphone e canali UPI basati su “feature phone”.</p>
<p>La RBI, attraverso un rapporto intitolato “Dichiarazione sullo Sviluppo e le Politiche Regolamentari”, ha affermato: “Poiché l’Intelligenza Artificiale (AI) sta diventando sempre più integrata nell’economia digitale, le istruzioni conversazionali hanno un enorme potenziale nel migliorare la facilità d’uso e, di conseguenza, la portata del sistema UPI.”</p>
<p>Dai un’occhiata all’arte <a href="https://www.gate.io/price/view/artificial-intelligence" target="_blank">Primi cripto coin e token di intelligenza artificiale per capitalizzazione di mercato</a></p>
<h2 id="h2-Cosa20sono20i20Sistemi20di20Pagamento20Conversazionali686858"><a name="Cosa sono i Sistemi di Pagamento Conversazionali?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Cosa sono i Sistemi di Pagamento Conversazionali?</h2><p>I pagamenti conversazionali sono un sistema in cui le transazioni finanziarie vengono elaborate utilizzando una conversazione o una chat. Due parti, di cui una è il fornitore di pagamento e l’altra è l’operatore di chat, sono coinvolte in ogni transazione. Inoltre, coinvolge l’uso di Chatbot, Assistenti Virtuali Intelligenti (IVA) e Voicebot.</p>
<p>In questo caso, i chatbot forniranno agli utenti collegamenti diretti per il pagamento o codici QR, consentendo alle parti coinvolte di eseguire pagamenti in modo fluido durante le loro conversazioni. Il fatto che una transazione avvenga all’interno di un ambiente consolidato aumenta la sicurezza e l’affidabilità del sistema di pagamento.</p>
<p>Secondo la banca centrale, durante la prima fase la funzione di pagamento UPI conversazionale sarà disponibile in inglese e hindi. Tuttavia, con il passare del tempo, verranno aggiunte altre lingue.</p>
<p>Leggi anche: <a href="https://www.gate.io/learn/articles/what-are-ai-tokens/501" target="_blank">Cosa sono i token AI?</a></p>
<h2 id="h2-La20tecnologia20UPI20e20Near20Field20Communication20NFC72374"><a name="La tecnologia UPI e Near Field Communication (NFC)" class="reference-link"></a><span class="header-link octicon octicon-link"></span>La tecnologia UPI e Near Field Communication (NFC)</h2><p>Il sistema di pagamento transazionale alimentato da intelligenza artificiale si basa su due tecnologie principali, la comunicazione in prossimità del campo (NFC) e UPI. L’interfaccia di pagamenti unificata (UPI) è una funzionalità di transazione da pari a pari e da pari a commerciante utilizzabile su telefoni cellulari.</p>
<p>D’altra parte, la Near Field Communication (NFC), una tecnologia che consente a due dispositivi come gli smartphone di comunicare tra loro, consente alle persone di effettuare transazioni senza contatto quando si trovano a una certa distanza l’una dall’altra.</p>
<p>Secondo la RBI, “Questa funzionalità non solo consentirà pagamenti digitali al dettaglio in situazioni in cui la connettività internet/telecom è debole o non disponibile, garantirà anche velocità, con un minimo di transazioni respinte. Le istruzioni al NPCI saranno emesse a breve.”</p>
<p>Un vantaggio del sistema di pagamento conversazionale alimentato da AI è che consente pagamenti in tempo reale anche quando la connessione internet/telecom è debole o non disponibile. Inoltre, il sistema declina pochissime transazioni.</p>
<p>Ancora, l’uso del sistema di pagamento conversazionale può ulteriormente migliorare l’adozione dell’UPI, rendendo i pagamenti tramite codice QR accessibili a molte persone nel paese. Inoltre, coloro che incontravano difficoltà nella navigazione delle applicazioni mobili per effettuare pagamenti digitali troveranno il nuovo sistema molto user-friendly. Questo perché l’intelligenza artificiale li guiderà.</p>
<p>Leggi anche su <a href="https://www.gate.io/blog_detail/553/india-s-crypto-tax" target="_blank">La tassa sulle criptovalute in India</a></p>
<h2 id="h2-Valuta20digitale20della20banca20centrale415066"><a name="Valuta digitale della banca centrale" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Valuta digitale della banca centrale</h2><p>La RBI ha anche annunciato che è in fase di sviluppo la sua valuta digitale della banca centrale, l’eRupee. Già, l’e-rupee è nella fase di test in cui oltre 100.000 clienti e 170.000 commercianti stanno partecipando al programma pilota.</p>
<p>La Rupee digitale sarà un mezzo di pagamento legale nel paese e sarà scambiabile a parità con la sua controparte fisica. In effetti, la Rupee digitale, una valuta digitale in India, è una versione di criptovaluta creata dal governo indiano e sarà ufficialmente legalizzata, il che significa che consentirà pagamenti in criptovaluta nel paese.</p>
<h2 id="h2-Regolamentazione20delle20criptovalute20in20India911152"><a name="Regolamentazione delle criptovalute in India" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Regolamentazione delle criptovalute in India</h2><p>Ora che abbiamo <a href="https://www.gate.io/how-to-buy/rupee-rup" target="_blank">menzionato Rupee digitale</a> come una versione di criptovaluta, discutiamo la regolamentazione attuale delle criptovalute nel paese.</p>
<p>Attualmente, le criptovalute non sono regolamentate in India. Ciò significa che non ci sono regole che regolano l’uso delle criptovalute nel paese. Quindi, se ci sono controversie relative al trading di criptovalute o alla conduzione di pagamenti in criptovalute, non c’è nessuna risoluzione legale delle controversie su questo. Di conseguenza, il trading di asset digitali come gli NFT e le criptovalute è fatto a rischio degli investitori.</p>
<p>Leggi anche: <a href="https://www.gate.io/blog_detail/378/how-are-cryptocurrencies-currently-regulated-in-countries-around-the-world" target="_blank">Come sono attualmente regolamentate le criptovalute nei paesi di tutto il mondo?</a></p>
<p>Sebbene non vi sia un divieto legale ufficiale di trattare con criptovalute, la posizione del governo basata sui suoi portavoce come il governatore della Reserve Bank of India e il ministro delle Finanze mostra che le criptovalute sono illegali nel paese. Tuttavia, dal 2021 il governo sta lavorando a un disegno di legge sulle criptovalute intitolato “Cryptocurrency and Regulation of Official Digital Currency Bill, 2021”.</p>
<h2 id="h2-Conclusion527453"><a name="Conclusion" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusion</h2><p>La banca centrale dell’India sta attualmente lavorando all’introduzione di un sistema di pagamento conversazionale basato su AI basato sul sistema UPI. La sua implementazione di successo è probabile che aumenti l’adozione del sistema di pagamento dell’interfaccia di pagamenti unificata. Inoltre, la RBI sta conducendo un programma pilota sull’uso della Rupee digitale. Nonostante la proposta… <a href="https://www.gate.io/learn/articles/what-are-central-bank-digital-currencies/363" target="_blank">uso del CBDC</a>, non esiste una regolamentazione criptata in India.</p>
<h2 id="h2-Domande20frequenti20sulle20criptovalute20in20India986914"><a name="Domande frequenti sulle criptovalute in India" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Domande frequenti sulle criptovalute in India</h2><h3 id="h3-Gateio2020legale20in20India477127"><a name="Gate.io è legale in India?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Gate.io è legale in India?</h3><p>Gate.io è un legittimo scambio di criptovalute disponibile in più di 180 paesi, tra cui l’India. Gate.io offre vari servizi di criptovalute che includono trading spot, futures, mercato NFT e prodotti di guadagno.</p>
<div class="blog-details-info"><br><div>Autore: <strong>Mashell C.</strong>, Ricercatore 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 venga fatto riferimento a Gate.io. In tutti i casi, saranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div>