R2F0ZS5pbyBBTUEgbWV0IFZlcmFzaXR5IC0gRWVuIG9wZW4gbGVkZ2VyIGVjb3N5c3RlZW0gZGF0IHZlcnRyb3V3ZW4gZW4gdHJhbnNwYXJhbnRpZSBicmVuZ3QgaW4gZGlnaXRhbGUgYWR2ZXJ0ZW50aWVzIGVuIGJldGFsaW5nZW4=

<p><img src="https://gimg2.gateimg.com/image/article/17016799261.jpeg" alt=""><br><strong>Tijd: 8 november 2023 om 13:00 UTC</strong><br><strong><a href="https://www.gate.io" target="_blank">Gate.io</a> organiseerde een AMA (Ask-Me-Anything) sessie met Elliot Hill, CMO bij Verasity in de <a href="https://twitter.com/i/spaces/1OwxWYRzrkZGQ" rel="nofollow noopener noreferrer" target="_blank">Twitter Space</a>.</strong><br><strong>Officiële website: <a href="http://www.verasity.io/" rel="nofollow noopener noreferrer" target="_blank">http://www.verasity.io/</a></strong><br><strong>Twitter: <a href="https://twitter.com/verasitytech" rel="nofollow noopener noreferrer" target="_blank">https://twitter.com/verasitytech</a></strong><br><strong>Volg Verasity op <a href="https://twitter.com/verasitytech" rel="nofollow noopener noreferrer" target="_blank">Twitter</a> en <a href="https://t.me/VRAchannel" rel="nofollow noopener noreferrer" target="_blank">Telegram</a></strong><br><strong>Gast</strong><img src="https://gimg2.gateimg.com/image/article/17016801742.jpeg" alt=""><br><strong>Elliot Hill - CMO bij Verasity</strong></p>
<h2 id="h2-Vraag20amp20Antwoord20van20Gateio896056"><a name="Vraag &amp; Antwoord van Gate.io" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Vraag &amp; Antwoord van Gate.io</h2><h3 id="h3-Q120Wat20is20Verasity20VRA695599"><a name="Q1: Wat is Verasity (VRA)?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q1: Wat is Verasity (VRA)?</h3><p><strong>Elliot</strong> Verasity is een open-ledger ecosysteem dat is ontworpen om advertentiefraude te bestrijden, open toegang te bieden tot infrastructuur voor uitgevers en adverteerders, en gebruikers te belonen voor het bekijken van videomateriaal. Verasity biedt ook betalingsoplossingen en een belonend staking ecosysteem met gegarandeerde opbrengsten van 15% tot april 2024.</p>
<p>Aangedreven door een mix van kunstmatige intelligentie (AI), machine learning (ML) en toonaangevende blockchaintechnologieën, bouwt Verasity het krachtigste advertentie-ecosysteem ter wereld via VeraViews; het ontwikkelen van een open toegankelijk betalingsplatform via VeraWallet, de VeraCard, en het verbeteren van de aandachtseconomie via haar gepatenteerde Rewarded Video-module.</p>
<h3 id="h3-Q220Wat20is20de20rol20van20de20VRAtoken20in20jullie20ecosysteem91188"><a name="Q2: Wat is de rol van de VRA-token in jullie ecosysteem?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q2: Wat is de rol van de VRA-token in jullie ecosysteem?</h3><p><img src="https://gimg2.gateimg.com/image/article/17016801963.jpeg" alt=""><br><strong>Elliot</strong>: De VRA-token vervult een veelzijdige rol binnen het Verasity-ecosysteem en fungeert als een utility-token met een breed scala aan toepassingen. Het wordt gebruikt om advertentiecampagnes te financieren binnen VeraViews, te staken via VeraWallet, betalingen te doen via VeraCard en Watch &amp; Earn-beloningen te verspreiden.</p>
<h3 id="h3-Vraag20320Wat20zijn20de20patenten20van20Verasity20en20hoe20gebruikt20u20ze20in20uw20technologiestack50766"><a name="Vraag 3: Wat zijn de patenten van Verasity en hoe gebruikt u ze in uw technologiestack?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Vraag 3: Wat zijn de patenten van Verasity en hoe gebruikt u ze in uw technologiestack?</h3><p><strong>Elliot</strong>: Het eigen technologieportfolio van Verasity omvat twee gepatenteerde innovaties.</p>
<p>De eerste, gepatenteerd in de VS, China, Zuid-Korea, Hong Kong, Eurazië en meest recentelijk Europa, is Proof of View, of ‘PoV’ - een module voor het detecteren van advertentiefraude die voorkomt dat frauduleuze weergaven worden geregistreerd tijdens een advertentiecampagne. De Proof of View-technologie van Verasity zorgt ervoor dat advertenties die via videospelers met een PoV-integratie worden geleverd, aan echte kijkers worden getoond. Dit gebeurt door gebruik te maken van een combinatie van blockchain en 13 andere modules, waaronder kunstmatige intelligentie (AI) en machine learning (ML), om echte kijkers van advertenties te bepalen. Proof of View slaat deze gegevens vervolgens op de blockchain op, op onze op maat gemaakte sidechain, VeraChain, zodat adverteerders en uitgevers hun campagnes kunnen controleren.</p>
<p>Het tweede technologiestuk, Rewarded Video, gepatenteerd in de VS, omvat alle vormen van beloonde video’s waarbij gebruikers beloningen worden aangeboden, zoals in-game valuta of andere voordelen, voor het bekijken van video’s, inclusief die mogelijk advertenties bevatten. Alleen al in de VS wordt verwacht dat de uitgaven voor beloonde video’s tegen 2024 zullen groeien tot $4,2 miljard, en volgens Statista zal het grootste deel hiervan worden in ruil voor in-game valuta. Ons patent voor Rewarded Video stelt ons in staat om onze oplossing te verkopen, of licentiekosten te vragen, voor onze Rewarded Video-methode en -systeem via licentieovereenkomsten, waardoor een nieuwe inkomstenstroom voor Verasity wordt geopend.</p>
<h3 id="h3-Q420Welke20partners20en20integraties20hebben20Verasity20en20VeraViews27130"><a name="Q4: Welke partners en integraties hebben Verasity en VeraViews?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q4: Welke partners en integraties hebben Verasity en VeraViews?</h3><p><strong>Elliot</strong> Een van onze belangrijkste samenwerkingen is met Brightcove, een beursgenoteerd bedrijf genoteerd aan NASDAQ. Samen hebben we met succes onze VeraViews advertentiestapel naadloos geïntegreerd in hun enorm populaire videospeler, gebruikt door meer dan 30.000 uitgevers. Deze mijlpaal markeerde een belangrijk moment in de beginfase van onze oplossing en heeft grote uitgevers zoals nieuwsuitgever, The Times of Israel, geholpen om onze technologiestapel te adopteren. Onze strategische relaties strekken zich uit tot de branche-reuzen zoals Amazon, waar we worden erkend als een Amazon Ads Partner. Deze status geeft ons toegang tot de Amazon Ads API en de mogelijkheid om nieuwe prospects te genereren door deelname aan de Amazon Ads Partner Directory. Bovendien heeft onze opname in de IAB Global Vendor List onze banden met enterprise clients verder versterkt. We hebben ook recentelijk de krachten gebundeld met Carbon Browser, een Web3-browser met meer dan 7 miljoen gebruikers, om de integratie van onze gepatenteerde ad-fraudedetectietechnologie, Proof of View (PoV), in de Carbon Browser te verkennen.</p>
<p>In de wereld van crypto hebben we samengewerkt met Alphaday om met succes onze uitgebreide ecosysteembronnen te combineren op één centrale locatie. Deze integratie dient om navigatie te vereenvoudigen, waardoor het voor zowel nieuwkomers als veteranen gemakkelijker wordt om onze aanbiedingen effectief te verkennen en te gebruiken. Bovendien heeft onze samenwerking met DAMEX, een toonaangevende Digitale Asset Finance Applicatie, ons in staat gesteld de VeraCard te lanceren. Deze veelzijdige debetkaart is ontworpen om naadloze online en in-store transacties te vergemakkelijken, waarbij gebruik wordt gemaakt van onze ecosysteemeigen token, VRA. De VeraCard stelt gebruikers niet alleen in staat om gemakkelijk aankopen te doen, maar maakt ook soepele on-en-off-ramp operaties mogelijk, waardoor de bruikbaarheid en praktische toepassing van VRA binnen ons ecosysteem verder worden verbeterd.</p>
<h3 id="h3-Q520Kun20je20praten20over20jullie20recente20Warchest20token20verbranding20en20jullie20tokenomics20roadmap568184"><a name="Q5: Kun je praten over jullie recente Warchest token verbranding en jullie tokenomics roadmap?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q5: Kun je praten over jullie recente Warchest token verbranding en jullie tokenomics roadmap?</h3><p><strong>Elliot</strong>: De Warchest-tokens, in totaal 10 miljard VRA, zijn verbrand vanwege feedback van onze tokenomics-communityraadpleging in het tweede kwartaal van 2023. De Warchest werd aanvankelijk geslagen voor mogelijke overnames en strategische groei, maar met VeraViews die een omzetstadium bereikt en een bewezen pad naar commerciële adoptie heeft, werd de Warchest niet langer noodzakelijk geacht.</p>
<p>Daarnaast worden er 90 miljard PoV Marker-tokens uitgegeven op hetzelfde contract als de circulerende VRA en worden ze gebruikt voor gegevensoverdrachtsdoeleinden om de VeraViews-ad-stack van stroom te voorzien. Ze dragen niet bij aan de circulerende voorraad. Ze zijn echter geïdentificeerd als het uitoefenen van druk op de tokenomics van Verasity, wat van invloed is op het vertrouwen van nieuwe investeerders en verwarring veroorzaakt rond de functionaliteit van het aanmaken en verbranden. Door ze naar een aparte blockchain te verplaatsen, zouden deze problemen kunnen worden verlicht. We ueren actief verschillende blockchain-oplossingen en betrekken experts op dit gebied, evenals onze community, voor hun inzichten.<br><img src="https://gimg2.gateimg.com/image/article/17016802184.jpeg" alt=""><br>Om dit besluitvormingsproces te ondersteunen, hebben we een tweede consultatiefase gelanceerd, waarbij we feedback vragen van zowel professionals uit de industrie als onze tokenhouders om ons te helpen bij het selecteren van de meest geschikte laag 1 blockchain voor de PoV Marker tokens.</p>
<div class="blog-details-info"><br><div>Auteur: <strong>Rio Fu.</strong>, Gate.io-gemeenschap<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 voor op dit artikel. Het opnieuw plaatsen van het artikel is toegestaan op voorwaarde dat Gate.io wordt vermeld. In alle glen zullen juridische stappen worden ondernomen wegens auteursrechtinbreuk.<br></div><p></p><br></div></div></div>