R2F0ZS5pbyBBTUEgY29uIEthcmF0IC0gTGEgcGnDuSBncmFuZGUgcmV0ZSBkYXRpIHN1IHprU3luYw==

<p><img src="https://gimg2.gateimg.com/image/article/16927711601.jpeg" alt=""><br><strong>Ora: 18 agosto 2023 alle 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 Shaw, rappresentante di Karat nel <a href="https://twitter.com/i/spaces/1lPJqBOMqVwxb" rel="nofollow noopener noreferrer" target="_blank">Twitter Space</a>.</strong><br><strong>Sito Ufficiale: <a href="https://karatdao.com/" rel="nofollow noopener noreferrer" target="_blank">https://karatdao.com/</a></strong><br><strong>Twitter: <a href="https://twitter.com/KaratDAO" rel="nofollow noopener noreferrer" target="_blank">https://twitter.com/KaratDAO</a></strong><br><strong>Segui Karat su <a href="https://twitter.com/KaratDAO" rel="nofollow noopener noreferrer" target="_blank">Twitter</a> e <a href="https://t.co/72GxoPUgIB" rel="nofollow noopener noreferrer" target="_blank">Discord</a></strong><br><strong>Ospite</strong><img src="https://gimg2.gateimg.com/image/article/16927713502.jpg" alt=""><br><strong>Shaw — Rappresentante di Karat</strong></p>
<h2 id="h2-QampA20da20Gateio377946"><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><h3 id="h3-Q120Come20KaratDAO20garantisce20la20privacy20e20la20sicurezza20dei20dati20degli20utenti20durante20lo20sviluppo20di20un20middleware20dati20condivisibile20onchain149910"><a name="Q1: Come KaratDAO garantisce la privacy e la sicurezza dei dati degli utenti durante lo sviluppo di un middleware dati condivisibile on-chain?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q1: Come KaratDAO garantisce la privacy e la sicurezza dei dati degli utenti durante lo sviluppo di un middleware dati condivisibile on-chain?</h3><p>KaratDAO mette la tua privacy al primo posto, utilizzando la Multi-Party Computation (MPC) on-chain e la tecnologia Zero Knowledge (ZK). Le informazioni degli utenti, come gli indirizzi email e Twitter, vengono crittografate, legate al loro portafoglio e archiviate su IPFS. Con la chiave privata MPC, gli utenti di Karat assumono il totale controllo.</p>
<h3 id="h3-Q220Che20cos20KaratDAO927579"><a name="Q2: Che cos’è KaratDAO?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q2: Che cos’è KaratDAO?</h3><p>KaratDao brilla come la star della scena di ZKSync. Immagina più di 300.000 portafogli con dati <a href="/web3" target="_blank" class="blog_inner_link">web3</a> e web2 verificati, alimentati da professionisti provenienti da Apple, Google e un imprenditore Forbes 30 sotto i 30 anni.</p>
<p>Combina la magia di MPC on-chain e ZK per una miscela di ID condivisibili Web 2 e 3. Bitmart, <a href="/price/neo-neo" rel="nofollow noopener noreferrer" target="_blank">NEO</a> Eco unisciti alla festa, assicurando email, tweet su IPFS. Gli utenti e i nodi regolano i dati con chiavi private MPC.</p>
<p>KaratDao apre la strada per future Dapps - Web3 social, indicizzazione dei dati, ad flair, atmosfera di accesso fluida.</p>
<p>Ora, Main Net magico. Karat ridefinisce la partecipazione - scommetti, reclama, convalida - è il turno dell’utente di rinnovare insieme a Social-Fi di blockchain!</p>
<h3 id="h3-Q320Cosa20distingue20KaratDAO20dagli20altri20protocolli20su20ZKSync407829"><a name="Q3: Cosa distingue KaratDAO dagli altri protocolli su ZKSync?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q3: Cosa distingue KaratDAO dagli altri protocolli su ZKSync?</h3><p>KaratDAO si distingue per il suo focus nello sviluppo di un middleware dati on-chain condivisibile sia per il Web 2 che per il Web 3. Questo middleware consente agli utenti di registrare i propri ID Web 2 e gli indirizzi del portafoglio Web 3, guadagnando ricompense in modo sicuro e nel rispetto della privacy. Inoltre, le partnership di KaratDAO con comunità e validatori di spicco rafforzano la credibilità e la solidità del suo ecosistema.</p>
<h3 id="h3-Q420Puoi20fornire20esempi20di20casi20duso20in20cui20linfrastruttura20di20KaratDAO20svolge20un20ruolo20cruciale575409"><a name="Q4: Puoi fornire esempi di casi d’uso in cui l’infrastruttura di KaratDAO svolge un ruolo cruciale?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q4: Puoi fornire esempi di casi d’uso in cui l’infrastruttura di KaratDAO svolge un ruolo cruciale?</h3><p>KaratDAO getta le basi per le prossime Dapps che necessitano di social Web3, indicizzazione dei dati, annunci e accessi. Connette Web 2 e Web 3 per una condivisione e un controllo dei dati fluidi, dando potere agli utenti e agli sviluppatori nei social media decentralizzati, nella verifica dell’identità e negli annunci personalizzati.</p>
<h3 id="h3-Q520Cos20KAT20Puoi20condividere20con20noi20ulteriori20dettagli828145"><a name="Q5: Cos’è $KAT? Puoi condividere con noi ulteriori dettagli?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q5: Cos’è $KAT? Puoi condividere con noi ulteriori dettagli?</h3><p>Parliamo di $KAT - il Token Karat. È strettamente legato al valore dei dati sulla rete Karat. Man mano che vengono aggiunti dati di valore alla rete, vengono estratti i token KAT. Ora, c’è questo sistema interessante di ‘Verifica per Guadagnare’. Quando gli utenti confermano la loro identità, vengono ricompensati in base al loro saldo ETH e KARAT, all’età del portafoglio, al livello del validatore e alla distribuzione giornaliera. Questo stimola i dati e gli asset sulla rete, incoraggia il possesso di KAT e spinge i validatori a scommettere di più. Abbiamo un limite giornaliero per evitare che grandi gruppi di mining e scambi lo sovraccarichino. Inoltre, i validatori ottengono un aumento del punteggio quando nuovi richiedenti verificano e i portafogli ricevono token KAT in base ai loro punteggi.</p>
<h3 id="h3-Q620Puoi20spiegare20come2020strutturata20la20tua20distribuzione20di20token20Quanti20token20verranno20emessi20e20Quanti20token20saranno20bloccati20dal20Team927667"><a name="Q6: Puoi spiegare come è strutturata la tua distribuzione di token? Quanti token verranno emessi? e Quanti token saranno bloccati dal Team?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q6: Puoi spiegare come è strutturata la tua distribuzione di token? Quanti token verranno emessi? e Quanti token saranno bloccati dal Team?</h3><p>Bene, abbiamo in totale 2 miliardi di KAT. Di questi, il 70% è riservato per il mining sociale della comunità per i prossimi dieci anni. Nei primi mesi dopo il 22 agosto, possono essere coniati e minati 70 milioni di KAT. Solo il 10% va al team. Il restante 30%, destinato al team, consulenti, marketing, operazioni e investitori, è bloccato per 4 anni con un rilascio graduale mensile.</p>
<h3 id="h3-Q720Secondo20la20roadmap20del20progetto20quali20sono20le20tue20priorit20pi20importanti576232"><a name="Q7: Secondo la roadmap del progetto, quali sono le tue priorità più importanti?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q7: Secondo la roadmap del progetto, quali sono le tue priorità più importanti?</h3><p>Al momento ci stiamo dedicando al lancio e all’incremento della nostra rivoluzionaria Main Net. Mentre entriamo in questa nuova era di Social-Fi, i nostri principali focus sono:<br>Lancio della Main Net: La nostra massima priorità è garantire un lancio senza intoppi il 22 agosto 2023. Stiamo lavorando sodo per assicurarci che gli utenti abbiano un’esperienza senza soluzione di continuità fin dall’inizio.</p>
<p>Coinvolgimento dell’Ecosistema: Stiamo costruendo un ecosistema prospero. Coinvolgendo stakeholder, richiedenti, validatori e tutti coloro coinvolti per creare un ambiente collaborativo in cui tutti possano contribuire e guadagnare.</p>
<p>Onboarding dei Validatori: La Fase II è in corso e stiamo coinvolgendo i validatori che condividono la nostra visione. Li stiamo supportando per stabilire una presenza preziosa nella rete.</p>
<p>Rendere facile la richiesta: stiamo semplificando il processo per diventare richiedenti. Vogliamo che gli utenti verifichino le loro credenziali senza sforzo e si uniscano alla nostra iniziativa di guadagnare attraverso la verifica.</p>
<p>Successo dello staker: siamo tutti impegnati a incrementare i guadagni dello staker. Forniamo strumenti e informazioni utili agli utenti per prendere decisioni intelligenti in merito alla staking e ottimizzare il rendimento.</p>
<p>Crescere la comunità: puntiamo ad espandere la nostra comunità riconoscendo validatori preziosi ma sottoposti a staking insufficiente. Stiamo portando nuovi richiedenti e stakeholder che vedono il potenziale della nostra piattaforma.</p>
<p>Miglioramento continuo: stiamo sempre perfezionando. Migliorare l’esperienza dell’utente, prendere in considerazione i feedback e migliorare continuamente la nostra piattaforma sono le nostre principali priorità.</p>
<h3 id="h3-Q820Ci20sono20notizie20o20aggiornamenti20interessanti20riguardanti20KAT20che20ti20piacerebbe20condividere20con20gli20utenti355804"><a name="Q8: Ci sono notizie o aggiornamenti interessanti riguardanti KAT che ti piacerebbe condividere con gli utenti?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q8: Ci sono notizie o aggiornamenti interessanti riguardanti KAT che ti piacerebbe condividere con gli utenti?</h3><p>Abbiamo alcune notizie entusiasmanti da condividere su $KAT! La nostra Main Net, progettata per le persone, sta ridefinendo Social-Fi nel mondo delle blockchain. Gli utenti ora possono guadagnare dalla crescita di progetti e comunità facendo stake con il nostro Karat Validator.</p>
<p>Ecco cosa c’è di nuovo e in corso:<br>Unisciti alla MainNet: il 22 agosto, puoi salire a bordo come richiedente e ottenere gratuitamente i token $KAT. È un’opportunità per far parte di questa rete rivoluzionaria.</p>
<p>Stake for Growth: Puoi utilizzare i tuoi token $KAT per scommettere con i validatori più promettenti, il che può significare guadagnare mentre i progetti prosperano. Trova quelli con potenziale e otterrai ritorni massimizzati.<br>Diventa un Validatore: Nella Fase II, scommettendo 35.000 token KAT puoi diventare un validatore. Puoi pubblicare sulla News Feed dell’app Karat, lanciare campagne allettanti e guadagnare ricompense KAT attraverso le operazioni di validazione.</p>
<p>Per quanto riguarda i guadagni:<br>Nel primo mese sono disponibili ben 70 milioni di token KAT, di cui 5 milioni il giorno del lancio.<br>Gli stakeholder ricevono circa 1⁄6di ricompense per ogni nuovo richiedente attraverso validatori in staking.</p>
<p>I validatori guadagnano in base all’importo di KAT scommesso e alla scommessa complessiva della rete.</p>
<p>Quindi, tempi entusiasmanti in arrivo! Fai parte di questo viaggio innovativo, dove $KAT non è solo un token ma una chiave per plasmare il futuro di Social-Fi.</p>
<div class="blog-details-info"><br><div>Autore: <strong>Rio Fu.</strong>, Comunità 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 si faccia riferimento a Gate.io. In tutti i casi, saranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div>