SlAgTW9yZ2FuIGNvbnNpZGVyYSBpIHRva2VuIGRpIGRlcG9zaXRvIGJhc2F0aSBzdSBibG9ja2NoYWluIHBlciB0cmFuc2F6aW9uaSBwacO5IHZlbG9jaSBlIGNvc3RpIHJpZG90dGk=

2023-09-19, 08:49

<p><img src="https://gimg2.gateimg.com/image/article/1690791857hotspot.jpeg" alt=""><br>J.P. Morgan Bank sta pianificando di sviluppare e lanciare un sistema di pagamenti basato su blockchain.</p>
<p>Il sistema di pagamenti transfrontalieri di J.P. Morgan consentirà alle banche e ad altre istituzioni finanziarie di trasferire denaro utilizzando token di deposito digitali.</p>
<p>Il JPM Coin consente ai suoi clienti di trasferire fondi tra le sue filiali che esistono in paesi diversi.</p>
<p>Il sistema di pagamento basato su blockchain di J.P. Morgan è più veloce, più economico e più sicuro del sistema finanziario tradizionale.</p>
<p>Parole chiave: Token di deposito basato su blockchain, Pagamenti basati su blockchain, depositi blockchain e token, pagamenti transfrontalieri, JP Morgan Chase &amp; Co. Investimenti criptografici di JPMorgan, JP Morgan blockchain, sviluppatore blockchain</p>
<h2 id="h2-Introduzione5663"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>La tecnologia blockchain ha migliorato il modo in cui le persone inviano e ricevono denaro in tutto il mondo. Di conseguenza, molte istituzioni finanziarie stanno elaborando nuovi modi per rendere il trasferimento internazionale di fondi più sicuro, veloce ed economico. Oggi, discutiamo di come J.P. Morgan sta utilizzando la tecnologia blockchain per migliorare il suo sistema di trasferimento di denaro.</p>
<h3 id="h3-JP20Morgan20presenta20i20token20di20deposito20alimentati20da20blockchain398283"><a name="J.P. Morgan presenta i token di deposito alimentati da blockchain" class="reference-link"></a><span class="header-link octicon octicon-link"></span>J.P. Morgan presenta i token di deposito alimentati da blockchain</h3><p>J.P. Morgan, una banca multinazionale e universale, sta esplorando modi per utilizzare token di deposito digitali basati su blockchain per facilitare il trasferimento senza soluzione di continuità dei fondi tra le sue filiali in tutto il mondo e altre banche affiliate. L’utilizzo dei token di deposito migliorerà i pagamenti transfrontalieri veloci e più economici.</p>
<p>Secondo Bloomberg, J.P. Morgan Chase &amp; Co ha già un’infrastruttura valida per sostenere il suo sistema di pagamenti proposto. Tuttavia, sta ancora aspettando il via libera dai necessari regolatori degli Stati Uniti. Secondo una fonte affidabile, J.P. Morgan lancerà il sistema di pagamenti basato su blockchain entro un anno dall’ottenimento dell’approvazione legale richiesta.</p>
<p>Notizie correlate: <a href="https://www.gate.io/blog_detail/561/jp-morgan-seeks-business-opportunities-in-the-metaverse" target="_blank">JP Morgan cerca opportunità di business nel Metaverse</a></p>
<h2 id="h2-Come20funziona20il20sistema878758"><a name="Come funziona il sistema?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Come funziona il sistema?</h2><p>Prima di tutto, dobbiamo capire cos’è un token di deposito e il suo ruolo nel sistema finanziario del nuovo ordine mondiale. Un token di deposito è una moneta digitale che rappresenta una pretesa nei confronti di una banca commerciale.</p>
<p>In particolare, la moneta JPM consentirà ai clienti della J.P. Morgan Bank di inviare e ricevere denaro nei luoghi in cui ha filiali. Ciò è possibile grazie a un sistema di conformità che verifica la validità di tutte le transazioni in tempo reale. Nella prima fase il suo token di deposito basato su blockchain sarà denominato in dollari statunitensi, anche se in futuro introdurrà altre valute fiat.</p>
<p>Il suo principale vantaggio è che i depositi blockchain e token facilitano il trasferimento istantaneo di pagamenti tra conti istituzionali, semplificando così il processo bancario. Tuttavia, è importante notare che le persone non utilizzeranno i token di deposito come pagamento per l’acquisto di criptovalute. Non li utilizzeranno allo stesso modo delle stablecoin poiché funzionano solo come mezzo per trasferire valore finanziario tra le parti.</p>
<p>L’altra cosa interessante è che i token vengono utilizzati solo all’interno del sistema finanziario tradizionale, dove agevolano il trasferimento delle valute fiat. Il motivo è che i token di deposito digitale funzionano come depositi bancari. Un portavoce di J.P. Morgan ha fornito ulteriori dettagli su come funzionano i token.</p>
<p>Ha detto, “<br><strong>I token di deposito portano molti potenziali benefici, ma apprezziamo anche che i regolatori vogliano essere ponderati e diligenti prima che venga sviluppato e utilizzato un nuovo prodotto. Se tale appetito si sviluppasse, la nostra infrastruttura blockchain sarebbe in grado di supportare il lancio di token di deposito in modo relativamente rapido.</strong>”</p>
<p>Durante la prima fase, solo le banche e altre grandi istituzioni finanziarie utilizzeranno i token per effettuare pagamenti, riducendo i loro costi di gestione. Ancora una volta, gli investimenti cripto di JP Morgan permetteranno ai suoi clienti di inviare fondi ad altre banche e grandi aziende finanziarie che si registrano al sistema di pagamenti basato su blockchain.</p>
<h2 id="h2-La20JPM20Coin688928"><a name="La JPM Coin" class="reference-link"></a><span class="header-link octicon octicon-link"></span>La JPM Coin</h2><p>I token di deposito basati su blockchain sono diversi dalle monete JPM esistenti lanciate nel 2019. Le monete JPM sono stablecoin interne per il trasferimento di valore all’interno del suo sistema unico. Pertanto, varie organizzazioni aziendali possono trasferire fondi tra le filiali della J.P. Morgan Bank. Possono utilizzare il sistema per trasferire dollari ed euro in tutte le sedi in cui sono presenti filiali della J.P. Morgan. Dall’avvio, la moneta JPM ha facilitato il trasferimento di più di $300.000.</p>
<p>Leggi anche: <a href="https://www.gate.io/blog_detail/847/jp-morgan-decentraland-a-metaverse-marriage." target="_blank">JP Morgan &amp; Decentraland: Un Matrimonio Metaversale</a></p>
<h3 id="h3-La20JPM20Coin20supporta20lEuro568420"><a name="La JPM Coin supporta l’Euro" class="reference-link"></a><span class="header-link octicon octicon-link"></span>La JPM Coin supporta l’Euro</h3><p>La moneta JPM ora supporta l’Euro. Il conglomerato tedesco Siemens è stato il primo cliente di J.P. Morgan a utilizzarla. <a href="https://www.gate.io/bitwiki/detail/736" target="_blank">JPM coin</a> per trasferire l’Euro tra le sue filiali. In particolare, la JPM coin è ONYX, la moneta basata sulla piattaforma blockchain di J.P. Morgan lanciata nel 2020.</p>
<h3 id="h3-JP20Morgan20Applica20Blockchain20alle20transazioni20interbancarie20in20dollari20statunitensi801536"><a name="J.P. Morgan Applica Blockchain alle transazioni interbancarie in dollari statunitensi" class="reference-link"></a><span class="header-link octicon octicon-link"></span>J.P. Morgan Applica Blockchain alle transazioni interbancarie in dollari statunitensi</h3><p>J.P. Morgan intende utilizzare il suo sistema di pagamento basato su blockchain per le transazioni interbancarie denominate negli Stati Uniti in India, in un contesto di crescente tendenza alla de-dollarizzazione.</p>
<p>Pertanto, si è associata a diverse banche indiane come ICICI Bank, Axis Bank, HDFC Bank, Yes Bank e IndusInd Bank per facilitare i trasferimenti interbancari utilizzando la moneta JPM. Questo sistema riduce il tempo di transazione quasi istantaneo e funziona.24⁄7.</p>
<h3 id="h3-Lesperienza20precedente20di20JP20Morgan20con20progetti20blockchain20e20criptovalute167700"><a name="L’esperienza precedente di JP Morgan con progetti blockchain e criptovalute" class="reference-link"></a><span class="header-link octicon octicon-link"></span>L’esperienza precedente di JP Morgan con progetti blockchain e criptovalute</h3><p>Per cominciare, nel 2022 la banca ha stretto una partnership con l’Autorità Monetaria di Singapore per testare il suo sistema di depositi blockchain e token. Il motivo è che la banca si concentra sull’introduzione di soluzioni di transazioni finanziarie basate su blockchain che cambiano il gioco.</p>
<p>A tal proposito, Umar Farooq, CEO di Onyx, la divisione <a href="/web3" target="_blank" class="blog_inner_link">web3</a> di J.P. Morgan, ha detto: “J<br><strong>PMorgan continua a sviluppare soluzioni basate su blockchain per i servizi finanziari e vede i depositi accessibili sulla blockchain pubblica come il prossimo passo nell’evoluzione del denaro bancario commerciale digitalizzato.</strong>”</p>
<p>Come già evidenziato, la banca ha introdotto il suo JPM coin nel 2019 come mezzo per rivoluzionare il modo in cui conduce le sue transazioni finanziarie. Questa moneta fa parte del sistema di pagamento condizionale della banca che dipende dai contratti intelligenti. Un tale sistema è diverso dai metodi di pagamento tradizionali che separano il messaggio di transazione dal movimento fisico dei fondi, rendendo le riconciliazioni molto difficili.</p>
<p>In secondo luogo, la banca ha già sviluppato il suo JP Morgan blockchain che supporta lo sviluppo, il lancio e l’uso dei token di deposito basati su blockchain. Una volta che il governo degli Stati Uniti approva il token, il suo sviluppatore di blockchain operazionalizzerà l’intero sistema.</p>
<h2 id="h2-Benefici20del20sistema20di20pagamenti20basato20su20blockchain20di20JP20Morgan814135"><a name="Benefici del sistema di pagamenti basato su blockchain di J.P. Morgan" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Benefici del sistema di pagamenti basato su blockchain di J.P. Morgan</h2><p>Le persone possono utilizzare il sistema per inviare denaro a individui che utilizzano altre banche. Inoltre, i clienti di J.P. Morgan possono liquidare pagamenti che coinvolgono altri strumenti finanziari presenti sulla blockchain. Inoltre, il sistema dispone di robusti controlli antiriciclaggio e antifrode.</p>
<p>Tuttavia, le persone non possono scambiare il token su scambi crittografici poiché è funzionale solo all’interno del sistema finanziario tradizionale.</p>
<p>In uno studio recente, J.P. Morgan ha detto: “Crediamo che i token di deposito diventeranno una forma di denaro ampiamente utilizzata all’interno dell’ecosistema degli asset digitali, proprio come i soldi delle banche commerciali sotto forma di depositi bancari costituiscono oltre il 90% del denaro circolante oggi.”</p>
<p>Confronto tra il sistema di pagamenti basato su blockchain di J.P. Morgan e il sistema finanziario tradizionale<br>Naturalmente, la somiglianza principale tra il sistema di pagamenti basato su blockchain di J.P. Morgan e il sistema finanziario tradizionale è che consentono agli utenti di trasferire valori finanziari tra di loro. Tuttavia, hanno diversi modi di operare e vantaggi come indica la tabella seguente.</p>
<table>
<thead>
<tr>
<th>Pagamenti basati su blockchain</th>
<th>Sistema di Pagamento Finanziario Tradizionale</th>
</tr>
</thead>
<tbody>
<tr>
<td>I fondi vengono trasferiti quasi istantaneamente, indipendentemente dalle posizioni geografiche.</td>
<td>Spesso ci vogliono diversi giorni perché i soldi raggiungano la loro destinazione.</td>
</tr>
<tr>
<td>Il sistema è più economico.</td>
<td>Il sistema è più costoso.</td>
</tr>
<tr>
<td>Non ci sono intermediari.</td>
<td>Gli intermediari facilitano la maggior parte delle transazioni.</td>
</tr>
<tr>
<td>C’è un movimento sincrono dei messaggi di transazione e del denaro.</td>
<td>Spesso i messaggi di transazione si muovono più velocemente dei soldi.</td>
</tr>
<tr>
<td>I soldi sono più sicuri in quanto le transazioni vengono memorizzate su una rete di computer.</td>
<td>Le transazioni sono memorizzate in un’unica posizione che potrebbe aumentare i rischi.</td>
</tr>
<tr>
<td>Il sistema è trasparente in quanto i record delle transazioni esistono sulla blockchain.</td>
<td>C’è un rischio maggiore di frodi poiché i record delle transazioni sono mantenuti nei server centralizzati.</td>
</tr>
<tr>
<td>Spesso offrono prodotti e servizi finanziari limitati.</td>
<td>Le banche spesso offrono più prodotti e servizi.</td>
</tr>
<tr>
<td>Alcuni governi non regolano i sistemi basati su blockchain, il che riduce la protezione dei consumatori.</td>
<td>C’è una migliore protezione dei consumatori poiché il governo regola il sistema.</td>
</tr>
</tbody>
</table>
<h2 id="h2-Sfide20che20JP20Morgan20potrebbe20affrontare240361"><a name="Sfide che J.P. Morgan potrebbe affrontare" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Sfide che J.P. Morgan potrebbe affrontare</h2><p>Nell’implementazione del suo sistema di pagamenti transfrontalieri basato su blockchain, J.P. Morgan probabilmente si troverà ad affrontare alcuni problemi. Può affrontare sfide regolamentari dagli Stati Uniti e da altri paesi che potrebbero non approvare il suo token di deposito digitale.</p>
<p>Il secondo problema è un possibile basso tasso di adozione. Potrebbe volerci molto tempo prima che molte grandi banche e istituzioni finanziarie adottino il suo sistema di pagamenti transfrontalieri.</p>
<p>Successivamente, J.P. Morgan potrebbe incontrare molta concorrenza da parte di altre istituzioni finanziarie che potrebbero introdurre i propri token di deposito in futuro.</p>
<h3 id="h3-Come20il20sistema20di20pagamenti20basato20su20blockchain20di20JP20Morgan20influisce20su20altre20banche291276"><a name="Come il sistema di pagamenti basato su blockchain di J.P. Morgan influisce su altre banche" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Come il sistema di pagamenti basato su blockchain di J.P. Morgan influisce su altre banche</h3><p>Il successo del sistema di pagamenti basato su Blockchain di J.P. Morgan potrebbe influenzare altre banche e istituzioni finanziarie a implementare sistemi simili. Questo perché i loro clienti potrebbero richiedere loro di sviluppare tali sistemi di pagamento.</p>
<h2 id="h2-Conclusione895450"><a name="Conclusione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusione</h2><p>J.P. Morgan sta esplorando modi per utilizzare un sistema di pagamenti e regolamenti basato su blockchain adatto per le banche e altre grandi istituzioni finanziarie. Attualmente, sta utilizzando il suo JPM coin per facilitare il trasferimento di fondi tra le sue filiali. Tuttavia, sta pianificando di lanciare un sistema di trasferimento di denaro interbancario in India. Il sistema transfrontaliero di J.P. Morgan ha diversi vantaggi rispetto al tradizionale sistema finanziario, tra cui transazioni più veloci e meno costose.</p>
<h2 id="h2-Domande20frequenti20su20JPMorgan381462"><a name="Domande frequenti su JPMorgan" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Domande frequenti su JPMorgan</h2><h3 id="h3-Come20sta20utilizzando20JP20Morgan20la20blockchain888943"><a name="Come sta utilizzando J.P. Morgan la blockchain?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Come sta utilizzando J.P. Morgan la blockchain?</h3><p>J.P. Morgan sta utilizzando la blockchain per facilitare i pagamenti transfrontalieri e altri regolamenti finanziari. Utilizza la moneta JPM per consentire ai suoi utenti di inviare e ricevere fondi. Inoltre, sta pianificando di sviluppare un token di deposito basato su blockchain che facilita il trasferimento del valore finanziario tra diverse banche e grandi istituzioni.</p>
<h3 id="h3-Cos20ONYX20di20JPMorgan840204"><a name="Cos’è ONYX di JPMorgan?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Cos’è ONYX di JPMorgan?</h3><p>ONYX è la piattaforma basata su blockchain di JPMorgan che consente alle persone di trasferire fondi utilizzando la sua moneta JPM. Attualmente, la moneta JPM supporta il trasferimento di denaro contante utilizzando l’euro. Ciononostante, sta pianificando di aggiungere il dollaro statunitense al suo sistema di pagamento.</p>
<div class="blog-details-info"><br><div>Autore:<strong> Mashell C.</strong>, Gate.io Ricercatore<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 venga fatto riferimento a Gate.io. In tutti i casi, verranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div>