VHJhZEZpIHBlciBjcmVhcmUgdW5hIHBpYXR0YWZvcm1hIGRpIHRyYWRpbmcgZGkgb2JibGlnYXppb25pIGRpZ2l0YWxpIHN1IGJsb2NrY2hhaW4=

2023-04-27, 08:37

<p><img src="https://gimg2.gateimg.com/blog/1679447253500249423shendu.jpeg" alt=""></p>
<h2 id="h2-TL20DR320811"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p>CIB e SEB sono esempi di istituzioni finanziarie tradizionali che mirano a introdurre piattaforme di trading di criptovalute per obbligazioni.</p>
<p>La Banca europea per gli investimenti (BEI) è stata la prima istituzione finanziaria a emettere un bond digitale nell’aprile 2021.</p>
<p>I bond blockchain aumentano la trasparenza e la sicurezza nel trading di asset digitali.</p>
<p>L’emissione di trading di obbligazioni digitali è limitata dalla mancanza di regolamentazione e dalla possibilità di cyber crimini.</p>
<h2 id="h2-Introduzione518747"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>I debiti giocano un ruolo importante in varie economie poiché aiutano le aziende ad accedere ai fondi per avviare o espandere le proprie attività. Uno degli strumenti di debito popolari sono i bond che i mutuatari emettono per raccogliere fondi per i propri progetti. Come sappiamo, un bond è una promessa di pagare qualcuno in futuro. Oggi discutiamo come i bond digitali stanno per rivoluzionare il settore finanziario.</p>
<h2 id="h2-TradFi20Banks20si20unisce20per20creare20un20bond20digitale172386"><a name="TradFi Banks si unisce per creare un bond digitale" class="reference-link"></a><span class="header-link octicon octicon-link"></span>TradFi Banks si unisce per creare un bond digitale</h2><p>Anche se i bond sono parte integrante di TradFi, le banche tradizionali stanno pianificando di lanciare bond digitali sulla blockchain. La banca svedese SEB e la banca d’investimento francese Credit Agricole CIB, due delle banche più popolari in Europa, si sono unite per sviluppare una piattaforma sulla blockchain che creerà bond digitali.</p>
<p>Leggi anche: <a href="https://www.gate.io/blog_detail/794/crypto-regulation-in-the-eu-practical-implications-and-game-theory" target="_blank">Regolamentazione delle criptovalute nell’UE: Implicazioni pratiche e teoria dei giochi</a></p>
<p>Le aziende saranno in grado di creare obbligazioni digitali sulla piattaforma, aumentando l’efficienza e consentendo la sincronizzazione dei dati in tempo reale. In altre parole, le aziende utilizzeranno contratti intelligenti per gestire le loro obbligazioni digitali.</p>
<p><img src="https://gimg2.gateimg.com/image/article/16825845111581682584276_.pic.jpg" alt=""><br>I bond digitali possono esistere sulla blockchain - Financeautomate</p>
<p>La piattaforma digitale di Sobond, CIB e SEB utilizzerà il protocollo di convalida “Proof of Climate awaReness”, che consente agli utenti di ridurre la loro impronta di carbonio. Secondo il team, Sobond incoraggerà il consumo di energia a un livello simile ad altri progetti non basati su blockchain.</p>
<p>In sostanza, Sobond ricompenserà i nodi per la riduzione del consumo energetico. A tal fine, il team ha dichiarato: “Ogni nodo verrà remunerato per i suoi sforzi secondo una formula legata al suo impatto climatico.” È importante notare che Sobond sarà il primo protocollo blockchain a utilizzare il protocollo di convalida Proof of Climate Awareness.</p>
<p>CIB e SEB non sono i primi progetti a produrre obbligazioni digitali. La Banca Europea per gli Investimenti (BEI) ha lanciato la sua obbligazione digitale sul <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> blockchain nell’aprile 2021. In effetti, la BEI ha collaborato <a href="https://www.gate.io/blog_detail/1257/goldman-sachs-and-barclays-invest-in-uk-crypto-trading-platform-elwood" target="_blank">con Goldman Sachs</a>, Santander, e Société Générale emetteranno e liquidano un bond di due anni da €100 milioni.</p>
<p><img src="https://gimg2.gateimg.com/image/article/16825845551591682584288_.pic.jpg" alt=""><br>La Banca europea per gli investimenti ha emesso un bond digitale nel 2021 - Reuters</p>
<p>Il processo di emissione di obbligazioni digitali è molto semplice e comprensibile. Il primo passo è tokenizzare l’obbligazione. Da lì l’emittente dell’obbligazione si avvicinerà alle banche d’investimento. In cambio, una banca interessata creerà il documento di sintesi che firmeranno.</p>
<p>Dopo di che, la piattaforma di trading blockchain genererà un libro mastro che consiste in offerte e ordini di investitori interessati. Le transazioni avverranno una volta che il sistema completa i passaggi chiave.</p>
<p>La blockchain semplifica il processo di emissione e vendita di obbligazioni. In particolare, il processo elimina la procedura intensiva di carta per l’emissione di obbligazioni che esiste nel settore finanziario tradizionale. Nel settore finanziario tradizionale, i titoli di reddito fisso come le obbligazioni, che vengono vendute fuori dal mercato (OTC), comportano lavori di carta manuali che richiedono tempo e sono laboriosi.</p>
<p>Leggi anche: <a href="https://www.gate.io/blog_detail/2397/crashing-banks-push-crypto-towards-a-bull-market" target="_blank">Le banche in crash spingono le criptovalute verso un mercato rialzista</a></p>
<p>L’emissione di obbligazioni sulla blockchain è efficiente ed economica, il che dovrebbe aumentarne l’adozione. Di conseguenza, ciò aumenta la sostenibilità e la durata per le banche finanziarie tradizionali.</p>
<h2 id="h2-Benefici20dellutilizzo20della20tecnologia20blockchain20per20emettere20e20regolare20obbligazioni83817"><a name="Benefici dell’utilizzo della tecnologia blockchain per emettere e regolare obbligazioni" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Benefici dell’utilizzo della tecnologia blockchain per emettere e regolare obbligazioni</h2><p>Un bond digitale è un bond che viene emesso e liquidato tramite la blockchain. È un titolo con un interesse fisso che i mutuatari utilizzano per ottenere capitale per le loro aziende. Ci sono bond aziendali e bond governativi che le persone possono scambiare.</p>
<h3 id="h3-Emissione20agevole20di20obbligazioni578757"><a name="Emissione agevole di obbligazioni" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Emissione agevole di obbligazioni</h3><p>Il processo di emissione di obbligazioni digitali è fluido e automatizzato, il che migliora l’efficienza e riduce i costi. Questo è diverso dalle obbligazioni tradizionali che richiedono tempo per essere emesse e regolate. Inoltre, c’è una bassa probabilità di commettere errori durante la gestione delle obbligazioni digitali.</p>
<h3 id="h3-C20trasparenza466150"><a name="C’è trasparenza" class="reference-link"></a><span class="header-link octicon octicon-link"></span>C’è trasparenza</h3><p>La tecnologia blockchain porta alla trasparenza nella condivisione dei dati relativi alla liquidità, ai documenti di emissione, alla determinazione dei prezzi e alle performance degli asset. Questo crea un mercato equo e competitivo per le obbligazioni e altri titoli. La trasparenza aiuta gli investitori a prendere decisioni di investimento informate.</p>
<h3 id="h3-Precisione518259"><a name="Precisione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Precisione</h3><p>La blockchain consente la condivisione e lo storage di dati precisi poiché nessuno può modificarli. Oltre ai dati immutabili, la blockchain consente la condivisione in tempo reale delle informazioni a tutte le parti interessate. Con i bond digitali tutti i partecipanti al mercato possono accedere agli aggiornamenti delle transazioni in ogni momento.</p>
<h3 id="h3-riduzione20dei20costi416932"><a name="riduzione dei costi" class="reference-link"></a><span class="header-link octicon octicon-link"></span>riduzione dei costi</h3><p>Nel settore finanziario tradizionale, l’emissione di obbligazioni coinvolge molte parti. Ad esempio, è necessaria l’approvazione regolamentare, la registrazione e l’iscrizione che coinvolgono diversi attori. D’altra parte, la tecnologia blockchain consente la decentralizzazione di questi processi poiché non ci sono intermediari.</p>
<h3 id="h3-Maggiore20liquidit612035"><a name="Maggiore liquidità" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Maggiore liquidità</h3><p>Tokenizzare i bond porta a una maggiore liquidità rispetto al mercato tradizionale. Questo perché i bond possono essere frazionati e venduti a molti investitori. Pertanto, gli emittenti di bond digitali hanno accesso a una base di investitori più ampia rispetto al settore finanziario tradizionale. Ciò rende il processo di offerta più competitivo.</p>
<h3 id="h3-Migliore20sicurezza995566"><a name="Migliore sicurezza" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Migliore sicurezza</h3><p>L’uso della crittografia migliora la sicurezza dei bond. Ciò perché non vi è alcuna possibilità che poche persone possano alterare le informazioni sui bond che esistono sulla blockchain. Con i bond tradizionali, le parti coinvolte potrebbero smarrire alcuni dei documenti importanti.</p>
<h2 id="h2-Sfide20dei20bond20digitali69909"><a name="Sfide dei bond digitali" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Sfide dei bond digitali</h2><p>La tecnologia blockchain non risolve tutti i problemi che le persone incontrano quando emettono e liquidano obbligazioni.</p>
<h3 id="h3-Mancanza20di20regolamentazione20di20supporto473956"><a name="Mancanza di regolamentazione di supporto" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Mancanza di regolamentazione di supporto</h3><p>Non c’è dubbio che la tecnologia blockchain abbia il potenziale per rendere l’emissione di obbligazioni efficiente e trasparente. Tuttavia, l’assenza della regolamentazione richiesta impedisce alle imprese di investire nella tecnologia. Ciò rende l’emissione di obbligazioni blockchain rischiosa e ne impedisce l’adozione diffusa.</p>
<h3 id="h3-Scalabilit665603"><a name="Scalabilità" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Scalabilità</h3><p>Quando c’è la necessità di emettere un alto volume di obbligazioni sulla blockchain, l’elaborazione diventa più lenta a causa della crittografia, della complessità e della natura distribuita. Oltre alle transazioni più lente, il costo di elaborazione delle obbligazioni digitali diventa elevato.</p>
<h3 id="h3-Problemi20di20sicurezza769522"><a name="Problemi di sicurezza" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Problemi di sicurezza</h3><p>Gli asset digitali che esistono sulla blockchain sono soggetti a furti informatici come l’hacking. Ad esempio, la natura collusiva dei minatori o dei validatori di rete può causare attacchi del 51% con conseguente perdita di finanza sulla blockchain.</p>
<h2 id="h2-Conclusione757852"><a name="Conclusione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusione</h2><p>La nuova tendenza nel TradFi in cui le banche sono disposte a emettere obbligazioni digitali è probabile che aumenti l’efficienza e la trasparenza nel settore. Ciò avviene perché le obbligazioni digitali riducono il tempo di elaborazione, diminuiscono i costi di emissione delle obbligazioni crittografiche e ne migliorano la sicurezza.</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à consentita la ripubblicazione dell'articolo a condizione che venga citato Gate.io. In tutti i casi, saranno intraprese azioni legali a causa di violazione del copyright.<br></div><p></p><br></div></div></div>