R2F0ZS5pbyBBTUEgY29uIFRlcm5vYS1Fdm9sdXRpb25hcnkgTkZUIEJsb2NrY2hhaW4sIExpYmVyYSBpbCBQb3RlcmUgZGkgV2ViMw==

<p><img src="https://gimg2.gateimg.com/image/article/16848250951.png" alt=""><br><strong>Ora: 26 gennaio 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 Mickael Canu, CEO di Ternoa nel <a href="https://t.me/gateio" rel="nofollow noopener noreferrer" target="_blank">Community di scambio Gate.io</a>.</strong><br><strong>Sito Web Ufficiale: <a href="https://www.ternoa.network/" rel="nofollow noopener noreferrer" target="_blank">https://www.ternoa.network/</a></strong><br><strong>Twitter: <a href="https://twitter.com/Ternoa_" rel="nofollow noopener noreferrer" target="_blank">https://twitter.com/Ternoa_</a></strong><br><strong>Segui Ternoa su <a href="https://t.me/ternoa" rel="nofollow noopener noreferrer" target="_blank">Telegram</a> e <a href="https://discord.com/invite/cNZTGtGJNR" rel="nofollow noopener noreferrer" target="_blank">Discord</a></strong><br><strong>Ospite</strong><img src="https://gimg2.gateimg.com/image/article/16848253432.png" alt=""><br><strong>Mickael Canu - CEO di Ternoa</strong></p>
<h2 id="h2-QampA20da20Gateio792390"><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-Q120Quindi20cominciamo20con20il20conoscere20cosa2020Ternoa20potresti20spiegarlo20e20le20sue20principali20caratteristiche409479"><a name="Q1: Quindi cominciamo con il conoscere cosa è Ternoa, potresti spiegarlo e le sue principali caratteristiche?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q1: Quindi cominciamo con il conoscere cosa è Ternoa, potresti spiegarlo e le sue principali caratteristiche?</h3><p><strong>Mickael</strong>: Certamente!<br>Ternoa è la blockchain NFT potenziata. La nostra tecnologia aggiunge un’utilità unica all’NFT di tutti i giorni crittografandoli e permettendo agli utenti di memorizzare dati al loro interno a lungo termine. Aggiungiamo anche protocolli di invio e altre azioni, il che significa che un utente può inviare un NFT, con dati privati al suo interno, a chiunque e quando vuole, anche dopo la sua morte!</p>
<p>I nostri NFT aumentati possono essere utilizzati per creare numerosi DApp per uso personale, attività commerciali reali, giochi, casi d’uso orientati alla cripto, metaverse/VR e altro. Anche celebrità o artisti possono creare un NFT Ternoa, aggiungendo canzoni o arte esclusive all’interno e poi venderle ai loro fan.</p>
<p>Dal lato più tecnico, la blockchain di Ternoa è alimentata da <a href="/price/polkadot-dot" rel="nofollow noopener noreferrer" target="_blank">Polkadot</a> e costruito su Substrate Framework. Avendo iniziato 1 anno fa, siamo attualmente su testnet e abbiamo la nostra versione beta dell’applicazione Ternoa Wallet, oltre a qualche DApp disponibile. Mainnet sarà lanciato all’inizio del 2022.<br><img src="https://gimg2.gateimg.com/image/article/16848253743.png" alt=""><br>Sentiti libero di trovare ulteriori informazioni sul nostro sito web: <a href="https://www.ternoa.com/" rel="nofollow noopener noreferrer" target="_blank">https://www.ternoa.com/</a><br>E il nostro white paper: <a href="https://bit.ly/3BJZYDw" rel="nofollow noopener noreferrer" target="_blank">https://bit.ly/3BJZYDw</a></p>
<h3 id="h3-Q220Quindi20per20capire20meglio20Quali20sono20alcuni20esempi20di20casi20duso20per20Ternoa968916"><a name="Q2: Quindi per capire meglio. Quali sono alcuni esempi di casi d’uso per Ternoa?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q2: Quindi per capire meglio. Quali sono alcuni esempi di casi d’uso per Ternoa?</h3><p><strong>Mickael</strong> Un esempio sono le nostre Capsule del Tempo, create per il grande pubblico per beneficiare nella creazione di una capsula del tempo NFT, aggiungendo qualsiasi informazione privata importante che desiderano e scegliendo un destinatario e quando lo riceverà, ad esempio tra alcuni anni o anche dopo che l’utente è morto. Per maggiori informazioni puoi controllare qui: <a href="https://www.ternoa.com/capsules" rel="nofollow noopener noreferrer" target="_blank">https://www.ternoa.com/capsules</a></p>
<p>Stiamo anche lavorando con altre celebrità, ad esempio Kyan Khojandi e Jérôme Le Banner, creando NFT aumentati con loro per i loro fan, tenendo <a href="/price/secret-scrt" rel="nofollow noopener noreferrer" target="_blank">Segreto</a> contenuto all’interno, ad esempio biglietti VIP a vita o un biglietto per visitarli di persona.</p>
<p>Gli use case possono applicarsi anche a aziende e associazioni del mondo reale, ad esempio i notai possono fornire ai loro clienti opzioni di trasmissione dei dati post-mortem (come il nostro protocollo di morte), e anche avvocati e ospedali possono fornire uno spazio sicuro per la crittografia e la conservazione dei dati.</p>
<p>Siamo davvero interessati a vedere cosa ha in mente la comunità per i casi d’uso della nostra tecnologia NFT e abbiamo appena lanciato un programma di finanziamento per motivare gli sviluppatori a crearne alcuni!</p>
<p>Se hai la tua fantastica idea per un progetto sulla nostra blockchain, sentiti libero di inviarla! <a href="https://www.ternoa.com/en/grants" rel="nofollow noopener noreferrer" target="_blank">https://www.ternoa.com/it/grants</a>. Ci piacerebbe sentirti.</p>
<h3 id="h3-Q320Cosa20ha20raggiunto20Ternoa20fino20ad20ora20Puoi20anche20indicare20gli20obiettivi20futuri226238"><a name="Q3: Cosa ha raggiunto Ternoa fino ad ora? Puoi anche indicare gli obiettivi futuri?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q3: Cosa ha raggiunto Ternoa fino ad ora? Puoi anche indicare gli obiettivi futuri?</h3><p><strong>Mickael</strong> In soli 1 anno, Ternoa ha ottenuto molto. Inclusi:<br>🌎 Crescita di una comunità di oltre 160k persone<br>📲 Applicazione Wallet rilasciata a luglio e installata da oltre 80k utenti<br>🚀 Testnet lanciata a settembre<br>🖼 Oltre 200k NFT creati sulla nostra testnet<br>🌐 100+ Nodi installati nel mondo<br>🤝 60+ partner internazionali che supportano e investono nel progetto, tra cui Mr. Beast, Master Ventures, Binance NFT, Elrond, <a href="/price/polygon-matic" rel="nofollow noopener noreferrer" target="_blank">Polygon</a>, e altro ancora!</p>
<p>Il nostro obiettivo per i prossimi mesi è ottenere il massimo numero di DApp pronte per il lancio della nostra mainnet entro la fine del primo trimestre del 2022, in modo da poter mostrare tutte le diverse funzionalità e opportunità che la nostra tecnologia può offrire. Abbiamo già 16 DApp in fase di revisione e 7 già in fase di creazione in collaborazione con aziende, celebrità, team di criptovalute e altro ancora!</p>
<p>Rimani aggiornato sulle imminenti grandi annunci seguendo il nostro account Twitter: <a href="https://twitter.com/Ternoa_" rel="nofollow noopener noreferrer" target="_blank">https://twitter.com/Ternoa_</a><br>e unirsi al nostro Telegram: <a href="https://t.me/ternoa" rel="nofollow noopener noreferrer" target="_blank">https://t.me/ternoa</a></p>
<h3 id="h3-Q420E20che20ne20pensi20del20tuo20token20CAPS20Puoi20dirci20di20pi20a20riguardo20e20dei20vantaggi20per20i20possessori577523"><a name="Q4: E che ne pensi del tuo token $CAPS? Puoi dirci di più a riguardo e dei vantaggi per i possessori?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q4: E che ne pensi del tuo token $CAPS? Puoi dirci di più a riguardo e dei vantaggi per i possessori?</h3><p><strong>Mickael</strong>:Il nostro token, CAPS, è stato quotato a maggio 2021 e da allora è stato quotato su oltre 8 CEX/DEX tra cui: AscendEX, Gate.io, <a href="/price/uniswap-uni" rel="nofollow noopener noreferrer" target="_blank">Uniswap</a>, <a href="/price/pancakeswap-cake" rel="nofollow noopener noreferrer" target="_blank">PancakeSwap</a>, ApeSwap, Beefy, AscendEX, Zapper, Liquid, Just Mining e Raydium. Trova i <a href="/price/link-ln" target="_blank" class="blog_inner_link">link</a> diretti per acquistare sul nostro sito web: <a href="https://www.ternoa.com/token" rel="nofollow noopener noreferrer" target="_blank">https://www.ternoa.com/token</a></p>
<p>Siamo sempre alla ricerca di nuovi modi per premiare la nostra comunità! Abbiamo farming, LP e ricompense su <a href="/price/pancakeswap-cake" rel="nofollow noopener noreferrer" target="_blank">PancakeSwap</a>, Raydium, <a href="/price/uniswap-uni" rel="nofollow noopener noreferrer" target="_blank">Uniswap</a>, Apeswap, Alpaca, Gate.io, Ascendex e Cropper Finance. Abbiamo anche recentemente lanciato nodi, e la nostra piattaforma di lancio per i detentori di CAPS per beneficiare di premi per investimenti anticipati.</p>
<p>L’utilità del token è essere la chiave della nostra governance blockchain per la creazione di time capsule/SecretNFT, rendendo l’universo Ternoa <a href="/price/flow-flow" rel="nofollow noopener noreferrer" target="_blank">Flusso</a>. È anche una merce, con un’offerta fissa di 2,5 miliardi di token.</p>
<p>Ogni volta che viene creato un NFT, sono richiesti 10 CAPS. E per metterlo in prospettiva, solo con il testnet abbiamo creato 100k NFT in soli 2 mesi, puoi immaginare che con il mainnet ogni giorno la blockchain creerà migliaia di NFT e naturalmente userà CAPS.<br><img src="https://gimg2.gateimg.com/image/article/16848253854.png" alt=""><br>E abbiamo appena annunciato anche una nuova competizione di trading CAPS con Gate! <a href="https://www.gate.io/article/24912/?ch=en_sm_0122" target="_blank">https://www.gate.io/article/24912/?ch=en_sm_0122</a></p>
<h3 id="h3-Q520Puoi20dirci20di20pi20sul20tuo20lancio865158"><a name="Q5: Puoi dirci di più sul tuo lancio?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q5: Puoi dirci di più sul tuo lancio?</h3><p><strong>Mickael</strong>: Sì! Molto emozionante, abbiamo appena lanciato il Ternoa Launchpad: <a href="https://launchpad.ternoa.com/" rel="nofollow noopener noreferrer" target="_blank">https://launchpad.ternoa.com/</a></p>
<p>Questa piattaforma consente ai detentori di CAPS di partecipare a progetti di alta qualità sviluppati sulla blockchain di Ternoa.</p>
<p>I titolari di CAPS possono beneficiare di airdrop giornalieri e di estrazioni NFT (con ricompense speciali) da quelle prossime DApps! Per partecipare e iniziare a guadagnare, c’è un sistema molto semplice di hold-to-earn in cui gli utenti si connettono al launchpad con i loro portafogli che detengono un minimo di 10.000 CAPS. Più CAPS e più a lungo si tiene, maggiori sono le ricompense!</p>
<p>Processo molto semplice.</p>
<p>Questo è un ENORME passo per noi, aprendo nuove porte, portando più valore al nostro token e permettendo anche alla nostra community di seguire nuove emozionanti DApps da realizzare con la nostra tecnologia NFT potenziata. Trova maggiori informazioni qui: <a href="https://medium.com/ternoa/ternoa-launchpad-how-to-connect-and-start-participating-in-early-stage-dapps-32b9a63475a" rel="nofollow noopener noreferrer" target="_blank">https://medium.com/ternoa/ternoa-launchpad-come-connettersi-e-iniziare-a-partecipare-a-dapps-di-fase-iniziale-32b9a63475a</a></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, saranno intraprese azioni legali a causa di violazione del copyright.<br></div><p></p><br></div></div></div>