R2F0ZS5pbyBBTUEgbWV0IEJhYnlTd2FwIC0gRWVuIEJhYnkgTWV0YUZpIG9wIEJOQiBDaGFpbiBkYXQgdmVyZGVyIGdhYXQgZGFuIEFNTSwgTkZUIGVuIEdhbWVQYWQ=

<p><img src="https://gimg2.gateimg.com/image/article/16909497971.jpeg" alt=""><br><strong>Tijd: 13 oktober 2021, 13:00 UTC</strong><br><strong><a href="https://www.gate.io" target="_blank">Gate.io</a> organiseerde een AMA-sessie (Ask-Me-Anything) met Ava, Global director van BabySwap in de <a href="https://t.me/gateio" rel="nofollow noopener noreferrer" target="_blank">Gate.io Exchange Gemeenschap</a> Officiële website: <a href="https://home.babyswap.finance/" rel="nofollow noopener noreferrer" target="_blank">https://home.babyswap.finance/</a></strong><br><strong>Twitter: <a href="https://twitter.com/babyswap_bsc" rel="nofollow noopener noreferrer" target="_blank">https://twitter.com/babyswap_bsc</a></strong><br><strong>Volg BabySwap op <a href="https://twitter.com/babyswap_bsc" rel="nofollow noopener noreferrer" target="_blank">Twitter</a> en <a href="https://t.me/baby_swap" rel="nofollow noopener noreferrer" target="_blank">Telegram</a></strong><br><strong>Gast</strong><img src="https://gimg2.gateimg.com/image/article/16909500092.jpg" alt=""><br><strong>Ava — Global directeur van BabySwap</strong></p>
<h2 id="h2-Vragen20en20antwoorden20van20Gateio194577"><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-Q120Om20te20beginnen20wat20heeft20geleid20tot20de20ontwikkeling20van20BabySwap20Kunt20u20de20achtergrond20uitleggen20en20hoe20kwam20u20op20het20idee48657"><a name="Q1: Om te beginnen, wat heeft geleid tot de ontwikkeling van BabySwap? Kunt u de achtergrond uitleggen en hoe kwam u op het idee?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q1: Om te beginnen, wat heeft geleid tot de ontwikkeling van BabySwap? Kunt u de achtergrond uitleggen en hoe kwam u op het idee?</h3><p><strong>Ava</strong>: Binance Smart Chain is een geweldige plek voor pasgeboren en long-tail projecten om te groeien, echter, ze missen ondersteuning in DEX. De bestaande DEX richt zich doorgaans alleen op de top projecten van BSC, en kan niet effectief voorzien in de behoeften van pasgeboren en long-tail projecten op BSC. Deze projecten hebben geen effectieve operationele ondersteuning, zoals marketing, fondsen, middelen, enzovoort.</p>
<p>Aan de andere kant is er een verkeersdilemma voor DeFi-projecten, waarbij nieuwe NFT- en GameFi-projecten de traditionele markt met de cryptowereld beginnen te verbinden door nieuw verkeer aan te trekken, en dat is niet genoeg, dus we hebben het gevoel dat we op onze eigen manier mensen van buitenaf moeten aantrekken.</p>
<p>Dus De ontwikkeling van BabySwap is verdeeld in twee fasen en evolueert geleidelijk van DeFi naar GameFi. AMM is de basis, NFT is de connector en GameFi is de verkeerspool.</p>
<h3 id="h3-Q220En20het20lijkt20erop20dat20BabySwap20snel20groeit20in20deze20drie20maanden20en20de20laatste20tijd20steeds20meer20wordt20besproken20Wat20hebben20jullie20de20afgelopen20drie20maanden20gedaan604374"><a name="Q2: En het lijkt erop dat BabySwap snel groeit in deze drie maanden en de laatste tijd steeds meer wordt besproken. Wat hebben jullie de afgelopen drie maanden gedaan?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q2: En het lijkt erop dat BabySwap snel groeit in deze drie maanden en de laatste tijd steeds meer wordt besproken. Wat hebben jullie de afgelopen drie maanden gedaan?</h3><p><strong>Ava</strong> Ik wil graag een paar van BabySwap’s laatste prestaties met u delen. BabySwap nam deel aan het BSC MVBIII-programma. De gemiddelde DAU (dagelijks actieve gebruikers) stond op de 5e plaats in alle BSC-apps. Het gemiddelde dagelijkse handelsvolume is ongeveer 60 miljoen en staat op de 3e plaats in alle BSC DEX. Onze sociale signaal stond op de 2e plaats in alle BSC-apps en op de 1e plaats in BSC DEX. De beveiligingsscore van BabySwap stond op de 2e plaats in het hele BSC-ecosysteem. De rangschikkingsgegevens komen van BSC Daily, DeBank, DappRadar, enz.</p>
<p>Gedurende deze drie maanden bleef BabySwap werken aan de infrastructuur, waaronder productfuncties, samenwerking, projectdiensten, enzovoort.</p>
<p>Over het projectoverzicht, om beter aan te sluiten bij de projecten met verschillende behoeften, hebben we verschillende ‘Baby’-programma’s gelanceerd voor DEX-vermelding, waaronder Bubbly Baby, Celebrity Baby, Flash Baby en MVBIII Baby. We hielden wekelijks een lijst bij van nieuwe 3-5 Pools en we zijn nooit gestopt met het zoeken naar potentiële projecten.</p>
<p>We hebben er alles aan gedaan om zowel de samenwerkende projecten als de gebruikers van BabySwap beter van dienst te zijn. En het harde werk loont.</p>
<h3 id="h3-Q320Zeker20hard20werken20loont20En20gefeliciteerd20met20alle20prestaties20Om20het20project20beter20te20begrijpen20heeft20BabySwap20yield20farms20en20pools20In20het20BSCecosysteem20dat20zoveel20gevestigde20platforms20heeft20wat20maakt20jullie20project20uniek20in20jullie20ogen503355"><a name="Q3: Zeker, hard werken loont! En gefeliciteerd met alle prestaties! Om het project beter te begrijpen, heeft BabySwap yield farms en pools. In het BSC-ecosysteem, dat zoveel gevestigde platforms heeft, wat maakt jullie project uniek in jullie ogen?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q3: Zeker, hard werken loont! En gefeliciteerd met alle prestaties! Om het project beter te begrijpen, heeft BabySwap yield farms en pools. In het BSC-ecosysteem, dat zoveel gevestigde platforms heeft, wat maakt jullie project uniek in jullie ogen?</h3><p><strong>Ava</strong>: De ontwikkeling van BabySwap is verdeeld in twee fasen en evolueert geleidelijk van DeFi naar GameFi. DEX is de basis, NFT is de connector en GameFi is de verkeerspool.</p>
<p>Naast de basisfuncties die hetzelfde zijn als andere DEXs - swap, farms en pools, heeft BabySwap enkele innovatieve optimalisatie- en ondersteunende diensten:<br>I. Handelsmining<br>Ontvang een BABY-miningbeloning telkens wanneer je handelt op BabySwap. 40% van de $BABY blokemissie wordt trade miningbeloningen.<br>II. <a href="/price/tether-usdt" rel="nofollow noopener noreferrer" target="_blank">Tether</a> Aanbevolen route van BabySwap is <a href="/price/tether-usdt" target="_blank" class="blog_inner_link">Tether</a> (USDT). Onze voordelen zijn het gemak en de lage kosten voor beginners op BSC, en het is gemakkelijker om te communiceren met CEXs omdat ze voornamelijk USDT-handelsparen gebruiken. III. BabySwap Grants Het Grants-programma verbetert sterk de zakelijke partnerschappen tussen BabySwap en alle andere BSC-projecten en biedt een enorme uitbreiding van de gebruiksmogelijkheden van BABY.</p>
<p>Tenslotte en het belangrijkste, we gaan uiteindelijk over naar GameFi. Het spel creëert een geheel nieuw systeem dat BabySwap DEX-functies, sociale activiteiten, play-to-earn mechanismen en NFT’s als spelattributen omvat.<br><img src="https://gimg2.gateimg.com/image/article/16909500413.png" alt=""><br>Al deze functies stellen BABY in staat om verschillende hulpprogramma’s te bieden en een gezond ecosysteem rondom BABY te implementeren.</p>
<h3 id="h3-Q420Ok20en20het20lijkt20inderdaad20een20zeer20compleet20project20te20zijn20Echter20er20zijn20nu20veel20DEXen20in20de20industrie20wat20kan20BabySwap20bieden20voor20de20projecten20in20het20ecosysteem956305"><a name="Q4: Oké, en het lijkt inderdaad een zeer compleet project te zijn… Echter, er zijn nu veel DEX’en in de industrie, wat kan BabySwap bieden voor de projecten in het ecosysteem?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q4: Oké, en het lijkt inderdaad een zeer compleet project te zijn… Echter, er zijn nu veel DEX’en in de industrie, wat kan BabySwap bieden voor de projecten in het ecosysteem?</h3><p><strong>Ava</strong>: Nu we aan een project beginnen, zullen we het volledige beeld ervan begrijpen en de meest passende diensten aanbieden.</p>
<p>Baby biedt drie basisdiensten voor één token:<br>Liquiditeitsmining (Farm): helpt om de marktdiepte te vergroten<br>Enkele muntmining (Pool): om te helpen bij een hoogwaardige tokenverdeling<br>Handelsmining: helpt om het handelsvolume te vergroten</p>
<p>Naast dit hebben we Playground gelanceerd om onze partners die toepassingen met BABY hebben gelanceerd beter te ondersteunen. Baby werkt als een broncentrum en legt verbindingen tussen verschillende partijen en introduceert vrienden van Baby. We verwachten in oktober de Bottle (groeifonds) functie te lanceren om projecten met echt geld te ondersteunen.</p>
<h3 id="h3-Q520Interessant20ok20en20we20hebben20gemerkt20dat20BabySwap20zijn20eigen20NFTs20uitgeeft20Kun20je20hier20meer20over20vertellen20Hoe20is20de20NFB20Pool20ontworpen20om20een20versterking20te20zijn20voor20BABY728873"><a name="Q5: Interessant…. oké en we hebben gemerkt dat BabySwap zijn eigen NFT’s uitgeeft. Kun je hier meer over vertellen? Hoe is de NFB Pool ontworpen om een versterking te zijn voor $BABY?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q5: Interessant…. oké en we hebben gemerkt dat BabySwap zijn eigen NFT’s uitgeeft. Kun je hier meer over vertellen? Hoe is de NFB Pool ontworpen om een versterking te zijn voor $BABY?</h3><p><strong>Ava</strong>: BabySwap heeft plannen om een volledig NFT-systeem op te bouwen, en het doel is om een BabySwap metaverse op te zetten. We geloven altijd dat NFT een brug is naar de traditionele industrie en de belichaming van eigendom is. Als een DEX die zich richt op start-ups en gemeenschappen, willen we meer mensen en projecten betrekken, niet alleen door kunstwerken te kopen, maar door NFT echt te versterken, zodat we de infrastructuur kunnen bieden voor het metaverse.</p>
<p>De minted NFT’s van BabySwap worden NFB (Non-Fungible Baby) genoemd. Elke NFB heeft zijn nominale waarde, zoals 1000 BABY. Gebruikers kunnen hun NFB in de NFB-stakingspool met nominale waarde inzetten, maar verdienen een hogere APR.<br><img src="https://gimg2.gateimg.com/image/article/16909500244.jpg" alt=""><br>BabySwap NFB is voortdurend in de top drie op Treasureland gerangschikt. Dit geeft aan dat mensen erkennen dat NFB een hogere waarde heeft en gemakkelijk verkocht kan worden op de secundaire markt met zeer goede liquiditeit.</p>
<h3 id="h3-Q620Maar20om20terug20te20komen20op20het20project20haha20wat20staat20er20te20gebeuren20Wat20zijn20de20komende20belangrijke20plannen20voor20het20einde20van20202120Blijven20jullie20bij20jullie20routekaart253201"><a name="Q6: Maar om terug te komen op het project haha… wat staat er te gebeuren? Wat zijn de komende belangrijke plannen voor het einde van 2021? Blijven jullie bij jullie routekaart?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q6: Maar om terug te komen op het project haha… wat staat er te gebeuren? Wat zijn de komende belangrijke plannen voor het einde van 2021? Blijven jullie bij jullie routekaart?</h3><p><strong>Ava</strong>: Ons doel in de toekomst is eenvoudig, voor het AMM-gedeelte willen we de op één na grootste DEX van BSC zijn die zich richt op nieuwe of longtail-projecten. Voor NFT willen we het topmerkbeeld/avatar zijn in de cryptowereld. Voor GameFi willen we eenvoudigweg meer gebruikers aantrekken.</p>
<p>We zullen voortdurend meer en meer BEP 20 Assets ondersteunen, projecten van andere chains aantrekken voor BSC (AMM), en verkeer en gebruikers van buiten de crypto (NFT+GameFi) aantrekken.</p>
<p>En ja, we houden het bij om onze routekaart te volgen. En we zullen een vruchtbare oktober hebben met veel nieuwe functies die worden gelanceerd en het hele ecosysteem is steeds completer. Dit zijn de Smart Router, Hold-functie, Bottle-functie, Crypto BABY (Profiel) en vBABY.</p>
<h3 id="h3-Q720Wow20zoveel20nieuwe20dingen20die20eraan20komen20Kunt20u20ze20alstublieft20in20detail20introduceren662463"><a name="Q7: Wow, zoveel nieuwe dingen die eraan komen. Kunt u ze alstublieft in detail introduceren?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q7: Wow, zoveel nieuwe dingen die eraan komen. Kunt u ze alstublieft in detail introduceren?</h3><p><strong>Ava</strong>: Om het doel voor AMM te bereiken, zullen we in oktober een slimme router implementeren om de handelservaring te verbeteren. We zullen ook bottle en Hold als nieuwe functies hebben in oktober om meer BABY vast te zetten en een sterkere basis te bieden voor BABY. UI en UX zullen ook worden geüpgraded en een dashboard, roi calculator en aangepaste instellingen toevoegen, om gebruikers ten goede te komen.</p>
<p>Voor NFT zal de NFT-marktplaats in oktober worden gelanceerd en we zullen ook sociale avatars hebben samen met de marktplaats. Speelgoedfiguren in de echte wereld zullen later dit jaar of volgend jaar ook worden opgenomen.</p>
<p>Voor GameFi worden Play2earn kaartspellen en simulatiespellen allemaal ontwikkeld.</p>
<p>Naarmate we groeien, leren we van de markt en leren we van het MVB III-programma om onze gebruikers en partners beter te ondersteunen. Lange termijn projecten zijn de kernactiva en we zullen het snelle tempo behouden om de top 2 te zijn op BSC.</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 standpunten van de onderzoeker en vormt geen beleggingsadviezen.<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 wegens inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div>