R01UIENvaW46IFByb2dldHRvIEVhcm4tVG8tTW92aW5nIGRpIFNURVBOIGUgQW5hbGlzaSBkZWkgUHJlenpp

2025-04-17, 01:51

<p><img src="https://gimg2.gateimg.com/image/article/1744854802kp.png" alt=""></p>
<h2 id="h2-Introduzione198075"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>GMT è il token di governance della piattaforma STEP, che è un gioco ‘play-to-earn’ basato sul <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> blockchain, incoraggiando gli utenti a guadagnare token e ricompense NFT attraverso attività all’aperto. Come progetto leader nel settore GameFi dal 2021 al 2023, la moneta GMT di STEP ha raggiunto una capitalizzazione di mercato di $12 miliardi, dimostrando la sua influenza sul mercato. Questo articolo approfondirà la storia dello sviluppo della moneta GMT, le dinamiche recenti di STEP GO, le fluttuazioni dei prezzi (in particolare l’impatto del piano BurnGMT nel novembre 2024) e il futuro. <a href="/price-prediction" rel="nofollow noopener noreferrer" target="_blank">Previsione del prezzo</a>.</p>
<p>Negozia ora GMT:<br><a href="https://www.gate.io/trade/GMT_USDT" target="_blank">https://www.gate.io/trade/GMT_USDT</a><a href="https://www.gate.io/trade/GMT_USDT" target="_blank">https://www.gate.io/trade/GMT_USDT</a></p>
<h2 id="h2-STEPN20Guidare20la20rivoluzione20del20gigante20GameFi20di20guadagnare20mentre20si20gioca244803"><a name="STEPN: Guidare la rivoluzione del gigante GameFi di guadagnare mentre si gioca" class="reference-link"></a><span class="header-link octicon octicon-link"></span>STEPN: Guidare la rivoluzione del gigante GameFi di guadagnare mentre si gioca</h2><p>Come principale progetto GameFi nel ciclo precedente dal 2021 al 2023, <a href="/price/stepn-gmt" rel="nofollow noopener noreferrer" target="_blank">STEPN</a> (GMT) ha scatenato una rivoluzione nell’intersezione tra criptovalute e uno stile di vita sano con il suo innovativo modello ‘guadagna mentre ti muovi’.</p>
<p><img src="https://gimg2.gateimg.com/image/article/17448543191.png" alt=""></p>
<p><a href="/price/stepn-gmt" target="_blank" class="blog_inner_link">STEPN</a> è stata fondata da Find Satoshi Lab (FSL) in Australia nell’agosto 2021 ed è rapidamente diventata leader nel campo del GameFi. La sua innovazione risiede nel combinare la tecnologia blockchain con uno stile di vita sano. Gli utenti equipaggiano le sneakers NFT per partecipare alle attività all’aperto, guadagnando GST (Green Satoshi Token) e GMT. GMT funge non solo da token di governance, ma anche per funzioni di sblocco e ricompensa all’interno dell’ecosistema.</p>
<p>Nel novembre 2021, GMT ha raggiunto un massimo storico di $4.90, con un’offerta circolante di circa 250 milioni e una capitalizzazione di mercato di circa $12.25 miliardi, dimostrando un alto grado di riconoscimento di mercato per STEP. Tuttavia, dopo il 2022, <a href="/price" rel="nofollow noopener noreferrer" target="_blank">mercato crittografico</a> è entrato in un mercato ribassista. <a href="/price/stepn-gmt" rel="nofollow noopener noreferrer" target="_blank">prezzo GMT</a> Un forte calo, con un prezzo di $0.04625 il 15 aprile 2025 e un valore di mercato di $130 milioni, in ribasso del 99% rispetto al suo massimo storico.</p>
<h2 id="h2-Meccanismo20operativo20di20STEPN20sistema20a20doppio20token379169"><a name="Meccanismo operativo di STEPN: sistema a doppio token" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Meccanismo operativo di STEPN: sistema a doppio token</h2><p>Il nucleo di <a href="/price/stepn-gmt" target="_blank" class="blog_inner_link">STEPN</a> risiede nel suo sistema a doppio token: GST è utilizzato per premiare le attività sportive degli utenti; GMT è utilizzato per la governance e l’espansione dell’ecosistema. Gli utenti devono acquistare o noleggiare scarpe sportive NFT, ogni paio di scarpe ha rarità e attributi diversi, che influenzano i guadagni. Gli utenti guadagnano GST e scatole misteriose (contenenti NFT e token) indossando scarpe sportive per attività all’aperto e consumando l’energia delle scarpe.</p>
<p>Oltre a guadagnare attraverso lo sport, STEP offre anche un sistema di leasing di sneaker, permettendo agli utenti senza NFT di noleggiare scarpe per iniziare a guadagnare, riducendo la barriera all’ingresso. Secondo il white paper di STEP, il sistema di leasing è implementato tramite FSL ID e gli utenti possono iniziare con soltanto una email e un codice di attivazione, mirando a promuovere l’adozione di <a href="/web3" rel="nofollow noopener noreferrer" target="_blank">Web3</a>.</p>
<p>La governance della comunità di STEPN è la sua caratteristica importante, gli utenti che detengono e puntano GMT possono partecipare al voto, influenzando la direzione futura dello sviluppo della piattaforma. Ad esempio, GMT può essere utilizzato per votare sull’uso del fondo ecologico o sull’introduzione di nuove funzionalità, migliorando il coinvolgimento della comunità.</p>
<h2 id="h2-STEPN20GO20Una20nuova20applicazione20di20stile20di20vita20che20combina20social20e20gaming827017"><a name="STEPN GO: Una nuova applicazione di stile di vita che combina social e gaming" class="reference-link"></a><span class="header-link octicon octicon-link"></span>STEPN GO: Una nuova applicazione di stile di vita che combina social e gaming</h2><p>A maggio 2024, STEPN ha annunciato il lancio di una nuova applicazione per il fitness sociale, STEPN GO, sulla piattaforma ufficiale X, che include più interazioni sociali come l’ingresso facilitato attraverso il sistema Haus, la capacità di prestare Sneakers agli altri, la presentazione di più design sulla mappa interattiva all’interno dell’applicazione e l’introduzione di un nuovo token GGT (GO GAME TOKEN). GGT, come token di gioco, ha un’offerta illimitata, mentre GMT rimane il token di governance. In STEPN GO, GMT è ancora utilizzato per l’aggiornamento delle sneaker, ecc.</p>
<p><img src="https://gimg2.gateimg.com/image/article/17448543433.png" alt=""></p>
<p><a href="/price/stepn-gmt" rel="nofollow noopener noreferrer" target="_blank">STEPN</a> La versione 2.0 di GO ha portato molte innovazioni all’intero ecosistema delle sneaker, in particolare nell’introduzione dei token GGT, nel lancio del sistema di noleggio delle scarpe e nel più strategico design della soglia di ingresso. Per i primi giocatori, questa è senza dubbio una nuova opportunità.</p>
<p>Inoltre, STEPN GO ha introdotto anche GGT (GO GAME TOKEN) come nuovo token di utilità, arricchendo ulteriormente l’ecosistema. Secondo il sito web ufficiale di STEPN GO, GGT è utilizzato per incentivare gli utenti a partecipare alle attività sociali e di gioco, migliorando la fedeltà degli utenti.</p>
<h2 id="h2-Piano20BurnGMT20Aumento20temporaneo20del20prezzo20della20moneta20GMT731425"><a name="Piano BurnGMT: Aumento temporaneo del prezzo della moneta GMT" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Piano BurnGMT: Aumento temporaneo del prezzo della moneta GMT</h2><p>A novembre 2024, STEP ha annunciato il piano BurnGMT, con il team che ricomprerà circa 6 miliardi di monete GMT e donerà questi token al fondo dell’ecosistema gestito da GMT DAO. Secondo l’introduzione ufficiale, questi token provengono principalmente da investitori precoci, consulenti e assegnazioni del team di token sbloccati.</p>
<p>Successivamente, il team ha sviluppato la piattaforma BurnGMT.com, che consente agli utenti di bloccare le monete GMT per votare se distruggere o meno questi token ricomprati. L’attività di voto durerà dal 21 novembre 2024 al 20 gennaio 2025, per un totale di 60 giorni. Gli utenti che partecipano al voto riceveranno anche una ricompensa di 1 milione di GMT come incentivo.</p>
<p>Lo scopo del piano BurnGMT è quello di potenziare le proprietà deflazionistiche di GMT riducendo l’offerta circolante. Dopo l’annuncio del piano, <a href="/price/stepn-gmt" rel="nofollow noopener noreferrer" target="_blank">prezzo GMT</a> Inizia a salire, raggiungendo $0.40 entro la fine del 2024, mostrando le aspettative ottimistiche del mercato per il piano BurnGMT.</p>
<p>Tuttavia, dal momento dell’ingresso nel 2025, il <a href="/price/stepn-gmt" rel="nofollow noopener noreferrer" target="_blank">prezzo GMT</a> è continuamente diminuita, scendendo attualmente a un minimo di $0.046, con una capitalizzazione di mercato di $130 milioni, in calo del 82.33% nell’ultimo anno. Questo potrebbe essere correlato alla volatilità dell’intero mercato delle criptovalute, o potrebbe riflettere le aspettative pessimistiche degli investitori per lo sviluppo lento di STEP N GO.</p>
<h2 id="h2-Conclusione385376"><a name="Conclusione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusione</h2><p>Come token di governance di STEPN, GMT ha assistito alla trasformazione di STEPN dal leader in GameFi all’applicazione per lo stile di vita <a href="/web3" target="_blank" class="blog_inner_link">Web3</a> costantemente innovativa. L’attuazione del piano BurnGMT e il lancio di STEPN GO hanno portato nuove opportunità di crescita per GMT. Nonostante il prezzo attuale sia inferiore ai massimi storici, il mercato continua a mantenere una visione ottimistica sul potenziale a lungo termine di STEPN e GMT. Gli investitori dovrebbero seguire da vicino gli ultimi sviluppi di STEPN e le tendenze di mercato, valutando attentamente i rischi di mercato.</p>
<p>Avviso di rischio: Il <a href="/price" rel="nofollow noopener noreferrer" target="_blank">mercato delle criptovalute</a> è altamente volatile, e il prezzo di GMT potrebbe essere influenzato da fattori come le politiche regolamentari e la crescita dei concorrenti, portando a differenze tra le prestazioni effettive e le aspettative.</p>
<div class="blog-details-info"><br>  <div>Autore: Charle A., Ricercatore Gate.io<div class="info-tips"><em>Questo articolo rappresenta solo le opinioni dell'autore e non costituisce alcun consiglio di trading. Investire comporta rischi, quindi le decisioni dovrebbero essere prese con cautela.<br></em><div><em></em>Questo contenuto è originale e il copyright appartiene a Gate.io. Se è necessario riutilizzarlo, si prega di indicare l'autore e la fonte, altrimenti si perseguirà la responsabilità legale.<br></div><p></p><br></div></div></div>