U1RFUE4gR08gc2kgcmludmlnb3Jpc2NlIGNvbiBsYSBjb2xsYWJvcmF6aW9uZSBBZGlkYXMgTkZU

2024-10-08, 09:18

<p><img src="https://gimg2.gateimg.com/image/article/17283786111690791857hotspot.jpeg" alt=""></p>
<h2 id="h2-TL20DR236726"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p><a href="/price/stepn-gmt" rel="nofollow noopener noreferrer" target="_blank">STEPN</a> ha collaborato con Adidas per lanciare la collezione di sneaker Genesis NFT.</p>
<p>STEPN in alleanza con Adidas ha lanciato 1.000 collezionabili NFT sul Marketplace di Mooar.</p>
<p>Le incertezze normative continuano a soffocare le innovazioni nel settore della blockchain.</p>
<h2 id="h2-Introduzione134545"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>Le partnership tra progetti criptati con lo stesso focus stanno contribuendo al progresso del settore. Queste alleanze portano a grandi pool di capitali e allargamento delle basi di competenza. Portano anche a grandi comunità che sono essenziali per il successo dei progetti criptati. Inoltre, le collaborazioni possono migliorare l’immagine dei progetti. La recente alleanza tra <a href="/price/stepn-gmt" target="_blank" class="blog_inner_link">STEPN</a> e Adidas è un esempio specifico di partnership tra un marchio leader (Adidas) e un promettente progetto basato su blockchain.</p>
<h2 id="h2-STEPN20GO20e20Adidas20Sboccare20nuove20strade251893"><a name="STEPN GO e Adidas: Sboccare nuove strade" class="reference-link"></a><span class="header-link octicon octicon-link"></span>STEPN GO e Adidas: Sboccare nuove strade</h2><p><a href="https://www.gate.io/learn/articles/what-is-stepn-all-you-need-to-know-about-gmt/1679" target="_blank">STEPN, un’app di stile di vita Web3</a>, con elementi di SocialFi e Game-Fi, ha rinnovato la sua collaborazione con Adidas per lanciare una edizione limitata di 1.000 Genesis Sneaker NFT. Queste sneaker co-branded saranno disponibili esclusivamente sulla piattaforma STEPN GO. La collaborazione prevederà quattro design di sneaker unici, tra cui edizioni speciali degli ALTS, ispirate alle scarpe da corsa di Adidas. Inoltre, la collezione esclusiva Genesis Sneaker NFT comprenderà design unici che fondono moda, tecnologia blockchain e le leggendarie scarpe da corsa di Adidas. È probabile che gli appassionati di fitness e i collezionisti richiederanno molto queste sneaker per la loro esclusività.</p>
<p>Inoltre, la collezione Genesis NFT Sneaker rappresenta l’utilità dell’innovativa piattaforma M2E di STEPN e l’unicità dell’eredità atletica di Adidas. Questa collaborazione mostra la sinergia tra le visioni di STEPN e Adidas che comprendono la forma fisica, l’utilità della tecnologia blockchain e l’essenza dei collezionabili digitali. Fondamentalmente, <a href="https://www.gate.io/blog/1197/is-stepn-a-ponzi-scheme" target="_blank">STEPN utilizza la sua tecnologia blockchain per il fitness</a> per premiare i propri utenti per la loro forma fisica. Pertanto, l’introduzione della collezione Adidas NFT probabilmente aumenterà l’interazione <a href="https://www.gate.io/learn/articles/network-effects-in-web3-games/910" target="_blank">nell’app Web3 Lifestyle</a>.</p>
<p>Coinvolgimento di Adidas nel <a href="/web3" rel="nofollow noopener noreferrer" target="_blank">web3</a> lo spazio mostra il suo impegno nel sfruttare nuove tecnologie. Pertanto, la partnership STEPN GO Adidas e il lancio della collezione NFT mostrano che l’azienda vuole promuovere il fitness adattandosi ai cambiamenti delle tendenze della moda attraverso l’adozione della tecnologia blockchain.<br><img src="https://gimg2.gateimg.com/image/article/17283787791.jpg" alt=""><br>STEPN Partnership Adidas: x.com/STEPN</p>
<p>Commentando sulla partnership <a href="https://stepnofficial.medium.com/stepn-is-partnering-with-adidas-to-revolutionise-the-web3-industry-f6ba7051efb1" rel="nofollow noopener noreferrer" target="_blank">STEPN ha detto</a>, “Questa partnership è stata accolta calorosamente dalla nostra comunità, dimostrando il nostro potenziale illimitato nel spingere il <a href="/web3" target="_blank" class="blog_inner_link">web3</a> verso l’adozione globale. All’insegna di “STEPN x adidas: Step into the Future”, il nostro obiettivo è quello di rivoluzionare l’ecosistema web3 dotando gli NFT di qualcosa di più di un semplice valore collezionistico, ma anche di una reale utilità”.</p>
<p>Aggiunge, “Utilizzando le tue STEPN x adidas co-branded Genesis Sneaker, non ti stai solo unendo alla comunità più grande del web3; stai anche abbracciando uno stile di vita più sano in cui <a href="https://www.gate.io/blog/1623/how-to-improve-your-health-and-finances-with-stepn" target="_blank">ogni passo ti ricompensa nell’ecosistema STEPN</a>.”</p>
<h2 id="h2-Raffle20Mint20Svelare20la20Collezione20Genesis20Sneaker20NFT105686"><a name="Raffle Mint: Svelare la Collezione Genesis Sneaker NFT" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Raffle Mint: Svelare la Collezione Genesis Sneaker NFT</h2><p>L’alleanza tra STEPN GO e Adidas presenterà una serie di 1.000 Genesis Sneakers, sotto forma di NFT. Questa collezione è stata presentata tramite una lotteria che ha avuto luogo il 25 settembre sul marketplace MOOAR e durerà fino al 30. Pertanto, queste 1.000 sneakers erano disponibili da quella data. Per partecipare, ogni interessato doveva pagare una tariffa che sarebbe stata rimborsata ai partecipanti che non fossero riusciti ad ottenere le sneakers. In effetti, le Genesis sneakers esistono in diversi design che includono Ultraboost 5X, Supernova Rise, adiZero Adios Pro 3 e adiStar BYD.</p>
<p>L’annuncio della partnership STEPN GO Adidas è avvenuto pochi giorni dopo che FSL, creatore di STEPN GO, ha stretto una collaborazione con Mythos Foundation, un’azienda focalizzata sui giochi blockchain e gli esports. Questa alleanza permetterà a Mythos Chain di integrarsi con l’ecosistema di FSL, portando a esperienze condivise tra le loro comunità. Inoltre, saranno in grado di sviluppare asset virtuali co-branded che potrebbero diventare oggetti da collezione digitali nel settore del fitness.</p>
<h2 id="h2-Go20Gaming20Tokens20come20gli20utenti20li20guadagnano20e20li20utilizzano65569"><a name="Go Gaming Tokens: come gli utenti li guadagnano e li utilizzano" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Go Gaming Tokens: come gli utenti li guadagnano e li utilizzano</h2><p>I token del gioco Go (GGT) sono la criptovaluta nativa di STEPN che gli utenti guadagnano come ricompense per il fitness criptato per partecipare a attività fisiche che includono camminare, correre e fare jogging. Gli utenti che guadagnano questi oggetti da collezione digitali per il fitness potranno usarli per acquistare vari asset in-app come le scarpe da ginnastica. Possono anche utilizzare i token Go Gaming per coniare asset digitali sotto forma di NFT come le scatole delle scarpe.</p>
<p>Un’altra evoluzione è stata l’introduzione del sistema Haus che consente agli utenti di STEPN di prestare le proprie scarpe da ginnastica ad altre persone e condividere la loro energia. In modo ancora più significativo, gli utenti possono anche condividere i loro guadagni con gli amici che rimangono fisicamente attivi. STEPN Go ha altre funzionalità come la funzione Livello di Fitness che consente agli utenti di guadagnare ricompense aggiuntive in criptovaluta per il fitness. Inoltre, altre funzionalità permettono agli utenti di connettersi tra loro.</p>
<h2 id="h2-Accuse20di20Ponzinomics20Limpatto20sulla20base20di20utenti20di20STEPN20GO861964"><a name="Accuse di Ponzinomics: L’impatto sulla base di utenti di STEPN GO" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Accuse di Ponzinomics: L’impatto sulla base di utenti di STEPN GO</h2><p>Il lancio della serie Genesis Sneakers offre <a href="https://www.gate.io/price-prediction/stepn-gmt" target="_blank">STEPN</a> la possibilità di riposizionarsi come un progetto crypto affidabile. Questo perché la sua immagine è stata precedentemente compromessa dalle accuse che utilizza la ponzinomica. In sostanza, STEPN è stato vietato in Cina a causa dell’accusa che i suoi principi economici siano simili a quelli <a href="https://www.gate.io/blog/1197/is-stepn-a-ponzi-scheme" target="_blank">che molti schemi Ponzi utilizzano</a>. Tale regolamentazione degli NFT in Cina ha portato alla diminuzione del numero di utenti STEPN. Pertanto, il successo della sua partnership con Adidas e l’adozione di un nuovo modello economico potrebbero riconfigurarlo come un autentico progetto di gioco.</p>
<h2 id="h2-Sfide20di20STEPN20Come20rispecchiano20i20problemi20che20il20settore20NFT20sta20affrontando450859"><a name="Sfide di STEPN: Come rispecchiano i problemi che il settore NFT sta affrontando?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Sfide di STEPN: Come rispecchiano i problemi che il settore NFT sta affrontando?</h2><p>Le sfide affrontate da STEPN fin dalla sua fondazione riflettono i problemi che molti progetti di giochi NFT incontrano. Ad esempio, STEPN è stato vietato in Cina a causa del sospetto che la sua tokenomia violasse la normativa del paese. Allo stesso modo, la SEC Wells Notice contro OpenSea ha creato molte incertezze regolamentari per i progetti di giochi NFT. A causa di tali sfide regolamentari e paure, molti progetti di giochi apportano modifiche alle loro visioni originali. Ad esempio, a seguito della SEC Wells Notice contro OpenSea, Magic Eden ha apportato cambiamenti strutturali che avranno un impatto sui giocatori.</p>
<h2 id="h2-Conclusion111145"><a name="Conclusion" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusion</h2><p>La partnership STEPN GO Adidas probabilmente porterà ad un aumento della domanda per la collezione di NFT Genesis sneaker e per i relativi asset digitali. Il 25 settembre, STEPN in collaborazione con Adidas ha lanciato la collezione NFT sul mercato di Mooar. Tale sviluppo ha permesso a STEPN di riposizionarsi come un vero e proprio protocollo di gioco, a seguito delle accuse di ponzinomia e del divieto in Cina. Nel complesso, le collaborazioni di STEPN con Adidas e Mythos Foundation probabilmente porteranno ad un aumento della domanda per i suoi asset e servizi digitali.</p>
<div class="blog-details-info"><br><div>Autore: Mashell C., 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.<br></em><div><em></em>Gate.io si riserva tutti i diritti su questo articolo. Sarà consentito ripubblicare l'articolo a condizione che si faccia riferimento a Gate.io. In tutti i casi, saranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div>