Z2F0ZUxpdmUgQU1BIFJlY2FwLURhcHBSYWRhcg==

2023-04-20, 06:21
<p><img src="https://gimg2.gateimg.com/image/article/1681971790Blogy.png" alt=""></p>
<h2 id="h2-Wat20is20het20RADARhulpprogramma20en20zijn20er20wijzigingen20gepresenteerd20in20de20recent20bijgewerkte20Whitepaper33875"><a name="Wat is het RADAR-hulpprogramma en zijn er wijzigingen gepresenteerd in de recent bijgewerkte Whitepaper?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wat is het RADAR-hulpprogramma en zijn er wijzigingen gepresenteerd in de recent bijgewerkte Whitepaper?</h2><p><strong>Dragos Dunica (Medeoprichter):</strong><br>De RADAR-token heeft meerdere doeleinden binnen het DappRadar-ecosysteem, met diverse belangrijke toepassingen:</p>
<p>Staking: Staking is fundamenteel voor het DappRadar-ecosysteem en vormt de basis voor product- en tokenomics-elementen. Gebruikers kunnen RADAR-tokens inzetten om toegang te krijgen tot het PRO-lidmaatschap, waarmee geavanceerde functies en voordelen worden ontgrendeld. Staking is ook gekoppeld aan Boosting Power, waarover ik later meer zal uitleggen, en het fungeert als een tokensink en vermindert het circulerende aanbod van RADAR-tokens. In de nieuwe update worden er een paar wijzigingen doorgevoerd waarbij het product rechtstreeks wordt verbonden met de Staking-functie.</p>
<p>PRO-lidmaatschap: DappRadar PRO biedt geavanceerde functies en voordelen aan gebruikers die RADAR-tokens inzetten. Naarmate we het platform blijven ontwikkelen, wordt het PRO-lidmaatschap steeds waardevoller, waardoor gebruikers worden gestimuleerd om hun tokens in te zetten en de token-economie te versterken. Ik kan hier apart op ingaan, omdat het een veel groter onderwerp is.</p>
<p>Boosting Power: Door RADAR-tokens te staken, ontvangen gebruikers Boosting Power om hun favoriete dapps te ondersteunen en hun zichtbaarheid op het platform te vergroten. Deze functionaliteit moedigt belanghebbenden zoals VC’s, marketingbureaus, app-uitgevers, communities en individuele gebruikers aan om RADAR-tokens aan te schaffen en te staken.</p>
<p>Terugkoopprogramma: Om aan de marktvraag naar RADAR-tokens te voldoen, herinvesteert het terugkoopprogramma een deel van de inkomsten van DappRadar in het kopen van RADAR-tokens op de open markt, die vervolgens naar de DAO-schatkist worden gestuurd. Dit initiatief heeft als doel om bredere toegankelijkheid tot DappRadar-producten en -functies te waarborgen zonder potentiële gebruikers of partners te beperken. DappRadar heeft een aantal bestaande inkomstenstromen en we werken nu aan enkele DAO-native mogelijkheden die rechtstreeks bijdragen aan deze functionaliteit.</p>
<p>Governance: RADAR-tokenhouders kunnen de toekomst van de DappRadar DAO en het platform helpen vormgeven. Ze kunnen feedback geven, stemmen over voorstellen of hun eigen voorstellen maken en zo een samenwerkend en gedecentraliseerd ecosysteem bevorderen. Op dit moment hebben we 3 lopende voorstellen en waarschijnlijk een van de belangrijkste, die verband houdt met PRO 2.0 over staking, is nog steeds actief.</p>
<h2 id="h2-Hoe20zal20het20PROlidmaatschap20veranderen20voor20gebruikers20en20brengt20u20PRO20ook20naar20ontwikkelaars743712"><a name="Hoe zal het PRO-lidmaatschap veranderen voor gebruikers en brengt u PRO ook naar ontwikkelaars?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Hoe zal het PRO-lidmaatschap veranderen voor gebruikers en brengt u PRO ook naar ontwikkelaars?</h2><p><strong>Dragos Dunica (Medeoprichter):</strong><br>DappRadar PRO is aanzienlijk geëvolueerd sinds de introductie ervan samen met RADAR in december 2021. In eerste instantie bood het een paar geavanceerde functies die gericht waren op het verbeteren van de bruikbaarheid voor RADAR-houders. We hebben sindsdien meer waarde toegevoegd aan PRO-gebruikers door functies toe te voegen zoals Geavanceerde meldingen, downloadbare gegevens en toegang tot alle slimme contracten van een dapp. Met de aankomende update wordt het PRO-lidmaatschap iets duurder en de enige manier om het te verkrijgen is door RADAR-tokens te staken. Dit komt door een paar redenen: de waarde die PRO-services bieden afstemmen en de token-economie blijven aanpassen om de gewenste vorm te bereiken.</p>
<p>Naast het bestaande PRO-lidmaatschap voor gebruikers introduceren we ‘Premium voor Dapp-ontwikkelaars’, dat anders zal functioneren. Door maandelijks een abonnement te betalen in fiat of crypto, krijgen dapp-ontwikkelaars toegang tot een reeks tools en functies die zijn ontworpen om hen te helpen bij het verwerven van gebruikers, contact te leggen met hun publiek, transparantie te bieden via gegevens, en hun gemeenschap op de hoogte te houden van hun voortgang. We zullen dit concept verder uitwerken in het Whitepaper en blijven nieuwe functies uitrollen in de komende kwartalen.</p>
<p>PRO-lidmaatschap zal meer opvallen op ons platform, gericht op zowel gebruikers als ontwikkelaars die op zoek zijn naar geavanceerdere gegevens, extra functies en een algeheel verbeterde ervaring.</p>
<h2 id="h2-DappRadar20gaat20over20naar20een20DAO20met20RADAR20als20kern20Wat20is20het20proces20hiervoor20en20hoe20zullen20we20dit20zien138360"><a name="DappRadar gaat over naar een DAO, met RADAR als kern. Wat is het proces hiervoor en hoe zullen we dit zien?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>DappRadar gaat over naar een DAO, met RADAR als kern. Wat is het proces hiervoor en hoe zullen we dit zien?</h2><p><strong>Dragos Dunica (Co-founder):</strong><br>De overgang naar een volledig gedecentraliseerde DAO is een geleidelijk en zorgvuldig gepland proces, dat begon in december 2021. We volgen verschillende stappen om een succesvolle overgang te garanderen:</p>
<p>Progressieve decentralisatie: We omarmen community samenwerking en feedback terwijl we werken aan interne processen om meer transparantie en een mindset van ‘werken in het openbaar’ te brengen. Dit is uitdagend omdat het een nieuw niveau van openheid en aanpasbaarheid vereist van onze teamleden. Vermeld juridische en financiële processen (LFG).</p>
<p>Interne leersessies: We leiden ons team op over DAO-operaties, waarbij aspecten als stemvoorstellen, aanwerving, onboarding, teambeheer en het opzetten van efficiënte processen om resultaten te leveren, als DAO aan bod komen.</p>
<p>Gemeenschapsvoorstellen en stemming: We hebben tot nu toe meer dan 10 voorstellen gehad, waarbij we nauw samenwerken met onze gemeenschap om ze vorm te geven en erover te stemmen via Snapshot. We streven ernaar om de betrokkenheid van de gemeenschap bij het maken van voorstellen en het stemmen te vergroten. Transparantie, openbare mindset</p>
<p>Roadmap: Onze routekaart schetst belangrijke initiatieven voor het jaar, waaronder het afronden van de juridische en financiële structuur om te opereren als een DAO in een onzekere omgeving. We zullen ook een ambassadeursprogramma lanceren, een DAO-grondwet publiceren en een raad vormen om progressieve decentralisatie te bevorderen.</p>
<p>Technische ontwikkeling: We zijn van plan om meer van onze codebase open-source te maken en belanghebbenden in staat te stellen rechtstreeks bij te dragen aan de DAO.</p>
<p>Door dit proces te volgen, streven we ernaar een sterke basis te leggen voor onze DAO, met als doel een soepele overgang te garanderen terwijl we actief onze gemeenschap en belanghebbenden betrekken bij het vormgeven van de toekomst van DappRadar.</p>
<h2 id="h2-In20de20routekaart20noemde20je20Buybacks20Kun20je20ons20een20idee20geven20en20een20gedachteproces20erachter75520"><a name="In de routekaart noemde je Buybacks? Kun je ons een idee geven en een gedachteproces erachter?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>In de routekaart noemde je Buybacks? Kun je ons een idee geven en een gedachteproces erachter?</h2><p><strong>Dragos Dunica (Medeoprichter):</strong><br>De introductie van Buybacks in onze roadmap was zeker een weloverwogen beslissing op basis van uitgebreide samenwerking met tokenomics-experts. Ons doel was om alle belangrijke belanghebbenden in het DappRadar-ecosysteem te identificeren, de waarde die ze brengen in kaart te brengen en passende prikkels te ontwerpen om een gezonde economie te waarborgen.</p>
<p>We hebben de tokenomics gemodelleerd om de vraag- en aanbodverhouding te onderzoeken en manieren te vinden om deze in evenwicht te brengen, met als uiteindelijk doel een duurzaam ecosysteem te waarborgen. DappRadar heeft meerdere inkomstenstromen die de operaties en productontwikkeling financieren. Naarmate we nieuwe inkomstenstromen introduceren, zullen sommige DAO-native zijn, wat betekent dat de inkomsten ofwel rechtstreeks naar de DAO-schatkist zullen gaan of zullen worden gebruikt om RADAR-tokens van de markt terug te kopen en naar de DAO-schatkist te sturen.</p>
<p>Ons langetermijndoel is om zoveel mogelijk inkomstenstromen over te zetten naar een vergelijkbaar mechanisme, waarbij het aantal RADAR-tokens dat op de markt wordt gekocht, wordt verhoogd op basis van de totale inkomsten die door DappRadar worden gegenereerd. Dit creëert een directe verbinding tussen het succes van het bedrijf en het token, wat zorgt voor focus en een sterke fundamentele relatie tussen de twee.</p>
<p>Niet alle inkomstenstromen kunnen worden geprijsd in RADAR, en sommige klanten kunnen niet werken met crypto of tokens. In deze glen blijven traditionele methoden zoals banken en fiatvaluta de beste keuze. Het Buyback-programma legt de noodzakelijke verbinding tussen traditionele en crypto-inkomstenstromen, waardoor een meer inclusief en aanpasbaar bedrijfsmodel mogelijk wordt.</p>
<p>Door Buybacks te implementeren, streven we ernaar een sterkere verbinding te creëren tussen het succes van DappRadar en de RADAR-token, terwijl we marktbeperkingen aanpakken en een duurzaam ecosysteem opbouwen.</p>
<div class="blog-details-info"><br><div>Auteur:<strong> GateLive</strong>, Gate.io Team<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 op dit artikel. Het opnieuw plaatsen van het artikel is toegestaan mits er naar Gate.io wordt verwezen. In alle glen zullen juridische stappen worden ondernomen vanwege auteursrechtinbreuk.<br></div><p></p><br></div></div></div>
Share
Content
gate logo
Gate
Trade Now
Join Gate to Win Rewards