R2F0ZS5pbyBBTUEgY29uIE5hc2RleC1EZW1vY3JhdGl6emFuZG8gZ2xpIGFzc2V0IGRlbCBtb25kbyByZWFsZSBhdHRyYXZlcnNvIGlsIGRpZ2l0YWxl

<p><img src="https://gimg2.gateimg.com/image/article/16891486521.jpg" alt=""><br><strong>Ora: 4 novembre 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 Josh Du, direttore degli investimenti e Belinda Zhou, direttore marketing di Nasdex nel <a href="https://t.me/gateio" rel="nofollow noopener noreferrer" target="_blank">Comunità di Gate.io Exchange</a>.</strong><br><strong>Sito ufficiale: <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>Segui Nasdex su <a href="https://twitter.com/nasdex_xyz" rel="nofollow noopener noreferrer" target="_blank">Twitter</a> e <a href="https://t.me/nasdexannouncement" rel="nofollow noopener noreferrer" target="_blank">Telegram</a></strong><br><strong>Ospiti</strong><img src="https://gimg2.gateimg.com/image/article/16891488582.png" alt=""><br><strong>Josh Du — Chief investment officer from Nasdex</strong><img src="https://gimg2.gateimg.com/image/article/16891488723.png" alt=""><br><strong>Belinda Zhou - Chief marketing officer di Nasdex</strong></p>
<h2 id="h2-QampA20da20Gateio652905"><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-Q120Quindi20innanzitutto20cos20NASDEX2020un20DEX20Che20prodotto20fornisce181959"><a name="Q1: Quindi, innanzitutto, cos’è NASDEX? È un DEX? Che prodotto fornisce?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q1: Quindi, innanzitutto, cos’è NASDEX? È un DEX? Che prodotto fornisce?</h3><p><strong>Belinda</strong>: Grazie Tom! Prenderò la prima Q.</p>
<p>Quindi dal nome, saprai che si tratta di un DEX e ha a che fare con le azioni.</p>
<p>NASDEX è il principale scambio decentralizzato che consente la negoziazione di azioni asiatiche on-chain.</p>
<p>Il DEX consentirà agli utenti di gestire tutte le posizioni, inclusi stock e criptovalute, su una singola piattaforma semplicemente collegando i loro portafogli.</p>
<p>Sono sicuro che gestire un portafoglio in stile <a href="/web3" target="_blank" class="blog_inner_link">web3</a> sia stato un sogno per molti appassionati di criptovalute.</p>
<p>Quindi, per metterla semplicemente, nasdex.xyz è una piattaforma user-friendly in cui gli investitori possono comprare e vendere equity tokenizzata così facilmente come criptovaluta con24⁄7trading, acquisto di azioni frazionate e yield farming.</p>
<p>Immagina solo tu dalla Turchia puoi acquistare $COIN o $BABA, che sono al di fuori della tua giurisdizione.<br>E non solo puoi possedere queste azioni Alibaba o Coinbase, puoi anche impostare coppie Baba/USDT e guadagnare ricompense di mining di liquidità e commissioni di scambio.</p>
<p>Le azioni tokenizzate sono il primo passo, in futuro, le nostre offerte di prodotti verranno ampliate a ETF, indici e materie prime fisiche.</p>
<p>Il trading con leva sarà disponibile anche nelle future versioni.</p>
<h3 id="h3-Q220Grazie20Belinda20sono20sicuro20che20molte20persone20della20comunit20crittografica20saranno20entusiaste20di20una20piattaforma20che20consente20lo20scambio20decentralizzato20di20azioni20tokenizzate20Ora20perch20non20ci20raccontate20un20po20di20voi20stessi20la20vostra20storia20come20siete20entrati20nel20mondo20delle20criptovalute20e20cosa20vi20ha20portato20qui20oggi442137"><a name="Q2: Grazie Belinda, sono sicuro che molte persone della comunità crittografica saranno entusiaste di una piattaforma che consente lo scambio decentralizzato di azioni tokenizzate. Ora, perché non ci raccontate un po’ di voi stessi… la vostra storia, come siete entrati nel mondo delle criptovalute e cosa vi ha portato qui oggi?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q2: Grazie Belinda, sono sicuro che molte persone della comunità crittografica saranno entusiaste di una piattaforma che consente lo scambio decentralizzato di azioni tokenizzate. Ora, perché non ci raccontate un po’ di voi stessi… la vostra storia, come siete entrati nel mondo delle criptovalute e cosa vi ha portato qui oggi?</h3><p><strong>Belinda</strong>: 100%!</p>
<p>Sono della <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> classe del 2018!</p>
<p>È stato allora che sono caduto nella tana del coniglio della blockchain.</p>
<p>Da allora ho aiutato parecchi progetti, token, fondi e exchange con attività di marketing e comunità.</p>
<p>La criptovaluta è fondamentalmente il mio primo lavoro dopo l’università. È incredibile crescere con lo spazio.</p>
<p>Qui a NASDEX, sarò anche a capo degli sforzi di PR, marketing e comunità!</p>
<p><strong>Josh</strong>: La mia carriera è stata principalmente nel settore Tradfi.</p>
<p>Così, negli ultimi 15 anni, ho avuto una carriera come gestore di fondi istituzionali. Ho trascorso del tempo in molti hedge fund e grandi banche storiche come Morgan Stanley, Deutsche Bank, ecc.</p>
<p>Ma naturalmente, ho visto la luce. Ho investito personalmente nello spazio cripto per diversi anni. E ora sono completamente impegnato nel cripto e nel DeFi come investitore e fondatore.</p>
<h3 id="h3-Q320Tornando20al20progetto20cosa20rende20NASDEX20diverso20dagli20altri20Exchange20l20fuori123281"><a name="Q3: Tornando al progetto, cosa rende NASDEX diverso dagli altri Exchange là fuori?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q3: Tornando al progetto, cosa rende NASDEX diverso dagli altri Exchange là fuori?</h3><p><strong>Josh</strong>: Certo, posso rispondere a questa domanda.</p>
<p>Quindi la caratteristica principale è la tokenizzazione delle azioni in modo che le azioni possano essere scambiate su una catena.</p>
<p>Gli utenti possono acquistare le loro azioni preferite tramite il nostro dex senza bisogno di kyc, il che significa che gli utenti possono trovarsi ovunque nel mondo senza preoccuparsi dell’apertura dell’account.</p>
<p>Quindi gli utenti possono mettere in gioco quegli asset tokenizzati per guadagnare ancora di più. E poiché si tratta di criptovalute, l’accesso al trading è aperto24⁄7.</p>
<p>Al momento il nostro dex è focalizzato sugli investitori asiatici con principalmente azioni asiatiche da tokenizzare per la prima volta con nomi come Tencent, Meituan, TSMC, Samsung, ecc.</p>
<p>E poiché tutti gli asset possono essere tokenizzati e probabilmente lo saranno a un certo punto, la nostra piattaforma aumenterà gradualmente le offerte includendo l’esposizione a ETF, indici e altre classi di asset e derivati.</p>
<p>Fondamentalmente stiamo mirando ad un TAM completamente diverso rispetto alla maggior parte dei tradizionali crypto DEX presenti.</p>
<h3 id="h3-Q420Ora20puoi20dirci20di20pi20sul20token20NSDX20Quali20sono20i20casi20duso20del20token20e20come20avviene20la20distribuzione166912"><a name="Q4: Ora puoi dirci di più sul token $NSDX? Quali sono i casi d’uso del token e come avviene la distribuzione?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q4: Ora puoi dirci di più sul token $NSDX? Quali sono i casi d’uso del token e come avviene la distribuzione?</h3><p><strong>Josh</strong>: Sicuramente la funzione principale del token è fondamentalmente quella di condividere i profitti di NASDEX con la nostra comunità e con i detentori del token NSDX.</p>
<p>I titolari di NSDX condivideranno tutti i vantaggi di NASDEX attraverso la ricezione di una parte dei ricavi della piattaforma. Altre funzioni del token includono caratteristiche di governance come la possibilità di votare su nuove azioni da elencare. E NSDX sarà anche utile come garanzia nella coniazione di azioni tokenizzate in futuro.</p>
<p>In realtà, abbiamo il 40% delle tokenomics totali destinato alla coltivazione di LP di stock farm, che entrerà in funzione nel Q4 insieme al nostro prodotto, quindi rimanete sintonizzati.</p>
<h3 id="h3-Q520Potresti20darci20informazioni20sulle20tappe20del20progetto20sui20tuoi20obiettivi20intermedi20e20sui20tuoi20piani20futuri131514"><a name="Q5: Potresti darci informazioni sulle tappe del progetto, sui tuoi obiettivi intermedi e sui tuoi piani futuri?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q5: Potresti darci informazioni sulle tappe del progetto, sui tuoi obiettivi intermedi e sui tuoi piani futuri?</h3><p><strong>Belinda</strong>: Sì, abbiamo alcune novità molto interessanti.</p>
<p>Il nostro token NSDX è negoziabile su Quickswap DEX e ovviamente su Gate.io.</p>
<p>Ora siamo partner di Anyswap e alle 14:00 UTC del 4 novembre, il nostro token nativo $NSDX sarà disponibile su Pancakeswap!</p>
<p>Che è tra 30 minuti!</p>
<p>Molti appassionati di bsc sono così impazienti di questo!</p>
<p>In termini di tokenizzati stock DEX, la nostra estrazione di liquidità sarà attiva entro il Q4.</p>
<p>Più presto arrivi, più alta è l’APR!</p>
<p>Se ti sei perso Mirror o Synthetix, sentiti libero di controllare app.nasdex.xyz.</p>
<p>E infine, sentiti libero di unirti al nostro Telegram e seguirci su Twitter per gli ultimi aggiornamenti!<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>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 si faccia riferimento a Gate.io. In tutti i casi, verranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div>