RGVsb2l0dGUsIGlsIGdpZ2FudGUgZGVsbGEgY29udGFiaWxpdMOgLCBlbnRyYSBhIGZhciBwYXJ0ZSBkZWwgc2lzdGVtYSBQb2xrYWRvdA==

<p><img src="https://gimg2.gateimg.com/image/article/1684401099RDZZ.jpeg" alt=""></p>
<h2 id="h2-TL20DR786609"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p>Deloitte ha collaborato con Parachain su <a href="/price/polkadot-dot" rel="nofollow noopener noreferrer" target="_blank">Polkadot</a>, KILT, per fornire servizi di identità e credenziali.</p>
<p>Deloitte fornirà un portafoglio di credenziali sulla sua estensione del browser.</p>
<p>Il prezzo di DOT è aumentato del 40% a seguito dell’annuncio di Deloitte della sua partnership con la blockchain KILT.</p>
<h2 id="h2-Introduzione553542"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>È importante per le aziende utilizzare la verifica Conosci il tuo cliente (KYC) e Conosci la tua azienda (KYB). Nel settore finanziario tradizionale, il KYC e il KYB comportano molta carta e duplicazioni. Tuttavia, il KYC e il KYB basati sul blockchain eliminano la necessità di documentazione cartacea. Questo articolo illustra come l’integrazione di Deloitte e il protocollo KILT migliorano le verifiche KYC e KYB senza carta.</p>
<h2 id="h2-Il20protocollo20KILT20offre20credenziali20di20identit20digitali489478"><a name="Il protocollo KILT offre credenziali di identità digitali" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Il protocollo KILT offre credenziali di identità digitali</h2><p>Deloitte, la gigante società di contabilità, ha annunciato la sua intenzione di rilasciare credenziali firmate utilizzando la tecnologia blockchain <a href="https://www.gate.io/price/kilt-protocol-kilt" target="_blank">sul protocollo KILT</a>. In realtà, Deloitte si integrerà con il Protocollo KILT, un <a href="/price/polkadot-dot" rel="nofollow noopener noreferrer" target="_blank">Polkadot</a> parachain che si specializza su identità e credenziali decentralizzate verificabili.</p>
<p>Deloitte utilizzerà la blockchain, attraverso il protocollo KILT, per supportare i suoi Know Your Business (KYB) e Know Your Customer (KYC), importanti per proteggere le istituzioni da crimini come il riciclaggio di denaro e le frodi.</p>
<p>Leggi anche: <a href="https://www.gate.io/how-to-buy/polkadot-dot" target="_blank">Come acquistare Polkadot (DOT) - HODL o commerciare criptovalute</a></p>
<p><img src="https://gimg2.gateimg.com/image/article/1684401364Deloitte 1.png" alt=""></p>
<p>La cosa positiva è che Deloitte può modificare le credenziali se ci sono cambiamenti nello status di individui e aziende. Un vantaggio nell’utilizzare la blockchain per rilasciare queste credenziali e identità è che diventano riutilizzabili in quanto i proprietari possono darle a qualsiasi parte desiderino.</p>
<p><a href="https://www2.deloitte.com/ch/en/pages/press-releases/articles/deloitte-integrates-kilt-identity-blockchain-creating-new-markets-with-reusable-digital-credentials.html" rel="nofollow noopener noreferrer" target="_blank">Come da comunicato stampa, Deloite ha detto</a> Le credenziali sono memorizzate nel portafoglio del cliente sul proprio dispositivo, rimanendo sotto il loro controllo in ogni momento. Il cliente può scegliere con chi condividere le proprie credenziali e quali punti dati delle credenziali rendere disponibili.</p>
<p>L’uso di Conosci il tuo cliente e Conosci la tua attività serve a verificare l’esistenza di un cliente o di un’attività. Tradizionalmente, il KYB e il KYC sono stati sotto forma di certificati cartacei che sono molto difficili da elaborare. La verifica dell’identità comporta la valutazione dei dati di un’altra parte, come la data di nascita, l’aspetto facciale e il paese di residenza.</p>
<p><a href="https://www2.deloitte.com/ch/en/pages/press-releases/articles/deloitte-integrates-kilt-identity-blockchain-creating-new-markets-with-reusable-digital-credentials.html" rel="nofollow noopener noreferrer" target="_blank">Deloitte sostiene che</a>“Queste credenziali hanno molteplici utilizzi, tra cui conformità normativa per il settore bancario e Finanza Decentralizzata (DeFi), verifica dell’età per il commercio elettronico, accessi privati e raccolta fondi.”</p>
<p>Utilizzare la blockchain per la verifica dell’identità e delle credenziali è efficiente, economico e meno dispendioso in termini di tempo rispetto al metodo tradizionale su carta. È importante notare che la verifica digitale, dove i dati sono archiviati su più database, potrebbe comportare la violazione della privacy personale.</p>
<p>Con la tecnologia blockchain, gli utenti saranno responsabili dei propri dati. Inoltre, le stesse credenziali possono essere utilizzate su piattaforme di servizio multiple. <a href="/price/polkadot-dot" rel="nofollow noopener noreferrer" target="_blank">Polkadot</a> Il protocollo KILT di ‘s elimina i processi di fiducia basati su certificati cartacei come patenti di guida e passaporti e li sostituisce con un processo di verifica basato sulla blockchain che è sicuro e sotto il controllo di un individuo.</p>
<p>In questo contesto Micha Bitterli, responsabile dei servizi gestiti di Deloitte, ha dichiarato: “Offrendo credenziali digitali riutilizzabili ancorate alla blockchain KILT, Deloitte sta trasformando i processi di verifica per individui ed entità.”</p>
<p>Ha aggiunto che “Le credenziali digitali che sono convenienti, economiche e sicure hanno il potenziale per aprire nuovi mercati digitali, dal commercio elettronico e DeFi al gioco. Deloitte ha la conoscenza tecnologica, la portata e la fiducia per rilasciare credenziali che sono accettate a livello globale.”</p>
<h2 id="h2-La20necessit20di20un20portafoglio926944"><a name="La necessità di un portafoglio" class="reference-link"></a><span class="header-link octicon octicon-link"></span>La necessità di un portafoglio</h2><p>Le credenziali KYC e KYB riutilizzabili vengono memorizzate in un portafoglio digitale che le rende molto accessibili e convenienti da usare. Come potete immaginare, gli utenti possono installare i portafogli sui loro dispositivi elettronici come computer desktop e smartphone. In questo modo, l’utente ha il privilegio di decidere quali dati vuole condividere e con chi.</p>
<p>Pertanto, Deloitte introdurrà un portafoglio di credenziali che gli utenti possono gestire utilizzando l’estensione del browser web. Secondo Deloitte, il portafoglio digitale sarà molto facile da usare al punto che anche gli utenti senza conoscenza della blockchain possono accedere e condividere le loro credenziali.</p>
<h2 id="h2-Come20funziona20il20sistema254032"><a name="Come funziona il sistema" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Come funziona il sistema</h2><p>Fondamentalmente tre parti sono coinvolte nella creazione e certificazione delle credenziali di un individuo o di un’azienda. In primo luogo, la blockchain KILT consentirà ai suoi utenti di presentare le proprie caratteristiche alle entità di fiducia conosciute come attestanti. Se l’attestante ritiene che le informazioni siano accurate, le certifica e rilascia il certificato all’utente, chiamato richiedente.</p>
<p>Il valore hash del certificato è conservato nella blockchain. Di conseguenza, il richiedente sarà in grado di fornire il certificato a un verificatore che può verificare la validità del certificato utilizzando il suo hash blockchain.</p>
<h2 id="h2-Impatto20della20notizia20della20partnership20tra20Deloitte20e20Kilt20Protocol20sul20prezzo20di20Polkadot702347"><a name="Impatto della notizia della partnership tra Deloitte e Kilt Protocol sul prezzo di Polkadot" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Impatto della notizia della partnership tra Deloitte e Kilt Protocol sul prezzo di Polkadot</h2><p>L’annuncio di Deloitte della sua partnership con <a href="/price/polkadot-dot" rel="nofollow noopener noreferrer" target="_blank">Polkadot</a> la parachain KILT ha portato ad un aumento del prezzo di <a href="/price/polkadot-dot" rel="nofollow noopener noreferrer" target="_blank">dot crypto</a> In realtà, l’entusiasmo che circonda questa partnership ha portato a un aumento del 40% del valore di DOT. Tuttavia, <a href="/price/polkadot-dot" rel="nofollow noopener noreferrer" target="_blank">dot crypto</a> non ha mantenuto il momentum al rialzo del prezzo come <a href="/price/the-graph-grt" rel="nofollow noopener noreferrer" target="_blank">Il Grafico</a> mostra.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1684401374Deloitte 2.png" alt=""></p>
<p>Come <a href="/price/the-graph-grt" rel="nofollow noopener noreferrer" target="_blank">Il Grafico</a> come indica, c’è stato un aumento di prezzo il 4 maggio, il giorno in cui Deloitte ha annunciato la sua partnership con <a href="/price/polkadot-dot" rel="nofollow noopener noreferrer" target="_blank">Polkadot</a> Il protocollo KILT di ’s. DOT è riuscito a mantenere un alto slancio tra il 4 e l’8 maggio.</p>
<p>Tuttavia, da quel momento <a href="https://www.gate.io/price/polkadot-dot" target="_blank">il suo prezzo</a> è sceso fino al 13 maggio quando è risalito di nuovo. Al momento della scrittura, il valore di DOT sta salendo, avendo guadagnato lo 0,36% nelle ultime 24 ore. Il fatto che il valore di DOT sia aumentato del 12% nell’ultima settimana, terminando venerdì (12 maggio), mostra che il suo prezzo ha il potenziale per continuare a salire nelle settimane seguenti.</p>
<p>Leggi anche: <a href="https://www.gate.io/price-prediction/polkadot-dot" target="_blank">Previsione del prezzo di Polkadot (DOT) 2023-2030</a></p>
<h2 id="h2-Conclusione216091"><a name="Conclusione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusione</h2><p>Deloitte si è associata a KILT blockchain per offrire credenziali di identità digitale per individui e aziende. Queste identità e credenziali Know Your Customer e Know Your Business sono riutilizzabili poiché esistono sulla blockchain. Deloitte fornirà un portafoglio di credenziali sull’estensione del suo browser che consentirà agli utenti individuali di controllare i propri dati.</p>
<h2 id="h2-Domande20frequenti20sulla20blockchain20Polkadot203656"><a name="Domande frequenti sulla blockchain Polkadot" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Domande frequenti sulla blockchain Polkadot</h2><p><strong>Cosa è <a href="/price/polkadot-dot" rel="nofollow noopener noreferrer" target="_blank">Polkadot</a>? </strong></p>
<p><a href="/price/polkadot-dot" rel="nofollow noopener noreferrer" target="_blank">Polkadot</a> è un protocollo decentralizzato che collega le blockchain, consentendo loro di comunicare tra loro. Pertanto, consente il trasferimento di valore tra diverse blockchain.</p>
<p><strong>Cos’è <a href="/price/polkadot-dot" rel="nofollow noopener noreferrer" target="_blank">Polkadot</a> casi d’uso?</strong></p>
<p><a href="/price/polkadot-dot" rel="nofollow noopener noreferrer" target="_blank">Polkadot</a> è scalabile e veloce poiché svolge molte delle attività off-chain utilizzando le sue catene parallele. Il suo scopo principale è quello di consentire a blockchain come <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> e <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> condividere i loro dati.</p>
<p><strong>Che tipo di blockchain è <a href="/price/polkadot-dot" rel="nofollow noopener noreferrer" target="_blank">Polkadot</a>? </strong></p>
<p><a href="/price/polkadot-dot" rel="nofollow noopener noreferrer" target="_blank">Polkadot</a> è una blockchain di livello 0 che supporta altre blockchain come <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> e <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> permettendo loro di comunicare tra di loro. È una base su cui possono esistere vari progetti crypto.</p>
<p><strong>Chi compete con <a href="/price/polkadot-dot" rel="nofollow noopener noreferrer" target="_blank">Polkadot</a>? </strong><br><a href="/price/polkadot-dot" rel="nofollow noopener noreferrer" target="_blank">Polkadot</a> ha diversi concorrenti che includono <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a>, <a href="/price/chainlink-link" rel="nofollow noopener noreferrer" target="_blank">Chainlink</a>, Eclipse, Cosmos e Octopus Network. Queste blockchain consentono ai progetti cripto, comprese le applicazioni decentralizzate, di esistere su di esse.</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 venga fatto riferimento a Gate.io. In tutti i casi, saranno intraprese azioni legali a causa della violazione del copyright.<br></div><p></p><br></div></div></div>