R2F0ZS5pbyBBTUEgbWV0IENST1dOIC0gRUVOIEVYQ0xVU0lFVkUgUkVJUyBWQU4gSVBTIE5BQVIgTkZUJ1MgRU4gREUgTUVUQVZFUlNF

<p><img src="https://gimg2.gateimg.com/image/article/16818012881.jpeg" alt=""><br><strong>Tijd: 17 april 2023, 13:30 UTC</strong><br><strong><a href="https://www.gate.io" target="_blank">Gate.io</a> organiseerde een AMA (Ask-Me-Anything) sessie met de vertegenwoordigers van CROWN in de <a href="https://twitter.com/i/spaces/1OyKAVNDQMOGb" rel="nofollow noopener noreferrer" target="_blank">Twitter Space</a>.</strong><br><strong>Officiële website: <a href="https://crowntoken.io" rel="nofollow noopener noreferrer" target="_blank">https://crowntoken.io</a></strong><br><strong>Twitter: <a href="https://twitter.com/CROWNtokenclub" rel="nofollow noopener noreferrer" target="_blank">https://twitter.com/CROWNtokenclub</a></strong><br><strong>Volg CROWN op <a href="https://discord.com/invite/UBetr9R3tq" rel="nofollow noopener noreferrer" target="_blank">Discord</a> en <a href="https://t.me/CROWNcommunity_global" rel="nofollow noopener noreferrer" target="_blank">Telegram</a></strong><br><strong>Gasten</strong><img src="https://gimg2.gateimg.com/image/article/16818017022.png" alt=""><br><strong>Pannathorn Lorattawut - CEO bij CROWN</strong><img src="https://gimg2.gateimg.com/image/article/16818017293.png" alt=""><br><strong>Demi Korntanasap - Community Manager</strong><img src="https://gimg2.gateimg.com/image/article/16818017444.png" alt=""><br><strong>Maetus Chinnapha - Hoofd Juridische Zaken</strong><img src="https://gimg2.gateimg.com/image/article/16818017675.png" alt=""><br><strong>Kanin Towiwak - Hoofd Product</strong></p>
<h2 id="h2-QampA20van20Gateio409053"><a name="Q&amp;A van Gate.io" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q&amp;A van Gate.io</h2><h3 id="h3-V120Geef20een20korte20introductie20over20het20project696279"><a name="V1: Geef een korte introductie over het project." class="reference-link"></a><span class="header-link octicon octicon-link"></span>V1: Geef een korte introductie over het project.</h3><p><strong>Pan</strong>: CROWN is de allereerste wereldwijde entertainmenttoken door traditionele intellectuele eigendommen (IE) te verbinden met blockchaintechnologie om het bedrijf te verbeteren en waarde te creëren voor CROWN-tokenhouders en de gemeenschap.<br><img src="https://gimg2.gateimg.com/image/article/16818018076.png" alt=""><br>Onze tokenhouders zullen blootstelling krijgen aan de snelgroeiende sectoren van intellectuele eigendommen, NFT’s en Metaverse, terwijl ze beloningen, voordelen en privileges ontvangen van onze ecoen.</p>
<h3 id="h3-Q220Wat20maakt20uw20project20uniek539994"><a name="Q2: Wat maakt uw project uniek?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q2: Wat maakt uw project uniek?</h3><p><strong>Pan</strong> We worden ondersteund door Aziatische conglomeraten met verschillende Web3-ondernemingen onder de paraplu. We hebben een achterstand met jarenlange intellectuele eigendomsrechten en diepe partnerschappen met de allerbeste in de industrie. Een van de belangrijkste drijfveren van ons project zijn intellectuele eigendommen met hun inkomstenstroom en groeimogelijkheden.</p>
<h3 id="h3-V320Geef20enkele20hoogtepunten20van20uw20project20op84246"><a name="V3: Geef enkele hoogtepunten van uw project op." class="reference-link"></a><span class="header-link octicon octicon-link"></span>V3: Geef enkele hoogtepunten van uw project op.</h3><p><strong>Demi</strong>: CROWN token biedt een aantrekkelijke blootstelling aan alle platforms in ons ecosysteem dat zich uitstrekt over de<br>entertainment-, technologie- en media-industrie.<br><img src="https://gimg2.gateimg.com/image/article/16818018397.png" alt=""><br>KROON<br>•Ondersteund door hoogwaardige IP-projecten, waaronder geanimeerde films, series en platforms<br>•Sterk ecosysteem binnen onze groepsbedrijven en partners<br>•Tokenhouders:<br>Kunnen tokens inzetten voor diverse beloningen, voordelen en nutsvoorzieningen<br>Krijgen wereldwijde exposure in de entertainment-, tech- en mediaindustrie<br>Krijgen exclusieve toegang tot onze NFT’s en ADOT-marktplaats<br>Krijgen vroegtijdige toegang tot Translucia, onze Metaverse voor het goede</p>
<h3 id="h3-Q420Vertel20ons20alstublieft20enkele20hoogtepunten20van20uw20IPs20in20de20lineup132804"><a name="Q4: Vertel ons alstublieft enkele hoogtepunten van uw IPs in de line-up." class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q4: Vertel ons alstublieft enkele hoogtepunten van uw IPs in de line-up.</h3><p><strong>Demi</strong>: Zoals vermeld door Pan, hebben we in de loop der jaren een schat aan intellectuele eigendomsrechten opgebouwd en diepgaande partnerschappen met de beste in de branche. Momenteel worden onze tekenfilmseries uitgezonden op topplatforms zoals Netflix, ABC en meer. Al onze producties worden geleid door Academy Award-winnende teams. Bijvoorbeeld, Onze aankomende fantasy-animatiefilm, The Forestias, komt uit in 2024, en wordt geschreven door hetzelfde scenarioschrijversteam dat werkte aan The Lion King, Tarzan en de Klokkenluider van de Notre Dame. Ik wil ook ons meest recente werk noemen, Legend of the Two Heroes, een actieanimatie over twee apenkoningen. Nogmaals, het scenarioschrijversteam bestaat uit personen die aan enkele van Disney’s meest geliefde tekenfilms hebben gewerkt. We zullen in mei een beperkte NFT-collectie uitbrengen met enkele personages uit Legend of the Two Heroes, vooruitlopend op de filmrelease later dit jaar. Je kunt nu een voorproefje nemen van de eerste gelimiteerde collectie op het ADOT-platform.</p>
<h3 id="h3-Q520Kunt20u20ons20vertellen20waarom20intellectuele20eigendommen20waardevol20zijn804638"><a name="Q5: Kunt u ons vertellen waarom intellectuele eigendommen waardevol zijn?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q5: Kunt u ons vertellen waarom intellectuele eigendommen waardevol zijn?</h3><p><strong>Maetus</strong> Wij geloven in de kracht van intellectuele eigendommen (IP’s). De IP’s van één verhaal kunnen worden uitgebreid naar andere snelgroeiende industrieën zoals gaming, strips, romans, merchandise, series, films en NFT’s. Gecombineerd zijn deze industrieën een enorme markt geworden die terugkerende inkomsten genereert.</p>
<h3 id="h3-V620Hoe20zijn20IPs20gekoppeld20aan20de20CROWN20Token692710"><a name="V6: Hoe zijn IP’s gekoppeld aan de CROWN Token?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>V6: Hoe zijn IP’s gekoppeld aan de CROWN Token?</h3><p><strong>Maetus</strong>: Wij denken dat blockchain-technologie een positieve invloed kan hebben op de conventionele manier van ondernemen en deze kan verstoren en toegevoegde waarde kan creëren voor alle belanghebbenden. We integreren onze IP’s in de blockchain-industrie door een koppeling te maken tussen de IP’s en ons token; het token zal dan een koppeling maken met de NFT’s en uiteindelijk verbinding maken met de metaverse.</p>
<h3 id="h3-Q720Kunt20u20ons20een20overzicht20geven20In20het20bijzonder20vertel20ons20alstublieft20over20de20ADOTmarktplaats20Hoe20is20het20verbonden20met20de20CROWN20Token104477"><a name="Q7: Kunt u ons een overzicht geven? In het bijzonder, vertel ons alstublieft over de ADOT-marktplaats. Hoe is het verbonden met de CROWN Token?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q7: Kunt u ons een overzicht geven? In het bijzonder, vertel ons alstublieft over de ADOT-marktplaats. Hoe is het verbonden met de CROWN Token?</h3><p><strong>Kanin</strong>: Via ons eigen ADOT-platform kunnen tokenhouders tokens inzetten voor beloningen en voordelen, evenals stemmen om de richting van een film, karakterontwerpen, kunstconcepten, inhoud en meer te selecteren. CROWN zal worden gebruikt om NFT’s te kopen, verkopen of bieden op de ADOT-marktplaats. Tokenhouders krijgen de kans om deel te nemen aan een gemeenschappelijk beloningsfonds en ontvangen een deel van de transactiekosten.</p>
<p><strong>Demi</strong>: Deze samenwerkingen geven tokenhouders een gemeenschap die fanatisme viert en kunstliefhebbers, enthousiastelingen en makers bij elkaar brengt.</p>
<h3 id="h3-Q820Hoe20zit20het20met20andere20entertainmentplatforms622480"><a name="Q8: Hoe zit het met andere entertainmentplatforms?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q8: Hoe zit het met andere entertainmentplatforms?</h3><p><strong>Kanin</strong>: CROWN werkt samen met partners zoals live streaming platforms en e-sports. CROWN en ons platform zullen ook hun crypto-betalingsgateway zijn. We werken ook samen met partners in diverse sectoren.</p>
<h3 id="h3-Q920Wat20zijn20de20CROWN20Tokeneconomie99623"><a name="Q9: Wat zijn de CROWN Token-economie?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q9: Wat zijn de CROWN Token-economie?</h3><p><strong>Pan</strong>: We streven ernaar om aantrekkelijke use cases, meer diversificatie en wereldwijde marktbelichting te bieden aan onze tokenhouders.<br>Onze use cases worden gedreven door 1) intellectuele eigendomsprojecten en bijbehorende bedrijven zoals games, licenties en merchandising, NFT’s, strips, themaparken; 2) het ADOT-platform, onze NFT-marktplaats met een programma voor het delen van inkomsten/ transactiekosten; en 3) ons sterke ecosysteem van ons netwerk van bedrijven en partners.</p>
<h3 id="h3-Q1020Wat20is20het20gebruik20van20de20CROWN20Token140749"><a name="Q10: Wat is het gebruik van de CROWN Token?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q10: Wat is het gebruik van de CROWN Token?</h3><p><strong>Demi</strong>:<br>•Staken voor stabiele munten, CROWN, NFT’s<br>•Deelname en governance bij projecten<br>•Beloningspools van IPs<br>•Transactiekosten delen<br>•Voorrechten en exclusieve rechten</p>
<h3 id="h3-Q1120Welk20voordeel20biedt20het20voor20dit20stemproces41360"><a name="Q11: Welk voordeel biedt het voor dit stemproces?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q11: Welk voordeel biedt het voor dit stemproces?</h3><p><strong>Maetus</strong>: Het is de verdeling van macht die gepaard gaat met transparantie en geen grenzen - een gevoel van eigendom, deel van de gemeenschap. We kunnen ons wereldwijd richten op ons doelpubliek.</p>
<h3 id="h3-Q1220Vertel20ons20alstublieft20over20het20Team20achter20het20CROWN20Token20Project399097"><a name="Q12: Vertel ons alstublieft over het Team achter het CROWN Token Project." class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q12: Vertel ons alstublieft over het Team achter het CROWN Token Project.</h3><p><strong>Demi</strong>: CROWN is een door vrouwen geleid team in Azië met wereldwijde projecten en mogelijkheden - We zetten traditionele hiërarchieën op zijn kop in de crypto-industrie en de grotere zakenwereld - en de implicaties in Azië, waar het landschap over het algemeen meer verweven is met de entertainmentindustrie.</p>
<h3 id="h3-Q1320Het20leiden20van20een20door20vrouwen20geleid20Web3bedrijf20met20name20in20Azi20waar20het20landschap20over20het20algemeen20meer20verweven20is20met20de20entertainmentindustrie20dan20in20het20Westen20tot20nu20toe724042"><a name="Q13: Het leiden van een door vrouwen geleid Web3-bedrijf, met name in Azië, waar het landschap over het algemeen meer verweven is met de entertainmentindustrie dan in het Westen tot nu toe." class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q13: Het leiden van een door vrouwen geleid Web3-bedrijf, met name in Azië, waar het landschap over het algemeen meer verweven is met de entertainmentindustrie dan in het Westen tot nu toe.</h3><p><strong>Pan</strong>: Het westen heeft sterke voetafdrukken van de blauwe scheepvaartbedrijven. Echter, de entertainment industrie en de bijbehorende bedrijven komen sneller terug in Azië. De adoptie van crypto en blockchain technologie groeit ook snel hier. De fusie tussen de twee is een grote kracht en een wind in de rug voor ons project.</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 beleggingssuggestie.<br></em><div><em></em>Gate.io behoudt alle rechten van dit artikel. Het opnieuw plaatsen van het artikel wordt toegestaan op voorwaarde dat Gate.io wordt vermeld. In alle glen zal juridische actie worden ondernomen vanwege auteursrechtinbreuk.<br></div><p></p><br></div></div></div>