R2F0ZS5pbyBBTUEgY29uIEtJTFQtRm9ybmlyZSBzb2x1emlvbmkgZGkgaWRlbnRpdMOgIHNpY3VyZSBlIHByYXRpY2hlIHBlciBpbXByZXNlIGUgY29uc3VtYXRvcmk=

<p><img src="https://gimg2.gateimg.com/image/article/16812809931.jpg" alt=""><br><strong>Ora: 7 aprile 2022, 13:00 UTC</strong><br><strong><a href="https://www.gate.io" target="_blank">Gate.io</a> ha ospitato una sessione AMA (Ask-Me-Anything) con Ingo Ruebe, Fondatore del Protocollo KILT nel <a href="https://t.me/gateio" rel="nofollow noopener noreferrer" target="_blank">Comunità di Gate.io Exchange</a>.</strong><br><strong>Sito Ufficiale: <a href="https://www.kilt.io/" rel="nofollow noopener noreferrer" target="_blank">https://www.kilt.io/</a></strong><br><strong>Twitter: <a href="https://twitter.com/Kiltprotocol" rel="nofollow noopener noreferrer" target="_blank">https://twitter.com/Kiltprotocol</a></strong><br><strong>Segui il protocollo KILT su <a href="https://t.me/KILTProtocolChat" rel="nofollow noopener noreferrer" target="_blank">Telegram</a> e <a href="https://discord.com/invite/HztRqvzbhG" rel="nofollow noopener noreferrer" target="_blank">Discord</a></strong><br><strong>Ospite</strong><img src="https://gimg2.gateimg.com/image/article/16812812172.png" alt=""><br><strong>Ingo Ruebe - Fondatore del Protocollo KILT</strong></p>
<h2 id="h2-QampA20da20Gateio297024"><a name="Q&amp;A da Gate.io" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q&amp;A da Gate.io</h2><p>Introduzione: Ingo non sarà in grado di unirsi a noi oggi, ma la sua collega Christine sarà qui.<br>Per dare a tutti una breve introduzione su Christine.<br>Christine Mohan è Vice Presidente dello Sviluppo Aziendale per il Protocollo KILT, dove gestisce <a href="/price/polkadot-dot" rel="nofollow noopener noreferrer" target="_blank">Polkadot</a> partnership nell’ecosistema, nonché PR e marketing di crescita.<br>In precedenza, Christine è stata Chief Marketing Officer presso <a href="/web3" target="_blank" class="blog_inner_link">Web3</a> Foundation e <a href="/price/polkadot-dot" rel="nofollow noopener noreferrer" target="_blank">Polkadot</a>, dove ha lavorato con i fondatori dell’ecosistema su più di 100 annunci (DeFi, identità, privacy, giochi, IoT, supply chain, storage, portafogli).<br>Ha iniziato nel settore blockchain nel 2017 come co-fondatrice di Civil Media, una piattaforma di sindacazione delle notizie finanziata da ConsenSys e costruita su <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a>.<br>Christine ha esperienza nel lancio di aziende blockchain, tecnologie emergenti e aziende di media digitali, e ha trascorso 11 anni al The New York Times e al Wall Street Journal gestendo siti web e piattaforme di distribuzione dei contenuti.<br>Ora che tutti sappiamo un po’ su Christine, perché non iniziamo a fare le cose?</p>
<h3 id="h3-Q120Christine20raccontaci20cos20lidentit20digitale978981"><a name="Q1: Christine, raccontaci, cos’è l’identità digitale?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q1: Christine, raccontaci, cos’è l’identità digitale?</h3><p><strong>Christine</strong>: KILT Protocol è un sistema per mantenere le identità digitali. L’identità inizia con un identificatore (come il nome di una persona), a cui sono collegati documenti come i passaporti. L’identità viene costruita aggiungendo sempre più documenti a un identificatore, come la patente di guida o il diploma universitario. Se si desidera creare un’identità digitale, è necessario sia un identificatore - per persone o cose - e poi sono necessari diversi tipi di documenti collegati all’identificatore. Poi passo dopo passo si produce un’identità digitale.<br><img src="https://gimg2.gateimg.com/image/article/16812812403.png" alt=""><br>Questo può essere fatto anche per le macchine. L’identificatore del dispositivo potrebbe essere un numero molto lungo, ad esempio. Questo dispositivo può essere identificato da questo numero perché questo numero gli è unico. E poi, passo dopo passo, si aggiungono sempre più credenziali ad esso. Quindi il dispositivo ottiene un’identità digitale.</p>
<h3 id="h3-Q220Perch20hai20avviato20il20Protocollo20KILT2020quali20problemi20volevi20risolvere847214"><a name="Q2: Perché hai avviato il Protocollo KILT - quali problemi volevi risolvere?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q2: Perché hai avviato il Protocollo KILT - quali problemi volevi risolvere?</h3><p><strong>Christine</strong> Quando si guarda all’identità digitale in Web2, questa identità è essenzialmente detenuta da grandi aziende e social network. Questi monopoli aggregano i tuoi dati e li conservano nei loro database. Questo diventa davvero pericoloso perché non sono solo i tuoi dati che si stanno aggregando, ma anche i dati di tutti gli altri. Quindi questo è un enorme esca per gli hacker.</p>
<p>Ho visto che la blockchain aveva il potenziale per affrontare queste situazioni in cui gli utenti hanno perso il controllo dei propri dati. Volevo costruire una soluzione che potesse essere implementata su larga scala da parte di aziende e governi, ma abbastanza flessibile da consentire agli sviluppatori di creare rapidamente le proprie attività intorno all’identità e alla verifica delle credenziali.</p>
<p>Siamo stati tra i primi adottanti nel 2018 di Substrate, un sistema modulare sviluppato da Parity Technologies che facilita la creazione di blockchain personalizzate. Substrate consente un’integrazione senza soluzione di continuità con <a href="/price/polkadot-dot" rel="nofollow noopener noreferrer" target="_blank">Polkadot</a>, una rete che supera i problemi precedenti di sicurezza, scalabilità e interoperabilità che finora hanno rallentato l’adozione della blockchain.</p>
<h3 id="h3-Q320Cos20SocialKYC20e20come2020utile20per20i20giocatori854378"><a name="Q3: Cos’è SocialKYC e come è utile per i giocatori?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q3: Cos’è SocialKYC e come è utile per i giocatori?</h3><p><strong>Christine</strong>: SocialKYC è un servizio per riprendere il controllo della propria identità digitale che si basa su KILT. KYC o “Know Your Customer” è una pratica standard durante l’apertura di un conto presso una banca o un exchange, dove i clienti devono dimostrare di possedere credenziali emesse dal governo come un passaporto. SocialKYC dà agli utenti il potere di estendere la fiducia costruendo un’identità digitale utilizzando il proprio indirizzo email o account social (Twitter, Twitch, Github, Discord).<br><img src="https://gimg2.gateimg.com/image/article/16812812934.png" alt=""><br>I giocatori e le aziende di gioco possono utilizzare SocialKYC per:</p>
<ul>
<li>Sviluppare registri per l’accoppiamento dei giocatori e il monitoraggio dei premi</li><li>Emettere crediti educativi e verifica dell’età per i giochi giovanili</li><li>Fornire KYC per premi e sistemi di pagamento</li><li>Monitorare le prestazioni su più piattaforme di gioco e reti.</li></ul>
<h3 id="h3-Q420Cosa20sono20i20DIDs20e20come20possono20essere20utilizzati20in20affari64426"><a name="Q4: Cosa sono i DIDs e come possono essere utilizzati in affari?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q4: Cosa sono i DIDs e come possono essere utilizzati in affari?</h3><p><strong>Christine</strong>: Un DID è un identificatore decentralizzato e appare così:<br>did:kilt:4s8kEBWV9nwU5znxmfR7DVA31DdBoqYGj49SAiAPzzigwJDm</p>
<p>Si tratta di un insieme unico di numeri e lettere che identifica in modo univoco un’identità (come un’impronta digitale) in modo verificabile e decentralizzato. In KILT, l’identità è costruita aggiungendo credenziali al DID. Gli sviluppatori possono utilizzare KILT per creare identificatori e credenziali per esseri umani, macchine, servizi, casi d’uso IoT e qualsiasi altra cosa che necessiti di un’identità.</p>
<p>Ad esempio, il nostro partner Authtrail integrerà KILT DIDs nella loro piattaforma, per migliorare la sua affidabilità e la trasparenza dei dati. <a href="/price/flow-flow" rel="nofollow noopener noreferrer" target="_blank">Flusso</a> per i loro clienti aziendali. Un altro partner, Attarius Network, utilizzerà KILT DIDs e credenziali verificabili nel loro marketplace NFT per l’industria del gioco.</p>
<h3 id="h3-Q520Come20si20differenzia20DIDsign20dal20software20di20firma20Web2380433"><a name="Q5: Come si differenzia DIDsign dal software di firma Web2?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q5: Come si differenzia DIDsign dal software di firma Web2?</h3><p><strong>Christine</strong>: DIDsign è decentralizzato. Solo il mittente e il destinatario hanno accesso ai file; non sono archiviati da nessun’altra parte. Altri software di firma come Docusign sono centralizzati e archiviano i documenti che si stanno firmando.<br>DIDsign è flessibile. È possibile firmare qualsiasi file digitale - PDF, audio, video, software - direttamente nel proprio browser utilizzando un identificatore decentralizzato unico (DID). Le piattaforme di firma Web2 firmano di solito solo i PDF.<br>DIDsign è verificabile. Diverse persone possono firmare lo stesso documento separatamente e confermare che ogni parte ha firmato il documento nella sua forma originale.<br>DIDsign è conveniente. È possibile scaricare il file firmato insieme alla firma sul proprio dispositivo come file zip e inviarlo a chiunque tramite e-mail, Telegram, WhatsApp, ecc. Il destinatario può quindi verificare facilmente che il file non è stato manomesso.<br>DIDsign è gratuito. Firmare, inviare e verificare i file è sempre gratuito.</p>
<h3 id="h3-Q620Quali20sono20i20prossimi20passi20per20KILT20Cosa20stai20costruendo20ora878837"><a name="Q6: Quali sono i prossimi passi per KILT? Cosa stai costruendo ora?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q6: Quali sono i prossimi passi per KILT? Cosa stai costruendo ora?</h3><p><strong>Christine</strong>: La prossima settimana lanceremo una nuova applicazione per la creazione di nomi DID personalizzati unici. Questo nome è un modo personale per rappresentare il tuo identificatore decentralizzato (DID) on-chain, che è una stringa di lettere e numeri che costituisce il nucleo della tua identità digitale KILT. Ad esempio, i validatori e i collatori possono personalizzare un nome che li renda facili da identificare. Questo nome può anche essere utilizzato con DIDsign, aggiungendo un ulteriore livello di verifica quando condividi file digitali che hai firmato.</p>
<p>Riveleremo il nome e dimostreremo l’applicazione la prossima settimana alla Paris Blockchain Week.</p>
<div class="blog-details-info"><br><div>Autore: <strong>Rio Fu.</strong>, Comunità 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 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>