R2F0ZS5pbyBBTUEgbWV0IERlcnBERVgtVHJhZGUsIHZlcmRpZW5lbiwgc3Rha2VuIGVuIGNyeXB0byBsYW5jZXJlbiBtZXQgZGUgYmVzdGUgREVYIG9wIGhldCBpbnRlcm5ldA==

<p><img src="https://gimg2.gateimg.com/image/article/17010635701.jpeg" alt=""><br><strong>Tijd: 23 november 2023, 13:00 UTC</strong><br><strong><a href="https://www.gate.io" target="_blank">Gate.io</a> hoste een AMA (Ask-Me-Anything) sessie met Iamderp, Chief Derp Officer en Derpina, Marketingleider van DerpDEX 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://derpdex.com/" rel="nofollow noopener noreferrer" target="_blank">https://derpdex.com/</a></strong><br><strong>Telegram: <a href="https://t.me/derpdex" rel="nofollow noopener noreferrer" target="_blank">https://t.me/derpdex</a></strong><br><strong>Volg DerpDEX op <a href="https://t.me/derpdex" rel="nofollow noopener noreferrer" target="_blank">Telegram</a> en <a href="https://twitter.com/DerpDEXcom" rel="nofollow noopener noreferrer" target="_blank">Twitter</a></strong><br><strong>Gasten</strong><img src="https://gimg2.gateimg.com/image/article/17010638852.jpeg" alt=""><br><strong>Iamderp - Chief Derp Officer</strong><img src="https://gimg2.gateimg.com/image/article/17010638983.jpeg" alt=""><br><strong>Derpina —Marketing Lead</strong></p>
<h2 id="h2-Vraag20en20antwoord20van20Gateio378537"><a name="Vraag en antwoord van Gate.io" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Vraag en antwoord van Gate.io</h2><h3 id="h3-V120Wat20is20DerpDEX651675"><a name="V1: Wat is DerpDEX?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>V1: Wat is DerpDEX?</h3><p><strong>Derpina</strong>: De visie van DerpDEX is om de toonaangevende gecentraliseerde liquiditeit DEX te worden, met een geïntegreerd DeFi-ecosysteem op L2-netwerken zoals zkSync, Base en opBNB, die uitstekende prestaties biedt voor handelaren, liquiditeitsverschaffers en nieuwe projecten die geïntegreerde DeFi-infrastructuurtools willen bieden. “Meme + DEX Ecosysteem”</p>
<p>Belangrijkste hoogtepunten van het project:<br>💥 Een op meme gerichte token voor de web3-gemeenschap<br>💥 UniV3 gecentraliseerde liquiditeitsmarkt makende algoritme AMM op L2-keten<br>💥 $DERP token economie met deflatie en token inkoop en vernietigingsfuncties<br>💥 Ervaren DeFi team, degens, handelaren en bouwers van ex-JPM, ex-SCB, ex-Spartan VC en meer<br>💥 Aangedreven door DWF Labs en beveiligd gecontroleerd door MetaTrust Labs.<br><img src="https://gimg2.gateimg.com/image/article/17010639234.jpeg" alt=""><br>Iamderp: In feite is DerpDEX een meme-DEX op L2-kanalen (zkSync, Base, opBNB) met een lanceerplatform, ecosysteem en meer.</p>
<ol>
<li>Onthoud, memes bestaan ​​zowel in een bull- als een bearmarkt.</li><li>Waarom zou je op zoek gaan naar memetokens als je meme kunt kopen van DerpDEX launchpad? Goedkopere gasvergoedingen en whitelist-toewijzing.</li><li>Memes zijn hier om te blijven. Denk aan de volgende-PEPE, de volgende-SHIBA, de volgende-FLOKI.</li><li>DERP-token op DerpDEX is de volgende 100x meme-token!</li></ol>
<h3 id="h3-Q220Wat20is20de20reden20om20in20de20eerste20plaats20een20DEX20te20zijn20die20zich20richt20op20meme20Welke20kansen20ziet20u20op20de20markt20en20hoe20onderscheidt20DerpDEX20zich619209"><a name="Q2: Wat is de reden om in de eerste plaats een DEX te zijn die zich richt op “meme”? Welke kansen ziet u op de markt en hoe onderscheidt DerpDEX zich?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q2: Wat is de reden om in de eerste plaats een DEX te zijn die zich richt op “meme”? Welke kansen ziet u op de markt en hoe onderscheidt DerpDEX zich?</h3><p><strong>Derpina</strong>: DerpDEX richt zich op het meme-verhaal, bouwt de competitieve DEX met innovatie en ecosysteem rond meme-gemeenschappen die lancering en handel mogelijk maken, zoals 1-klik-om-meme-te-lanceren, meme-bots, launchpad, enzovoort.</p>
<p>Hier zijn de belangrijkste inzichten die we ontdekken in onze ervaring met het bouwen en verhandelen van meme tokens:</p>
<ol>
<li>Er is een kloof in de markt, vooral op L2, waar het voornamelijk een VC-spel is en het alleen een volume spel is zonder daadwerkelijke voordelen voor gebruikers om te handelen, wat geld te verdienen en te genieten van een betere omgeving voor het verhandelen van nieuwe tokens.</li></ol>
<p>Bijvoorbeeld, onze concurrenten op zkSync, de top 3 grootste DEXs, TVL en handelsvolume zijn voornamelijk gericht op ETH en stablecoins. Hoe zal dit daadwerkelijke gebruikers stimuleren om te handelen en nieuwe tokens te kopen? Alleen stablecoins verhandelen? Geen winst te behalen!</p>
<ol>
<li>Naar onze mening zal Layer 2 de katalysator worden voor de stierenloop waar ze de meeste TVL, groei en handelsvolume zullen krijgen. Dit is vergelijkbaar met de vorige stierenloop, waar u kunt zien dat alle liquiditeit, handelsvolume en activiteiten zijn geroteerd bij BSAC. <a href="/price/polygon-matic" rel="nofollow noopener noreferrer" target="_blank">Polygon</a>, <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a>, <a href="/price/avalanche-avax" rel="nofollow noopener noreferrer" target="_blank">Lawine</a>, en <a href="/price/terra-luna" rel="nofollow noopener noreferrer" target="_blank">Terra</a>. We geloven dat L2 de plaats zal zijn waar de volgende groei volgend jaar zal zijn.</li><li>MEMEs zullen er ook zijn, ongeacht of het een stieren- of berenmarkt is. In de vorige stierenmarkt waren er SHIBA, FLOKI en DOGE. In de huidige berenmarkt zijn er ‘PEPE’, ‘BITCOIN’ en ‘MEME’ gelanceerd 10 dagen geleden. Memes maken deel uit van <a href="/web3" target="_blank" class="blog_inner_link">web3</a> en zullen blijven bestaan.</li></ol>
<p>Wij geloven dat DerpDEX perfect in dat verhaal past en een GROTE kans heeft om de lacunes op te vullen!</p>
<p>Ook als je DerpDEX bezoekt, zie je dat we moeite hebben gedaan om onze persoonlijkheid te creëren. Maak het leuk. Maak het gemakkelijk te gebruiken. Creëer onze eigen identiteit. Niet zomaar kopiëren en plakken van een andere DEX.</p>
<p>We geloven dat het hebben van zo’n identiteit ons een voordeel geeft op het gebied van gebruikerservaring en ‘stickiness’. UX 1e!</p>
<p><strong>Iamderp</strong>: We begrepen dat memes een blijvend onderdeel zullen zijn van de web3-identiteit.</p>
<ol>
<li>In de laatste bull run waren er DOGE, SHIBA, FLOKI. Allemaal werden het meer dan $10 miljard meme token. Geen doel. Gewoon plezier.</li><li>In dit jaar, de berenmarkt, was er PEPE, “BITCOIN”. en MEME (en BRC20, GROK en meer), die in de laatste 6 maanden gelanceerd werden.</li><li>Dus, memes zijn hier om te blijven. MAAR het is erg moeilijk om memes te vinden voordat anderen dat doen en NA het heeft 10x gepompt.</li><li>WAT ALS je deze aankomende memes tokens kunt vinden vóór de lancering op DerpDEX?</li><li>En goedkopere gas kosten om ze te kopen? $0.01 aan gas kosten in plaats van kopen van <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a>($100/gas kosten). Het is gek.</li><li>En DERP-token is de inheemse token op DerpDEX.</li><li>ALS u geen 100 meme-tokens kunt selecteren, kopen en vasthouden? WAAROM dan niet gewoon de DERP-token vasthouden, die de DerpDEX ecosysteemtoken is?!</li><li>Dus, DERP-token is een meme-token. EN het wordt geleverd met een DEX + launchpad + utility + ecosysteem!</li></ol>
<h3 id="h3-Q320Welke20inspanning20heeft20DerpDEX20geleverd20om20een20geweldig20product20voor20gebruikers20te20bouwen954988"><a name="Q3: Welke inspanning heeft DerpDEX geleverd om een geweldig product voor gebruikers te bouwen?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q3: Welke inspanning heeft DerpDEX geleverd om een geweldig product voor gebruikers te bouwen?</h3><p><strong>Derpina</strong>: Ik hou van de vraag, we hebben hier zeker veel over nagedacht!</p>
<p>DerpDEX is gebouwd met ons hart (niet alleen kopiëren en plakken van <a href="/price/uniswap-uni" rel="nofollow noopener noreferrer" target="_blank">Uniswap</a>). Als u de DerpDEX-website bezoekt en alle producten, branding, design, UI en UX verkent, zult u weten dat we veel moeite hebben gedaan om het interessanter en beter te maken voor de gebruikerservaring.</p>
<p>Maar om het uit te leggen:</p>
<ol>
<li>We hebben DerpDEX gebouwd om zo naadloos mogelijk te zijn voor handel en ook verdienen. We hebben bijvoorbeeld een tool gelanceerd genaamd ‘zap-to-earn’. Zap-to-earn stelt gebruikers in staat om gewoon 1 token te kiezen; d.w.z. USDT, USDC of ETH/ <a href="/price/bnb-bnb" rel="nofollow noopener noreferrer" target="_blank">BNB</a>, om gemakkelijk in LP te zappen en het te staken om LP-kosten en landbouwvoordelen te verdienen. Bekijk het eens <a href="https://mirror.xyz/0x44776D7E55e9D4502c3e082211e6c8B2630753bf/xFsdpRNEunCMN__xElF51p9QCrLAVVmALw2t6Ha6gGE" rel="nofollow noopener noreferrer" target="_blank">https://mirror.xyz/0x44776D7E55e9D4502c3e082211e6c8B2630753bf/xFsdpRNEunCMN__xElF51p9QCrLAVVmALw2t6Ha6gGE</a></li><li>We voegen ook wat grappige elementen toe aan de swap, het toevoegen van liquiditeit, het verwijderen van liquiditeit en meer. Dit zijn memes en zijn grappig voor degen. We zullen in de loop van de tijd doorgaan met het verbeteren van onze UI en UX.</li></ol>
<p>Laat me doorgaan:</p>
<ol>
<li>We hebben ook gekozen voor L2 om een reden. L1 zoals <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> en BSC is nog steeds duur voor gewone gebruikers. Wist je dat op opBNB een ruil 90% goedkoper is dan <a href="/price/pancakeswap-cake" target="_blank" class="blog_inner_link">Pancakeswap</a> op BSC? Het kost minder dan 0,001 voor een ruil op DerpDEX opBNB.</li><li>En in onze routekaart zijn we van plan om een mobiele app voor DerpDEX te bouwen om het gemakkelijk te maken voor degenen om meme-coins te verhandelen, in meme-launchpad IDO te stappen, enzovoort.</li></ol>
<p>Er is meer:</p>
<ol>
<li>In onze toekomstige routekaart, wanneer DerpDEX zijn eigen rollup L2 lanceert, opDERP, kunnen we ook DERP-tokens gebruiken om gasvergoedingen te betalen, waardoor de noodzaak voor gebruikers om <a href="/price/bnb-bnb" target="_blank" class="blog_inner_link">BNB</a> of ETH te hebben om gasvergoedingen te betalen, wordt verwijderd. Dapps gebouwd op opDERP kunnen DERP gebruiken om gas te betalen namens de gebruiker met ‘Account abstractie erc-4337’</li><li>MAAR het belangrijkste is dat DERP voldoende handelsvolume, liquiditeit en GROTE marktkapitaal moet hebben zoals MEME-token nu. &gt;$1b marktkapitaal. Dit zal vertrouwen en vertrouwen aantrekken voor bouwers en handelaren om in de toekomst op opDERP-keten te bouwen.</li></ol>
<p><strong>Iamderp</strong>: Onze DerpDEX is gebouwd met hart en de inspanning van onze ontwerper. We kopiëren niet simpelweg en plakken. Als je DerpDEX bezoekt, zie je dat de UI en UX echt op maat gemaakt zijn voor degens en meme-jagers.</p>
<p>En daarbovenop hebben we verschillende geweldige innovaties.</p>
<ol>
<li>“zap-to-earn”. Dit is een 1 stap om gebruikers te helpen hun $ in de LP-pools op derpdex te steken en handelskosten en ook opbrengsten te verdienen.</li><li>We hebben ook een “aankomende opbrengstversterker”-programma geïntroduceerd om nut te creëren voor DERP-tokens. Net als CAKE op Pancakes Wap</li></ol>
<p>Probeer het zelf op derpdex.com</p>
<h3 id="h3-Q420Kun20je20praten20over20mogelijke20verkoopdruk20en20hoe20je20je20tokenomics20hebt20afgestemd20om20dit20op20korte20en20lange20termijn20te20verminderen653297"><a name="Q4: Kun je praten over mogelijke verkoopdruk en hoe je je tokenomics hebt afgestemd om dit op korte en lange termijn te verminderen?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q4: Kun je praten over mogelijke verkoopdruk en hoe je je tokenomics hebt afgestemd om dit op korte en lange termijn te verminderen?</h3><p><strong>Iamderp</strong> We hebben veel inspanningen voor use-cases voor DERP-tokens!</p>
<p>Gebruikers kunnen DERP vasthouden en inzetten om van deze voordelen te genieten!</p>
<ol>
<li>Whitelist-toewijzing voor Initial Derp Offering (IDO) lanceerplatform,</li><li>Snapshot-stemming voor yield booster farming APR% toewijzing,</li><li>Protocol-inkomstendistributie voor xDERP (binnenkort beschikbaar),</li><li>Voorproefje van bètalanceringproducten; bijv. meme-bot signalen met AI (binnenkort beschikbaar), en meer.</li></ol>
<p>MAAR MAAR MAAR!</p>
<p>Onthoud dat DERP een meme-munt is. + nut + DEX + lanceerplatform + ecosysteem.</p>
<p>WAAROM zijn we beter dan andere meme-tokens?</p>
<ol>
<li>Heb je enige daadwerkelijke gebruikstoepassingen gezien voor DOGE, FLOKI, PEPE of MEME-token?</li><li>Al deze meme-munten hebben 0 nut en zijn gewoon LEUK!</li></ol>
<p>EN!</p>
<ol>
<li>DERP-token heeft zoveel gebruiksmogelijkheden! Bovendien is het een DERP-meme-munt!</li><li>En DERP is slechts $10m terwijl MEME $2b is!</li><li>FLOKI was $3b in 2021 while DERP is $10m. 300x potential gem!</li></ol>
<h3 id="h3-Q520Nu20DERP20is20gelanceerd20wat20voor20soort20plan20en20toekomstige20ontwikkeling20heeft20het20project20voor20de20toekomst550962"><a name="Q5: Nu $DERP is gelanceerd, wat voor soort plan en toekomstige ontwikkeling heeft het project voor de toekomst?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q5: Nu $DERP is gelanceerd, wat voor soort plan en toekomstige ontwikkeling heeft het project voor de toekomst?</h3><p><strong>Derpina</strong>: De $DERP-token is twee dagen geleden gelanceerd op CEX en DEX, inclusief Gate.io.<br>Het vermelden van $DERP is slechts het begin en legt een geweldig platform voor het project om te beginnen met werken aan de dingen die we hebben toegezegd te leveren!</p>
<p><strong>Iamderp</strong>: We hebben veel routekaarten en plannen voor 2024!</p>
<ol>
<li>Lanceerplatform voor meme-tokens! Zet je DERP in om een whitelist-toewijzing te krijgen</li><li>Meme-signaalbots met AI. Ontdek nieuwe meme-tokens voordat iedereen ze heeft.</li><li>Mobiele app. Om het voor retailgebruikers gemakkelijk te maken om meme-tokens te kopen tijdens het reizen! Zelfs als je op het toilet zit!</li><li>Derp chain! Stel je een DERP-ecosysteem voor met alle meme-tokens!</li><li>Meme-grant voor opkomende artiesten om hun eigen meme te lanceren!<br><a href="https://derpdex.gitbook.io/home/roadmap-and-launch-plan" rel="nofollow noopener noreferrer" target="_blank">https://derpdex.gitbook.io/home/roadmap-and-launch-plan</a><img src="https://gimg2.gateimg.com/image/article/17010639525.jpeg" alt=""><div class="blog-details-info"><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 beleggingsaanbevelingen.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het opnieuw plaatsen van het artikel zal worden toegestaan mits Gate.io wordt vermeld. In alle glen zal juridische actie worden ondernomen wegens schending van het auteursrecht.<br></div></div></div></div></li></ol>