QW5hbGlzaSBkZWwgdHJlbmQgZGVpIHByZXp6aSBkaSBBWFM6IFF1YWwgw6ggbGEgcHJvc3BldHRpdmEgcGVyIEF4aWUgSW5maW5pdHk/

2025-05-13, 13:05

<p><img src="https://gimg2.gateimg.com/image/article/1747141443axs.png" alt="">
</p><p><a href="/price/axie-infinity-axs" rel="nofollow noopener noreferrer" target="_blank">Axie Infinity</a> Si basa su una catena di Ronin <a href="/web3" rel="nofollow noopener noreferrer" target="_blank">Web3</a> Progetto di gioco lanciato dal team vietnamita Sky Mavis. I giocatori partecipano al gioco raccogliendo, allevando e combattendo animali digitali NFT chiamati ‘Axies’ e possono guadagnare token AXS e SLP completando compiti, combattendo, ecc. Il gioco ha scatenato una frenesia di ‘Gioca per Guadagnare’ nel 2021, attirando milioni di utenti in tutto il mondo e diventando un progetto rappresentativo di GameFi. Axie non solo promuove lo sviluppo di NFT e giochi blockchain, ma esplora anche nuovi modelli di economia di gioco decentralizzata e governance della comunità. AXS è utilizzato per la governance e vari premi per eventi nell’ecosistema di gioco, collegando i giocatori con il team del progetto ed è ancora considerato un asset blue-chip nell’ecosistema di GameFi.</p>
<h2 id="h2-Movimento20del20prezzo20di20AXS731856"><a name="Movimento del prezzo di AXS" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Movimento del prezzo di AXS</h2><p>AXS ha raggiunto il suo picco nell’ottobre 2021, con un prezzo unitario che ha raggiunto circa $150. Successivamente, con il declino generale del <a href="/price" rel="nofollow noopener noreferrer" target="_blank">mercato crittografico</a> e l’esposizione delle proprie questioni economiche di Axie, <a href="/price/axie-infinity-axs" rel="nofollow noopener noreferrer" target="_blank">prezzo AXS</a> Ritiro deciso. Nel 2025, AXS continua a essere sotto pressione. Al 13 maggio 2025, il prezzo di AXS è sceso al punto più basso dal 2021, con AXS attualmente scambiato a $3.25, con una capitalizzazione di mercato di $527 milioni.</p>
<p>Nonostante il continuo rilascio ufficiale degli aggiornamenti del gioco (come il lancio della 12a stagione di Origins a metà aprile e il lancio della 9a stagione di Classic Showdown a maggio), AXS <a href="/price-prediction" rel="nofollow noopener noreferrer" target="_blank">movimento del prezzo</a> Ancora in una fase di stallo. Vale la pena notare che il nuovo aggiornamento del gioco Atia’s Legacy lanciato dal team Axie non ha aumentato significativamente il prezzo di AXS. Al momento, il prezzo di AXS oscilla tra i 2 e i 3 dollari, leggermente sotto pressione rispetto all’inizio dell’anno, ma alcuni analisti credono che possa esserci un rimbalzo nella seconda metà dell’anno.</p>
<h2 id="h2-Aggiornamenti20ufficiali20e20aggiustamenti20delleconomia20dei20token3356"><a name="Aggiornamenti ufficiali e aggiustamenti dell’economia dei token" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Aggiornamenti ufficiali e aggiustamenti dell’economia dei token</h2><p>Recenti aggiornamenti ufficiali provenienti dagli ecosistemi di Axie e Ronin meritano attenzione. Nel aprile 2025, la catena di Ronin ha completato la migrazione dei ponti con Chainlink CCIP, trasferendo in modo sicuro oltre $4.5 miliardi di asset a CCIP, portando una maggiore sicurezza cross-chain alla rete di Ronin.</p>
<p>In termini di gioco, Sky Mavis continua a lanciare eventi e caratteristiche nel 2024-2025: come il nono episodio del Classic Showdown annunciato a maggio 2025 (con un totale di 35.000 premi AXS), e la stagione Origins lanciata ad aprile 2025. Queste attività mirano ad aumentare l’interazione dei giocatori, ma il miglioramento a breve termine dei prezzi di AXS è limitato.</p>
<p>Inoltre, il team di Axie ha modificato il modello economico. All’inizio del 2024 ha annunciato un tetto massimo di 4,4 miliardi di SLP (token di utilità) e un meccanismo di ‘Fondo di stabilità’, restituendo 2 token al fondo per ogni 10 SLP bruciati per controllare l’inflazione. Queste misure contribuiscono alla sostenibilità economica complessiva. Allo stesso tempo, l’offerta totale di AXS è di 270 milioni, prevista per essere interamente circolata entro il 2026, il che significa che il rilascio dei token sarà completato gradualmente, mettendo pressione sui prezzi futuri.</p>
<h2 id="h2-Supporto20allindice20dellecologia20dei20giochi20Web333797"><a name="Supporto all’indice dell’ecologia dei giochi Web3" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Supporto all’indice dell’ecologia dei giochi Web3</h2><p>L’attività dei giocatori e del trading all’interno dell’ecosistema Axie sono fattori importanti che supportano il valore di mercato di AXS. I dati mostrano che Axie ha raggiunto un picco di quasi 2,8 milioni di utenti attivi al giorno nel 2021-2022. Anche se il numero di giocatori è diminuito significativamente, l’ecosistema rimane ampio. I rapporti di ricerca indicano che il volume cumulativo delle transazioni del mercato NFT sulla catena Ronin ha superato i $4,5 miliardi, con la serie Axie che rappresenta circa $4,3 miliardi nel volume totale delle transazioni, dimostrando che Axie rimane l’attività di gioco più popolare su Ronin.</p>
<p>Su scala globale, l’attività complessiva di <a href="/web3" rel="nofollow noopener noreferrer" target="_blank">Web3</a> I giochi stanno crescendo rapidamente: i portafogli attivi giornalieri hanno raggiunto i 7,4 milioni nel 2024, con un aumento del 421% rispetto all’anno precedente. Questi dati sull’ecosistema indicano che nonostante il basso prezzo di AXS, Axie e l’intero settore del gioco <a href="/web3" target="_blank" class="blog_inner_link">Web3</a> hanno ancora una base utenti significativa e un volume di transazioni, fornendo un supporto a lungo termine per il valore di mercato di AXS.</p>
<h2 id="h2-Prospettive20del20settore20e20previsioni20del20prezzo20di20AXS160367"><a name="Prospettive del settore e previsioni del prezzo di AXS" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Prospettive del settore e previsioni del prezzo di AXS</h2><p>C’è una differenza di opinioni sul mercato riguardo al movimento dei prezzi di AXS nel 2025. Alcune società di analisi e strumenti di previsione mantengono un’atteggiamento cauto ottimista nei suoi confronti. Ad esempio, un’analisi tecnica di una piattaforma mainstream suggerisce che il range di prezzo di AXS nel 2025 si aggira intorno a $3.87–$4.60; un altro sito di ricerca prevede un intervallo di negoziazione annuale di $3.04–$5.39, con un prezzo medio annuo di circa $4.18.</p>
<p>La previsione relativamente ottimista dell’industria dà un intervallo di $5-8, e prevede addirittura che possa raggiungere $9-14 in uno scenario di mercato rialzista. D’altro canto, alcuni analisti adottano una visione pessimistica: secondo la teoria dell’onda tecnica, AXS potrebbe oscillare tra $0.50-6.50 entro la fine del 2025, scendendo a circa $0.50 al minimo.</p>
<p>Complessivamente, la maggior parte delle istituzioni si aspetta che il prezzo medio di AXS nel 2025 sia inferiore a $10, mentre il movimento del prezzo di AXS dipende dall’ambiente di mercato complessivo della crittovaluta e del gioco Web3.</p>
<h2 id="h2-Prospettive20future20di20Axie20Infinity328282"><a name="Prospettive future di Axie Infinity" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Prospettive future di Axie Infinity</h2><p>AXS gioca un ruolo fondamentale nell’economia del gioco Web3, collegando non solo i giocatori e la governance del progetto, ma servendo anche come nucleo del meccanismo di incentivi dell’ecosistema di Axie. La crescita di <a href="/price/axie-infinity-axs" rel="nofollow noopener noreferrer" target="_blank">Axie Infinity</a> dimostra il potenziale dei token GameFi nel guidare la partecipazione dei giocatori e il trading di NFT, ma espone anche il rischio di un modello economico instabile.</p>
<p>Un rapporto di ricerca sottolinea che il team di Axie si impegna a migliorare e espandere continuamente il proprio ecosistema IP, ma la stabilità a lungo termine dell’economia del token affronta ancora sfide. A tal fine, il team del progetto sta lavorando per ottimizzare il sistema economico introducendo meccanismi come il limite di SLP e il fondo di stabilità. In futuro, il valore sostenuto di AXS dipenderà dagli effetti combinati dell’innovazione del gioco di Axie, dalla crescita dei giocatori e dagli aggiustamenti della politica dei token.</p>
<p>Da un punto di vista più ampio, se l’industria del gioco Web3 continua a svilupparsi, AXS, come rappresentante dei primi progetti GameFi leader, conserva ancora una significato a lungo termine; tuttavia, garantire la sostenibilità del modello GameFi richiede ulteriore maturità e stabilità negli incentivi economici e nelle comunità dei giocatori.</p>
<p>Avvertenza sul rischio: la volatilità di mercato, i cambiamenti nella politica normativa o i rischi tecnici possono influenzare il movimento dei prezzi e le prospettive di applicazione di AXS.</p>
<div class="blog-details-info"><br><div>Autore: <strong>Ghiaccia</strong>, Ricercatore di Gate.io<br><div class="info-tips"><em>Questo articolo rappresenta solo le opinioni del ricercatore e non costituisce alcun suggerimento di investimento. Gli investimenti comportano rischi e gli utenti devono prendere decisioni oculate.<br><div></div>Gate.io si riserva tutti i diritti su questo articolo. Il ri-pubblicare dell'articolo sarà consentito a condizione che venga citato Gate.io. In tutti i casi, saranno intraprese azioni legali a causa di violazione del copyright.<br><p></p><br></em></div></div></div>