R2F0ZS5pbyBBTUEgbWV0IERyYWdvblNCIC0gRGUgZWVyc3RlIE1ldGF2ZXJzZSBNTU9SUEcgZ2Vib3V3ZCBvcCBoZXQgQmluYW5jZSBTbWFydCBDaGFpbi1wbGF0Zm9ybQ==

<p><img src="https://gimg2.gateimg.com/image/article/16811102261.jpg" alt=""><br><strong>Tijd: 8 juni 2022, 13:00 uur UTC</strong><br><strong><a href="https://www.gate.io" target="_blank">Gate.io</a> organiseerde een AMA (Ask-Me-Anything) sessie met Lorna Nguyen, Community Manager van DragonSB 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://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>Volg DragonSB op <a href="https://discord.com/invite/XB3bBKVUS2" rel="nofollow noopener noreferrer" target="_blank">Discord</a> en <a href="https://twitter.com/sbgroup_finance" rel="nofollow noopener noreferrer" target="_blank">Twitter</a></strong><br><strong>Gast</strong><img src="https://gimg2.gateimg.com/image/article/16811104552.png" alt=""><br><strong>Lorna Nguyen - Gemeenschapsmanager van DragonSB</strong></p>
<h2 id="h2-QampA20van20Gateio326780"><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-Q120Kunt20u20zichzelf20en20DragonSB20alstublieft20voorstellen258073"><a name="Q1: Kunt u zichzelf en DragonSB alstublieft voorstellen?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q1: Kunt u zichzelf en DragonSB alstublieft voorstellen?</h3><p><img src="https://gimg2.gateimg.com/image/article/16811104873.png" alt=""><br><strong>Lorna</strong>: Mijn naam is Lorna en ik ben de Community Manager van DragonSB. We zijn er trots op te kunnen aankondigen dat DragonSB de eerste Metaverse MMORPG is die gebouwd is op <a href="/price/terra-luna" rel="nofollow noopener noreferrer" target="_blank">Terra</a> Protocol en Binance Smart Chain. Door mee te doen aan het spel zullen spelers de drakenwereld ervaren met extreem mooie 3D-graphics en de meest levendige en realistische beelden en geluiden. DragonSB is een NFT play-to-earn spel waarmee spelers gevechten kunnen aangaan, missies kunnen uitvoeren, deel kunnen nemen aan evenementen, NFT’s kunnen verhandelen en kunnen deelnemen aan staking en farming om inkomsten te genereren.</p>
<h3 id="h3-Q220Zoals20we20weten20zal20SB20Group20de20StretchtoEarnapp20lanceren20kunt20u20ons20hier20meer20over20vertellen353040"><a name="Q2: Zoals we weten, zal SB Group de Stretch-to-Earn-app lanceren, kunt u ons hier meer over vertellen?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q2: Zoals we weten, zal SB Group de Stretch-to-Earn-app lanceren, kunt u ons hier meer over vertellen?</h3><p><strong>Lorna</strong>: Stretch-to-Earn is ‘s werelds eerste verdienende fitness-app. SB Group is verheugd een gebruiksvriendelijke fitness-app te lanceren die passief inkomen combineert. In het STE-programma hoef je alleen maar wat eenvoudige oefeningen te doen volgens onze tutorial in de app. Je zult gezond zijn met een strak lichaam en ook winstgevender zijn wanneer je rekt en geld verdient.</p>
<h3 id="h3-Q320Heeft20StretchtoEarn20NFT20Zo20ja20vertel20ons20dan20meer20details20over20NFT292230"><a name="Q3: Heeft Stretch-to-Earn NFT? Zo ja, vertel ons dan meer details over NFT." class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q3: Heeft Stretch-to-Earn NFT? Zo ja, vertel ons dan meer details over NFT.</h3><p><img src="https://gimg2.gateimg.com/image/article/16811105104.png" alt=""><br><strong>Lorna</strong> Ja, we hebben NFT. In versie 1 verkopen we alleen 200 T-shirts NFT met $250 per stuk. Het totaal aantal T-shirts NFT is 2000, inclusief 1000 T-shirts voor vrouwen NFT (NFT W1) en 1000 T-shirts voor mannen NFT (NFT M1). Slechts één paar NFT’s kan per persoon worden gekocht.</p>
<h3 id="h3-Q420Hoe20zit20het20met20het20slaan20van20NFTs20Kun20je20ons20meer20vertellen20over20hoe20je20NFTs20kunt20slaan478589"><a name="Q4: Hoe zit het met het slaan van NFT’s? Kun je ons meer vertellen over hoe je NFT’s kunt slaan?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q4: Hoe zit het met het slaan van NFT’s? Kun je ons meer vertellen over hoe je NFT’s kunt slaan?</h3><p><strong>Lorna</strong>: Om NFT te maken, heb je zowel T-shirts NFT voor vrouwen als mannen nodig. Je moet met beide sporten in 7 dagen. Je kunt maximaal 7 andere NFT’s maken, maar je moet een vergoeding betalen. In detail:<br>NFT S1: $600 ($100 SB + $500 STE) (maximaal 5 NFT maken)<br>NFT W1 of NFT M1: $200 ($60 SB, $140 STE) (maximaal willekeurig 2 NFT maken)</p>
<h3 id="h3-Q520Hoe20NFTinflatie20in20de20toekomst20te20vermijden364752"><a name="Q5: Hoe NFT-inflatie in de toekomst te vermijden?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q5: Hoe NFT-inflatie in de toekomst te vermijden?</h3><p><strong>Lorna</strong>: Goede vraag. Ik kan bevestigen dat de NFT in de toekomst niet inflatoir zal zijn, maar steeds schaarser zal worden. Met het originele shirt kun je slechts 30 dagen geld verdienen. Na 30 dagen is het shirt niet meer bruikbaar. Volgens het mechanisme kan NFT S1 slechts 90 dagen worden gebruikt en 30 dagen met 2 NFT’s van geslacht. Daarom is de ‘bestaansduur’ van de NFT beperkt, zodat deze geen inflatie kan genereren.</p>
<h2 id="h2-Live20QampA20van20Gateio20Community905768"><a name="Live Q&amp;A van Gate.io Community" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Live Q&amp;A van Gate.io Community</h2><h3 id="h3-V120Spelen20om20te20verdienen20games20is20een20trend20onder20op20blockchain20gebaseerde20games20en20de20instapkosten20zijn20nogal20hoog20en20ik20las20dat20SB20verschillende20gratis20te20spelen20en20STRETCHTOEARN20gameeconomiemodellen20combineert20waarbij20inkomsten20worden20gegenereerd20uit20verschillende20bronnen20wat20is20de20minimale20investering20die20spelers20nodig20hebben20om20te20spelen20op20het20STRETCHTOEARN20spel20op20SB870663"><a name="V1: Spelen om te verdienen games is een trend onder op blockchain gebaseerde games en de instapkosten zijn nogal hoog en ik las dat SB verschillende gratis te spelen en STRETCH-TO-EARN game-economiemodellen combineert, waarbij inkomsten worden gegenereerd uit verschillende bronnen, wat is de minimale investering die spelers nodig hebben om te spelen op het STRETCH-TO-EARN spel op SB??" class="reference-link"></a><span class="header-link octicon octicon-link"></span>V1: Spelen om te verdienen games is een trend onder op blockchain gebaseerde games en de instapkosten zijn nogal hoog en ik las dat SB verschillende gratis te spelen en STRETCH-TO-EARN game-economiemodellen combineert, waarbij inkomsten worden gegenereerd uit verschillende bronnen, wat is de minimale investering die spelers nodig hebben om te spelen op het STRETCH-TO-EARN spel op SB??</h3><p><strong>Lorna</strong>: Bedankt voor je interessante vraag. We lanceren nu een ‘Free-to-Earn’ versie, dus het kost je niets om te spelen. Bovendien kun je om je inkomen te verhogen een NFT kopen voor $250 en na 30 dagen training $450 verdienen ($15 per dag).</p>
<h3 id="h3-Q220Waarom20is20de20STE20App20nog20steeds20in20BETA20maar20is20er20al20Identiteitsverificatie20Waarom20perfectioneer20je20eerst20niet20het20andere20systeem20voordat20je20identiteitsverificatie20maakt20is20dat20niet20te20overhaast20Terwijl20de20app20nog20in20bta20is20is20deze20nog20steeds20kwetsbaar20voor20fouten373210"><a name="Q2: Waarom is de STE App nog steeds in BETA maar is er al Identiteitsverificatie? Waarom perfectioneer je eerst niet het andere systeem voordat je identiteitsverificatie maakt, is dat niet te overhaast? Terwijl de app nog in bèta is, is deze nog steeds kwetsbaar voor fouten." class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q2: Waarom is de STE App nog steeds in BETA maar is er al Identiteitsverificatie? Waarom perfectioneer je eerst niet het andere systeem voordat je identiteitsverificatie maakt, is dat niet te overhaast? Terwijl de app nog in bèta is, is deze nog steeds kwetsbaar voor fouten.</h3><p><strong>Lorna</strong>: Dit zal bots en oplichting voorkomen. We streven naar actieve mensen.</p>
<h3 id="h3-Vraag20320Waarom20is20de20prijs20van20NFT20STE20duurder20dan20NFT20Dragon20Komt20dit20door20het20verschil20in20kwaliteit20Of20verschillende20functies20die20worden20gespeeld20Of20verdien20je20meer20geld20tijdens20het20spelen20wat20NFT20STE20gemakkelijker20verdient402069"><a name="Vraag 3: Waarom is de prijs van NFT STE duurder dan NFT Dragon? Komt dit door het verschil in kwaliteit? Of verschillende functies die worden gespeeld? Of verdien je meer geld tijdens het spelen, wat NFT STE gemakkelijker verdient?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Vraag 3: Waarom is de prijs van NFT STE duurder dan NFT Dragon? Komt dit door het verschil in kwaliteit? Of verschillende functies die worden gespeeld? Of verdien je meer geld tijdens het spelen, wat NFT STE gemakkelijker verdient?</h3><p><strong>Lorna</strong>: Ik ben blij dat je het vraagt. Hoewel de prijs van STE NFT iets hoger is dan de prijs van Dragon NFT, is de winst die STE NFT oplevert veel groter. Met een paar vrouwen- en mannen-NFT’s kunnen gebruikers meer dan $15.000,00 verdienen. Bovendien maak je zelfs kans om nog een nieuw paar originele NFT’s te bezitten om opnieuw te verdienen, dubbel of zelfs driedubbel je interesse.</p>
<h3 id="h3-Q420Kun20je20ons20vertellen20over20de20soorten20NFTs20die20we20zullen20vinden20in20Sbgroup20Stretch20To20Earn20Game20Welke20items20of20gameonderdelen20zullen20NFTs20zijn20Hoeveel20zullen20er20nodig20zijn20om20te20beginnen20met20spelen20Kun20je20ons20details20geven20over20hun20release20Hoe20en20wanneer20zullen20we20ze20kunnen20kopen259348"><a name="Q4: Kun je ons vertellen over de soorten NFT’s die we zullen vinden in Sbgroup Stretch To Earn Game? Welke items of game-onderdelen zullen NFT’s zijn? Hoeveel zullen er nodig zijn om te beginnen met spelen? Kun je ons details geven over hun release? Hoe en wanneer zullen we ze kunnen kopen?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q4: Kun je ons vertellen over de soorten NFT’s die we zullen vinden in Sbgroup Stretch To Earn Game? Welke items of game-onderdelen zullen NFT’s zijn? Hoeveel zullen er nodig zijn om te beginnen met spelen? Kun je ons details geven over hun release? Hoe en wanneer zullen we ze kunnen kopen?</h3><p><strong>Lorna</strong>: In Stretch-to-Earn zal SB Group veel NFT’s ontwikkelen om rijke ervaringen aan spelers te bieden. In versie 1 zal SB Group alleen NFT-shirts (heren- en damesshirts) lanceren. In de volgende versies zullen we andere NFT’s uitbrengen: trainingsbroeken, hoeden, schoenen, enzovoort.</p>
<h3 id="h3-Q520Ik20heb20opgemerkt20dat20je20een20nieuw20verdienconcept20introduceert20genaamd20Stretch20to20Earn20STE20Kun20je20uitleggen20hoe20dit20STEconcept20verschilt20van20MoveToEarn20MTE20En20wat20heb20ik20nodig20om20te20beginnen20met20verdienen20met20dit20Stretch20to20Earn20STE20concept20moet20ik20NFTs20kopen20Graag20een20uitleg373433"><a name="Q5: Ik heb opgemerkt dat je een nieuw verdienconcept introduceert, genaamd “Stretch to Earn (STE)”. Kun je uitleggen hoe dit STE-concept verschilt van Move-To-Earn (MTE)? En wat heb ik nodig om te beginnen met verdienen met dit Stretch to Earn (STE) concept, moet ik NFT’s kopen? Graag een uitleg." class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q5: Ik heb opgemerkt dat je een nieuw verdienconcept introduceert, genaamd “Stretch to Earn (STE)”. Kun je uitleggen hoe dit STE-concept verschilt van Move-To-Earn (MTE)? En wat heb ik nodig om te beginnen met verdienen met dit Stretch to Earn (STE) concept, moet ik NFT’s kopen? Graag een uitleg.</h3><p><strong>Lorna</strong>: Inderdaad, Move-to-Earn is op dit moment dé trend in de cryptowereld. Maar Stretch-to-Earn is meer dan alleen bewegen om geld te verdienen, het is ook bewegen om gebruikers een gezonde levensstijl en een goed inkomen te bieden.<br>De reden waarom we ervoor hebben gekozen om Stretch-to-Earn te ontwikkelen, is omdat ons team zich realiseert dat mensen hun gezondheid verwaarlozen in deze moderne tijd. Daarom richten we ons op het opbouwen van STE om mensen te motiveren meer te bewegen, een evenwichtiger leven te leiden en tegelijkertijd meer inkomen te genereren.</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 visie van de onderzoeker en vormt geen beleggingssuggesties.<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 zullen juridische stappen worden ondernomen vanwege inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div>