R2F0ZS5pbyBBTUEgY29uIFRhbGtlbiAtIFVuYSBzdWl0ZSBkaSBORlQgbXVsdGktY2hhaW4=

<p><img src="https://gimg2.gateimg.com/image/article/16910458291.jpeg" alt=""><br><strong>Ora: 23 settembre 2021, 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 Daniel Jee, CEO di Talken in <a href="https://t.me/gateio" rel="nofollow noopener noreferrer" target="_blank">Comunità di scambio di Gate.io</a>.</strong><br><strong>Sito Ufficiale: <a href="https://talken.io/" rel="nofollow noopener noreferrer" target="_blank">https://talken.io/</a></strong><br><strong>Twitter: <a href="https://twitter.com/Talken_" rel="nofollow noopener noreferrer" target="_blank">https://twitter.com/Talken_</a></strong><br><strong>Segui Talken su <a href="https://twitter.com/Talken_" rel="nofollow noopener noreferrer" target="_blank">Twitter</a> e <a href="https://discord.com/invite/S33c5DA9cW" rel="nofollow noopener noreferrer" target="_blank">Discord</a></strong><br><strong>Ospite</strong><img src="https://gimg2.gateimg.com/image/article/16910459992.png" alt=""><br><strong>Daniel Jee - CEO di Talken</strong></p>
<h2 id="h2-QampA20da20Gateio531046"><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-Q120Siamo20entusiasti20di20averti20qui20Quindi20raccontaci20di20pi20su20Talken20Che20cos183304"><a name="Q1: Siamo entusiasti di averti qui! Quindi raccontaci di più su Talken… Che cos’è?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q1: Siamo entusiasti di averti qui! Quindi raccontaci di più su Talken… Che cos’è?</h3><p><strong>Daniel</strong>: Talken è un portafoglio NFT decentralizzato multi-chain con una grande community. È una Suite NFT multi-chain interamente interoperabile, dove le star del K-pop, gli artisti e gli influencer possono coniare, mettere all’asta, memorizzare e scambiare NFT. Talken è un ecosistema NFT aperto che collega gli appassionati di NFT in Corea ai NFT nativi di Talken e ad altri famosi NFT tramite protocolli come NBA TopShot, Rarible, OpenSea e altri. La nostra missione è promuovere un’espansione inclusiva e senza confini degli NFT, e dotare i creatori e i collezionisti digitali di migliori strumenti e servizi per portare gli NFT alla ribalta.</p>
<p>Ecco i vantaggi di Talken</p>
<ul>
<li>Interoperabilità senza soluzione di continuità: portafoglio e infrastruttura multi-chain NFT, un ecosistema NFT aperto in cui le star del K-pop e gli influencer possono creare, mettere all’asta, conservare e scambiare NFT.</li><li>Ecosistema NFT aperto: Collegamento degli appassionati di NFT inesplorati della Corea ai NFT nativi di Talken e ad altri famosi protocolli NFT come NFT Hero, NBA TopShot, Rarible, OpenSea, ecc.</li><li>Monopolio NFT in Corea: Talken è il primo portafoglio NFT proveniente dalla Corea. Crescita esponenziale prevista nella base utenti, NFT creati e volume di transazioni.</li></ul>
<h3 id="h3-Q220Potresti20dirci20qualcosa20su20di20te20e20sul20tuo20team20Quali20sono20le20tue20esperienze20passate221036"><a name="Q2: Potresti dirci qualcosa su di te e sul tuo team? Quali sono le tue esperienze passate?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q2: Potresti dirci qualcosa su di te e sul tuo team? Quali sono le tue esperienze passate?</h3><p><strong>Daniel</strong>: Grazie. Siamo molto orgogliosi dei nostri successi e ci sforziamo di continuare i nostri sforzi di sviluppo.</p>
<p>Sono Jee, Daniel, CEO di Talken. Prima di questo, ero Global BD &amp; Blockchain per Clayone(Coinmanager) e Co-organizzatore della Good Society(B4GS).</p>
<p>Il nostro team include sia veterani della crittografia con molteplici uscite di successo, sia sviluppatori esperti con esperienza nella costruzione dell’infrastruttura finanziaria tradizionale. Il signor Kim, Kyungmin è il CBO di Talken. In precedenza è stato responsabile della divisione dell’Istituto di Tecnologia, Dipartimento NexG, e responsabile della pianificazione strategica presso Hansol NexG.</p>
<h3 id="h3-Q320Quindi20perch20tu20e20il20tuo20team20avete20deciso20di20costruire20Talken892733"><a name="Q3: Quindi perché tu e il tuo team avete deciso di costruire Talken?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q3: Quindi perché tu e il tuo team avete deciso di costruire Talken?</h3><p><strong>Daniel</strong> Il motivo principale per cui abbiamo deciso di costruire Talken è quello di creare una suite NFT all-in-one per utenti e creatori che interoperi in modo trasparente Multi-Chain. Un luogo unico per creare, collezionare, memorizzare e scambiare Digital Collectibles unici di K-pop stars, celebrità e artisti basati su una governance decentralizzata.</p>
<p>Abbiamo visto una grande opportunità nello spazio NFT, ma ci siamo resi conto che si tratta di un mercato inesplorato. Il nostro team ha una solida esperienza in IT, sicurezza informatica e sviluppo, quindi è stato naturale per noi interessarci al blockchain e allo spazio dei “token non fungibili”.</p>
<h3 id="h3-Q420Approfondiamo20i20tuoi20token20Talk20Puoi20condividere20con20noi20la20tua20tokenomica20E20quali20sono20alcuni20dei20casi20duso20di20TALK770640"><a name="Q4: Approfondiamo i tuoi token $Talk. Puoi condividere con noi la tua tokenomica? E quali sono alcuni dei casi d’uso di $TALK?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q4: Approfondiamo i tuoi token $Talk. Puoi condividere con noi la tua tokenomica? E quali sono alcuni dei casi d’uso di $TALK?</h3><p><strong>Daniel</strong>: $TALK è il token di governance dell’ecosistema Talken NFT Suite. Con $TALK è possibile prendere decisioni operative in modo decentralizzato attraverso proposte e votazioni. Talken è un progetto guidato dalla comunità con DAO, il che significa che il potere decisionale è dato alla comunità di Talken.</p>
<p>$Talk serve anche a molti scopi di utilità, gli utenti possono usare $TALK per acquistare NFT. Gli artisti possono acquistare pacchetti di marketing sulla piattaforma TALKEN con $TALK. Questo ricavo viene suddiviso tra la fondazione e gli staker di $TALK come ricompense. Staking: Stake $TALK per ottenere esclusive NFT, incontri con fan nel metaverso e contenuti esclusivi.</p>
<p>Usa $TALK così come altri token supportati per creare, possedere e scambiare NFT ultra rari. Brucia i token calcolati algoritmicamente per creare un’economia deflazionistica intrinseca. I fan sono incentivati a bloccare per periodi più lunghi per accedere a vantaggi esclusivi con celebrità e artisti.</p>
<h3 id="h3-Q520Ok20molto20bene20potresti20dirci20quali20sono20i20tuoi20attuali20prodotti68024"><a name="Q5: Ok molto bene, potresti dirci quali sono i tuoi attuali prodotti?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q5: Ok molto bene, potresti dirci quali sono i tuoi attuali prodotti?</h3><p><strong>Daniel</strong>: TALKEN NFT Suite offre una serie di prodotti per ogni fase del ciclo di vita degli NFT. 1. NFT Wallet: Portafoglio multi-chain ultra-conveniente e sicuro. 2. Navigazione senza soluzione di continuità per chain supportate o DApps. 3. Multi-chain: <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a>, HECO, BSC, <a href="/price/klaytn-klay" rel="nofollow noopener noreferrer" target="_blank">Klaytn</a>, <a href="/price/polygon-matic" rel="nofollow noopener noreferrer" target="_blank">Polygon</a>, <a href="/price/flow-flow" rel="nofollow noopener noreferrer" target="_blank">Flusso</a> (in corso), AVAX (in corso), <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a>(in progress)，ICP (in progress), <a href="/price/tron-trx" rel="nofollow noopener noreferrer" target="_blank">TRON</a>(in corso)</p>
<ol>
<li>Strumento Semplice per la Creazione di NFT: Strumento Creator fornito agli artisti per una facile procedura di creazione di NFT. - Crea NFT senza codifica e con un solo clic - Attraverso Talken, gli artisti possono creare e vendere su qualsiasi catena</li><li>Gocce NFT &amp; aste multichain per coinvolgere più utenti</li><li>Mercato NFT interoperabile: Pagamento mobile &amp; Pagamento crypto abilitato Multi-chain NFT Marketplace. (Lancio a settembre)</li><li>Trading sicuro e immutabile</li><li>Consentire agli utenti di scambiare in modo sicuro in-game e in-app</li><li>Scopri, acquista e vendi NFT rari e unici</li><li>Gli NFT creati dai tuoi NFT Marketplace preferiti come Opensea, Rarible, ecc. possono essere scambiati sul Mercato Secondario NFT</li></ol>
<h3 id="h3-Q620Portafoglio20piuttosto20buono20e20diversificato2020Ora20puoi20dirci20qualcosa20riguardo20alla20Roadmap20di20Talken228780"><a name="Q6: Portafoglio piuttosto buono e diversificato! … Ora, puoi dirci qualcosa riguardo alla Roadmap di Talken?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q6: Portafoglio piuttosto buono e diversificato! … Ora, puoi dirci qualcosa riguardo alla Roadmap di Talken?</h3><p><strong>Daniel</strong>: Talken sta già avanzando a passo rapido. Inoltre, ecco un’anteprima della nostra roadmap: - Lancio di Talken NFT Mint API V1.0 - Marketplace NFT - Marketplace NFT Secondario - Integrazione di non-EVM Chains (Tron, Flow, Solana, ecc.) - Lancio di Talken DAO - Aggregatore Marketplace NFT - Lancio di NFT DeFi (Prestito + Prestito)</p>
<h3 id="h3-Q720Dove20possiamo20trovare20ulteriori20informazioni20su20Talken541682"><a name="Q7: Dove possiamo trovare ulteriori informazioni su Talken?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q7: Dove possiamo trovare ulteriori informazioni su Talken?</h3><p><strong>Daniel</strong>: Ci piacerebbe che tutti venissero a unirsi a noi nelle nostre comunità e scoprissero di più su di noi!<br>Ci sono alcuni eventi entusiasmanti (compreso l’evento di regali di oggi!) in programma, quindi assicurati di rimanere sintonizzato.</p>
<p>Scarica per provare:<br>Android: <a href="https://play.google.com/store/apps/details?id=io.talken.wallet&amp;hl" rel="nofollow noopener noreferrer" target="_blank">https://play.google.com/store/apps/details?id=io.talken.wallet&amp;hl</a></p>
<p>iOS: <a href="https://apps.apple.com/app/TALKEN/id1459475831" rel="nofollow noopener noreferrer" target="_blank">https://apps.apple.com/app/TALKEN/id1459475831</a></p>
<p>Seguici sul sito web: <a href="https://talken.io/" rel="nofollow noopener noreferrer" target="_blank">https://talken.io/</a> Twitter: <a href="https://twitter.com/Talken_" rel="nofollow noopener noreferrer" target="_blank">https://twitter.com/Talken_</a></p>
<p>Media: <a href="https://talken-io.medium.com" rel="nofollow noopener noreferrer" target="_blank">https://talken-io.medium.com</a></p>
<p>Telegram: <a href="https://t.me/talken_global" rel="nofollow noopener noreferrer" target="_blank">https://t.me/talken_global</a></p>
<p>Telegram_Korean: <a href="https://t.me/talken_kr" rel="nofollow noopener noreferrer" target="_blank">https://t.me/talken_kr</a></p>
<p>Kakao: <a href="https://open.kakao.com/o/gVEOsLsd" rel="nofollow noopener noreferrer" target="_blank">https://open.kakao.com/o/gVEOsLsd</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 ripostare l'articolo a condizione che sia citato Gate.io. In tutti i casi, verranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div>