R2F0ZS5pbyBBTUEgY29uIE1pbG8gSW51IC0gQmFzYXRvIHN1bGxhIHNlcmllIGFuaW1hdGEgc2kgZXN0ZW5kZSBhbXBpYW1lbnRlIGEgTkZULCBHYW1lRmksIHNlcmllIGRpIGZpZ3VyaW5l

<p><img src="https://gimg2.gateimg.com/image/article/16811908801.jpg" alt=""><br><strong>Tempo: 18 aprile 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 Steady Hands e JF, amministratori di Milo Inu nel <a href="https://t.me/gateio" rel="nofollow noopener noreferrer" target="_blank">Comunità di scambio di Gate.io</a>.</strong><br><strong>Sito ufficiale: <a href="https://www.miloinu.io/" rel="nofollow noopener noreferrer" target="_blank">https://www.miloinu.io/</a></strong><br><strong>Twitter: <a href="https://twitter.com/MiloInu" rel="nofollow noopener noreferrer" target="_blank">https://twitter.com/MiloInu</a></strong><br><strong>Segui Milo Inu su <a href="https://t.me/MiloInu" rel="nofollow noopener noreferrer" target="_blank">Telegramma</a> e <a href="https://twitter.com/MiloInu" rel="nofollow noopener noreferrer" target="_blank">Cinguettare</a></strong><br><strong>Ospite</strong><img src="https://gimg2.gateimg.com/image/article/16811910942.png" alt=""><br><strong>Mani ferme - Amministratore di Milo Inu</strong></p>
<h2 id="h2-QampA20da20Gateio997155"><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-Q120Puoi20fornire20una20breve20presentazione20di20te20stesso20per20la20comunit493345"><a name="Q1: Puoi fornire una breve presentazione di te stesso per la comunità?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q1: Puoi fornire una breve presentazione di te stesso per la comunità?</h3><p><img src="https://gimg2.gateimg.com/image/article/16811911313.png" alt=""><br>Certamente. Sono Steady Hands e sono un amministratore di Milo Inu. Faccio parte di un team di circa 30 persone che include un team di sviluppo full stack, esperti di solidità, responsabili marketing e, soprattutto, il nostro team di sviluppo prodotto che sta attualmente lavorando alla nostra serie animata Milo Inu e ai prodotti periferici.</p>
<h3 id="h3-Q220Quindi20puoi20per20favore20dirci20qual2020la20dichiarazione20di20missione20di20Milo20Inu847408"><a name="Q2: Quindi puoi per favore dirci qual è la dichiarazione di missione di Milo Inu?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q2: Quindi puoi per favore dirci qual è la dichiarazione di missione di Milo Inu?</h3><p>Milo Inu mira a creare un’intera marca riconosciuta non solo dalla comunità criptografica ma anche dall’intero mondo nel suo complesso grazie alla ricchezza dell’animazione.</p>
<p>Questo avverrà sotto forma di NFT, prodotti periferici come figurine e giocattoli e le nostre serie animate. Avremo anche GameFi, CartoonFi ed e-sport competitivi online e LAN.</p>
<h3 id="h3-Q320Qual2020lutilit20di20Milo20Inu199527"><a name="Q3: Qual è l’utilità di Milo Inu?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q3: Qual è l’utilità di Milo Inu?</h3><p>Abbiamo un approccio a 360 gradi che comprenderà il successo e interconnetterà tutti gli aspetti del Milo Inu.</p>
<p>Questo include animazione, NFT, GameFi (p2e), IP del mondo reale (molto simile a Topolino, ad esempio), un centro commerciale virtuale e, soprattutto, il Mondo di Milo.</p>
<p>Milo Inu avrà il suo mondo “Milo World” che svolgerà il ruolo più importante nel sistema.</p>
<p>Lo sviluppo del mondo di Milo inizierà dopo il completamento della serie animata di Milo, NFT e GameFi.</p>
<p>L’utente finale sarà in grado di costruire la propria casa personalizzata nel Mondo di Milo.</p>
<h3 id="h3-Q420Quali20sono20le20tue20420principali20aree20di20sviluppo302048"><a name="Q4: Quali sono le tue 4 principali aree di sviluppo?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q4: Quali sono le tue 4 principali aree di sviluppo?</h3><p>Area 1 - Meme<br>Come puoi vedere sulla nostra pagina di BSC scan, abbiamo ricevuto il badge ufficiale del meme, tuttavia non siamo un progetto meme tipico.</p>
<p>Ci differenziamo portando questo al livello successivo con il nostro ecosistema di cui ho appena parlato, inclusi NFT, giochi p2e, le nostre serie animate e, soprattutto, Milo’s World. Uno dei nostri obiettivi principali è quello di diventare un nome familiare simile a personaggi del calibro di Topolino e abbiamo il team in atto per renderlo realtà.</p>
<p>Area 2 - NFT’s<br>Una volta pubblicata la nostra prima serie animata (abbiamo completato di recente l’Episodio 1 della stagione 1), lanceremo la nostra prima serie di NFT. I nostri NFT avranno la capacità di interagire con l’intero ecosistema.</p>
<p>Area 3 - GameFi<br>Sulla base delle nostre esperienze collettive come squadra, abbiamo capito cosa funziona e cosa non funziona per quanto riguarda i giochi p2e. Di conseguenza, offriremo vari tipi di gameplay e modalità per garantire che tutti i giocatori possano divertirsene con tutti i livelli di difficoltà e divertimento.</p>
<p>Area 4 - Il mondo di Milo<br>Questo è l’aspetto più importante del nostro progetto perché metterà insieme tutto ciò che abbiamo appena menzionato nel nostro Metaverse. Qui è dove la serie animata, gli NFT, GameFi e CartoonFi convergono per creare una piattaforma completamente interattiva per tutti da godere.<br><img src="https://gimg2.gateimg.com/image/article/16811911754.png" alt=""><br>Ricorda che stiamo anche creando bambole/figurine fisiche in modo che tu possa avere il tuo pezzo fisico del Metaverso.</p>
<h3 id="h3-Q520Abbiamo20finito20nelle20aree20di20sviluppo20quindi20ora20puoi20dirci20qual2020la20tokenomica20di20Milo20Inu411372"><a name="Q5: Abbiamo finito nelle aree di sviluppo, quindi ora puoi dirci qual è la tokenomica di Milo Inu?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q5: Abbiamo finito nelle aree di sviluppo, quindi ora puoi dirci qual è la tokenomica di Milo Inu?</h3><p>Fornitura iniziale totale - 690 trilioni di token</p>
<ol>
<li>Il 42% della fornitura è stato bruciato.</li><li>Il 25% della fornitura è stato bloccato per 69 anni in UniCrypt per la liquidità.</li><li>Il 10% è stato riservato e bloccato per GameFi.</li><li>Il 12% è stato riservato per il marketing.</li><li>Il 5% è stato riservato e bloccato per il team e continuerà ad essere bloccato.</li></ol>
<p>Milo Inu è un token senza tasse del 0%. Abbiamo fatto questo per 2 motivi principali; 1) Crediamo che i nostri investitori dovrebbero tenere più soldi propri senza dover fornire liquidità e altre commissioni. 2) Come sapete, i token senza tasse del 0% sono più favorevoli per gli scambi, il che rimuove una barriera per le nuove quotazioni.</p>
<h3 id="h3-Q620Milo20Inu2020stato20sottoposto20a20verifica20e20in20caso20affermativo20da20chi477472"><a name="Q6: Milo Inu è stato sottoposto a verifica e, in caso affermativo, da chi?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q6: Milo Inu è stato sottoposto a verifica e, in caso affermativo, da chi?</h3><p>Il nostro contratto è stato adottato e completamente verificato da Certik, al quale si può accedere tramite il sito web di Certik. La nostra verifica può anche essere scaricata in formato PDF.</p>
<p>Il nostro attuale ranking di sicurezza su Certik è 92⁄100.</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. La ripubblicazione dell'articolo sarà consentita a condizione che si faccia riferimento a Gate.io. In tutti i casi, saranno intraprese azioni legali a causa di violazioni del copyright.<br></div><p></p><br></div></div></div>