R2F0ZS5pbyBBTUEgY29uIERlcnBERVgtVHJhZGUsIGd1YWRhZ25hLCBzdGFrYSBlIGxhbmNpbyBjcmlwdG92YWx1dGUgY29uIGlsIG1pZ2xpb3IgREVYIHN1IGludGVybmV0

<p><img src="https://gimg2.gateimg.com/image/article/17010635701.jpeg" alt=""><br><strong>Ora: 23 novembre 2023, 13:00 UTC</strong><br><strong><a href="https://www.gate.io" target="_blank">Gate.io</a> ha ospitato una sessione AMA (Ask-Me-Anything) con Iamderp, Chief Derp Officer e Derpina, responsabile marketing di DerpDEX nel <a href="https://t.me/gateio" rel="nofollow noopener noreferrer" target="_blank">Comunità di scambio Gate.io</a>.</strong><br><strong>Sito Web Ufficiale: <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>Segui DerpDEX su <a href="https://t.me/derpdex" rel="nofollow noopener noreferrer" target="_blank">Telegram</a> e <a href="https://twitter.com/DerpDEXcom" rel="nofollow noopener noreferrer" target="_blank">Twitter</a></strong><br><strong>Ospiti</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 —Responsabile Marketing</strong></p>
<h2 id="h2-QampA20da20Gateio952188"><a name="Q&amp;A da Gate.io" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q&amp;A da Gate.io</h2><h3 id="h3-Q120Cos20DerpDEX745704"><a name="Q1: Cos’è DerpDEX?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q1: Cos’è DerpDEX?</h3><p><strong>Derpina</strong>: La visione di DerpDEX è quella di diventare il principale DEX di liquidità centralizzata, con un ecosistema DeFi integrato su reti L2 come zkSync, Base e opBNB, offrendo un’eccellente performance per trader, fornitori di liquidità e nuovi progetti rilasciati per fornire strumenti di infrastruttura DeFi integrati. “Meme + Ecosistema DEX”</p>
<p>Principali punti salienti del progetto:<br>💥 Un token incentrato sui meme per la comunità web3<br>💥 Algoritmo AMM di creazione di mercato di liquidità centralizzata UniV3 su chain L2<br>💥 Economia del token $DERP con funzioni di deflazione, riacquisto e distruzione del token<br>💥 Team esperto in DeFi, degens, trader e sviluppatori provenienti da ex-JPM, ex-SCB, ex-Spartan VC e altri<br>💥 Sviluppato da DWF Labs e sottoposto a verifica di sicurezza da parte di MetaTrust Labs.<br><img src="https://gimg2.gateimg.com/image/article/17010639234.jpeg" alt=""><br>Iamderp: Fondamentalmente, DerpDEX è un meme-DEX su catene L2 (zkSync, Base, opBNB) con launchpad, ecosistema e altro.</p>
<ol>
<li>Ricorda, i meme esistono sia in un mercato rialzista che ribassista.</li><li>Perché cercare token meme quando puoi acquistare meme da DerpDEX launchpad? Tariffe gas più economiche e assegnazione whitelist</li><li>I meme sono qui per restare. Pensate al prossimo-PEPE, al prossimo-SHIBA, al prossimo-FLOKI.</li><li>Il token DERP su DerpDEX è il prossimo token meme 100x!</li></ol>
<h3 id="h3-Q220Qual2020il20motivo20per20cui20si2020scelto20di20essere20un20tipo20di20DEX20focalizzato20sui20meme20in20primo20luogo20Quali20opportunit20vedete20nel20mercato20e20in20che20modo20DerpDEX20si20distingue140007"><a name="Q2: Qual è il motivo per cui si è scelto di essere un tipo di DEX focalizzato sui meme in primo luogo? Quali opportunità vedete nel mercato e in che modo DerpDEX si distingue?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q2: Qual è il motivo per cui si è scelto di essere un tipo di DEX focalizzato sui meme in primo luogo? Quali opportunità vedete nel mercato e in che modo DerpDEX si distingue?</h3><p><strong>Derpina</strong>: DerpDEX si concentra sulla narrazione dei meme, costruisce il DEX competitivo con innovazione e ecosistema intorno alle comunità di meme che lanciano e scambiano come 1-clic-per-lanciare-meme, meme bot, launchpad, ecc.</p>
<p>Ecco le principali intuizioni che abbiamo scoperto nella nostra esperienza nella costruzione e commercializzazione di token meme:</p>
<ol>
<li>C’è un vuoto nel mercato soprattutto su L2, dove è principalmente un gioco di VC ed è solo un gioco di volume senza i benefici effettivi per gli utenti per scambiare, fare qualche $ e godersi un ambiente migliore per il commercio di nuovi token.</li></ol>
<p>Ad esempio, i nostri concorrenti su zkSync, i primi 3 DEX più grandi, TVL e volume di trading sono principalmente concentrati su ETH e stablecoin. Come incoraggerà questo gli utenti effettivi a fare trading e acquistare nuovi token? Solo trading di stablecoin? Nessun profitto da guadagnare!</p>
<ol>
<li>Secondo noi, il Layer 2 sarà il catalizzatore per la corsa al rialzo, dove otterranno la maggior parte della TVL, della crescita e del volume di trading. Questo è simile alla precedente corsa al rialzo, in cui si può vedere tutta la liquidità, il volume di trading e le attività che si sono concentrate presso 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">Valanga</a>, e <a href="/price/terra-luna" rel="nofollow noopener noreferrer" target="_blank">Terra</a>. Crediamo che L2 sia il luogo in cui si verificherà la prossima crescita l’anno prossimo.</li><li>I MEME saranno presenti indipendentemente che si tratti di un mercato rialzista o ribassista. Nel precedente mercato rialzista c’erano SHIBA, FLOKI e DOGE. Nel mercato ribassista attuale ci sono “PEPE”, “BITCOIN” e “MEME” lanciati 10 giorni fa. I meme fanno parte del <a href="/web3" target="_blank" class="blog_inner_link">web3</a> e sono qui per restare.</li></ol>
<p>Crediamo che DerpDEX si inserisca perfettamente in questa narrazione e abbia una GRANDE opportunità di colmare le lacune!</p>
<p>Inoltre, SE visiti DerpDEX, puoi vedere che ci impegniamo a creare la nostra personalità. Rendilo divertente. Facile da usare. Crea la nostra identità. NON solo copia e incolla da un altro DEX.</p>
<p>Crediamo che avere un’identità del genere ci dia un vantaggio in termini di esperienza utente e fidelizzazione. UX al primo posto!</p>
<p><strong>Iamderp</strong> Abbiamo capito che i meme continueranno a far parte dell’identità web3.</p>
<ol>
<li>Nell’ultimo rally dei tori, c’erano DOGE, SHIBA, FLOKI. Tutti sono diventati meme token di &gt;$10 miliardi. Nessun scopo. Solo divertimento.</li><li>In questo anno, il mercato dell’orso, c’era PEPE, ‘BITCOIN’. e MEME (e BRC20, GROK e altro), che è stato lanciato negli ultimi 6 mesi.</li><li>Quindi, i meme sono qui per restare. MA è molto difficile trovare meme prima degli altri e DOPO che ha pompato 10 volte.</li><li>COSA ACCADREBBE se potessi trovare questi prossimi meme token prima del lancio su DerpDEX?</li><li>E costi del gas più bassi per acquistarli? $0.01 di commissioni di gas invece di acquistare da <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a>($100/tariffe gas). È pazzesco.</li><li>E DERP token è il token nativo su DerpDEX.</li><li>SE non puoi selezionare, acquistare e conservare 100 meme-token, perché non detenere il token DERG, ovvero il token dell’ecosistema DerpDEX?!</li><li>Quindi, il token DERP è un meme-token. E viene fornito con un DEX + launchpad + utilità + ecosistema!</li></ol>
<h3 id="h3-Q320Che20tipo20di20sforzo20ha20fatto20DerpDEX20per20creare20un20ottimo20prodotto20per20gli20utenti57698"><a name="Q3: Che tipo di sforzo ha fatto DerpDEX per creare un ottimo prodotto per gli utenti?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q3: Che tipo di sforzo ha fatto DerpDEX per creare un ottimo prodotto per gli utenti?</h3><p><strong>Derpina</strong>: Amo la domanda, abbiamo sicuramente dato molto pensiero a questo!</p>
<p>DerpDEX è costruito con il nostro cuore (non solo copia e incolla da <a href="/price/uniswap-uni" rel="nofollow noopener noreferrer" target="_blank">Uniswap</a>). SE visiti il sito web di DerpDEX ed esplori tutti i prodotti, il branding, il design, l’UI, l’UX. Saprai che abbiamo messo molto impegno per renderlo più interessante e migliore per l’esperienza dell’utente.</p>
<p>Ma per spiegarlo:</p>
<ol>
<li>Abbiamo costruito DerpDEX per rendere il trading il più fluido possibile e anche per guadagnare. Ad esempio, abbiamo lanciato uno strumento chiamato “zap-to-earn”. Zap-to-earn consente agli utenti di scegliere solo 1 token; ad esempio USDT, USDC o ETH/ <a href="/price/bnb-bnb" rel="nofollow noopener noreferrer" target="_blank">BNB</a>, per trasformarlo facilmente in LP e scommetterlo per guadagnare commissioni LP e vantaggi dell’agricoltura. Controlla <a href="https://mirror.xyz/0x44776D7E55e9D4502c3e082211e6c8B2630753bf/xFsdpRNEunCMN__xElF51p9QCrLAVVmALw2t6Ha6gGE" rel="nofollow noopener noreferrer" target="_blank">https://mirror.xyz/0x44776D7E55e9D4502c3e082211e6c8B2630753bf/xFsdpRNEunCMN__xElF51p9QCrLAVVmALw2t6Ha6gGE</a></li><li>Aggiungiamo anche alcuni elementi divertenti allo swap, aggiungendo liquidità, rimuovendo liquidità e altro. Questi sono meme e sono divertenti per i degen. Continueremo a migliorare nel tempo la nostra interfaccia utente e l’esperienza utente.</li></ol>
<p>Lasciami continuare:</p>
<ol>
<li>Abbiamo scelto anche L2 per una ragione. L1 come <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> e BSC sono ancora costosi per gli utenti normali. Sai che su opBNB, uno scambio è il 90% più economico rispetto a <a href="/price/pancakeswap-cake" target="_blank" class="blog_inner_link">Pancakeswap</a> su BSC? È inferiore a 0,001 per uno scambio su DerpDEX opBNB.</li><li>E nel nostro programma, intendiamo creare un’app mobile per DerpDEX per rendere facile per i degen scambiare meme-coin, entrare in meme-launchpad IDO, ecc.</li></ol>
<p>C’è di più:</p>
<ol>
<li>Nel nostro futuro piano di sviluppo, quando DerpDEX lancerà la propria rollup L2, opDERP, potremo anche utilizzare i token DERP per pagare le commissioni di gas, eliminando così la necessità che gli utenti abbiano <a href="/price/bnb-bnb" target="_blank" class="blog_inner_link">BNB</a> o ETH per pagare le commissioni di gas. Le Dapp costruite su opDERP possono utilizzare DERP per pagare le commissioni di gas per conto dell’utente con “Account Abstraction erc-4337”</li><li>MA soprattutto, DERP deve avere un volume di trading sufficiente, liquidità e un grande limite di mercato come il token MEME ora. &gt;$1 miliardo di limite di mercato. Ciò attirerà fiducia e fiducia per gli sviluppatori e i trader per costruire sulla catena opDERP in futuro.</li></ol>
<p><strong>Iamderp</strong>: Il nostro DerpDEX è costruito con cuore e sforzo del nostro designer. Non ci limitiamo a copiare e incollare. Se visiti DerpDEX, vedrai che l’interfaccia utente e l’esperienza utente sono davvero personalizzate e su misura per degens e cacciatori di meme.</p>
<p>E in cima a tutto ciò, abbiamo diverse grandi innovazioni.</p>
<ol>
<li>“zap-to-earn”. Questo è un passaggio per aiutare gli utenti a mettere i loro $ nei pool LP su derpdex e guadagnare commissioni di trading e anche rendimento.</li><li>Abbiamo anche introdotto un programma di “upcoming yield booster” per creare utilità per i token DERP. Proprio come CAKE su Pancakes Wap.</li></ol>
<p>Provalo tu stesso su derpdex.com</p>
<h3 id="h3-Q420Puoi20parlare20della20potenziale20pressione20di20vendita20e20di20come20hai20strutturato20la20tua20tokenomica20per20ridurla20nel20breve20e20lungo20termine939981"><a name="Q4: Puoi parlare della potenziale pressione di vendita e di come hai strutturato la tua tokenomica per ridurla nel breve e lungo termine?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q4: Puoi parlare della potenziale pressione di vendita e di come hai strutturato la tua tokenomica per ridurla nel breve e lungo termine?</h3><p><strong>Iamderp</strong>: Abbiamo molti sforzi per i casi d’uso dei token DERP!</p>
<p>Gli utenti possono detenere e impegnare DERP per godere di questi vantaggi!</p>
<ol>
<li>Assegnazione di whitelist per il lancio del launchpad Initial Derp Offering (IDO),</li><li>Votazione di snapshot per l’allocazione dell’APR% del booster di rendimento agricolo,</li><li>Distribuzione dei guadagni del protocollo per xDERP (in arrivo),</li><li>Anteprima dei prodotti in versione beta; ad esempio, segnali di meme-bot con intelligenza artificiale (in arrivo), e altro ancora.</li></ol>
<p>MA MA MA!</p>
<p>Ricorda, DERP è una meme-coin. + utilità + DEX + launchpad + ecosistema.</p>
<p>PERCHÉ siamo migliori degli altri token meme?</p>
<ol>
<li>Hai visto qualche caso d’uso effettivo per DOGE, FLOKI, PEPE o MEME token?</li><li>Tutte queste meme-coin non hanno alcuna utilità e sono solo divertenti!</li></ol>
<p>E!</p>
<ol>
<li>Il token DERP ha così tanti casi d’uso! Oltre ad essere una moneta meme DERP!</li><li>E DERP è solo $10m mentre MEME è $2b!</li><li>FLOKI era di $3 miliardi nel 2021 mentre DERP è di $10 milioni. Gemma con un potenziale di 300x!</li></ol>
<h3 id="h3-Q520Ora20che20DERP2020stato20lanciato20quali20sono20i20piani20e20lo20sviluppo20futuro20del20progetto217774"><a name="Q5: Ora che $DERP è stato lanciato, quali sono i piani e lo sviluppo futuro del progetto?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q5: Ora che $DERP è stato lanciato, quali sono i piani e lo sviluppo futuro del progetto?</h3><p><strong>Derpina</strong>: Il token $DERP è stato lanciato due giorni fa su CEX e DEX, inclusa Gate.io.<br>La quotazione di $DERP è solo l’inizio e crea una grande piattaforma per il progetto per iniziare a lavorare sulle cose che ci siamo impegnati a consegnare!</p>
<p><strong>Iamderp</strong>: Abbiamo molti piani e roadmap per il 2024!</p>
<ol>
<li>Piattaforma di lancio per i token meme! Stakea il tuo DERP per ottenere l’allocazione nella whitelist</li><li>Meme-signal bot con intelligenza artificiale. Scopri nuovi token meme prima di tutti gli altri.</li><li>App mobile. Per rendere facile agli utenti al dettaglio acquistare i token meme in movimento! Anche quando sei in bagno!</li><li>Derp chain! Immagina un ecosistema DERP con tutti i meme token!</li><li>Meme-grant per artisti emergenti per lanciare il proprio meme!<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>Autore: <strong>Rio Fu.</strong>, Comunità di Gate.io<br><div class="info-tips"><em>Questo articolo rappresenta solo le opinioni del ricercatore e non costituisce alcun suggerimento di investimento.<br></em><div><em></em>Gate.io si riserva tutti i diritti su questo articolo. Sarà consentito ripubblicare l'articolo a condizione che venga menzionato Gate.io. In tutti i casi, saranno intraprese azioni legali a causa di violazioni del copyright.<br></div></div></div></div></li></ol>