R2F0ZS5pbyBBTUEgY29uIERyYWdvblNCLUlsIHByaW1vIE1NT1JQRyBtZXRhdmVyc28gY29zdHJ1aXRvIHN1bGxhIHBpYXR0YWZvcm1hIEJpbmFuY2UgU21hcnQgQ2hhaW4=

<p><img src="https://gimg2.gateimg.com/image/article/16811102261.jpg" alt=""><br><strong>Ora: 8 giugno 2022, 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 Lorna Nguyen, Community Manager di DragonSB in <a href="https://t.me/gateio" rel="nofollow noopener noreferrer" target="_blank">Comunità di scambio Gate.io</a>.</strong><br><strong>Sito Ufficiale: <a href="https://dragonsb.finance/" rel="nofollow noopener noreferrer" target="_blank">https://dragonsb.finance/</a></strong></p>
<p><strong>Twitter: <a href="https://twitter.com/sbgroup_finance" rel="nofollow noopener noreferrer" target="_blank">https://twitter.com/sbgroup_finance</a></strong></p>
<p><strong>Segui DragonSB su <a href="https://discord.com/invite/XB3bBKVUS2" rel="nofollow noopener noreferrer" target="_blank">Discord</a> e <a href="https://twitter.com/sbgroup_finance" rel="nofollow noopener noreferrer" target="_blank">Cinguettare</a></strong><br><strong>Ospite</strong><img src="https://gimg2.gateimg.com/image/article/16811104552.png" alt=""><br><strong>Lorna Nguyen - Responsabile della Community di DragonSB</strong></p>
<h2 id="h2-Domande20e20risposte20da20Gateio147976"><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-Q120Puoi20per20favore20presentarti20anche20DragonSB20554090"><a name="Q1: Puoi per favore presentarti anche DragonSB ?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q1: Puoi per favore presentarti anche DragonSB ?</h3><p><img src="https://gimg2.gateimg.com/image/article/16811104873.png" alt=""><br><strong>Lorna</strong>: Il mio nome è Lorna e sono il Community Manager di DragonSB. Siamo orgogliosi di presentare DragonSB come il primo MMORPG Metaverse costruito su <a href="/price/terra-luna" rel="nofollow noopener noreferrer" target="_blank">Terra</a> Protocol e Binance Smart Chain. Unendoti al gioco, i giocatori esperimenteranno il mondo dei draghi con grafica 3D estremamente bella e le immagini e i suoni più vividi e realistici. DragonSB è un gioco NFT play-to-earn che consente ai giocatori di partecipare a battaglie, svolgere missioni, partecipare a eventi, scambiare NFT e partecipare a staking e farming per generare guadagni.</p>
<h3 id="h3-Q220Come20sappiamo20SB20Group20lancer20lapp20StretchtoEarn20potresti20dirci20di20pi20a20riguardo227584"><a name="Q2: Come sappiamo, SB Group lancerà l’app Stretch-to-Earn, potresti dirci di più a riguardo?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q2: Come sappiamo, SB Group lancerà l’app Stretch-to-Earn, potresti dirci di più a riguardo?</h3><p><strong>Lorna</strong>: Stretch-to-Earn è la prima app di fitness che ti permette di guadagnare. SB Group è lieto di lanciare un’app di fitness facile da usare che combina reddito passivo. Nel programma STE, devi solo fare alcuni esercizi semplici seguendo il nostro tutorial sull’app. Sarai in salute con un corpo tonico e anche più redditizio quando ti allunghi e guadagni soldi.</p>
<h3 id="h3-Q320StretchtoEarn20ha20NFT20Se20s20per20favore20fornisci20maggiori20dettagli20sui20NFT416512"><a name="Q3: Stretch-to-Earn ha NFT? Se sì, per favore fornisci maggiori dettagli sui NFT." class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q3: Stretch-to-Earn ha NFT? Se sì, per favore fornisci maggiori dettagli sui NFT.</h3><p><img src="https://gimg2.gateimg.com/image/article/16811105104.png" alt=""><br><strong>Lorna</strong>: Sì, abbiamo NFT. Nella versione 1 vendiamo solo 200 T-shirt NFT a $250 ciascuna. Il totale delle T-shirt NFT è di 2000, inclusi 1000 T-shirt NFT per donne (NFT W1) e 1000 T-shirt NFT per uomini (NFT M1). Solo una coppia di NFT può essere acquistata per persona.</p>
<h3 id="h3-Q420E20come20funziona20la20creazione20di20NFT20Potresti20dirci20di20pi20su20come20creare20NFT631663"><a name="Q4: E come funziona la creazione di NFT? Potresti dirci di più su come creare NFT?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q4: E come funziona la creazione di NFT? Potresti dirci di più su come creare NFT?</h3><p><strong>Lorna</strong>: Per creare NFT, hai bisogno di entrambi gli NFT delle magliette da donna e da uomo. Devi fare esercizio con entrambi loro per 7 giorni. Puoi creare al massimo altri 7 NFT, ma devi pagare una tariffa. In dettaglio:<br>NFT S1: $600 ($100 SB + $500 STE) (crea al massimo 5 NFT)<br>NFT W1 o NFT M1: $200 ($60 SB, $140 STE) (crea al massimo 2 NFT casuali)</p>
<h3 id="h3-Q520Come20evitare20linflazione20delle20NFT20in20futuro612803"><a name="Q5: Come evitare l’inflazione delle NFT in futuro?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q5: Come evitare l’inflazione delle NFT in futuro?</h3><p><strong>Lorna</strong>: Buona domanda. Posso confermare che l’NFT non sarà inflazionario in futuro, ma diventerà sempre più raro. Con la maglietta originale, puoi fare soldi solo per 30 giorni. Dopo 30 giorni, la maglietta non sarà più utilizzabile. In base al meccanismo, NFT S1 può essere utilizzato solo per 90 giorni e 30 giorni con 2 NFT di genere. Pertanto, la “durata di esistenza” dell’NFT è limitata, quindi non sarà in grado di generare inflazione.</p>
<h2 id="h2-Domande20e20risposte20dal20Community20di20Gateio846793"><a name="Domande e risposte dal Community di Gate.io" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Domande e risposte dal Community di Gate.io</h2><h3 id="h3-Q120I20giochi20per20guadagnare20sono20una20tendenza20tra20i20giochi20basati20su20blockchain20e20le20commissioni20di20iscrizione20sono20piuttosto20alte20Ho20letto20che20SB20combina20vari20modelli20di20economia20di20gioco20gratuiti20e20strappati20per20guadagnare20generando20entrate20da20varie20fonti20Qual2020linvestimento20minimo20richiesto20per20i20giocatori20per20giocare20al20gioco20STRETCHTOEARN20su20SB213115"><a name="Q1: I giochi per guadagnare sono una tendenza tra i giochi basati su blockchain e le commissioni di iscrizione sono piuttosto alte. Ho letto che SB combina vari modelli di economia di gioco gratuiti e strappati per guadagnare, generando entrate da varie fonti. Qual è l’investimento minimo richiesto per i giocatori per giocare al gioco STRETCH-TO-EARN su SB?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q1: I giochi per guadagnare sono una tendenza tra i giochi basati su blockchain e le commissioni di iscrizione sono piuttosto alte. Ho letto che SB combina vari modelli di economia di gioco gratuiti e strappati per guadagnare, generando entrate da varie fonti. Qual è l’investimento minimo richiesto per i giocatori per giocare al gioco STRETCH-TO-EARN su SB?</h3><p><strong>Lorna</strong>: Grazie per la tua interessante domanda. Adesso stiamo lanciando una versione ‘Gratuita per Guadagnare’, quindi non ti costerà giocare. Inoltre, per aumentare il tuo reddito, puoi acquistare un NFT per $250 e guadagnare $450 dopo 30 giorni di allenamento ($15 al giorno).</p>
<h3 id="h3-Q220Perch20lapp20STE2020ancora20in20versione20BETA20ma20c20gi20la20verifica20dellidentit20perch20non20perfezionate20prima20gli20altri20sistemi20prima20di20creare20la20verifica20dellidentit20non2020troppo20frettoloso20mentre20lapp2020ancora20in20beta2020ancora20vulnerabile20ai20guasti948849"><a name="Q2: Perché l’app STE è ancora in versione BETA ma c’è già la verifica dell’identità? perché non perfezionate prima gli altri sistemi prima di creare la verifica dell’identità, non è troppo frettoloso? mentre l’app è ancora in beta è ancora vulnerabile ai guasti." class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q2: Perché l’app STE è ancora in versione BETA ma c’è già la verifica dell’identità? perché non perfezionate prima gli altri sistemi prima di creare la verifica dell’identità, non è troppo frettoloso? mentre l’app è ancora in beta è ancora vulnerabile ai guasti.</h3><p><strong>Lorna</strong>: In questo modo eviteremo bot e truffe. Il nostro obiettivo sono persone attive.</p>
<h3 id="h3-Q320Perch20il20prezzo20di20NFT20STE2020pi20costoso20rispetto20a20NFT20Dragon2020a20causa20della20differenza20di20qualit20o20differenti20funzioni20in20gioco20O2020diverso20nel20denaro20che20si20guadagna20durante20il20gioco20con20NFT20STE20che20guadagna20pi20facilmente879391"><a name="Q3: Perché il prezzo di NFT STE è più costoso rispetto a NFT Dragon? È a causa della differenza di qualità? o differenti funzioni in gioco? O è diverso nel denaro che si guadagna durante il gioco, con NFT STE che guadagna più facilmente?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q3: Perché il prezzo di NFT STE è più costoso rispetto a NFT Dragon? È a causa della differenza di qualità? o differenti funzioni in gioco? O è diverso nel denaro che si guadagna durante il gioco, con NFT STE che guadagna più facilmente?</h3><p><strong>Lorna</strong> Sono contento che tu abbia chiesto. Anche se il prezzo STE NFT è un po’ più alto rispetto a quello del Dragon NFT, il profitto che porta STE NFT è molto più grande. Con una coppia di NFT femminili e maschili, gli utenti saranno in grado di guadagnare oltre $15.000,00 e avrai persino la possibilità di possedere un’altra nuova coppia di NFT originali per ricominciare a guadagnare, raddoppiare o addirittura triplicare il tuo interesse.</p>
<h3 id="h3-Q420Puoi20dirci20quali20tipi20di20NFT20troveremo20nel20gioco20Sbgroup20Stretch20To20Earn20Quali20elementi20o20componenti20di20gioco20saranno20NFT20Quanti20ne20serviranno20per20iniziare20a20giocare20Ci20puoi20dare20dettagli20sul20loro20rilascio20Come20e20quando20potremo20acquistarli887240"><a name="Q4: Puoi dirci quali tipi di NFT troveremo nel gioco Sbgroup Stretch To Earn? Quali elementi o componenti di gioco saranno NFT? Quanti ne serviranno per iniziare a giocare? Ci puoi dare dettagli sul loro rilascio? Come e quando potremo acquistarli?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q4: Puoi dirci quali tipi di NFT troveremo nel gioco Sbgroup Stretch To Earn? Quali elementi o componenti di gioco saranno NFT? Quanti ne serviranno per iniziare a giocare? Ci puoi dare dettagli sul loro rilascio? Come e quando potremo acquistarli?</h3><p><strong>Lorna</strong>: In Stretch-to-Earn, SB Group svilupperà molti NFT per offrire esperienze ricche ai giocatori. Nella versione 1, SB Group lancerà solo magliette NFT (magliette da uomo e da donna). Nelle versioni successive, rilasceremo altri NFT: pantaloni da allenamento, cappelli, scarpe, ecc.</p>
<h3 id="h3-Q520Ho20notato20che20state20introducendo20un20nuovo20concetto20di20guadagno20chiamato20Stretch20to20Earn20STE20Puoi20spiegare20come20questo20concetto20di20STE2020diverso20da20MoveToEarn20MTE20E20cosa20devo20fare20per20iniziare20a20guadagnare20con20il20concetto20di20Stretch20to20Earn20STE20Devo20comprare20gli20NFT20Si20prega20di20spiegare323173"><a name="Q5: Ho notato che state introducendo un nuovo concetto di guadagno chiamato “Stretch to Earn (STE)”. Puoi spiegare come questo concetto di STE è diverso da Move-To-Earn (MTE)? E cosa devo fare per iniziare a guadagnare con il concetto di Stretch to Earn (STE)? Devo comprare gli NFT? Si prega di spiegare." class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q5: Ho notato che state introducendo un nuovo concetto di guadagno chiamato “Stretch to Earn (STE)”. Puoi spiegare come questo concetto di STE è diverso da Move-To-Earn (MTE)? E cosa devo fare per iniziare a guadagnare con il concetto di Stretch to Earn (STE)? Devo comprare gli NFT? Si prega di spiegare.</h3><p><strong>Lorna</strong>: Infatti, Move-to-Earn è la tendenza calda nello spazio criptato al momento. Tuttavia, Stretch-to-Earn è più di semplicemente muoversi per guadagnare denaro, è fare esercizio per portare agli utenti uno stile di vita sano e un ottimo reddito.<br>Il motivo per cui abbiamo scelto di sviluppare Stretch-to-Earn è perché il nostro team si rende conto del fatto che le persone stanno ignorando la propria salute in questo periodo moderno. Ecco perché ci concentriamo sulla costruzione di STE per motivare le persone a fare più esercizio, ottenendo una vita più equilibrata pur continuando a guadagnare di più.</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 il ripostaggio dell'articolo a condizione che venga fatto riferimento a Gate.io. In tutti i casi, saranno intraprese azioni legali a causa di violazione del copyright.<br></div><p></p><br></div></div></div>