R2F0ZS5pbyBBTUEgbWV0IE5hc2RleCAtIERlbW9jcmF0aXppbmcgUmVhbCBXb3JsZCBBc3NldHMgdGhyb3VnaCBEaWdpdGFs

<p><img src="https://gimg2.gateimg.com/image/article/16891486521.jpg" alt=""><br><strong>Tijd: 4 november 2021, 13:00 UTC</strong><br><strong><a href="https://www.gate.io" target="_blank">Gate.io</a> organiseerde een AMA (Ask-Me-Anything) sessie met Josh Du, Chief investment officer en Belinda Zhou, Chief marketing officer van Nasdex in de <a href="https://t.me/gateio" rel="nofollow noopener noreferrer" target="_blank">Gate.io Exchange Gemeenschap</a>.</strong><br><strong>Officiële website: <a href="https://www.nasdex.xyz/" rel="nofollow noopener noreferrer" target="_blank">https://www.nasdex.xyz/</a></strong><br><strong>Twitter: <a href="https://twitter.com/nasdex_xyz" rel="nofollow noopener noreferrer" target="_blank">https://twitter.com/nasdex_xyz</a></strong><br><strong>Volg Nasdex op <a href="https://twitter.com/nasdex_xyz" rel="nofollow noopener noreferrer" target="_blank">Twitter</a> en <a href="https://t.me/nasdexannouncement" rel="nofollow noopener noreferrer" target="_blank">Telegram</a></strong><br><strong>Gasten</strong><img src="https://gimg2.gateimg.com/image/article/16891488582.png" alt=""><br><strong>Josh Du — Chief Investment Officer van Nasdex</strong><img src="https://gimg2.gateimg.com/image/article/16891488723.png" alt=""><br><strong>Belinda Zhou - Chief marketing officer van Nasdex</strong></p>
<h2 id="h2-Vragen20en20antwoorden20van20Gateio761786"><a name="Vragen en antwoorden van Gate.io" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Vragen en antwoorden van Gate.io</h2><h3 id="h3-Q120Dus20in20de20eerste20plaats20wat20is20NASDEX20Is20het20een20DEX20Welk20product20biedt20het20aan202342"><a name="Q1: Dus, in de eerste plaats, wat is NASDEX? Is het een DEX? Welk product biedt het aan?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q1: Dus, in de eerste plaats, wat is NASDEX? Is het een DEX? Welk product biedt het aan?</h3><p><strong>Belinda</strong>: Bedankt Tom! Ik zal de eerste Q nemen.</p>
<p>Dus vanuit de naam zul je weten dat het een DEX is en te maken heeft met aandelen.</p>
<p>NASDEX is de toonaangevende gedecentraliseerde beurs die de handel in Aziatische aandelen on-chain mogelijk maakt.</p>
<p>De DEX stelt gebruikers in staat om alle posities, inclusief aandelen en crypto, via één platform te beheren door eenvoudigweg hun wallets te verbinden.</p>
<p>Ik weet zeker dat het beheren van een portefeuille op een web3-manier een droom is geweest voor veel cryptoliefhebbers.</p>
<p>Om het simpel te stellen, nasdex.xyz is een gebruiksvriendelijk platform waar investeerders tokenized equity net zo makkelijk kunnen kopen en verkopen als crypto met.24⁄7handel, aankoop van gefractioneerde aandelen en yield farming.</p>
<p>Stel je voor dat je uit Turkije $COIN of $BABA kunt kopen, die buiten jouw rechtsgebied vallen. En niet alleen kun jij deze Alibaba- of Coinbase-aandelen bezitten, je kunt ook Baba/USDT-paren opzetten en liquiditeitsmijnbeloningen en wisselkosten verdienen.</p>
<p>Tokenized aandelen is de eerste stap, in de toekomst zullen onze productaanbiedingen worden uitgebreid naar ETF’s, indices en fysieke grondstoffen.</p>
<p>Gefinancierde handel zal ook beschikbaar zijn in toekomstige versies.</p>
<h3 id="h3-Q220Bedankt20Belinda20ik20weet20zeker20dat20veel20mensen20in20de20cryptogemeenschap20enthousiast20zullen20zijn20over20een20platform20dat20gedecentraliseerde20getokeniseerde20aandelen20mogelijk20maakt20Nu20waarom20vertellen20jullie20ons20niet20een20beetje20over20jezelf20jullie20achtergrond20hoe20jullie20in20crypto20terecht20zijn20gekomen20en20wat20jullie20hier20vandaag20heeft20gebracht183310"><a name="Q2: Bedankt Belinda, ik weet zeker dat veel mensen in de cryptogemeenschap enthousiast zullen zijn over een platform dat gedecentraliseerde getokeniseerde aandelen mogelijk maakt. Nu, waarom vertellen jullie ons niet een beetje over jezelf… jullie achtergrond, hoe jullie in crypto terecht zijn gekomen en wat jullie hier vandaag heeft gebracht?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q2: Bedankt Belinda, ik weet zeker dat veel mensen in de cryptogemeenschap enthousiast zullen zijn over een platform dat gedecentraliseerde getokeniseerde aandelen mogelijk maakt. Nu, waarom vertellen jullie ons niet een beetje over jezelf… jullie achtergrond, hoe jullie in crypto terecht zijn gekomen en wat jullie hier vandaag heeft gebracht?</h3><p><strong>Belinda</strong>: 100%!</p>
<p>Ik kom uit <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> klas van 2018!</p>
<p>Dat is wanneer ik de konijnenpijp van blockchain ben ingegaan.</p>
<p>Sindsdien heb ik verschillende projecten, tokens, fondsen en beurzen geholpen met marketing- en gemeenschapsinspanningen.</p>
<p>Crypto is eigenlijk mijn eerste baan na de universiteit. Het is ongelooflijk om op te groeien in de ruimte.</p>
<p>Hier bij NASDEX zal ik ook de leiding hebben bij de PR-, marketing- en gemeenschapsinspanningen!</p>
<p><strong>Josh</strong>: Mijn carrière is eigenlijk voornamelijk in Tradfi doorgebracht.</p>
<p>Dus de afgelopen 15 jaar heb ik een carrière gehad als institutionele fondsmanager. Heb tijd doorgebracht bij veel hedgefondsen en grote legacy-banken zoals Morgan Stanley, Deutsche Bank, enzovoort.</p>
<p>Maar natuurlijk, ik heb het licht gezien. Ik investeer persoonlijk al enkele jaren in de cryptoruimte. En nu ben ik helemaal in crypto en DeFi als investeerder en oprichter.</p>
<h3 id="h3-Q320Terugkomend20op20het20project20wat20maakt20NASDEX20anders20dan20andere20beurzen20daarbuiten497002"><a name="Q3: Terugkomend op het project, wat maakt NASDEX anders dan andere beurzen daarbuiten?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q3: Terugkomend op het project, wat maakt NASDEX anders dan andere beurzen daarbuiten?</h3><p><strong>Josh</strong> Natuurlijk kan ik deze beantwoorden.</p>
<p>Dus de belangrijkste functie is de tokenisatie van aandelen, zodat ze op een keten kunnen worden verhandeld.</p>
<p>Gebruikers kunnen hun favoriete aandelen kopen via onze dex zonder de noodzaak van kyc, wat betekent dat gebruikers zich overal ter wereld kunnen bevinden zonder zich zorgen te hoeven maken over het openen van een rekening.</p>
<p>Gebruikers kunnen vervolgens die getokeniseerde activa inzetten om nog meer opbrengst te verdienen. En aangezien het crypto is, is de toegang tot handel open.24⁄7.</p>
<p>Op dit moment richt onze dex zich op Aziatische investeerders met voornamelijk Aziatische aandelen die voor het eerst ooit worden getokeniseerd met namen als Tencent, Meituan, TSMC, Samsung, enzovoort.</p>
<p>En aangezien alle activa getokeniseerd kunnen worden en waarschijnlijk op een bepaald punt ook zullen worden, zal ons platform het aanbod geleidelijk uitbreiden door exposure aan ETF’s, indices en andere aanvullende activaklassen en derivaten op te nemen.</p>
<p>In wezen richten we ons op een volledig andere TAM dan de meeste traditionele crypto DEX die er zijn.</p>
<h3 id="h3-Q420Kun20je20ons20nu20iets20vertellen20over20de20NSDXtoken20Wat20zijn20de20gebruiksglen20van20de20token20en20hoe20zit20het20met20de20distributie414822"><a name="Q4: Kun je ons nu iets vertellen over de $NSDX-token? Wat zijn de gebruiksglen van de token en hoe zit het met de distributie?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q4: Kun je ons nu iets vertellen over de $NSDX-token? Wat zijn de gebruiksglen van de token en hoe zit het met de distributie?</h3><p><strong>Josh</strong>: Natuurlijk is de belangrijkste functie van de token in feite om de winsten van NASDEX te delen met onze gemeenschap en NSDX-tokenhouders.</p>
<p>NSDX-houders zullen meedelen in alle voordelen van NASDEX door een deel van de platformopbrengsten te ontvangen. Andere functies van de token omvatten governance-functies zoals de mogelijkheid om te stemmen over nieuwe aandelen om te noteren. En NSDX zal ook nuttig zijn als onderpand bij het uitgeven van getokeniseerde aandelen in de toekomst.</p>
<p>In feite hebben we 40% van de totale tokenomics toegewezen aan stock farm LP farming, die live gaat in Q4 samen met ons product, dus blijf op de hoogte.</p>
<h3 id="h3-Q520Kun20je20ons20wat20informatie20geven20over20de20routekaart20van20het20project20jullie20mijlpalen20en20ook20jullie20toekomstplannen238363"><a name="Q5: Kun je ons wat informatie geven over de routekaart van het project, jullie mijlpalen en ook jullie toekomstplannen?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q5: Kun je ons wat informatie geven over de routekaart van het project, jullie mijlpalen en ook jullie toekomstplannen?</h3><p><strong>Belinda</strong>: Ja, we hebben een aantal behoorlijk spannende updates.</p>
<p>Onze NSDX-token is direct verhandelbaar op Quickswap DEX en natuurlijk Gate.io.</p>
<p>Nu hebben we een partnerschap gesloten met Anyswap en om 14.00 uur UTC op 4 november zal onze native token $NSDX op <a href="/price/pancakeswap-cake" target="_blank" class="blog_inner_link">Pancakeswap</a> worden geplaatst!</p>
<p>Die is over 30 minuten!</p>
<p>Veel bsc-mensen kijken hier zo naar uit!</p>
<p>Wat betreft tokenized stock DEX, zal onze liquiditeitsmining daar live gaan binnen Q4.</p>
<p>Hoe eerder je komt, hoe hoger de APR is!</p>
<p>Als je Mirror of Synthetix mist, voel je vrij om app.nasdex.xyz te controleren.</p>
<p>En tot slot, voel je vrij om lid te worden van onze Telegram en ons Twitter te volgen voor de laatste updates!<br><a href="https://t.me/nasdex_xyz" rel="nofollow noopener noreferrer" target="_blank">https://t.me/nasdex_xyz</a> <a href="https://t.me/nasdexannouncement" rel="nofollow noopener noreferrer" target="_blank">https://t.me/nasdexannouncement</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 beleggingsaanbevelingen.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het opnieuw plaatsen van het artikel zal worden toegestaan mits Gate.io wordt vermeld. In alle glen zal juridische actie worden ondernomen vanwege schending van het auteursrecht.<br></div><p></p><br></div></div></div>