R2F0ZS5pbyBBTUEgY29uIFR5cGVsdC1QZXIgZ3VhZGFnbmFyZSByZWRkaXRvIHBhc3Npdm8gc3ZvbGdlbmRvIGxhIGJhdHRpdHVyYSBxdW90aWRpYW5h

<p><img src="https://gimg2.gateimg.com/image/article/16928711941.jpeg" alt=""><br><strong>Data: 21 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 Patrick, Consulente di Typelt nel <a href="https://twitter.com/i/spaces/1RDGlayzPqNJL" rel="nofollow noopener noreferrer" target="_blank">Spazio Twitter</a>.</strong><br><strong>Sito Ufficiale: <a href="https://www.typeit.net/" rel="nofollow noopener noreferrer" target="_blank">https://www.typeit.net/</a></strong><br><strong>Twitter: <a href="https://twitter.com/typeit_" rel="nofollow noopener noreferrer" target="_blank">https://twitter.com/typeit_</a></strong><br><strong>Segui Typelt su <a href="https://twitter.com/typeit_" rel="nofollow noopener noreferrer" target="_blank">Twitter</a> e <a href="https://t.me/Typeit_Official" rel="nofollow noopener noreferrer" target="_blank">Telegram</a></strong><br><strong>Ospite</strong><img src="https://gimg2.gateimg.com/image/article/16928714152.png" alt=""><br><strong>Patrick - Consulente di Typelt</strong></p>
<h2 id="h2-Domande20e20risposte20da20Gateio727088"><a name="Domande e risposte da Gate.io" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Domande e risposte da Gate.io</h2><h3 id="h3-Q120Ti20preghiamo20di20presentare20TypeIt337979"><a name="Q1: Ti preghiamo di presentare TypeIt" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q1: Ti preghiamo di presentare TypeIt</h3><p><strong>Patrick</strong> Ciao a tutti, sono Patrick.</p>
<p>TypeIt è una tastiera <a href="/web3" target="_blank" class="blog_inner_link">Web3</a> che ti permette di guadagnare ricompense attraverso il “Type to Earn”, il che significa che puoi guadagnare reddito digitando. Oltre a questo, incorpora elementi di interazione sociale e gioco. Per quanto riguarda la privacy, tutti i dati di input sono crittografati e memorizzati in locale.</p>
<p>Attualmente, sia i nostri token che gli NFT sono attivi, utilizzando un modello a doppio token. Abbiamo due tipi di token e due categorie di NFT che interagiscono e circolano all’interno dell’ecosistema, mantenendo un saldo positivo attraverso funzionalità come la distruzione dei token e la creazione di NFT.</p>
<p>Inoltre, abbiamo stabilito partnership con varie aziende, tra cui l’attuale collaboratore Gate.io, così come RelationLabs, Manta Network, Soully, e altre ancora.</p>
<p>Nel suo nucleo, TypeIt mira a essere un hub centrale all’interno dell’ecosistema Web3. Sfrutta lo strumento tradizionale di una tastiera per fungere da gateway per gli utenti per entrare nel mondo Web3. In questo modo, gli utenti possono adattarsi senza soluzione di continuità al nuovo panorama Web3 e godere dei benefici di Web3 e dell’economia digitale.</p>
<h3 id="h3-Domanda20220Come20protegge20TypeIt20la20privacy20degli20utenti82077"><a name="Domanda 2: Come protegge TypeIt la privacy degli utenti?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Domanda 2: Come protegge TypeIt la privacy degli utenti?</h3><p><strong>Patrick</strong>: Per TypeIt, la privacy degli utenti e la sicurezza dei dati sono ambiti estremamente sensibili e tra le nostre massime priorità.</p>
<p>Prima di tutto, presso TypeIt, tutti i dati di input dell’utente rimangono offline e vengono crittografati localmente, il che significa che nessuno dei dati viene trasmesso su Internet. Chi è interessato può verificarlo in modo indipendente tramite strumenti.</p>
<p>A tal proposito, stiamo esplorando attivamente approcci più trasparenti per aiutare gli utenti a comprendere le nostre pratiche sulla privacy. Questi potrebbero includere metodi come Zero-Knowledge Proofs (ZK), audit e open sourcing.</p>
<p>Inoltre, per quanto riguarda l’esperienza dell’utente, crittografiamo localmente tutte le chiavi private del portafoglio importate. Gli utenti devono inserire le loro password di pagamento per avviare le esportazioni, proteggendo così dalle potenziali perdite dovute alla compromissione del dispositivo.</p>
<p>Per quanto riguarda gli appunti all’interno della tastiera, offriamo pulsanti funzionali che consentono agli utenti di attivare o disattivare l’accesso agli appunti.<br>Nel frattempo, stiamo collaborando con società di sicurezza per sfruttare la piattaforma della tastiera, offrendo agli utenti indicazioni su come riconoscere truffe di phishing, attività fraudolente e altre minacce potenziali per evitare eventuali perdite di asset.</p>
<p>Questi sforzi riflettono il nostro impegno per garantire la massima privacy e sicurezza per i dati e le interazioni dei nostri utenti.</p>
<h3 id="h3-Q320Potresti20spiegare20come20TypeIt20integra20la20tecnologia20blockchain20nella20sua20funzionalit20e20nellesperienza20utente559351"><a name="Q3: Potresti spiegare come TypeIt integra la tecnologia blockchain nella sua funzionalità e nell’esperienza utente?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q3: Potresti spiegare come TypeIt integra la tecnologia blockchain nella sua funzionalità e nell’esperienza utente?</h3><p><strong>Patrick</strong>: Attualmente, abbiamo già implementato diverse funzionalità basate su blockchain all’interno del nostro sistema.</p>
<p>Ad esempio, il nostro portafoglio blockchain consente l’accesso decentralizzato, e stiamo pianificando di potenziare ulteriormente questo con funzionalità di astrazione dell’account. Questo includerà l’utilizzo della computazione multi-partecipante (MPC) per funzionalità come l’autenticazione senza chiave e il recupero sociale.</p>
<p>Inoltre, tutti i nostri dati sono crittografati localmente. In futuro, stiamo esplorando partnership con servizi come Manta, che offre funzionalità zk zero-knowledge proof. Questo ci consentirà di sfruttare la tecnologia zk per migliorare la sicurezza dei nostri dati crittografati.</p>
<p>La tecnologia zk offre anche capacità di verifica. Ciò ci consentirà di introdurre una libreria di vocabolario condiviso, in cui gli utenti possono creare i propri dizionari e crittografarli utilizzando prove zk. Attraverso protocolli come IPFS e AR, possiamo ottenere archiviazione e condivisione decentralizzate.</p>
<p>Oltre a queste caratteristiche, come accennato in precedenza, Socialfi, Gamefi e le collaborazioni come il nostro partenariato con Soully per l’introduzione della funzionalità DID fanno tutti parte delle nostre implementazioni basate su blockchain.</p>
<p>TypeIt si impegna a sfruttare la tecnologia blockchain per migliorare la sicurezza, la privacy e l’esperienza dell’utente, introducendo al contempo funzionalità innovative e coinvolgenti nella nostra comunità.</p>
<h3 id="h3-Q420Quali20dati20di20milestone20pu20condividere20TypeIt184708"><a name="Q4: Quali dati di milestone può condividere TypeIt?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q4: Quali dati di milestone può condividere TypeIt?</h3><p><strong>Patrick</strong>: In primo luogo, durante la nostra fase di test interna, abbiamo ricevuto supporto e feedback da oltre 2.000 persone nella nostra comunità iniziale.</p>
<p>In secondo luogo, al lancio ufficiale del nostro token TYPE attraverso il Launchpad, abbiamo ottenuto il sostegno di oltre 5.200 individui, per un totale di finanziamento di $12 milioni.</p>
<p>Inoltre, ecco alcuni punti dati chiave che vorremmo condividere:</p>
<p>La nostra comunità attualmente si estende nelle principali regioni dell’Asia e delle Americhe, con una dimensione della comunità che supera i 30.000 membri. Abbiamo accumulato circa 35.000 utenti in totale, e il nostro conteggio degli utenti attivi quotidiani rimane costantemente sopra i 10.000.</p>
<p>Per quanto riguarda i nostri NFT, abbiamo condotto un totale di 5 round di vendite, con l’ultimo round conclusosi la scorsa settimana, che ha portato alla vendita di circa 50.000 scatole cieche.</p>
<p>Inoltre, al momento del lancio iniziale, in particolare nella sezione NFT del <a href="/price/bnb-bnb" rel="nofollow noopener noreferrer" target="_blank">BNB</a> Con Chain, abbiamo raggiunto un’elevata classifica per il consumo di gas e abbiamo ottenuto con successo una sovvenzione per il Gas dalla <a href="/price/bnb-bnb" target="_blank" class="blog_inner_link">BNB</a> Chain.</p>
<p>Al momento, poiché i nostri NFT e token vengono consumati attraverso gli aggiornamenti, abbiamo distrutto oltre 7 milioni di token TYPE, che corrisponde a più di $1,54 milioni, e questo numero continua a crescere. Accogliamo tutti a rimanere sintonizzati per ulteriori aggiornamenti.</p>
<h3 id="h3-Q520Qual2020il20modello20di20tokenomica20di20TypeIt244030"><a name="Q5: Qual è il modello di tokenomica di TypeIt?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q5: Qual è il modello di tokenomica di TypeIt?</h3><p><strong>Patrick</strong>: I nostri token sono principalmente divisi in due categorie: il token di utilità WORD e il token di governance TYPE, entrambi con un’offerta totale di 1 miliardo ciascuno.</p>
<p>Il 50% dei token TYPE sarà allocato come ricompensa per i trascrittori e subirà una riduzione del rendimento ogni 30 giorni, con gli aggiustamenti futuri determinati tramite governance della comunità.</p>
<p>Il prossimo token è WORD, che viene generato esclusivamente tramite il meccanismo Type to Earn, fornendo una quantità fissa giornaliera. Simile a TYPE, il suo rendimento diminuirà ogni 30 giorni. Gli guadagni da ciascun NFT vengono distribuiti in base alla proporzione della potenza computazionale. Ci sono due tipi di NFT: rosso e blu, ciascuno con un massimo di 5 livelli.</p>
<p>Gli NFT rossi consumano TYPE per gli aggiornamenti e la manutenzione, generando nel contempo ricompense WORD. Gli NFT blu, d’altro canto, utilizzano WORD per gli aggiornamenti e la manutenzione, generando ricompense TYPE.</p>
<p>Il funzionamento del modello economico intreccia questi componenti, garantendo che gli NFT non siano solo singole macchine minerarie e che i token non perdano la loro capacità di catturare il valore.</p>
<p>Inoltre, abbiamo incorporato vari scenari di gioco, come la scelta tra NFT rossi e blu, optando per la schiusa o la digitazione, decidendo sugli aggiornamenti o detenendo un maggior numero di NFT di livello inferiore, e così via.</p>
<h3 id="h3-Q620Come20costruisce20TypeIt20la20propria20ecologia820418"><a name="Q6: Come costruisce TypeIt la propria ecologia?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q6: Come costruisce TypeIt la propria ecologia?</h3><p><strong>Patrick</strong>: In primo luogo, il nostro principale flusso di entrate esterne si baserà sulla pubblicità. Incorporando pubblicità esterne, miriamo a fornire agli utenti ulteriori opportunità di reddito.</p>
<p>Sfruttando l’ampia base di utenti della tastiera, gli inserzionisti possono beneficiare di un’esposizione efficace.</p>
<p>In secondo luogo, all’interno del nostro ecosistema interno, pianifichiamo di introdurre varie funzioni coinvolgenti. Ciò include Socialfi e i mini-giochi di Gamefi, che consentono agli utenti di guadagnare ricompense extra partecipando a divertenti giochi di battitura.</p>
<p>Inoltre, abbiamo la funzione TNA (Tipo e Airdrop), che coinvolge design di skin collaborativi. Digitando con queste skin collaborative, gli utenti possono guadagnare ricompense sia da loro stessi che dalle entità con cui collaboriamo.</p>
<p>Per quanto riguarda le skin NFT, stiamo anche pianificando di lanciare un programma per creatori in futuro. Questo programma coinvolgerà gli utenti nella co-creazione e nell’integrazione dei loro design nell’ecosistema più ampio.</p>
<p>Queste iniziative riflettono il nostro impegno nel creare un ecosistema multifacetico che fornisce valore sia agli utenti che ai collaboratori, mantenendo un modello di redditività sostenibile.</p>
<h3 id="h3-Q720Quali20sono20le20differenze20tra20type20to20earn20e20altri20X2E290656"><a name="Q7: Quali sono le differenze tra type to earn e altri X2E?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q7: Quali sono le differenze tra type to earn e altri X2E?</h3><p><strong>Patrick</strong>: Grazie mille. Come tastiera, TypeIt si distingue dalle altre soluzioni X2E principalmente attraverso la scelta della lettera “X” - la digitazione - che raggiunge una barriera di ingresso zero.</p>
<p>In secondo luogo, la protezione della privacy è una considerazione fondamentale. I dati di input vengono crittografati e archiviati localmente, rendendoli inaccessibili a chiunque altro. Abbiamo anche collaborato con Manta, un fornitore di soluzioni modulari per la privacy specializzato nella tecnologia zk, per affrontare le preoccupazioni sulla privacy degli utenti. I nostri piani futuri prevedono di sfruttare la tecnologia zk per soluzioni di privacy avanzate.</p>
<p>In terzo luogo, il nostro modello economico incorpora token duali e NFT duali, accoppiati con meccanismi di consumo e di incubazione, insieme a un meccanismo di riduzione dei token che ricorda quello di BTC. Queste caratteristiche sono attentamente progettate per facilitare un ciclo sostenibile.</p>
<p>In quarto luogo, abbiamo una funzione di Freemint in corso, che consente agli utenti di ottenere un NFT Freemint partecipando a eventi ufficiali o unendosi alla comunità. Questo NFT offre un assaggio dell’esperienza di Type to Earn e può essere convertito in un NFT formale per aumentare gli guadagni.</p>
<p>Infine, rispetto ad altre offerte, TypeIt vanta un maggiore potenziale per scenari e collaborazioni. Ad esempio, la nostra collaborazione con partner ha portato all’introduzione di NFT co-branding. Questi NFT non solo generano le proprie ricompense, ma concedono anche incentivi cooperativi, noti come TNA (Type and Airdrop).</p>
<p>Grazie per l’opportunità di illustrare le caratteristiche uniche di TypeIt nel panorama di Gamefi.</p>
<h3 id="h3-Q820Nel20contesto20del20mutare20del20panorama20dei20tastiere20Web320e20dellincremento20dellattivit20come20si20posiziona20TypeIt20allinterno20di20questa20sfera20emergente570254"><a name="Q8: Nel contesto del mutare del panorama dei tastiere Web3 e dell’incremento dell’attività, come si posiziona TypeIt all’interno di questa sfera emergente?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q8: Nel contesto del mutare del panorama dei tastiere Web3 e dell’incremento dell’attività, come si posiziona TypeIt all’interno di questa sfera emergente?</h3><p><strong>Patrick</strong> Per noi, è il nostro impegno incrollabile a realizzare la nostra visione che ci spinge avanti. Questo impegno ci posiziona come la porta centrale verso il mondo Web3 e stiamo lavorando attivamente per costruire un ecosistema Web3 prospero attraverso molteplici vie.</p>
<p>In primo luogo, sul fronte dei ricavi esterni, introdurremo la pubblicità esterna per aiutare gli utenti a generare ulteriori entrate. Sfruttando la vasta base di utenti della nostra app per tastiera, gli inserzionisti possono ottenere una esposizione efficace.</p>
<p>Internamente, introdurremo una serie di funzioni coinvolgenti. Ad esempio, l’aspetto “Socialfi” che coinvolge chat criptate e i prossimi mini-giochi “Gamefi” consentiranno agli utenti di guadagnare ricompense extra partecipando a divertenti giochi di scrittura.</p>
<p>La funzionalità “Type and Airdrop” (TNA), che include design della skin collaborativi, consente agli utenti di guadagnare ricompense sia dalle proprie attività che da quelle dei nostri partner. La nostra recente collaborazione con Bitget per la nostra prima skin congiunta è solo l’inizio e continueremo a ottimizzare e raccogliere feedback per migliorare la funzionalità TNA.</p>
<p>Nel campo delle skin NFT, stiamo pianificando di introdurre un programma per creatori, che consentirà agli utenti di contribuire collaborativamente all’ecosistema.</p>
<p>L’ecosistema di TypeIt si compone principalmente di tre categorie: partner, utenti e creatori. I partner includono sia gli inserzionisti che le imprese/piattaforme di supporto che pagano. Gli utenti costituiscono la nostra base principale. Attraverso DAO e meccanismi di voto, miriamo a trasferire gradualmente il potere decisionale alla comunità, consentendo loro di plasmare la direzione del progetto.</p>
<p>In termini di attività, stiamo pianificando di organizzare vari eventi coinvolgenti. Le collaborazioni con istituti di ricerca e autori, dove i contenuti vengono presentati come esercizi di battitura, forniranno agli utenti sia la conoscenza di Web3 che ricompense. Inoltre, divertenti giochi competitivi, bonus per la creazione di contenuti assistita dall’IA, chat crittografate sulla privacy e altro ancora fanno tutti parte dei nostri piani.</p>
<p>TypeIt sta costruendo attivamente un ecosistema, andando oltre il suo ruolo di semplice app per tastiera. Siamo dedicati a creare un’esperienza Web3 arricchita, rendendo TypeIt una piattaforma completa per gli utenti per esplorare e interagire con il mondo di Web3.</p>
<h3 id="h3-Q920Quali20future20tendenze20o20tecnologie20pensi20possano20contribuire20a20proteggere20la20privacy55965"><a name="Q9: Quali future tendenze o tecnologie pensi possano contribuire a proteggere la privacy?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q9: Quali future tendenze o tecnologie pensi possano contribuire a proteggere la privacy?</h3><p><strong>Patrick</strong>: Dal mio punto di vista personale e dagli aspetti su cui mi concentro:</p>
<p>In primo luogo, le dimostrazioni a conoscenza zero (zk-SNARKs) hanno il potenziale per apportare significativi contributi alla privacy, che si tratti della loro concisione, della proprietà di zero conoscenza o della completezza.</p>
<p>zk-SNARKs possono verificare l’autenticità di una prova senza rivelare alcuna informazione dettagliata a sostegno dell’affermazione. Questo si allinea bene con i principi della blockchain e della privacy. In passato ci siamo associati a Manta Network, una soluzione modulare di zk-SNARKs, e esploreremo le sue applicazioni nella privacy dei dati della tastiera e degli utenti.</p>
<p>Ad esempio, nelle nostre prossime funzionalità come articoli e dizionari di battitura condivisi, gli utenti potranno condividere i loro dizionari esclusivi senza rivelare il contenuto in chiaro. Esperimenteranno solo la prioritizzazione delle parole candidate quando le utilizzano.</p>
<p>Allo stesso modo, nella nostra prossima funzione di chat privata, verrà implementata la crittografia end-to-end. Solo gli individui che utilizzano la tastiera TypeIt per la comunicazione avranno accesso ai contenuti decrittati.</p>
<p>Oltre a ciò, la Computazione Sicura Multi-Parte (MPC) potrebbe svolgere un ruolo significativo nella protezione della privacy. Ad esempio, i portafogli MPC che sono già in uso potrebbero essere un’altra strada che stiamo esplorando.</p>
<p>Queste tecnologie di miglioramento della privacy evidenziano il nostro impegno nel favorire la fiducia degli utenti e nella salvaguardia dei loro dati personali in modi innovativi.</p>
<h3 id="h3-Q1020Qual2020il20prossimo20piano20di20TypeIt734882"><a name="Q10: Qual è il prossimo piano di TypeIt?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q10: Qual è il prossimo piano di TypeIt?</h3><p><strong>Patrick</strong>: TypeIt continuerà a migliorare le sue offerte di prodotti in diverse aree:</p>
<ol>
<li>MPC / Account Abstract Wallet: stiamo introducendo un portafoglio astratto dell’account più conveniente per alleviare le preoccupazioni degli utenti riguardo alle chiavi private e supportare l’accesso sociale.</li><li>DID (Identità decentralizzata): stiamo collaborando con progetti come Relation per incorporare soluzioni di identità decentralizzata (DID), permettendo agli utenti di proteggere meglio la propria privacy.</li><li>Giochi Gamefi e Competizioni PvP: forniremo più divertimento attraverso giochi Gamefi e competizioni PvP, offrendo ricompense e incentivi consistenti per incoraggiare la partecipazione degli utenti.</li><li>Partnership: rafforzeremo le collaborazioni con piattaforme di scambio centralizzate (CEX) e prodotti Web3, come piattaforme rinomate come Gate, per offrire funzionalità migliorate e un’esperienza di trading migliorata.</li></ol>
<p>In futuro, gli utenti potranno inserire il nome di un token all’interno di TypeIt e la tastiera mostrerà il prezzo corrispondente. Cliccandoci sopra, gli utenti possono accedere alle informazioni pertinenti, iniziare a imparare attraverso la digitazione interattiva e guadagnare ricompense.</p>
<p>Successivamente, utilizzando la funzione di chat privata all’interno di TypeIt, gli utenti possono condividere queste informazioni con i loro amici. Durante questo processo, sia i dati che la privacy rimangono interamente sotto il controllo dell’utente. Questi sviluppi dimostrano il nostro impegno a combinare convenienza, privacy e coinvolgimento, consentendo agli utenti di mantenere il controllo dei propri dati e interazioni.</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 alcuna suggerimento di investimento.<br></em><div><em></em>Gate.io si riserva tutti i diritti su questo articolo. La ripubblicazione dell'articolo sarà consentita a condizione che venga citato Gate.io. In tutti i casi, verranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div>