V2F0IGlzIE1JUkFJPyBFZW4gYmFhbmJyZWtlbmQgZXhwZXJpbWVudCBpbiBkZSBXZWIzIGRpZ2l0YWxlIGlkZW50aXRlaXRzcmV2b2x1dGll

2025-05-16, 09:17

<p><img src="https://gimg2.gateimg.com/image/article/1747386918mirai.png" alt="">
</p><p>Volgens de officiële introductie is MIRAI ontwikkeld door het bekende Japanse digitale inhoudsbedrijf aww.inc, wat de intrede van virtuele personages in <a href="/web3" rel="nofollow noopener noreferrer" target="_blank">Web3</a> Een belangrijke mijlpaal in de wereld. Voortbouwend op de succesvolle ervaring van het creëren van het virtuele model imma, combineert het project de blockchain-infrastructuur van Holoworld en geavanceerde AI-technologie om revolutionaire virtuele karakters te creëren met autonomie, intelligente agentie en gemeenschapsinteractiemogelijkheden. Deze innovatie combineert de professionele expertise van aww.inc op het gebied van computergraphics met het gedecentraliseerde concept van Web3, en opent zo een nieuwe weg voor digitale identificatie.</p>
<p>Op 16 mei 2025 lanceerde Gate officieel de MIRAI spot trading, wat de formele intrede van het project in de mainstream cryptomarkt markeerde. Dit artikel zal zijn kernwaarde en toekomstige potentieel uitgebreid analyseren vanuit de dimensies van technische architectuur, toepassingsscenario’s en ecologische ontwikkeling.</p>
<h2 id="h2-MIRAI20marktprestaties402401"><a name="MIRAI marktprestaties" class="reference-link"></a><span class="header-link octicon octicon-link"></span>MIRAI marktprestaties</h2><p>MIRAI-token voorverkoop is gestart bij <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> Gelanceerd op de blockchain in de vorm van een 48-uurs beperkt aanbod, waarbij een groot aantal communitydeelnemers werd aangetrokken. Op 12 mei 2025 kondigde het MIRAI-team de voltooiing van de pre-sale aan, waarbij in totaal 76.831 SOL werd opgehaald, wat destijds ongeveer overeenkwam met 12,95 miljoen Amerikaanse dollars.</p>
<p>Na de voorverkoop verklaarde het MIRAI-team dat sinds 2018 het team continu virtuele mensen heeft gecreëerd, topmerken heeft bediend en echte inkomsten heeft gegenereerd. In de toekomst zal het team blijven werken aan de langetermijnontwikkeling van het MIRAI-project. Om deze reden heeft het team besloten om 50% van de fondsen terug te betalen aan alle deelnemers, en de overige 50% zal worden gebruikt voor project lancering, het verschaffen van liquiditeit en het betalen van noteringskosten (indien van toepassing), enz.</p>
<p>Op 13 mei kondigde het MIRAI-team aan dat 50% van de 76.831 SOL was teruggegeven aan gebruikers die deelnamen aan de MIRAI-token voorverkoop. Na afronding van de terugbetaling bedroegen de resterende fondsen van het team 38.415,5 SOL.</p>
<p>Om 2 uur ‘s nachts op 16 mei werd de MIRAI-token officieel gelanceerd. Het MIRAI-team zal 15% van de resterende 38.415,5 SOL gebruiken om toe te voegen aan de liquiditeitspool, ongeveer 5.762 SOL.</p>
<p>De totale voorraad MIRAI-tokens is 1 miljard, met een openingsprijs van 0,0121 Amerikaanse dollars. Om 17.00 uur op 16 mei bedraagt de circulerende marktwaarde van MIRAI $13 miljoen, met een handelsvolume van $9,4 miljoen in 24 uur. Het aantal houdersadressen heeft 7.810 bereikt, en er zijn nog maar 5.142 SOL-tokens over in de liquiditeitspool.</p>
<p>Volgens communitybronnen koos het MIRAI-team ervoor om het DLMM-zwembad op Meteora te creëren bij het creëren van on-chain liquiditeitspools en nam een bied-laat-modus aan om liquiditeit te verdelen, waarbij liquiditeit werd geconcentreerd aan de twee uiteinden van het prijsbereik. Deze ontwerp kan ertoe leiden dat tokenprijzen sterk schommelen in het middelste bereik en aanzienlijke doorbraakweerstand ondervinden bij het bereiken van de bodem- of topprijzen.</p>
<p>Daarnaast heeft de MIRAI-liquiditeitspool een basis handelstaks van 5%, wat betekent dat gebruikers 5% van de kosten zullen dragen bij het kopen en verkopen van MIRAI-tokens, wat in totaal 10% belastingpunten bedraagt.</p>
<h2 id="h2-Ecosysteem20en20Innovatieve20Toepassingen833191"><a name="Ecosysteem en Innovatieve Toepassingen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Ecosysteem en Innovatieve Toepassingen</h2><p>Het ecosysteemontwerp van MIRAI doorbreekt de beperkingen van traditionele virtuele rollen, voornamelijk weerspiegeld in de volgende aspecten:</p>
<ol>
<li>Open IP-architectuur: niet beperkt tot een enkele rol, maar een open IP-ecosysteem dat samen door de gemeenschap is opgebouwd.</li><li>Diverse toepassingsscenario’s: met innovatieve toepassingen zoals NFT-uitgifte, staking beloningen, gemeenschapsbestuur, en virtual reality.</li><li>Cross-domain potential: Door gebruik te maken van imma’s succesvolle ervaring in de mode-industrie, heeft MIRAI een natuurlijk voordeel bij het betreden van de entertainment, sociale en andere vakgebieden.</li></ol>
<h3 id="h3-Kerntechnische20hoogtepunten20van20het20project48646"><a name="Kerntechnische hoogtepunten van het project" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Kerntechnische hoogtepunten van het project</h3><ul>
<li>Intelligent agent system: virtueel personages voorzien van autonome besluitvorming en voortdurende leermogelijkheden.</li><li>Decentrale governance: Realiseer een gemeenschapsgovernance-IP-ontwikkelingsmodel via het mechanisme van token-economie.</li><li>Cross-platform compatibiliteit: Overweeg toegang vanaf meerdere platforms vanaf het ontwerpstadium om de universaliteit van virtuele identificatie te garanderen.</li></ul>
<h3 id="h3-MIRAIs20concurrentievoordeel284076"><a name="MIRAI’s concurrentievoordeel" class="reference-link"></a><span class="header-link octicon octicon-link"></span>MIRAI’s concurrentievoordeel</h3><p>Het concurrentievoordeel van het MIRAI-project komt tot uiting in twee kernaspecten:</p>
<ul>
<li>Technische integratiemogelijkheden: Als het eerste project om een full-stack oplossing van ‘AI-agent + on-chain identificatie + 3D-engine’ te implementeren, kan de verwerkingssnelheid duizenden transacties per seconde bereiken, met prestaties vergelijkbaar met het Visa-netwerk.</li><li>Partner Network: Ondersteund door het AWS Startup Programma en in samenwerking met Solaxy, een Layer 2 protocol in de <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> ecosysteem, om de cross-chain handelservaring te optimaliseren</li></ul>
<h2 id="h2-MIRAI20Project20Outlook361177"><a name="MIRAI Project Outlook" class="reference-link"></a><span class="header-link octicon octicon-link"></span>MIRAI Project Outlook</h2><p>MIRAI toont het oneindige potentieel van diepe integratie van virtuele inhoud en blockchaintechnologie, en de toekomstige ontwikkeling verdient voortdurende aandacht. Met de toenemende perfectie <a href="/web3" rel="nofollow noopener noreferrer" target="_blank">Web3</a> infrastructuur en de voortdurende popularisering van het metaverse concept, wordt verwacht dat dit nieuwe vorm van digitaal identificatiesysteem een belangrijke brug zal vormen tussen de virtuele en echte werelden.</p>
<p>Het is vermeldenswaard dat MIRAI de voorhoede vertegenwoordigt van het integreren van <a href="/web3" target="_blank" class="blog_inner_link">Web3</a> en AI, en de waardecreatiepad van de virtuele economie herdefinieert door innovatieve evolutionaire digitale identificatiesystemen en door de gemeenschap gedreven ecosysteemmodellen. Met de notering op belangrijke beurzen zoals Gate, is het MIRAI-project een cruciale fase van grootschalige ontwikkeling ingegaan.</p>
<p>Echter, wanneer de markt enthousiasme na de voorverkoop vervaagt, moeten we een fundamentele vraag beantwoorden: Heeft blockchain echt nieuwe waarde gegeven aan virtuele idolen, of heeft het gewoon een laag gedecentraliseerde “nieuwe kleren” aangetrokken? Misschien kan alleen de tijd het antwoord geven.</p>
<div class="blog-details-info"><br><div>Auteur: <strong>Blog Team</strong><br><div class="info-tips"><em>De inhoud hiervan vormt geen aanbod, uitnodiging of aanbeveling. U moet altijd onafhankelijk professioneel advies inwinnen voordat u investeringsbeslissingen neemt.<br><div></div>Let op dat Gate mogelijk het gebruik van alle of een deel van de diensten van Beperkte Locaties kan beperken of verbieden. Voor meer informatie kunt u de gebruikersovereenkomst lezen via <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>