Q29zXCfDqCBNSVJBST8gVW4gZXNwZXJpbWVudG8gcGlvbmllcmlzdGljbyBuZWxsYSByaXZvbHV6aW9uZSBkZWxsXCdpZGVudGl0w6AgZGlnaXRhbGUgV2ViMw==

2025-05-16, 09:17

<p><img src="https://gimg2.gateimg.com/image/article/1747386918mirai.png" alt="">
</p><p>Secondo l’introduzione ufficiale, MIRAI è sviluppato dalla nota azienda giapponese di contenuti digitali aww.inc, rappresentando l’ingresso dei personaggi virtuali in <a href="/web3" rel="nofollow noopener noreferrer" target="_blank">Web3</a> Un traguardo significativo nel mondo. Basandosi sull’esperienza di successo nella creazione del modello virtuale imma, il progetto combina l’infrastruttura blockchain di Holoworld e la tecnologia avanzata di intelligenza artificiale per creare personaggi virtuali rivoluzionari con autonomia, intelligenza e capacità di interazione comunitaria. Questa innovazione combina l’esperienza professionale di aww.inc nella grafica computerizzata con il concetto decentralizzato di Web3, aprendo una nuova strada per l’identificazione digitale.</p>
<p>Il 16 maggio 2025, Gate ha ufficialmente lanciato il trading spot MIRAI, segnando l’ingresso ufficiale del progetto nel mercato criptato mainstream. Questo articolo analizzerà in modo esaustivo il suo valore centrale e il potenziale futuro dalle dimensioni dell’architettura tecnica, degli scenari di applicazione e dello sviluppo ecologico.</p>
<h2 id="h2-Prestazioni20di20mercato20MIRAI612496"><a name="Prestazioni di mercato MIRAI" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Prestazioni di mercato MIRAI</h2><p>Il token MIRAI è iniziato in pre-vendita presso <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> Lanciato sulla blockchain sotto forma di offerta a tempo limitato di 48 ore, attirando un gran numero di partecipanti della comunità. Il 12 maggio 2025, il team MIRAI ha annunciato il completamento della pre-vendita, raccogliendo un totale di 76.831 SOL, equivalente a circa 12,95 milioni di dollari statunitensi all’epoca.</p>
<p>Dopo la prevendita, il team MIRAI ha dichiarato che dal 2018, il team ha creato continuamente esseri umani virtuali, ha servito i marchi più importanti e ha generato entrate reali. In futuro, il team continuerà a promuovere lo sviluppo a lungo termine del progetto MIRAI. A tal fine, il team ha deciso di rimborsare il 50% dei fondi a tutti i partecipanti, mentre il restante 50% sarà utilizzato per il lancio del progetto, fornire liquidità e pagare le commissioni di quotazione (se del caso), ecc.</p>
<p>Il 13 maggio, il team MIRAI ha annunciato che il 50% dei 76.831 SOL era stato restituito agli utenti che hanno partecipato alla prevendita del token MIRAI. Dopo il completamento del rimborso, i fondi rimanenti del team erano di 38.415,5 SOL.</p>
<p>Alle 2 del mattino del 16 maggio, il token MIRAI è stato ufficialmente lanciato. Il team MIRAI utilizzerà il 15% dei restanti 38.415,5 SOL per aggiungere al pool di liquidità, circa 5.762 SOL.</p>
<p>L’offerta totale dei token MIRAI è di 1 miliardo, con un prezzo di apertura di 0,0121 dollari statunitensi. Alle ore 17 del 16 maggio, il valore di mercato circolante di MIRAI è di 13 milioni di dollari, con un volume di scambi delle ultime 24 ore di 9,4 milioni di dollari. Il numero di indirizzi di detenzione ha raggiunto quota 7.810 e nel pool di liquidità sono rimasti solo 5.142 token SOL.</p>
<p>Secondo le fonti della comunità, il team MIRAI ha scelto di creare il pool DLMM su Meteora quando ha creato i pool di liquidità on-chain, e ha adottato una modalità Bid-Ask per distribuire liquidità, concentrandola agli estremi dell’intervallo di prezzo. Questo design potrebbe causare forti fluttuazioni dei prezzi dei token nell’intervallo intermedio, e affrontare una significativa resistenza di rottura quando si raggiungono i prezzi più bassi o più alti.</p>
<p>Inoltre, il pool di liquidità MIRAI ha una tassa di trading di base del 5%, il che significa che gli utenti sopporteranno il 5% del costo per l’acquisto e la vendita dei token MIRAI, per un totale di 10 punti fiscali.</p>
<h2 id="h2-Ecosistema20e20Applicazioni20Innovative442367"><a name="Ecosistema e Applicazioni Innovative" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Ecosistema e Applicazioni Innovative</h2><p>Il design dell’ecosistema di MIRAI rompe i limiti dei ruoli virtuali tradizionali, principalmente riflettendosi nei seguenti aspetti:</p>
<ol>
<li>Architettura IP aperta: non limitata a un singolo ruolo, ma un ecosistema IP aperto costruito dalla comunità insieme.</li><li>Diverse applicazioni: che coprono applicazioni innovative come l’emissione di NFT, i premi di staking, la governance della comunità e la realtà virtuale.</li><li>Potenziale cross-domain: sfruttando l’esperienza di successo di imma nell’industria della moda, MIRAI ha un vantaggio naturale nell’entrare nei settori dell’intrattenimento, sociale e di altri campi.</li></ol>
<h3 id="h3-Principali20punti20tecnici20del20progetto806294"><a name="Principali punti tecnici del progetto" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Principali punti tecnici del progetto</h3><ul>
<li>Sistema di agente intelligente: dotare i personaggi virtuali di capacità decisionali autonome e di apprendimento continuo.</li><li>Governance decentralizzata: Realizzare un modello di sviluppo IP basato sull’economia dei token attraverso la governance della comunità.</li><li>Compatibilità multi-piattaforma: Considera l’accesso multi-piattaforma fin dalla fase di progettazione per garantire l’universalità dell’identificazione virtuale.</li></ul>
<h3 id="h3-Il20vantaggio20competitivo20di20MIRAI799659"><a name="Il vantaggio competitivo di MIRAI" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Il vantaggio competitivo di MIRAI</h3><p>Il vantaggio competitivo del progetto MIRAI si riflette in due dimensioni principali:</p>
<ul>
<li>Capacità di integrazione tecnica: Essendo il primo progetto a implementare una soluzione full-stack di ‘agente AI + identificazione on-chain + motore 3D’, la sua velocità di elaborazione può raggiungere migliaia di transazioni al secondo, con prestazioni paragonabili alla rete Visa.</li><li>Rete di partner: supportata dal programma AWS Startup e collaborando con Solaxy, un protocollo Layer 2 nel <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> ecosistema, per ottimizzare l’esperienza di trading cross-chain</li></ul>
<h2 id="h2-Prospettive20del20Progetto20MIRAI531144"><a name="Prospettive del Progetto MIRAI" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Prospettive del Progetto MIRAI</h2><p>MIRAI dimostra l’infinito potenziale della profonda integrazione di contenuti virtuali e tecnologia blockchain, e il suo futuro sviluppo merita continua attenzione. Con il perfezionamento sempre maggiore <a href="/web3" rel="nofollow noopener noreferrer" target="_blank">Web3</a> infrastrutture e la continuativa popolarizzazione del concetto di metaverso, ci si aspetta che questo nuovo sistema di identificazione digitale diventi un importante ponte che collega i mondi virtuale e reale.</p>
<p>Vale la pena notare che MIRAI rappresenta la pratica all’avanguardia dell’integrazione di <a href="/web3" target="_blank" class="blog_inner_link">Web3</a> e AI, e sta ridefinendo il percorso di creazione di valore dell’economia virtuale attraverso innovativi sistemi di identificazione digitale evolutiva e modelli di ecosistema guidati dalla comunità. Con l’elenco su scambi mainstream come Gate, il progetto MIRAI è entrato in una fase cruciale di sviluppo su larga scala.</p>
<p>Tuttavia, quando l’entusiasmo di mercato dopo la prevendita svanisce, dobbiamo rispondere a una domanda fondamentale: la blockchain ha davvero dato un nuovo valore agli idoli virtuali, o ha solo messo uno strato di “nuovi vestiti” decentralizzati? Forse solo il tempo può dare la risposta.</p>
<div class="blog-details-info"><br><div>Autore: <strong>Team del blog</strong><br><div class="info-tips"><em>Il contenuto qui presente non costituisce alcuna offerta, sollecitazione o raccomandazione. Dovresti sempre cercare un parere professionale indipendente prima di prendere decisioni di investimento.<br><div></div>Si prega di notare che Gate potrebbe limitare o vietare l'uso di tutti o parte dei Servizi dalle Località Restrizionate. Per ulteriori informazioni, si prega di leggere l'Accordo dell'Utente tramite <a href="https://www.gate.io/legal/user-agreement" data-index="5">https://www.gate.io/legal/user-agreement</a>.<br><p></p><br></em></div></div></div>