R2F0ZS5pbyBBTUEgY29uIEJhYnlTd2FwIC0gVW5hIEJhYnkgTWV0YUZpIHN1IEJOQiBDaGFpbiBjaGUgdmEgb2x0cmUgQU1NLCBORlQgZSBHYW1lUGFk

<p><img src="https://gimg2.gateimg.com/image/article/16909497971.jpeg" alt=""><br><strong>Time: 13 ottobre 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 Ava, direttore globale di BabySwap 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://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>Segui BabySwap su <a href="https://twitter.com/babyswap_bsc" rel="nofollow noopener noreferrer" target="_blank">Twitter</a> e <a href="https://t.me/baby_swap" rel="nofollow noopener noreferrer" target="_blank">Telegram</a></strong><br><strong>Ospite</strong><img src="https://gimg2.gateimg.com/image/article/16909500092.jpg" alt=""><br><strong>Ava - Direttore globale di BabySwap</strong></p>
<h2 id="h2-QampA20da20Gateio644002"><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-Q120Quindi20per20iniziare20cosa20ti20ha20portato20a20sviluppare20il20BabySwap20Puoi20spiegare20lo20sfondo20e20come20ti2020venuta20lidea73960"><a name="Q1: Quindi per iniziare, cosa ti ha portato a sviluppare il BabySwap? Puoi spiegare lo sfondo e come ti è venuta l’idea?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q1: Quindi per iniziare, cosa ti ha portato a sviluppare il BabySwap? Puoi spiegare lo sfondo e come ti è venuta l’idea?</h3><p><strong>Ava</strong>: Binance Smart Chain è un ottimo luogo per i progetti appena nati e a lunga coda per crescere, tuttavia mancano di supporto nel DEX. Il DEX esistente tende a concentrarsi solo sui progetti di punta di BSC e non può soddisfare efficacemente i progetti appena nati e a lunga coda di BSC. Questi progetti non dispongono di un supporto operativo efficace, come marketing, fondi, risorse, e così via.</p>
<p>D’altra parte, c’è un dilemma del traffico dei progetti DeFi, i nuovi progetti NFT e GameFi iniziano a collegare il mercato tradizionale al mondo delle criptovalute attrarre nuovo traffico, e non è sufficiente, quindi ci sentiamo di utilizzare il nostro modo per attirare persone dall’esterno.</p>
<p>Lo sviluppo di BabySwap è diviso in due fasi ed evolve gradualmente da DeFi a GameFi. AMM è il fondamento, NFT è il collegamento e GameFi è il pool di traffico.</p>
<h3 id="h3-Q220E20sembra20che20BabySwap20stia20crescendo20rapidamente20in20questi20tre20mesi20e20ultimamente20si20parla20sempre20di20pi20Cosa20avete20fatto20voi20ragazzi20in20questi20ultimi20tre20mesi721985"><a name="Q2: E sembra che BabySwap stia crescendo rapidamente in questi tre mesi e ultimamente si parla sempre di più. Cosa avete fatto voi ragazzi in questi ultimi tre mesi?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q2: E sembra che BabySwap stia crescendo rapidamente in questi tre mesi e ultimamente si parla sempre di più. Cosa avete fatto voi ragazzi in questi ultimi tre mesi?</h3><p><strong>Ava</strong>: Vorrei condividere con te alcuni dei recenti risultati di BabySwap. BabySwap ha partecipato al programma BSC MVBIII. Il DAU medio (utenti attivi giornalieri) si classifica al 5° posto tra tutte le app BSC. Il volume medio di trading giornaliero è di circa 60 milioni, classificandosi al 3° posto tra tutti i BSC DEX. Il nostro segnale sociale si posiziona al 2° posto tra tutte le app BSC e al 1° posto tra i BSC DEX. Il punteggio di sicurezza di BabySwap si posiziona al 2° posto nell’intero ecosistema BSC. I dati di classifica provengono da BSC Daily, DeBank, DappRadar, ecc.</p>
<p>Durante questi tre mesi, BabySwap ha continuato a costruire l’infrastruttura, comprese le funzionalità del prodotto, la cooperazione, i servizi dei progetti, ecc.</p>
<p>Per quanto riguarda l’elenco dei progetti, per abbinare meglio i progetti alle diverse esigenze, abbiamo lanciato diversi programmi “”Baby”” per l’elenco DEX, tra cui Bubbly Baby, Celebrity Baby, Flash Baby e MVBIII Baby. Abbiamo tenuto un elenco settimanale di 3-5 piscine e non abbiamo mai smesso di occuparci di potenziali progetti.</p>
<p>Abbiamo fatto tutto il possibile per servire meglio sia i progetti collaborativi che gli utenti di BabySwap. E il duro lavoro paga.</p>
<h3 id="h3-Q320Sicuramente20il20duro20lavoro20paga20E20complimenti20per20tutti20i20risultati20Quindi20capendo20meglio20in20profondit20il20progetto20BabySwap20ha20fattorie20di20rendimento20e20pool20Nellecosistema20BSC20che20ha20cos20tante20piattaforme20consolidate20come20ti20senti20riguardo20a20queste20caratteristiche20che20rendono20il20tuo20progetto20unico206079"><a name="Q3: Sicuramente il duro lavoro paga! E complimenti per tutti i risultati! Quindi, capendo meglio in profondità il progetto, BabySwap ha fattorie di rendimento e pool. Nell’ecosistema BSC che ha così tante piattaforme consolidate, come ti senti riguardo a queste caratteristiche che rendono il tuo progetto unico?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q3: Sicuramente il duro lavoro paga! E complimenti per tutti i risultati! Quindi, capendo meglio in profondità il progetto, BabySwap ha fattorie di rendimento e pool. Nell’ecosistema BSC che ha così tante piattaforme consolidate, come ti senti riguardo a queste caratteristiche che rendono il tuo progetto unico?</h3><p><strong>Ava</strong>: Lo sviluppo di BabySwap è diviso in due fasi e si sta evolvendo gradualmente da DeFi a GameFi. DEX è il fondamento, NFT è il connettore e GameFi è il pool di traffico.</p>
<p>Oltre alle funzionalità di base che sono le stesse di altri DEX - swap, farms e pools, BabySwap ha alcune innovative ottimizzazioni e servizi di supporto:<br>I. Trade mining<br>Ottieni una ricompensa di mining BABY ogni volta che fai trading su BabySwap. Il 40% delle emissioni di blocco $BABY diventerà ricompense di mining per il trading.<br>II. <a href="/price/tether-usdt" rel="nofollow noopener noreferrer" target="_blank">Tether</a> Il percorso raccomandato da BabySwap è <a href="/price/tether-usdt" target="_blank" class="blog_inner_link">Tether</a> (USDT). I nostri vantaggi sono la convenienza e il basso costo per i principianti di BSC, ed è più facile interagire con i CEXs dal momento che principalmente utilizzano coppie di trading USDT. Il programma BabySwap Grants migliora notevolmente le partnership commerciali tra BabySwap e tutti gli altri progetti BSC e fornisce una massiccia espansione dei casi d’uso di BABY.</p>
<p>Infine, e soprattutto, stiamo finalmente passando al GameFi. Il gioco crea un sistema completamente nuovo che include le funzioni DEX di BabySwap, le attività sociali, i meccanismi play-to-earn e gli NFT come oggetti di scena.<br><img src="https://gimg2.gateimg.com/image/article/16909500413.png" alt=""><br>Tutte queste funzionalità permettono a BABY di avere varie utilità e di creare un ecosistema sano intorno a BABY.</p>
<h3 id="h3-Q420Ok20e20sembra20davvero20un20progetto20completo20Tuttavia20ora20ci20sono20molti20DEX20nellindustria20cosa20pu20offrire20BabySwap20per20i20progetti20nellecosistema841997"><a name="Q4: Ok e sembra davvero un progetto completo… Tuttavia, ora ci sono molti DEX nell’industria, cosa può offrire BabySwap per i progetti nell’ecosistema?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q4: Ok e sembra davvero un progetto completo… Tuttavia, ora ci sono molti DEX nell’industria, cosa può offrire BabySwap per i progetti nell’ecosistema?</h3><p><strong>Ava</strong>: Ora, quando iniziamo a lavorare su un progetto, impareremo l’intera immagine di esso e offriremo i servizi più adatti.</p>
<p>Baby fornisce tre servizi di base per un token:<br>Mining della liquidità (Farm): aiuta ad aumentare la profondità di mercato<br>Mining di una singola moneta (Pool): per aiutare a completare la distribuzione di token di alta qualità<br>Trade Mining: aiuta ad aumentare il volume di scambi</p>
<p>Oltre a ciò, abbiamo lanciato Playground per supportare meglio i nostri partner che hanno applicazioni con BABY. Baby sta lavorando come centro risorse, creando connessioni tra diverse parti e presentando gli amici di Baby. Ci aspettiamo di lanciare la funzione Bottle (fondo di crescita) in ottobre per supportare progetti con denaro reale.</p>
<h3 id="h3-Q520Interessante20ok20e20abbiamo20notato20che20BabySwap20crea20i20propri20NFT20Per20favore20condividi20di20pi20a20riguardo20Come2020stato20progettato20NFB20Pool20per20essere20un20modo20di20supporto20per20BABY538890"><a name="Q5: Interessante… ok e abbiamo notato che BabySwap crea i propri NFT. Per favore, condividi di più a riguardo. Come è stato progettato NFB Pool per essere un modo di supporto per $BABY?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q5: Interessante… ok e abbiamo notato che BabySwap crea i propri NFT. Per favore, condividi di più a riguardo. Come è stato progettato NFB Pool per essere un modo di supporto per $BABY?</h3><p><strong>Ava</strong>: BabySwap pianifica di costruire un sistema completo di NFT, e l’obiettivo è quello di stabilire un metaverso di BabySwap. Crediamo sempre che gli NFT siano un ponte verso l’industria tradizionale e siano l’incarnazione della proprietà. Come DEX focalizzato sulle start-up e sulla comunità, vogliamo coinvolgere più persone e progetti, non solo acquistando opere d’arte, ma dando un vero potere agli NFT in modo da poter fornire l’infrastruttura per il metaverso.</p>
<p>Gli NFT mintati da BabySwap vengono chiamati NFB (Non-Fungible Baby). Ogni NFB avrà un valore nominale, come ad esempio 1000 BABY. Gli utenti possono scommettere i propri NFB nel pool di scommesse NFB con il valore nominale, ma guadagnare con un APR più elevato.<br><img src="https://gimg2.gateimg.com/image/article/16909500244.jpg" alt=""><br>BabySwap NFB è costantemente classificato tra i primi tre su Treasureland. Ciò indica che le persone riconoscono che NFB ha un valore più elevato e può essere facilmente venduto sul mercato secondario con una liquidità molto buona.</p>
<h3 id="h3-Q620Ma20tornando20al20progetto20haha20cosa20sta20arrivando20Quali20sono20i20prossimi20piani20principali20prima20della20fine20del20202120State20ancora20seguendo20la20vostra20tabella20di20marcia996566"><a name="Q6: Ma tornando al progetto haha… cosa sta arrivando? Quali sono i prossimi piani principali prima della fine del 2021? State ancora seguendo la vostra tabella di marcia?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q6: Ma tornando al progetto haha… cosa sta arrivando? Quali sono i prossimi piani principali prima della fine del 2021? State ancora seguendo la vostra tabella di marcia?</h3><p><strong>Ava</strong>: Il nostro obiettivo per il futuro è semplice, per AMM, vogliamo essere il DEX #2 di BSC che si concentra su progetti nuovi o a coda lunga. Per gli NFT, vogliamo essere l’immagine/avatar del marchio più importante nel mondo delle criptovalute. Per il GameFi, vogliamo semplicemente attirare più utenti.</p>
<p>Continueremo costantemente,<br>Supportare sempre più Asset BEP 20<br>Attrarre progetti da altre catene per BSC (AMM)<br>Attrarre traffico e utenti al di fuori della criptovaluta (NFT+GameFi)</p>
<p>E sì, stiamo mantenendo il nostro impegno nel seguire la nostra roadmap. Avremo un ottobre fruttuoso con molte nuove funzionalità in arrivo e l’intero ecosistema è sempre più completo. Tra queste ci sono il Smart Router, la funzione Hold, la funzione Bottle, Crypto BABY (Profilo) e vBABY.</p>
<h3 id="h3-Q720Wow20cos20tante20nuove20cose20in20arrivo20Potresti20presentarle20in20dettaglio490175"><a name="Q7: Wow, così tante nuove cose in arrivo. Potresti presentarle in dettaglio?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q7: Wow, così tante nuove cose in arrivo. Potresti presentarle in dettaglio?</h3><p><strong>Ava</strong>: Per raggiungere l’obiettivo per AMM, implementeremo un router intelligente in ottobre per migliorare l’esperienza di trading. Avremo anche la funzionalità di blocco e mantenimento come nuove caratteristiche in ottobre per bloccare più BABY e fornire una base più solida per BABY. L’UI e l’UX saranno anche aggiornati e aggiungeremo il cruscotto, il calcolatore ROI e le impostazioni personalizzate, a beneficio degli utenti.</p>
<p>Per NFT, il marketplace NFT verrà lanciato a ottobre, e avremo anche avatar sociali insieme al marketplace. Le figure giocattolo nel mondo reale saranno incluse in seguito quest’anno o il prossimo.</p>
<p>Per GameFi, i giochi di carte Play2earn e i giochi di simulazione sono tutti in fase di sviluppo.</p>
<p>Man mano che cresciamo, impariamo dal mercato e dal programma MVB III per supportare meglio i nostri utenti e partner. I progetti a lunga coda sono gli asset principali, e manterremo un ritmo veloce per essere tra i primi 2 su BSC.</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 suggerimenti di investimento.<br></em><div><em></em>Gate.io si riserva tutti i diritti su questo articolo. La ripubblicazione dell'articolo sarà consentita a condizione che sia 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>