R2F0ZS5pbyBBTUEgbWV0IFRhbGtlbiAtIEVlbiBNdWx0aS1jaGFpbiBORlQgU3VpdGU=

<p><img src="https://gimg2.gateimg.com/image/article/16910458291.jpeg" alt=""><br><strong>Tijd: 23 september 2021, 13:00 UTC</strong><br><strong><a href="https://www.gate.io" target="_blank">Gate.io</a> hield een AMA (Ask-Me-Anything) sessie met Daniel Jee, CEO van Talken in de <a href="https://t.me/gateio" rel="nofollow noopener noreferrer" target="_blank">Gate.io Exchange Community</a>.</strong><br><strong>Officiële website: <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>Volg Talken op <a href="https://twitter.com/Talken_" rel="nofollow noopener noreferrer" target="_blank">Twitter</a> en <a href="https://discord.com/invite/S33c5DA9cW" rel="nofollow noopener noreferrer" target="_blank">Onenigheid</a></strong><br><strong>Gast</strong><img src="https://gimg2.gateimg.com/image/article/16910459992.png" alt=""><br><strong>Daniel Jee - CEO van Talken</strong></p>
<h2 id="h2-QampA20van20Gateio393298"><a name="Q&amp;A van Gate.io" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q&amp;A van Gate.io</h2><h3 id="h3-Q120Blij20om20je20hier20te20hebben20Vertel20ons20meer20over20Talken20Wat20is20het804677"><a name="Q1: Blij om je hier te hebben! Vertel ons meer over Talken… Wat is het?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q1: Blij om je hier te hebben! Vertel ons meer over Talken… Wat is het?</h3><p><strong>Daniel</strong>: Talken is een gedecentraliseerde NFT-portemonnee met meerdere ketens met een grote gemeenschap. Het is een naadloos interoperabele NFT-suite met meerdere ketens, waar K-popsterren, artiesten en influencers NFT’s kunnen slaan, veilen, opslaan en verhandelen. Talken is een open NFT-ecosysteem dat een brug slaat tussen onaangeboorde NFT-enthousiastelingen uit Korea en Talken’s native NFT’s en andere beroemde NFT’s door protocollen zoals NBA TopShot, Rarible, OpenSea en meer. Onze missie is om aan te dringen op een inclusieve en grenzeloze NFT-uitbreiding en digitale makers en verzamelaars te voorzien van betere tools en diensten om NFT mainstream te maken.</p>
<p>Dit zijn de voordelen van Talken</p>
<ul>
<li>Naadloos interoperabel: multi-chain NFT-portemonnee &amp; infrastructuur, een open NFT-ecosysteem waar K-popsterren en influencers NFT’s kunnen maken, veilen, opslaan en verhandelen.</li><li>Open NFT-ecosysteem: het overbruggen van onbenutte NFT-enthousiastelingen van Korea naar Talkens inheemse NFT en andere bekende NFT-protocollen zoals NFT Hero, NBA TopShot, Rarible, OpenSea, enz.</li><li>Koreaanse NFT-monopolie: Talken is de eerste NFT-portemonnee uit Korea. Prognose van exponentiële groei in gebruikersbestand, gemunte NFT’s en transactievolume.</li></ul>
<h3 id="h3-Q220Kun20je20ons20een20beetje20vertellen20over20jezelf20en20je20team20Wat20zijn20jullie20eerdere20ervaringen522225"><a name="Q2: Kun je ons een beetje vertellen over jezelf en je team? Wat zijn jullie eerdere ervaringen?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q2: Kun je ons een beetje vertellen over jezelf en je team? Wat zijn jullie eerdere ervaringen?</h3><p><strong>Daniel</strong>: Bedankt. We zijn erg trots op onze prestaties en streven ernaar onze ontwikkelingsinspanningen voort te zetten.</p>
<p>Ik ben Jee, Daniel, CEO van Talken. Hiervoor was ik Global BD &amp; Blockchain for Good Society(B4GS) Co-Organizer bij Clayone(Coinmanager).</p>
<p>Ons team bestaat uit zowel crypto-veteranen met meerdere succesvolle exits, als ervaren ontwikkelaars met ervaring in het bouwen van traditionele financiële infrastructuur. Mr. Kim, Kyungmin is de CBO van Talken. Eerder was hij Divisieleider van het Instituut voor Technologie, NexG Department, en manager van Strategische Planning bij Hansol NexG.</p>
<h3 id="h3-Q320Waarom20hebben20jij20en20je20team20besloten20om20Talken20te20bouwen411678"><a name="Q3: Waarom hebben jij en je team besloten om Talken te bouwen?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q3: Waarom hebben jij en je team besloten om Talken te bouwen?</h3><p><strong>Daniel</strong>: De belangrijkste reden waarom we hebben besloten om Talken te bouwen, is om een alles-in-één NFT-suite te bouwen voor gebruikers en makers die naadloos interoperabel is met Multi-Chain. Een one-stop locatie voor het maken, verzamelen, opslaan en verhandelen van unieke digitale verzamelobjecten van K-popsterren, beroemdheden en kunstenaars op basis van gedecentraliseerd bestuur.</p>
<p>We zagen een enorme kans in de NFT-ruimte, maar realiseerden ons dat het een onderontwikkelde markt is. Ons team heeft een sterke achtergrond in IT, cybersecurity en ontwikkeling, dus het was natuurlijk voor ons om geïnteresseerd te raken in blockchain en de ruimte van ‘non-fungible tokens’.</p>
<h3 id="h3-Q420Laten20we20ons20verdiepen20in20jouw20tokens20Talk20Kun20je20met20ons20jouw20tokenomics20delen20En20wat20zijn20enkele20van20de20TALK20use20cases146072"><a name="Q4: Laten we ons verdiepen in jouw tokens $Talk. Kun je met ons jouw tokenomics delen? En wat zijn enkele van de $TALK use cases?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q4: Laten we ons verdiepen in jouw tokens $Talk. Kun je met ons jouw tokenomics delen? En wat zijn enkele van de $TALK use cases?</h3><p><strong>Daniel</strong> $TALK is de governance token van het Talken NFT Suite-ecosysteem. Met $TALK kun je operationele beslissingen nemen op een gedecentraliseerde manier via voorstellen en stemmingen. Talken is een door de gemeenschap gedreven project met een DAO, wat betekent dat de beslissingsbevoegdheid aan de Talken-gemeenschap wordt gegeven.</p>
<p>$Talk heeft ook veel functionele doeleinden. Gebruikers kunnen $TALK gebruiken om NFT te kopen. Kunstenaars kunnen op het TALKEN-platform marketingpakketten kopen met $TALK. Deze inkomsten worden verdeeld tussen de stichting en $TALK-stakers als beloningen. Staking: Zet $TALK in voor exclusieve NFT-drops, fanbijeenkomsten in de metaverse en exclusieve content.</p>
<p>Gebruik $TALK, evenals andere ondersteunde tokens, om ultra zeldzame NFT’s te slaan, bezitten, verhandelen. Algoritmisch berekende tokenverbrandingen om een inherent deflatoir tokenomics te creëren. Fans worden gestimuleerd om voor langere periodes te staken om exclusieve voordelen te benutten met beroemdheden en artiesten.</p>
<h3 id="h3-Q520Ok20best20goed20kun20je20ons20iets20vertellen20over20je20huidige20producten445700"><a name="Q5: Ok best goed, kun je ons iets vertellen over je huidige producten?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q5: Ok best goed, kun je ons iets vertellen over je huidige producten?</h3><p><strong>Daniel</strong>: TALKEN NFT Suite biedt een reeks producten voor elke fase van de levenscyclus van NFT’s.</p>
<ol>
<li>NFT-portemonnee: ultra-handige en veilige multi-chain portemonnee.</li><li>Naadloos browsen voor ondersteunde chain of DApps</li><li>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">Stroom</a>(in progress), AVAX (in progress), <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> (in uitvoering), ICP (in uitvoering), <a href="/price/tron-trx" rel="nofollow noopener noreferrer" target="_blank">TRON</a>(in uitvoering)</li><li>Eenvoudige NFT-mintgereedschap: Creator Tool voorzien aan kunstenaars voor super eenvoudige NFT-mintprocedures. - Maak NFT’s zonder codering en met slechts één klik - Via Talken kunnen kunstenaars minten en verkopen op elke keten</li><li>Multichain NFT-drops &amp; veilingen om meer gebruikers te betrekken</li><li>Interoperabele NFT-marktplaats: Mobiele betaling &amp; Crypto-betaling ingeschakelde Multi-chain NFT-marktplaats. (Lancering in sept.)</li><li>Veilige en onveranderlijke handel</li><li>Gebruikers in staat stellen om veilig te handelen in-game en in-app</li><li>Ontdek, koop en verkoop zeldzame en unieke NFT’s</li><li>NFT’s gemunt uit favoriete NFT-marktplaatsen zoals Opensea, Rarible, enz. kunnen worden verhandeld op de NFT Secundaire Markt</li></ol>
<h3 id="h3-Q620Heel20goede20diverse20portfolio2020Nu20kunt20u20ons20vertellen20over20de20Routekaart20van20Talken902577"><a name="Q6: Heel goede diverse portfolio! … Nu, kunt u ons vertellen over de Routekaart van Talken?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q6: Heel goede diverse portfolio! … Nu, kunt u ons vertellen over de Routekaart van Talken?</h3><p><strong>Daniel</strong>: Talken beweegt al in een snel tempo vooruit. Daarnaast. Hier is een fragment van onze routekaart: - Lancering van Talken NFT Mint API V1.0 - NFT-marktplaats - Secundaire NFT-marktplaats - Integratie van Non-EVM Chains (Tron, Flow, Solana, enz.) - Lancering van Talken DAO - NFT-marktplaats Aggregator - Lancering van NFT DeFi (Lening + Lenen)</p>
<h3 id="h3-V720Waar20kunnen20we20meer20te20weten20komen20over20Talken580920"><a name="V7: Waar kunnen we meer te weten komen over Talken?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>V7: Waar kunnen we meer te weten komen over Talken?</h3><p><strong>Daniel</strong>: We zouden het geweldig vinden als iedereen zich bij onze gemeenschappen zou aansluiten en meer over ons te weten zou komen! Er staan ​​enkele spannende evenementen (inclusief het weggeefevenement van vandaag!) op de planning, dus zorg ervoor dat je blijft afstemmen.</p>
<p>Download om te proberen:<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>Volg ons op de website: <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>Medium: <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>Auteur:<strong> Rio Fu.</strong>, Gate.io Community<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de opvattingen van de onderzoeker en vormt geen enkele beleggingsaanbeveling.<br></em><div><em></em>Gate.io behoudt alle rechten voor op dit artikel. Het opnieuw plaatsen van het artikel is toegestaan op voorwaarde dat Gate.io wordt vermeld. In alle glen zal juridische actie worden ondernomen wegens schending van het auteursrecht.<br></div><p></p><br></div></div></div>