R2F0ZS5pbyBBTUEgY29uIE1vb25BcHAgLSBJbCBMYXllcjAgKyBMYXVuY2hwYWQgZGVsbCdFY29zaXN0ZW1hIEluamVjdGl2ZQ==

<p><img src="https://gimg2.gateimg.com/image/article/17053042371.jpeg" alt=""><br><strong>Ora: 12 gennaio 2023 alle 08: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 Chris Lee, Chief Strategy Officer di MoonApp nel <a href="https://twitter.com/i/spaces/1vOxwjDmalgJB" rel="nofollow noopener noreferrer" target="_blank">Twitter Space.</a></strong><br><strong>Sito ufficiale: <a href="https://www.moonapp.io/" rel="nofollow noopener noreferrer" target="_blank">https://www.moonapp.io/</a></strong><br><strong>Twitter: <a href="https://twitter.com/MoonAppOfficial" rel="nofollow noopener noreferrer" target="_blank">https://twitter.com/MoonAppOfficial</a></strong><br><strong>Segui MoonApp su <a href="https://twitter.com/MoonAppOfficial" rel="nofollow noopener noreferrer" target="_blank">Twitter</a> e <a href="https://t.me/MoonAppChat" rel="nofollow noopener noreferrer" target="_blank">Telegram</a></strong><br><strong>Ospite</strong><img src="https://gimg2.gateimg.com/image/article/17053044192.jpeg" alt=""><br><strong>Chris Lee - Capo Strategia di MoonApp</strong></p>
<h2 id="h2-QampA20da20Gateio623159"><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-Q120Per20coloro20che20stanno20sentendo20parlare20di20Moon20App20per20la20prima20volta20potresti20presentare20brevemente20il20progetto20Che20cos20Moon20App237030"><a name="Q1: Per coloro che stanno sentendo parlare di Moon App per la prima volta, potresti presentare brevemente il progetto? Che cos’è Moon App?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q1: Per coloro che stanno sentendo parlare di Moon App per la prima volta, potresti presentare brevemente il progetto? Che cos’è Moon App?</h3><p><strong>Chris</strong>: Moon app è la nuova piattaforma leader che ha reso gli IDO e gli ISO accessibili all’interno di un’app. È anche combinato con strumenti MEV come Sandwiching, Sniping, Ordini Limit e molto altro. Tutti sono ampiamente disponibili su Web, iOS e Android.</p>
<p>Il prodotto Moon App integra un launchpad, principalmente per progetti Injective, e bot di trading: trading on-chain, inserimento di ordini limite on-chain, sniping di presales, sniping di liquidità e in generale siamo stati i primi a creare un bot per sandwiching, che è disponibile per gli utenti al dettaglio.</p>
<h3 id="h3-Q220Qual2020stato20il20vostro20progresso20nello20sviluppo20dalluscita20della20vostra20app20Come2020andato20il20lancio20dellapplicazione20e20del20sito20web639842"><a name="Q2: Qual è stato il vostro progresso nello sviluppo dall’uscita della vostra app? Come è andato il lancio dell’applicazione e del sito web?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q2: Qual è stato il vostro progresso nello sviluppo dall’uscita della vostra app? Come è andato il lancio dell’applicazione e del sito web?</h3><p><strong>Chris</strong> Abbiamo avuto una crescita significativa dal lancio insieme all’intero ecosistema iniettivo e abbiamo davvero colpito il mercato del prodotto.</p>
<p>Moon App lanciata su App Store, Google Play store e web app e ha raggiunto 270 mila utenti in soli 3 mesi, 42 mila utenti giornalieri che utilizzano i nostri bot di trading con 30 mila scambi al giorno, che superano i $10 milioni di volume giornaliero. Per quanto riguarda il launchpad, abbiamo raggiunto oltre 90 mila partecipanti al nostro primo IDO, il token APP, il nostro token di utilità che ha avuto il maggior numero di partecipanti nel 2023 e 2024 e stiamo solo aspettando di essere quotati tra poche ore!</p>
<h3 id="h3-Q320Come20hai20detto20lapp20Moon2020gi20stata20lanciata20su20iOS20Android20e20Webapp20con20oltre2027020mila20utenti20Puoi20dirci20qualcosa20di20pi20su20cosa2020e20come20funzionale20sue20caratteristiche954150"><a name="Q3: Come hai detto, l’app Moon è già stata lanciata su iOS, Android e Webapp con oltre 270 mila utenti! Puoi dirci qualcosa di più su cosa è e come funziona/le sue caratteristiche?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q3: Come hai detto, l’app Moon è già stata lanciata su iOS, Android e Webapp con oltre 270 mila utenti! Puoi dirci qualcosa di più su cosa è e come funziona/le sue caratteristiche?</h3><p><strong>Chris</strong>: Sì, certo, in precedenza, i bot commerciali venivano costruiti solo internamente dai market maker o dai trader tecnicamente avanzati con grandi budget. Moon App consente a tutti di accedere a questi strumenti con 2-3 clic sul proprio smartphone, senza conoscenze commerciali avanzate, al fine di trarre profitto dalle stesse strategie dei fondi speculativi per svuotare la liquidità di mercato.</p>
<p>Nel nostro caso, ci definiamo una superapp di trading perché automatizziamo le opportunità di rendimento on-chain, il tutto all’interno di un’unica app mobile.</p>
<p>Presto, stiamo introducendo un indice cripto, che ti permetterà di trarre profitto dal trading di un pool di token narrativi tutti in una volta sola - ad esempio, un indice per i token gamefi, i token AI, i token dell’ecosistema injective, ecc.</p>
<h3 id="h3-Q420In20cosa20si20differenzia20Moon20App20dagli20altri20concorrenti20nello20spazio362449"><a name="Q4: In cosa si differenzia Moon App dagli altri concorrenti nello spazio?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q4: In cosa si differenzia Moon App dagli altri concorrenti nello spazio?</h3><p><strong>Chris</strong>: Moon App come prodotto è principalmente una piattaforma di lancio “dedicata” per l’ecosistema Injective.</p>
<p>Questo significa che lavoriamo con diversi incubatori nello spazio per portare progetti promettenti a Injective. E la nostra comunità può partecipare a quei progetti partecipando agli IDO, prima che quei progetti promettenti vengano elencati.</p>
<p>Come tutti sanno, Injective è cresciuto incredibilmente e penso che l’app Moon contribuirà a far schizzare il TVL di Injective introducendo ottimi progetti nella rete.<br><img src="https://gimg2.gateimg.com/image/article/17053044453.jpeg" alt=""><br>Abbiamo una crescente pipeline di applicazioni complete, giochi e altri progetti unici che seguiranno subito dopo il lancio del nostro token. Credo anche che il 2024 sarà l’anno di Injective, e Moon App sarà la piattaforma di lancio dove inizieranno le storie di successo di molti progetti di punta di Injective.</p>
<h3 id="h3-Q520Perch20hai20scelto20di20costruire20su20Injective20Cosa20ti20ha20attratto126996"><a name="Q5: Perché hai scelto di costruire su Injective? Cosa ti ha attratto?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q5: Perché hai scelto di costruire su Injective? Cosa ti ha attratto?</h3><p><strong>Chris</strong>: Injective è la comunità di trader in più rapida crescita - e abbiamo costruito l’app di trading più adatta ai trader al dettaglio. Inoltre, l’integrazione con Injective è semplice e facile da fare come l’integrazione con qualsiasi EVM.</p>
<p>Soprattutto considerando che possiamo fare affidamento sull’infrastruttura esistente su Injective, come instradare le negoziazioni attraverso HelixApp, che è uno dei protocolli di trading nativi più avanzati su qualsiasi catena, punto. Naturalmente, con il nostro Injective Launchpad nativo, vediamo l’opportunità di contribuire alla creazione della prossima generazione di app user-friendly per Injective e rendere la rete ancora più forte e attiva.</p>
<p>Injective si trova attualmente in una posizione unica e molto eccitante in cui ha già una comunità molto forte e ora sta attirando i costruttori di prim’ordine per costruire prodotti avanzati che vanno oltre la cripto e nel retail, il che sarà ancora più importante con il mercato toro. Con Moon App Launchpad, ciò che speriamo di fare è assistere i nuovi entranti nell’ecosistema Injective con strategie di go-to-market, marketing o qualsiasi altra questione in modo che costruiscano e migliorino la base utenti della rete.</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 alcuna 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 sia citato Gate.io. In tutti i casi, verranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div>