R2F0ZS5pbyBBTUEgY29uIFBSRU1BLUltYmFyY2F0aSBzdWxsYSBTdHJhZGEgZGVsbGEgQmxvY2tjaGFpbg==

<p><img src="https://gimg2.gateimg.com/image/article/16780858141.png" alt=""><br><strong>Ora: 3 marzo 2023, 11:00 UTC</strong><br><strong><a href="https://www.gate.io" target="_blank">Gate.io</a> ha ospitato una sessione AMA (Ask-Me-Anything) con Masahiro Kawakami, il fondatore e CEO del progetto PREMA in <a href="https://t.me/gateio" rel="nofollow noopener noreferrer" target="_blank">Comunità di scambio Gate.io</a>.</strong><br><strong>Sito web ufficiale: <a href="https://prmx.io/" rel="nofollow noopener noreferrer" target="_blank">https://prmx.io/</a></strong></p>
<p><strong>Twitter: <a href="https://twitter.com/prema_en" rel="nofollow noopener noreferrer" target="_blank">https://twitter.com/prema_en</a></strong></p>
<p><strong>Segui PREMA su <a href="https://twitter.com/prema_en" rel="nofollow noopener noreferrer" target="_blank">Twitter</a> e <a href="https://t.me/prmx_io_global" rel="nofollow noopener noreferrer" target="_blank">Telegram</a></strong></p>
<p><strong>Ospite</strong><img src="https://gimg2.gateimg.com/image/article/16780860102.png" alt=""><br><strong>Masahiro Kawakami — Fondatore e CEO del progetto PREMA</strong></p>
<h2 id="h2-QampA20da20Gateio780961"><a name="Q&amp;A da Gate.io" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q&amp;A da Gate.io</h2><h3 id="h3-Q120Puoi20per20favore20presentare20brevemente20il20progetto20PREMA278106"><a name="Q1: Puoi per favore presentare brevemente il progetto PREMA?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q1: Puoi per favore presentare brevemente il progetto PREMA?</h3><p><strong>Kawakami</strong>: La piattaforma PREMA è incentrata su PREMA X, un marketplace NFT, e utilizza il PREMA Wallet e il sistema di tracciabilità per collegare gli NFT con i luoghi in cui vengono utilizzati, come gli URL (UnReal Life, il mondo irreale) come i giochi blockchain del metaverso e gli IRL (In Real Life, il mondo reale) come i prodotti fisici e gli spazi.</p>
<p>Con il lancio della piattaforma PREMA in arrivo nel Q3 2023, ci stiamo attualmente concentrando sullo sviluppo delle tecnologie di base (NFC e AQR), lo sviluppo della catena PREMA, lo sviluppo del prodotto NFT, e così via.</p>
<h3 id="h3-Q220Potresti20anche20dirci20brevemente20cosa20sia20il20token20PREMA153102"><a name="Q2: Potresti anche dirci brevemente cosa sia il token PREMA?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q2: Potresti anche dirci brevemente cosa sia il token PREMA?</h3><p><strong>Kawakami</strong>: I token PREMA saranno la base di valore che sostiene la piattaforma PREMA, dove chiunque può accedere alle utility necessarie di URL e IRL in qualsiasi momento.<br>Inoltre, funzionerà come token nativo della suddetta blockchain non appena lo sviluppo di PREMA chain sarà completato in futuro.</p>
<p>A partire da febbraio 2023, viene scambiato su 10 borse.</p>
<h3 id="h3-Q320Di20cosa20parlerai20oggi20E20qual2020il20tema20specifico20di20oggi677551"><a name="Q3: Di cosa parlerai oggi? E qual è il tema specifico di oggi?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q3: Di cosa parlerai oggi? E qual è il tema specifico di oggi?</h3><p><strong>Kawakami</strong>: Grazie per il vostro interesse. Oggi parlerò di ciò che i nostri progetti e i prodotti che intendiamo sviluppare consentiranno in futuro. E il tema è uno dei nostri successi– Collezionabili delle famose comiche giapponesi’. Questo è un esempio di come potete sostenere il vostro comico preferito in un nuovo formato attraverso la tecnologia applicata dalla piattaforma PREMA, e come possiamo proporre un modo per sviluppare merchandise legato agli NFT.</p>
<h3 id="h3-Q420Come20accennato20in20precedenza20lAMA20di20oggi20si20basa20su202020Hai20mai20sentito20parlare20delle20carte20collezionabili20dei20comici20giapponesi20pi20popolari2020Puoi20riassumere20questo20articolo20per20noi287725"><a name="Q4: Come accennato in precedenza, l’AMA di oggi si basa su:   Hai mai sentito parlare delle carte collezionabili dei comici giapponesi più popolari?  Puoi riassumere questo articolo per noi?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q4: Come accennato in precedenza, l’AMA di oggi si basa su: <a href="https://prmx.medium.com/have-you-heard-of-the-popular-japanese-comedians-collectable-card-2f7a67da7f7b,could" rel="nofollow noopener noreferrer" target="_blank">Hai mai sentito parlare delle carte collezionabili dei comici giapponesi più popolari?</a> Puoi riassumere questo articolo per noi?</h3><p><strong>Kawakami</strong>: Certo!<br>Innanzitutto, questa popolare serie di carte da collezione NFT di comici permette che una parte dei proventi di ogni NFT venga restituita ai titolari dei diritti; più attiva è la negoziazione, più è possibile sostenere i comici preferiti.</p>
<p>In secondo luogo, la tecnologia chiave di .Prema, la tecnologia NFC, consente ai dispositivi di entrare in contatto a breve distanza per ottenere NFT.<br><img src="https://gimg2.gateimg.com/image/article/16780862203.jpg" alt=""><br>In questo modo è possibile ottenere oggetti unici o utilizzarli come utilità speciale in occasione di eventi.</p>
<p>Inoltre, la tecnologia AQR consente anche transazioni sicure tramite codici QR, consentendo ai detentori di contenuti di utilizzare confezioni di carte esistenti e canali di vendita di giocattoli per vendere NFT.<br><img src="https://gimg2.gateimg.com/image/article/16780860564.jpg" alt=""><br>Utilizzando le due tecnologie precedentemente menzionate, questa carta commerciale non solo abbassa la soglia per NFT, ma consente anche eventi reali e virtuali combinati!</p>
<h2 id="h2-Domande20e20risposte20in20diretta20da20Gateio46418"><a name="Domande e risposte in diretta da Gate.io" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Domande e risposte in diretta da Gate.io</h2><h3 id="h3-Q120Potresti20dirci20qualcosa20sul20tuo20token20che20viene20utilizzato20da20te20nel20tuo20ecosistema20cio20come20funziona20che20tipo20di20utilit20e20benefici20fornisce20agli20utenti20e20infatti20come20contribuisce20alla20crescita20e20al20progresso20del20tuo20ecosistema20in20questo20momento20e20in20futuro20prossimo609467"><a name="Q1: Potresti dirci qualcosa sul “tuo token” che viene utilizzato da te nel tuo ecosistema, cioè come funziona, che tipo di utilità e benefici fornisce agli utenti, e infatti, come contribuisce alla crescita e al progresso del tuo ecosistema in questo momento e in futuro prossimo?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q1: Potresti dirci qualcosa sul “tuo token” che viene utilizzato da te nel tuo ecosistema, cioè come funziona, che tipo di utilità e benefici fornisce agli utenti, e infatti, come contribuisce alla crescita e al progresso del tuo ecosistema in questo momento e in futuro prossimo?</h3><p><strong>Kawakami</strong>: Il token PREMA sarà la base di valore che sostiene la piattaforma PREMA, che consente a chiunque di accedere alle utilità necessarie dell’URL/IRL in qualsiasi momento. Servirà anche come token nativo della suddetta blockchain non appena sarà completato lo sviluppo della catena PREMA in futuro.</p>
<p>Le carte della collezione NFT dei comici, introdotte oggi, sono una serie popolare di carte che ha venduto oltre 2 milioni di carte fino alla terza serie finora rilasciata.</p>
<p>Utilizzando tecnologie proprietarie, le carte sono attese ad avere un’elevata utilità come NFT con valore intrinseco. Questo prodotto è strettamente legato al concetto fondamentale di PREMA di “connettere il mondo reale con il mondo virtuale”.</p>
<h3 id="h3-Q220Come20possiamo20acquistare20NFT20Quanto2020prezioso20questo20NFT20una20volta20che20lo20abbiamo2020possibile20che20questo20progetto20effettuer20un20airdrop20per20i20detentori20di20NFT20come20segno20di20apprezzamento20per20i20sostenitori20di20Prema68189"><a name="Q2: Come possiamo acquistare NFT? Quanto è prezioso questo NFT una volta che lo abbiamo? È possibile che questo progetto effettuerà un airdrop per i detentori di NFT come segno di apprezzamento per i sostenitori di Prema?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q2: Come possiamo acquistare NFT? Quanto è prezioso questo NFT una volta che lo abbiamo? È possibile che questo progetto effettuerà un airdrop per i detentori di NFT come segno di apprezzamento per i sostenitori di Prema?</h3><p><strong>Kawakami</strong>: Le nostre NFT Collection Card possono ‘collegare il mondo reale e quello virtuale.<br>Ad esempio, possiamo fornire ai visitatori carte da collezione NFT in edizione limitata che possono essere ottenute solo presso la sede dell’evento di un comico, utilizzando le nostre tecnologie proprietarie NFC e AQR che abbiamo descritto oggi.</p>
<p>Sarebbe anche possibile fare in modo che questo NFT funzioni come un biglietto o un coupon per l’acquisto di un prodotto per un evento diverso, o per distribuire Airdrop di diverse edizioni limitate di NFT ai loro proprietari.</p>
<h3 id="h3-Q320Sono20un20investitore20cripto20e20mi20interessa20solo20la20prospettiva20di20un20progetto20che20scelgo20dimmi20il20motivo20per20cui20dovrei20scegliere20PREMA20Qual2020il20tuo20vantaggio20rispetto20ad20altri20progetti20WEB320che20possono20convincermi20a20cambiare20dal20mio20preferito438553"><a name="Q3: Sono un investitore cripto e mi interessa solo la prospettiva di un progetto che scelgo, dimmi il motivo per cui dovrei scegliere #PREMA? Qual è il tuo vantaggio rispetto ad altri progetti #WEB3 che possono convincermi a cambiare dal mio preferito?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q3: Sono un investitore cripto e mi interessa solo la prospettiva di un progetto che scelgo, dimmi il motivo per cui dovrei scegliere #PREMA? Qual è il tuo vantaggio rispetto ad altri progetti #WEB3 che possono convincermi a cambiare dal mio preferito?</h3><p><strong>Kawakami</strong>: Ad esempio, come menzionato nell’articolo, le edizioni limitate di NFT disponibili presso i luoghi degli eventi reali ci ricordano il divertimento dell’evento e l’entusiasmo degli ospiti.</p>
<p>Intervenendo con l’NFT nell’esperienza fisica, l’unicità dell’NFT si integra con l’esperienza e la memoria. Il valore di un pezzo di NFT non è quindi solo aumentato relativamente dalla sua rarità, ma diventa anche “qualcosa di speciale per sé” che non può essere sostituito da un singolo utente. In questo modo, il mondo reale e il mondo virtuale sono inseparabilmente legati.</p>
<p>Il nostro progetto utilizzerà tecnologie innovative, utilizzando anche web3, per offrire agli utenti una nuova esperienza in cui l’URL (UnReal Life) e l’IRL (In Real Life) sono inseparabilmente collegati!</p>
<div class="blog-details-info"><br><div>Autore:<strong> Rio Fu.</strong>, Comunità 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 ripostaggio dell'articolo a condizione che Gate.io venga citato. In tutti i casi, saranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div>