TGEgbW9zc2EgZGkgVmlzYSBuZWkgdG9rZW4gZGlnaXRhbGk6IHJpdm9sdXppb25hcmUgbGEgdG9rZW5penphemlvbmUgZGVnbGkgYXNzZXQgZW50cm8gaWwgMjAyNQ==

2024-10-16, 03:06

<p><img src="https://gimg2.gateimg.com/image/article/17290475931690791857hotspot.jpeg" alt=""></p>
<h2 id="h2-TL20DR223002"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p>Visa ha lanciato la sua tecnologia VTAP che consente alle banche di sviluppare stablecoin garantite da fiat che possono utilizzare per facilitare le transazioni finanziarie.</p>
<p>Banco Bilbao Vizcaya Argentaria (BBVA) e Visa hanno stretto una partnership per sviluppare e testare la tecnologia VTAP.</p>
<p>Nel 2025 più banche potranno collaborare con Visa per testare i suoi prodotti finanziari.</p>
<h2 id="h2-Introduzione76453"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>Le partnership e la cooperazione sono aspetti fondamentali del settore blockchain poiché consentono alle aziende crittografiche di fornire i migliori servizi digitali ai propri utenti. Il momento in cui i progetti crittografici lavorano in isolamento sembra essere finito poiché devono potenziare le proprie capacità e resilienza. Ad esempio, le aziende crittografiche dovrebbero cooperare per garantire un’alta sicurezza. Questa analisi riguarda l’ingresso di VISA nel settore digitale e le potenziali partnership che formerà per avere successo.</p>
<h2 id="h2-VISA20si20avventura20nel20settore20RWA715727"><a name="VISA si avventura nel settore RWA" class="reference-link"></a><span class="header-link octicon octicon-link"></span>VISA si avventura nel settore RWA</h2><p>Recentemente, VISA ha comunicato la sua intenzione di avventurarsi <a href="https://www.gate.io/learn/articles/rwa-the-rise-of-real-world-assets/4011" target="_blank">nel settore della tokenizzazione del mondo reale</a> attraverso i suoi prodotti finanziari. In collaborazione con diverse istituzioni finanziarie, Visa <a href="https://www.gate.io/learn/articles/a-brief-history-of-real-world-assets-why-they-matter/4333 &quot;use real-world tokenized assets (RWAs" rel="nofollow noopener noreferrer" target="_blank">utilizzare asset tokenizzati del mondo reale (RWAs)</a>”) per migliorare le capacità di varie istituzioni finanziarie come le banche. Il suo prodotto, la Piattaforma di Asset Tokenizzato Visa (VTAP), aiuterà a colmare il divario tra la finanza tradizionale (TradFi) e il settore blockchain. Svelerà il suo prodotto in un progetto pilota su vasta scala nel 2025.</p>
<p>Al momento, VISA VTAP è accessibile sulla sua piattaforma per sviluppatori che consente ai partner affiliati di sviluppare e testare le loro risorse digitali come le valute digitali della banca centrale (CBDC) e altre stablecoin. Attualmente, il progetto è in fase di <a href="/price/the-sandbox-sand" rel="nofollow noopener noreferrer" target="_blank">The Sandbox</a> L’VTAP aiuterà fondamentalmente le istituzioni finanziarie ad integrare il sistema blockchain nelle loro operazioni finanziarie tradizionali. Questo migliorerà i servizi dei sistemi finanziari e renderà le loro operazioni commerciali efficienti e facilmente accessibili a molte persone. Quando lancerà il progetto, avrà più di 15.000 partner in oltre 200 paesi.</p>
<p>Oltre alla coniazione di stablecoin, VTAP è progettato per offrire alle istituzioni finanziarie un’infrastruttura end-to-end per eseguire in modo sicuro transazioni digitali come il trasferimento di token digitali Visa. Il servizio finanziario sarà disponibile su blockchain private e pubbliche, rendendolo accessibile a quanti più partner possibili. Fondamentalmente, le banche saranno in grado di coniare le loro stablecoin e utilizzarle per facilitare transazioni rapide all’interno dell’ecosistema blockchain Visa e delle strutture bancarie. In questo modo, questo sistema aiuterà le istituzioni finanziarie ad automatizzare i loro flussi di lavoro attuali e consentirà il movimento senza attrito di asset del mondo reale all’interno del sistema finanziario globale Visa. Attraverso questa trasformazione finanziaria digitale, le banche saranno in grado di liquidare i pagamenti in tempo reale, cosa che non è possibile se si basano solo sui loro sistemi di pagamento tradizionali. diventerà sicuro e conveniente effettuare pagamenti condizionati come deduzioni periodiche.</p>
<p>Un altro aspetto importante è che le istituzioni finanziarie saranno in grado di utilizzare la tecnologia della finanza decentralizzata senza violare i propri obblighi regolamentari. Allo stesso modo, non comprometteranno le loro misure di sicurezza, rendendo l’utilizzo della tokenizzazione degli asset applicabile al settore.</p>
<p>Con il suo attuale focus, Visa trasformerà probabilmente il sistema finanziario globale migliorando la trasparenza, le transazioni veloci e le soluzioni finanziarie affidabili. A riguardo, Vanessa Colella, Global Head of Innovation and Digital Partnerships di Visa, ha dichiarato, <em>“Visa è stata <a href="https://www.gate.io/learn/articles/comprehensive-analysis-of-web3-payments-from-digital-cash-and-tokenized-currency-to-the-future-of-payfi/3868" target="_blank">alla frontiera dei pagamenti digitali</a> per quasi sessant’anni, e con l’introduzione di VTAP, stiamo di nuovo dettando il passo per il settore. Siamo entusiasti di sfruttare la nostra esperienza nella tokenizzazione per aiutare le banche a integrare le tecnologie blockchain nelle loro operazioni.</em></p>
<h2 id="h2-Tokenizzazione20degli20asset20un20cambiamento20radicale20nel20settore20finanziario20globale514305"><a name="Tokenizzazione degli asset, un cambiamento radicale nel settore finanziario globale" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Tokenizzazione degli asset, un cambiamento radicale nel settore finanziario globale</h2><p>Come detto, VTAP probabilmente rivoluzionerà il sistema finanziario globale utilizzando la tecnologia blockchain nei prossimi anni. Ciò perché la piattaforma di token digitali consentirà alle banche di portare le valute fiat inchain in modo sicuro, efficiente e senza interruzioni. Questa innovazione finanziaria comporta vari vantaggi che includono i seguenti.</p>
<p>Integrazione: Utilizzando la piattaforma VTAP, le istituzioni finanziarie saranno in grado di elaborare transazioni utilizzando token garantiti da fiat, sotto forma di stablecoin. Oltre a coniare stablecoin, le banche saranno in grado di bruciarle a seconda della loro domanda.</p>
<p>Programmabilità: Le banche possono automatizzare varie transazioni poiché utilizzeranno contratti intelligenti. Ad esempio, possono utilizzare il sistema per amministrare le loro linee di credito. Inoltre, i loro clienti saranno in grado di utilizzare stablecoin garantite dal fiat per acquistare tesorerie e merci tokenizzate. Di conseguenza, diventerà più facile per gli individui investire in vari strumenti di investimento.</p>
<p>Interoperabilità: una delle cose positive è che l’emissione di asset digitali può avvenire su diverse blockchain, creando un’economia veramente tokenizzata. Ciò significa che i token possono essere transati tra diverse blockchain, migliorando così l’interoperabilità. Pertanto, in futuro, una banca che operi sotto i progetti di blockchain Visa avrà bisogno di un singolo API per beneficiare dei molteplici casi d’uso della tokenizzazione degli asset. Con questo, potrà interagire con diverse blockchain e altri partner finanziari. Di conseguenza, il sistema VTAP è progettato per facilitare transazioni sicure tra diverse catene di blocco. <a href="https://www.gate.io/learn/articles/tokenization-of-rwas-beyond-the-hype/1279" target="_blank">di asset reali tokenizzati (RWAs)</a> utilizzando asset digitali garantiti da fiat.</p>
<h2 id="h2-La20visione20di20Visa20quanto2020realizzabile278928"><a name="La visione di Visa: quanto è realizzabile?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>La visione di Visa: quanto è realizzabile?</h2><p>In sintesi, la visione di Visa è promuovere l’interoperabilità tra le blockchain che supportano il sistema esistente delle valute fiat. Ciò verrà raggiunto integrando la tecnologia attuale con la tecnologia blockchain in modo conveniente. L’interoperabilità svolge un ruolo importante nella promozione del trasferimento e dell’utilizzo di asset reali tokenizzati, che siano materie prime del tesoro o altri prodotti finanziari. Questo significa anche che alcune istituzioni finanziarie saranno in grado di portare le valute fiat sulla blockchain in modo che siano utilizzate in <a href="https://www.gate.io/learn/articles/top-bitcoin-defi-projects/2726" target="_blank">applicazioni di finanza decentralizzata (DeFi)</a>.</p>
<p>Mentre Visa sta attualmente lavorando con un singolo partner BBVA, nel 2025 aumenterà il numero di partner che parteciperanno al programma pilota. Inoltre, durante quel periodo, varie istituzioni finanziarie lavoreranno con Visa per sviluppare capacità e standard che promuoveranno il nuovo sistema di pagamento per operare in modo conforme, sicuro e affidabile. Pertanto, la visione Visa 2025 prevede il lancio del prodotto finanziario VTAP. Nel complesso, il programma di trasformazione della finanza digitale di Visa probabilmente porterà ad una maggiore adozione di cripto nel corso degli anni a venire rispetto ad oggi.</p>
<h2 id="h2-Partnerships20strategiche20di20Visa20per20migliorare20ladozione20di20asset20digitali20tokenizzati845738"><a name="Partnerships strategiche di Visa per migliorare l’adozione di asset digitali tokenizzati" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Partnerships strategiche di Visa per migliorare l’adozione di asset digitali tokenizzati</h2><p>Sia Banco Bilbao Vizcaya Argentaria (BBVA) che Visa hanno confermato di aver avviato una partnership mirata allo sviluppo e al collaudo della tecnologia VTAP. Già BBVA è stato coinvolto nel collaudo del VTAP di Visa. In modo significativo, continuerà a farlo mentre Visa attende altre partnership bancarie destinate al 2025. Alcuni dei test che BBVA sta conducendo includono l’emissione di asset digitali, il trasferimento dei token e il rimborso su un blockchain di test.</p>
<p>Pubblicando sul suo blog, <a href="https://www.bbva.com/en/innovation/bbva-to-explore-the-potential-of-visas-new-tokenized-asset-platform/" rel="nofollow noopener noreferrer" target="_blank">BBVA ha detto</a>, “BBVA è una delle prime banche della rete globale di Visa a utilizzare VTAP, una nuova piattaforma di Visa che consente alle istituzioni finanziarie di creare e gestire token digitali garantiti da valute fiat come l’euro e il dollaro. BBVA utilizzerà VTAP per creare token sul <a href="https://www.gate.io/bitwiki/detail/26/public-blockchain" target="_blank">blockchain pubblica Ethereum</a> con piloti in diretta previsti nel 2025.</p>
<p>Più specificamente, Francisco Maroto, responsabile di Blockchain e Asset Digitali (BBVA), ha detto, <em>“Siamo orgogliosi di continuare a guidare l’esplorazione delle soluzioni tokenizzate con Visa attraverso la sua piattaforma VTAP. Questa collaborazione segna una tappa significativa nella nostra esplorazione del potenziale della tecnologia blockchain e alla fine ci aiuterà ad ampliare i nostri servizi bancari ed espandere il mercato con nuove soluzioni finanziarie.”</em></p>
<h2 id="h2-Conclusione417480"><a name="Conclusione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusione</h2><p>Visa intende rivoluzionare il settore finanziario attraverso lo sviluppo di un sistema per tokenizzare e utilizzare asset del mondo reale, in particolare stablecoin. Con questo sistema le banche saranno in grado di sviluppare le loro stablecoin garantite dal fiat che useranno per facilitare il trasferimento di valore tra i partner. Attualmente, Visa si è associata a BBVA per sviluppare e testare la loro tecnologia, con la speranza di lanciarla nel 2025.</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. Tutti gli investimenti comportano rischi intrinseci; è essenziale prendere decisioni prudenti.<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, verranno intraprese azioni legali a causa della violazione del copyright.<br></div><p></p><br></div></div></div>