R2F0ZS5pbyBBTUEgY29uIEZpRGFuY2UgLSBVbiBnaW9jbyBibG9ja2NoYWluIE5GVCBQbGF5LXRvLUVhcm4gbmVsIE1ldGF2ZXJzbw==

<p><img src="https://gimg2.gateimg.com/image/article/16751470313.jpeg" alt=""><br><strong>Ora: 19 ottobre 2022, 11: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 l’esecutivo di FiDance, Simona Belmont in the <a href="https://t.me/gateio" rel="nofollow noopener noreferrer" target="_blank">Community di Gate.io Exchange</a>.</strong><br><strong>Sito Web ufficiale: <a href="https://www.fidance.online/" rel="nofollow noopener noreferrer" target="_blank">https://www.fidance.online/</a></strong><br><strong>Twitter: <a href="https://twitter.com/FIDANCEE" rel="nofollow noopener noreferrer" target="_blank">https://twitter.com/FIDANCEE</a></strong><br><strong>Segui Fidance su <a href="https://t.me/Fi_Dance" rel="nofollow noopener noreferrer" target="_blank">Telegram</a> e <a href="https://twitter.com/FIDANCEE" rel="nofollow noopener noreferrer" target="_blank">Twitter</a></strong></p>
<p><strong>Ospite</strong><img src="https://gimg2.gateimg.com/image/article/16751471681.png" alt=""><br><strong>Simona Belmont - Esecutivo presso FiDance</strong></p>
<h2 id="h2-Domande20e20risposte20da20Gateio51661"><a name="Domande e risposte da Gate.io" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Domande e risposte da Gate.io</h2><h3 id="h3-Q120Puoi20per20favore20dirci20di20pi20su20FiDance404387"><a name="Q1: Puoi per favore dirci di più su FiDance?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q1: Puoi per favore dirci di più su FiDance?</h3><p><strong>Simona</strong>: Fidance è un gioco blockchain NFT play-to-earn nel Metaverse che consentirà agli investitori di possedere asset, partecipare a giochi di danza nel metaverso, acquistare NFT e molto altro ancora.<br>Unendo un business multimiliardario, una blockchain completamente verificabile e un potenziale di guadagno illimitato grazie a NFT e alla partecipazione decentralizzata della comunità - non ci sono limiti alla crescita di FiDance!</p>
<h3 id="h3-Q220Sei20un20progetto20globale20o20un20progetto20locale20Su20quali20mercati20vi20state20concentrando458843"><a name="Q2: Sei un progetto globale o un progetto locale? Su quali mercati vi state concentrando?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q2: Sei un progetto globale o un progetto locale? Su quali mercati vi state concentrando?</h3><p><strong>Simona</strong> Stiamo sicuramente puntando a un pubblico mondiale, proprio per questo siamo ospitati qui oggi! Vogliamo che tutti possano godere del nostro progetto con le NOSTRE TASSE ZERO sul nostro contratto e incoraggiamo TUTTI a unirsi al nostro viaggio di prosperità!</p>
<h3 id="h3-Q320I20contratti20intelligenti20sono20inclini20al20fallimento20e20molti20progetti20ne20sono20vittime20Quanto20sono20affidabili20e20sicuri20i20vostri20contratti20intelligenti730344"><a name="Q3: I contratti intelligenti sono inclini al fallimento e molti progetti ne sono vittime. Quanto sono affidabili e sicuri i vostri contratti intelligenti?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q3: I contratti intelligenti sono inclini al fallimento e molti progetti ne sono vittime. Quanto sono affidabili e sicuri i vostri contratti intelligenti?</h3><p><strong>Simona</strong>: Questa è la ragione per cui abbiamo introdotto un rapporto di audit CERTIK per il nostro smart contract.<br>Un’altra ragione per cui le persone perdono fondi sono le tasse che vengono implementate nei progetti e, come sapete, noi non abbiamo ALCUNA TASSA!</p>
<h3 id="h3-Q420Puoi20dirci20qual2020il20ruolo20principale20della20tua20moneta164996"><a name="Q4: Puoi dirci qual è il ruolo principale della tua moneta?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q4: Puoi dirci qual è il ruolo principale della tua moneta?</h3><p><strong>Simona</strong>: Il nostro token servirà come utilità nel nostro gioco P2E. Giocando al gioco e vincendo, guadagnerai token FDC che potrai utilizzare in molti modi diversi.<br>Enorme lineup di NFT per supportare il gioco FDC.<br>Sviluppo completo del gioco p2e che sarà disponibile su IOS e Android.<br><img src="https://gimg2.gateimg.com/image/article/16751474682.png" alt=""><br>Quindi un ecosistema completo che supporterà la comunità FDC.</p>
<h3 id="h3-Q520Qual2020la20differenza20tra20il20vostro20progetto20e20gli20altri403870"><a name="Q5: Qual è la differenza tra il vostro progetto e gli altri?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q5: Qual è la differenza tra il vostro progetto e gli altri?</h3><p><strong>Simona</strong>: Sulla maggior parte dei token appena rilasciati, è necessario pagare un’imposta elevata quando si acquista o vende la propria moneta. Noi siamo contrari! Quindi abbiamo deciso di avere una FUNZIONALITÀ STRAORDINARIA, che quasi nessun altro ha. La nostra FUNZIONALITÀ STRAORDINARIA è che non abbiamo ALCUNA IMPOSTA!</p>
<h2 id="h2-Domanda20gratuita20dalla20comunit20di20Gateio109617"><a name="Domanda gratuita dalla comunità di Gate.io" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Domanda gratuita dalla comunità di Gate.io</h2><h3 id="h3-D20Il20tuo20progetto2020una20comunit20solo20per20paesi20di20lingua20inglese20o20per20utenti20di20altre20lingue733396"><a name="D: Il tuo progetto è una comunità solo per paesi di lingua inglese o per utenti di altre lingue?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>D: Il tuo progetto è una comunità solo per paesi di lingua inglese o per utenti di altre lingue?</h3><p><strong>Simona</strong>: Il nostro progetto è per tutti! Non importa da dove vieni! In futuro, si apriranno più gruppi in diverse lingue.</p>
<h3 id="h3-P20Hai20paura20che20un20giorno20ci20sar20un20altro20progetto20con20una20tecnologia20pi20innovativa20che20potrebbe20sostituire20il20tuo20progetto296351"><a name="P: Hai paura che un giorno ci sarà un altro progetto con una tecnologia più innovativa che potrebbe sostituire il tuo progetto?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>P: Hai paura che un giorno ci sarà un altro progetto con una tecnologia più innovativa che potrebbe sostituire il tuo progetto?</h3><p><strong>Simona</strong>: Non abbiamo assolutamente paura, lavoriamo sodo giorno e notte e dubito che qualcuno lavori tanto quanto noi! saremo in cima!</p>
<h3 id="h3-Q20Puoi20rispondere20alla20mia20domanda20Come20posso20comprare20questo20token2020disponibile20su20qualche20exchange473334"><a name="Q: Puoi rispondere alla mia domanda? Come posso comprare questo token? È disponibile su qualche exchange?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q: Puoi rispondere alla mia domanda? Come posso comprare questo token? È disponibile su qualche exchange?</h3><p><strong>Simona</strong>: FDC è disponibile su: Gate.io, Bitmart e MEXC.<br><img src="https://gimg2.gateimg.com/image/article/16751474954.png" alt=""><br>Contratto: 0x6d1A4650E83708b583C35d5E0952A0B46354Ca9b</p>
<h3 id="h3-Q20Veramente20hai20fatto20AMA20in20molti20gruppi20di20Telegram20quindi20cosa20farai20dopo20in20che20altro20modo20renderai20il20tuo20progetto20pi20popolare104338"><a name="Q: Veramente, hai fatto AMA in molti gruppi di Telegram, quindi cosa farai dopo, in che altro modo renderai il tuo progetto più popolare?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q: Veramente, hai fatto AMA in molti gruppi di Telegram, quindi cosa farai dopo, in che altro modo renderai il tuo progetto più popolare?</h3><p><strong>Simona</strong>: Prima di tutto, c’è il marketing! Inoltre, cerchiamo di interagire molto con la nostra comunità, quindi ci sono molti fantastici regali e airdrop per incoraggiare la nostra comunità a diventare l’esercito del progetto.</p>
<h3 id="h3-Domanda20Avete20dei20video20tutorial20in20modo20da20poter20conoscere20il20vostro20progetto20pi20chiaramente20o20avete20un20canale20YouTube20o20qualcosa20del20genere20Potete20condividerlo20con20noi21608"><a name="Domanda: Avete dei video tutorial in modo da poter conoscere il vostro progetto più chiaramente o avete un canale YouTube o qualcosa del genere? Potete condividerlo con noi?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Domanda: Avete dei video tutorial in modo da poter conoscere il vostro progetto più chiaramente o avete un canale YouTube o qualcosa del genere? Potete condividerlo con noi?</h3><p><strong>Simona</strong>: Sì, abbiamo video tutorial per rendere la vita dei nostri investitori un po’ più facile, inoltre, puoi trovare tutte le informazioni sul progetto sul nostro sito web e nel nostro gruppo TG:<br>Twitter- <a href="https://twitter.com/FIDANCEE" rel="nofollow noopener noreferrer" target="_blank">https://twitter.com/FIDANCEE</a><br>Telegram- gruppo <a href="https://t.me/Fi_Dance" rel="nofollow noopener noreferrer" target="_blank">https://t.me/Fi_Dance</a><br>Sito web- <a href="https://www.fidance.online/" rel="nofollow noopener noreferrer" target="_blank">https://www.fidance.online/</a><br>Medio- <a href="https://medium.com/" rel="nofollow noopener noreferrer" target="_blank">https://medium.com/</a> @FIDANCE</p>
<div class="blog-details-info"><br><div>Autore: <strong>Rio Fu.</strong>, Community 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 si faccia riferimento a Gate.io. In tutti i casi, saranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div>