R2F0ZS5pbyBBTUEgY29uIFByaW1hbC1Nb3ZlMkVhcm4gKyBGYW4gVG9rZW5zICsgSW5uZXIgQ2lyY2xlcw==

<p><img src="https://gimg2.gateimg.com/image/article/1674898428FmmCI_gX0AAbiIP.jpeg" alt=""><br><strong>Ora: 17 gennaio 2023, 13:00 AM (UTC)</strong><br><strong>Gate.io ha ospitato una sessione AMA (Ask-Me-Anything) con il Co-Fondatore di Primal, Ben nello spazio Twitter.</strong><br><strong>Sito Web Ufficiale: <a href="http://www.getprimal.com/" rel="nofollow noopener noreferrer" target="_blank">http://www.getprimal.com/</a></strong><br><strong>Twitter: <a href="https://twitter.com/enterprimal" rel="nofollow noopener noreferrer" target="_blank">https://twitter.com/enterprimal</a></strong><br><strong>Segui Primal su Telegram e Twitter</strong></p>
<p><strong>Ospite</strong><img src="https://gimg2.gateimg.com/image/article/167489852611.png" alt=""><br><strong>Ben — Co-fondatore di Primal</strong></p>
<h2 id="h2-Domande20e20risposte20da20Gateio920523"><a name="Domande e risposte da Gate.io" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Domande e risposte da Gate.io</h2><h3 id="h3-Q120Puoi20fornire20una20panoramica20di20PRIMAL469306"><a name="Q1: Puoi fornire una panoramica di PRIMAL?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q1: Puoi fornire una panoramica di PRIMAL?</h3><p><strong>Ben</strong>: PRIMAL è il 1° progetto di fan token per atleti con Move2Earn integrato che premia gli utenti per l’allenamento, mette in contatto i fan con atleti famosi e supporta gli atleti di tutti<br>livelli nel loro viaggio.<br>PRIMAL combina 2 concetti di grande successo: sport in stile app STEP + fan token in stile Chiliz.<br>Progettato per l’adozione di massa:<br>Mettere in contatto i fan con gli atleti famosi<br>Allenati e guadagna tutti i tipi di attività di fitness<br>Scambia i tuoi fan token preferiti dei tuoi atleti.<br>PRIMAL ha 3 pilastri principali, tutti alimentati da $PRIMAL.<br>Cerchio interno<br>L’Inner Circle di PRIMAL connette fan e atleti come mai prima d’ora attraverso la sua app che definisce il settore. Pensa che Patreon incontra la masterclass alimentata dalla blockchain.<br>Gettoni dei fan<br>I progetti in corso collegano i fan alle istituzioni. PRIMAL cerca di decentralizzare le grandi aziende e di mettere in contatto i fan direttamente con i loro atleti preferiti.<br>Mossa 2 Guadagna<br><img src="https://gimg2.gateimg.com/image/article/167489871512.png" alt=""><br>Allenati nel modo in cui vuoi, quando vuoi. A differenza di altri progetti M2E che si concentrano solo sulla corsa e ti penalizzano, PRIMAL sta lanciando un’app che premia tutti i tipi di attività fisica collegandosi ai dati biometrici.</p>
<h3 id="h3-Q220Puoi20discutere20dellutilit20del20token20PRIMAL248550"><a name="Q2: Puoi discutere dell’utilità del token $PRIMAL?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q2: Puoi discutere dell’utilità del token $PRIMAL?</h3><p><strong>Ben</strong>: $PRIMAL è il nostro principale token di governance e utilità. $PRIMAL alimenta l’intero nostro ecosistema.<br>Fan Tokens - Gli utenti utilizzeranno $PRIMAL per acquistare fan token da ogni atleta nell’ecosistema PRIMAL, aggiungendo una significativa pressione all’acquisto del token.<br>Cerchie Interne - Gli utenti pagheranno $PRIMAL agli atleti per accedere alle loro cerchie interne, campi di addestramento, contenuti esclusivi e forum.<br>App - Marketplace di NFT, acquisto di beni digitali e fisici da marchi e atleti.<br>Anche lo staking di $PRIMAL fornisce molti vantaggi, come sconti sulle commissioni di trading di NFT, NFT in edizione limitata e altro ancora.<br>PRIMAL ha anche meccanismi di burn che puoi visualizzare sul nostro sito web- <a href="https://www.getprimal.com/economy" rel="nofollow noopener noreferrer" target="_blank">https://www.getprimal.com/economy</a>.</p>
<h3 id="h3-Q320Cosa20ti20rende20diverso20dalla20concorrenza526027"><a name="Q3: Cosa ti rende diverso dalla concorrenza?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q3: Cosa ti rende diverso dalla concorrenza?</h3><p><strong>Ben</strong>: Gli altri progetti di Move2Earn ti permettono solo di camminare o correre e ti penalizzano effettivamente. L’app PRIMAL si sincronizza con i tuoi tracker fitness - questo significa più di 150.000.000 di potenziali utenti combinati.<br>La collaborazione con i dispositivi biometrici consente a PRIMAL di sfruttare dati chiave sulla salute, misurando l’attività del mondo reale e trasformando le calorie bruciate in denaro guadagnato. Ciò significa che la funzionalità è agnostica rispetto all’esercizio fisico, consentendo di contare tutte le attività e aprendo ampie possibilità di adesione degli utenti.<br>Questo include l’integrazione di Apple Health, Whoop, Oura Ring e Fitbit, offrendo utilità agli utenti esistenti che possiedono questi dispositivi fitness.<br>Ciò ti consente di allenarti COME vuoi, quando vuoi. Le persone hanno diversi livelli di forma fisica e ne siamo consapevoli.<br>Inoltre, non c’è altro progetto che collega sia i fan che gli atleti, consentendo loro di imparare, allenarsi e guadagnare mentre lo fanno.</p>
<h3 id="h3-Q420Cosa20hai20finora20raggiunto961414"><a name="Q4: Cosa hai finora raggiunto?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q4: Cosa hai finora raggiunto?</h3><p><strong>Ben</strong>: PRIMAL ha compiuto progressi significativi dal lancio ed è stato in grado di resistere al mercato ribassista, consolidandosi nello spazio sportivo e <a href="/web3" target="_blank" class="blog_inner_link">web3</a> mentre altri progetti sono rimasti dormienti.<br><img src="https://gimg2.gateimg.com/image/article/167489864313.png" alt=""><br>Fino ad oggi, PRIMAL ha:</p>
<ul>
<li>Lanciato $PRIMAL su 4 importanti CEX e Pancake swap</li><li>Token più scambiato tra tutti gli scambi su cui siamo quotati</li><li>$PRIMAL è diventato il quarto per volume in Pancakes Wap alcuni giorni dopo la quotazione, solo BNB, BUSD e USDT avevano un volume maggiore</li><li>L’app ha ora oltre 960.000 download, con 160.000 utenti attivi al giorno - una crescita del 100% rispetto al mese precedente</li><li>Prima vendita di NFT, esaurendo NFT del valore di $500.000, la vendita più grande di NFT di quest’anno</li><li>Diverse partnership con ponti di collegamento FIAT</li><li>Lancio di Fan token gecko, un sito per gli utenti per controllare il volume giornaliero, la capitalizzazione di mercato e il prezzo di tutti i token dei fan degli atleti. Abbiamo avuto 35k visualizzazioni il primo giorno + tempo medio di visualizzazione di 3 minuti</li><li>Campagna di crescita - tutti gli occhi sono stati puntati su di noi, l’unico progetto che offre e costruisce le basi per la prossima corsa al rialzo</li><li>Primo token dei fan con Andreas Pereira, un calciatore della Premier League insieme ad altri 15 ambassador</li><li>Il nostro sito di offerta di Fan Token è stato lanciato questa settimana - <a href="https://fto.getprimal.com/" rel="nofollow noopener noreferrer" target="_blank">https://fto.getprimal.com/</a></li></ul>
<h3 id="h3-Q520Quali20sono20le20prospettive20future20per20PRIMAL311103"><a name="Q5: Quali sono le prospettive future per $PRIMAL?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q5: Quali sono le prospettive future per $PRIMAL?</h3><p><strong>Ben</strong>: 2023 è l’anno di PRIMAL.<br>Abbiamo così tanto in arrivo nella prima parte dell’anno.</p>
<ul>
<li>Il nostro Fan Token DEX sarà lanciato questa settimana, dove gli utenti potranno scambiare i fan token da Binance e altre piattaforme</li><li>Partnership con un progetto tra i primi 100 in arrivo a breve</li><li>Il nostro primo fan token sarà lanciato molto presto</li><li>Il nostro Mainnet sarà lanciato il 10 Febbraio con la funzionalità M2E e altre funzionalità dell’app</li><li>I nostri primi Inner Circles con atleti di punta saranno attivi sull’app PRIMAL</li><li>Altre partnership e altri atleti da annunciare</li><li>Altri Exchange da annunciare</li><li>Stiamo celebrando PRIMAL per la nostra settimana di PRIMAL takeover in Corea del Sud nel Q1/2 di quest’anno, dove parteciperanno celebrità insieme ai nostri atleti.</li></ul>
<div class="blog-details-info"><br><div>Autore: <strong>Rio Fu.</strong>, Community 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 il repostaggio dell'articolo a condizione che venga citato Gate.io. In tutti i casi, saranno intraprese azioni legali a causa della violazione del copyright.<br></div><p></p><br></div></div></div>