R2F0ZS5pbyBBTUEgbWV0IFBSRU1BIC0gQmVnaW4gYWFuIGRlIHdlZyBuYWFyIEJsb2NrY2hhaW4=

<p><img src="https://gimg2.gateimg.com/image/article/16780858141.png" alt=""><br><strong>Tijd: 3 maart 2023, 11:00 UTC</strong><br><strong><a href="https://www.gate.io" target="_blank">Gate.io</a> organiseerde een AMA (Ask-Me-Anything) sessie met Masahiro Kawakami, de oprichter en CEO van het PREMA-project in de <a href="https://t.me/gateio" rel="nofollow noopener noreferrer" target="_blank">Gate.io Exchange Gemeenschap</a>.</strong><br><strong>Officiële website: <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>Volg PREMA op <a href="https://twitter.com/prema_en" rel="nofollow noopener noreferrer" target="_blank">Twitter</a> en <a href="https://t.me/prmx_io_global" rel="nofollow noopener noreferrer" target="_blank">Telegram</a></strong></p>
<p><strong>Gast</strong><img src="https://gimg2.gateimg.com/image/article/16780860102.png" alt=""><br><strong>Masahiro Kawakami - Oprichter en CEO van het PREMA-project</strong></p>
<h2 id="h2-Vragen20en20antwoorden20van20Gateio477770"><a name="Vragen en antwoorden van Gate.io" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Vragen en antwoorden van Gate.io</h2><h3 id="h3-Q120Kunt20u20het20PREMAproject20kort20introduceren106452"><a name="Q1: Kunt u het PREMA-project kort introduceren?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q1: Kunt u het PREMA-project kort introduceren?</h3><p><strong>Kawakami</strong>: Het PREMA-platform is gericht op PREMA X, een NFT-marktplaats, en maakt gebruik van de PREMA Wallet en traceerbaarheidssysteem om NFT’s te verbinden met de plaatsen waar ze worden gebruikt, zoals URL’s (UnReal Life, de onwerkelijke wereld) zoals metaverse blockchain-spellen en IRL’s (In Real Life, de echte wereld) zoals fysieke producten en ruimtes.</p>
<p>Met de lancering van het PREMA-platform in het derde kwartaal van 2023, richten we ons momenteel op de ontwikkeling van kerntechnologieën (NFC en AQR), de ontwikkeling van de PREMA-keten, de ontwikkeling van NFT-producten, enzovoort.</p>
<h3 id="h3-Q220Kunt20u20ons20ook20kort20iets20vertellen20over20de20PREMAtoken484512"><a name="Q2: Kunt u ons ook kort iets vertellen over de PREMA-token?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q2: Kunt u ons ook kort iets vertellen over de PREMA-token?</h3><p><strong>Kawakami</strong>: PREMA-tokens zullen de waardebasis vormen die de PREMA-platform ondersteunt, waar iedereen op elk moment toegang kan krijgen tot de benodigde hulpprogramma’s van URLs en IRLs.<br>Het zal ook fungeren als de native token van de genoemde blockchain zodra de ontwikkeling van de PREMA-ketting in de toekomst is voltooid.</p>
<p>Vanaf februari 2023 wordt het verhandeld op 10 beurzen.</p>
<h3 id="h3-Q320Waar20ga20je20vandaag20over20praten20En20wat20is20het20specifieke20thema20van20vandaag575676"><a name="Q3: Waar ga je vandaag over praten? En wat is het specifieke thema van vandaag?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q3: Waar ga je vandaag over praten? En wat is het specifieke thema van vandaag?</h3><p><strong>Kawakami</strong>: Bedankt voor uw interesse. Vandaag zal ik praten over wat onze projecten en de producten die we van plan zijn te ontwikkelen in de toekomst mogelijk zullen maken. En het thema is Een van onze prestaties - Verzamelbare kaarten van populaire Japanse komieken. Dit is een voorbeeld van hoe je je favoriete komiek kunt ondersteunen in een nieuw formaat door de technologie toegepast door het PREMA-platform, en hoe we een manier kunnen voorstellen om merchandise te ontwikkelen die gekoppeld is aan de NFT.</p>
<h3 id="h3-Q420Zoals20eerder20vermeld20is20de20AMA20van20vandaag20gebaseerd20op202020httpsprmxmediumcomhebjegehoordvandepopulairejapansekomiekenverzamelkaart2f7a67da7f7bkon2020kunt20u20dit20artikel20voor20ons20samenvatten970393"><a name="Q4: Zoals eerder vermeld, is de AMA van vandaag gebaseerd op:   https://prmx.medium.com/heb-je-gehoord-van-de-populaire-japanse-komieken-verzamelkaart-2f7a67da7f7b,kon  kunt u dit artikel voor ons samenvatten?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q4: Zoals eerder vermeld, is de AMA van vandaag gebaseerd op: <a href="https://prmx.medium.com/have-you-heard-of-the-popular-japanese-comedians-collectable-card-2f7a67da7f7b,could" rel="nofollow noopener noreferrer" target="_blank">https://prmx.medium.com/heb-je-gehoord-van-de-populaire-japanse-komieken-verzamelkaart-2f7a67da7f7b,kon</a> kunt u dit artikel voor ons samenvatten?</h3><p><strong>Kawakami</strong>: Natuurlijk!<br>Ten eerste maakt deze populaire serie van NFT-ruilkaarten van komieken het mogelijk dat een deel van de opbrengst van elke NFT wordt teruggegeven aan de rechthebbenden; hoe actiever de handel, hoe meer je je favoriete komieken kunt steunen.</p>
<p>Ten tweede maakt de belangrijkste technologie van Prema, NFC-technologie, het mogelijk dat apparaten op korte afstand contact maken om NFT te verkrijgen.<br><img src="https://gimg2.gateimg.com/image/article/16780862203.jpg" alt=""><br>Dit maakt het mogelijk om unieke items te verkrijgen of ze te gebruiken als een speciale voorziening bij evenementen.</p>
<p>Bovendien maakt AQR-technologie ook veilige transacties via QR-codes mogelijk, waardoor contenthouders bestaande kaartpakketten en speelgoedverkoopkanalen kunnen gebruiken om NFT’s te verkopen.<br><img src="https://gimg2.gateimg.com/image/article/16780860564.jpg" alt=""><br>Met behulp van de twee eerder genoemde technologieën verlaagt deze handelskaart niet alleen de drempel voor NFT’s, maar maakt het ook mogelijk om echte en virtuele evenementen te combineren!</p>
<h2 id="h2-Live20QampA20vanuit20Gateio655701"><a name="Live Q&amp;A vanuit Gate.io" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Live Q&amp;A vanuit Gate.io</h2><h3 id="h3-Vraag20120Kunt20u20ons20iets20vertellen20over20uw20token20dat20door20u20in20uw20ecosysteem20wordt20gebruikt20dwz20hoe20het20werkt20wat20voor20soort20hulpprogrammas20en20voordelen20het20biedt20aan20gebruikers20en20in20feite20hoe20draagt20het20bij20aan20de20groei20en20vooruitgang20van20uw20ecosysteem20op20dit20moment20en20in20de20nabije20toekomst74756"><a name="Vraag 1: Kunt u ons iets vertellen over “uw token” dat door u in uw ecosysteem wordt gebruikt, d.w.z. hoe het werkt, wat voor soort hulpprogramma’s en voordelen het biedt aan gebruikers, en in feite, hoe draagt het bij aan de groei en vooruitgang van uw ecosysteem op dit moment en in de nabije toekomst?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Vraag 1: Kunt u ons iets vertellen over “uw token” dat door u in uw ecosysteem wordt gebruikt, d.w.z. hoe het werkt, wat voor soort hulpprogramma’s en voordelen het biedt aan gebruikers, en in feite, hoe draagt het bij aan de groei en vooruitgang van uw ecosysteem op dit moment en in de nabije toekomst?</h3><p><strong>Kawakami</strong>: Het PREMA token zal de waardebasis zijn die het PREMA-platform ondersteunt, waardoor iedereen op elk moment toegang heeft tot de noodzakelijke hulpprogramma’s van de URL/IRL. Het zal ook dienen als het native token van de genoemde blockchain zodra de ontwikkeling van de PREMA-keten in de toekomst is voltooid.</p>
<p>De NFT Collection Cards van Komieken, vandaag geïntroduceerd, is een populaire serie kaarten die tot nu toe meer dan 2 miljoen kaarten heeft verkocht in de eerste drie series.</p>
<p>Met behulp van eigen technologie wordt verwacht dat de kaarten een hoge bruikbaarheid hebben als NFT’s met inherente waarde. Dit product is nauw verbonden met het kernconcept van PREMA van ‘het verbinden van de echte wereld met de virtuele wereld’.</p>
<h3 id="h3-Q220Hoe20kunnen20we20NFT20verkrijgen20Hoe20waardevol20is20deze20NFT20zodra20we20die20hebben20Is20het20mogelijk20dat20dit20project20een20airdrop20zal20uitvoeren20voor20NFThouders20als20blijk20van20waardering20voor20de20supporters20van20Prema771883"><a name="Q2: Hoe kunnen we NFT verkrijgen? Hoe waardevol is deze NFT zodra we die hebben? Is het mogelijk dat dit project een airdrop zal uitvoeren voor NFT-houders als blijk van waardering voor de supporters van Prema?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q2: Hoe kunnen we NFT verkrijgen? Hoe waardevol is deze NFT zodra we die hebben? Is het mogelijk dat dit project een airdrop zal uitvoeren voor NFT-houders als blijk van waardering voor de supporters van Prema?</h3><p><strong>Kawakami</strong>: Onze NFT-collectiekaarten kunnen ‘de echte en virtuele werelden verbinden. Zo kunnen we bijvoorbeeld bezoekers voorzien van limited edition NFT-collectiekaarten die alleen verkrijgbaar zijn op de locatie van een evenement van een komiek, met gebruikmaking van onze eigen NFC- en AQR-technologieën die we vandaag hebben beschreven.</p>
<p>Het zou ook mogelijk zijn om deze NFT te laten functioneren als een ticket of productaankoopbon voor een ander evenement, of om verschillende NFT’s in beperkte oplage naar hun eigenaren te Airdroppen.</p>
<h3 id="h3-Q320Ik20ben20een20cryptoinvesteerder20en20ik20geef20alleen20om20het20vooruitzicht20van20een20project20dat20ik20kies20vertel20me20waarom20ik20voor20PREMA20moet20kiezen20Wat20is20jullie20voordeel20ten20opzichte20van20andere20WEB3projecten20die20me20kunnen20overtuigen20om20over20te20stappen20van20mijn20favoriete20project694494"><a name="Q3: Ik ben een crypto-investeerder en ik geef alleen om het vooruitzicht van een project dat ik kies, vertel me waarom ik voor #PREMA moet kiezen? Wat is jullie voordeel ten opzichte van andere #WEB3-projecten die me kunnen overtuigen om over te stappen van mijn favoriete project?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q3: Ik ben een crypto-investeerder en ik geef alleen om het vooruitzicht van een project dat ik kies, vertel me waarom ik voor #PREMA moet kiezen? Wat is jullie voordeel ten opzichte van andere #WEB3-projecten die me kunnen overtuigen om over te stappen van mijn favoriete project?</h3><p><strong>Kawakami</strong>: Bijvoorbeeld, zoals vermeld in het artikel, herinneren beperkt verkrijgbare NFT’s die beschikbaar zijn op echte evenementlocaties ons aan het plezier van het evenement en het enthousiasme van de gasten.</p>
<p>Door NFT te integreren in de fysieke ervaring, wordt de uniciteit van de NFT gecombineerd met de ervaring en herinnering.<br>De waarde van een stuk NFT wordt dan niet alleen relatief verhoogd door zijn zeldzaamheid, maar wordt ook ‘iets speciaals voor zichzelf’ dat niet kan worden vervangen door een individuele gebruiker. Op deze manier zijn de echte wereld en de virtuele wereld onlosmakelijk met elkaar verbonden.</p>
<p>Ons project zal innovatieve technologieën gebruiken en ook <a href="/web3" target="_blank" class="blog_inner_link">web3</a> gebruiken om gebruikers een nieuwe ervaring te bieden waarin de URL (UnReal Life) en de IRL (In Real Life) onlosmakelijk verbonden zijn!</p>
<div class="blog-details-info"><br><div>Auteur:<strong> Rio Fu.</strong>, Gate.io Community<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de standpunten van de onderzoeker en vormt geen enkele beleggingsaanbeveling.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het opnieuw plaatsen van het artikel zal worden toegestaan mits er naar Gate.io wordt verwezen. In alle glen zullen juridische stappen worden ondernomen vanwege inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div>