RGVnZW4gQ2hhaW4gdmVyYnJpanplbHQgZGUgRXRoZXJldW0tZWNvc3lzdGVlbXJlY29yZHMgbWV0IGVlbiBvbmdla2VuZGUgVFBTLXNuZWxoZWlkOiBlZW4gZGllcGUgZHVpayBpbiB6aWpuIGVjb25vbWlzY2hlIGJydWlrYmFhcmhlaWQgZW4gc2NoYWFsYmFhcmhlaWQ=

2024-05-09, 02:06

<p><img src="https://gimg2.gateimg.com/image/article/1715219937rdzz.jpeg" alt=""></p>
<h2 id="h2-TL20DR513449"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p>Tussen 18 en 19 april registreerde de Degen Chain 37,12 transacties per seconde.</p>
<p>Sommige cryptodeskundigen hebben gewaarschuwd om niet te vertrouwen op het TPS-telling van een blockchain bij het ueren van de prestaties van een cryptocurrency.</p>
<p>De prijs van de Degen-token schommelt de afgelopen twee weken tussen $0,02 en $0,04.</p>
<h2 id="h2-Introductie999529"><a name="Introductie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introductie</h2><p>Memecoins zijn een van de dominante crypto-assetklassen geworden. Op dit moment hebben Memecoins een totale marktkapitalisatie van $51,1 miljard, wat hun groeiende populariteit onder de cryptogemeenschap laat zien. Het goede is dat er elk jaar nieuwe Memecoins op de markt komen. Er is echter een recente trend ontstaan in de Memecoin-sector. De ontwikkelaars van deze tokens voegen er nut aan toe.</p>
<p>In dit artikel onderzoeken we hoe de Degen blockchain <a href="https://www.gate.io/learn/articles/how-to-get-started-with-the-degen-eco-a-step-by-step-guide-to-operating-it/2555" target="_blank">ondersteunt de $DEGEN-token</a> die bestaat op de <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Netwerk. We zullen ook de prestaties van DEGEN en <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> vergelijken. Ten slotte zullen we kijken naar de <a href="https://www.gate.io/learn/articles/degen-on-base-network-dont-call-it-memecoin/2454" target="_blank">oorzaken van de populariteit van Degen onder cryptoliefhebbers</a>.</p>
<h2 id="h2-Indrukwekkende20prestatie20van20Degen20in202024410087"><a name="Indrukwekkende prestatie van Degen in 2024" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Indrukwekkende prestatie van Degen in 2024</h2><p>Degen Chain, een Ethereum-laagnetwerk, registreerde het hoogste aantal transacties per seconde (TPS) binnen het Ethereum-ecosysteem gedurende de periode van 18 tot 19 april. De TPS van Degen Chain steeg met ongeveer 68,56% tot een indrukwekkende 37,12, waarmee het die van Base, een van de toonaangevende schaalbaarheidsoplossingen op het Ethereum-netwerk, overtrof, die in dezelfde periode een TPS van 30,81 bereikte.</p>
<p><a href="https://l2beat.com/scaling/activity" rel="nofollow noopener noreferrer" target="_blank">De LBEAT-gegevens tonen aan</a> dat de Degen Chain meer dan 3,2 miljoen transacties heeft verwerkt binnen de periode van 24 uur. De volgende tabel vat de prestaties van Degen Chain en de andere toonaangevende blockchains samen die gebaseerd zijn op het Ethereum-netwerk.<br><img src="https://gimg2.gateimg.com/image/article/17152200771.jpeg" alt=""><br>ETH TPS Record <a href="https://l2beat.com/scaling/activity" rel="nofollow noopener noreferrer" target="_blank">L2BEAT</a></p>
<p>Zoals te zien is in de bovenstaande tabel, presteerde Degen Chain beter dan andere toonaangevende blockchains zoals zkSync Era, Arbitrum Orbit en Ethereum. Opmerkelijk is dat Degen Chain in de afgelopen 30 dagen in totaal 43,41 miljoen transacties heeft verwerkt en daarmee de vierde beste blockchain is op dit gebied, achter Base, Linea en Arbitrum Orbit.</p>
<p>Er is geen twijfel dat de Degen Chain, een ultra-low-cost layer 3 blockchain die gebruik maakt van Arbitrum Orbit en Base’s settlement layer voor schaalbaarheid, zich competitief heeft gepositioneerd in de blockchain sector. Op dezelfde manier behaalde de blockchain gedurende de genoemde periode van 24 uur een handelsvolume van meer dan $819.600.</p>
<h2 id="h2-Vergelijking20met20de20transactiewaarden20van20Ethereum20en20Base440628"><a name="Vergelijking met de transactiewaarden van Ethereum en Base" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Vergelijking met de transactiewaarden van Ethereum en Base</h2><p>Hoewel Degen schaalbaar is vanwege het hoge aantal transacties per seconde (TPS), tonen de andere metingen aan dat Base en Ethereum het beter doen op andere metingen.</p>
<p>Bijvoorbeeld, gedurende de aangehaalde periode had Degen slechts een handelsvolume van $788.813, wat een gemiddelde transactiewaarde van ongeveer $0,24 geeft. Daarentegen hadden Ethereum en Base hogere gemiddelde transactiewaarden van respectievelijk $172 en $2.166. Dit contrast onthult een zwakte van de Degen Chain. De volgende tabel vergelijkt de prestaties van Degen Chain en de andere toonaangevende netwerken.<br><img src="https://gimg2.gateimg.com/image/article/17152201242.jpeg" alt=""><br>Bron: <a href="https://twitter.com/syndicateio/status/1781004490302480607/photo/1" rel="nofollow noopener noreferrer" target="_blank">x.com</a></p>
<p>Zoals je kunt zien op de afbeelding, hadden Degen Chain en Immutable X een hoger percentage toename qua TPS-telling gedurende de genoemde periode. Iets anders dat het vermelden waard is, is dat de Degen Chain, met een marktkapitalisatie van $345 miljoen, op 19 april $4,1 miljoen aan totale waarde had vergrendeld.</p>
<h2 id="h2-Kritiek20op20de20TPSmetris15021"><a name="Kritiek op de TPS-metris" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Kritiek op de TPS-metris</h2><p>Hoewel de TPS-metriek veel wordt gebruikt in de cryptosector, hebben sommige experts gewaarschuwd voor een te grote afhankelijkheid ervan. Het belangrijkste zwakke punt is dat het geen rekening houdt met de computationele omvang van elke transactie. Cointelegraph citeerde Steven Goldfeder, een oprichter bij Offchain Labs. <a href="https://cointelegraph.com/news/degen-chain-l3-tops-transaction-tps-charts-ethereum-eco" rel="nofollow noopener noreferrer" target="_blank">zoals gezegd</a>, “<br><strong>Het gebruik van TPS is een beetje zoals het tellen van het aantal bankbiljetten in je portemonnee, maar zonder rekening te houden met het feit dat sommige enkele biljetten zijn, sommige twintigjes en sommige honderdjes.</strong>.”</p>
<p>Hier benadrukt Goldgeder dat wanneer we de prestaties van blockchain vergelijken, het niet alleen een kwestie is van een hoog aantal transacties per seconde; we moeten ook de kwaliteit van de transacties ueren.</p>
<h2 id="h2-De20populariteit20van20de20DEGEN20Token20en20Degen20Chain591874"><a name="De populariteit van de DEGEN Token en Degen Chain" class="reference-link"></a><span class="header-link octicon octicon-link"></span>De populariteit van de DEGEN Token en Degen Chain</h2><p>Zoals hierboven aangegeven, is een van de belangrijkste redenen waarom de Degen-token erg populair is, de economische functionaliteit die het biedt aan de Farcaster. Op dit gedecentraliseerde sociale mediaplatform is het een fooitjestoken. Op dezelfde manier, toen de ontwikkelaars een airdrop lanceerden naar de gemeenschapsleden van Degen die ook deel uitmaakten van de Base en Farcaster ecoen, <a href="https://www.gate.io/learn/articles/how-to-get-started-with-the-degen-eco-a-step-by-step-guide-to-operating-it/2555" target="_blank">de populariteit van DEGEN nam toe</a>.</p>
<p>Farcaster staat bekend om Frames, een functie waarmee ontwikkelaars interactieve mini-apps kunnen maken met behulp van de app Warpcast. De mini-apps stellen ontwikkelaars in staat om deel te nemen aan activiteiten zoals het spelen van spelletjes, het maken van NFT’s en het doen van transacties zonder het Farcaster-ecosysteem te verlaten. DEGEN is een utility-token dat wordt gebruikt als betaalmiddel bij interactie met deze mini-apps.</p>
<p>Daarnaast wordt de DEGEN-token gebruikt om Farcaster-communityleden te belonen voor hun actieve betrokkenheid op het platform. Sommige communityleden belonen inhoudmakers, mini-app-bouwers en andere actieve gebruikers door middel van fooien.</p>
<p>Naast het zijn van een fooitjestoken, kunnen investeerders ook deelnemen aan het liquiditeitsdelvingsprogramma. Volgens <a href="https://cointelegraph.com/news/degen-chain-l3-tops-transaction-tps-charts-ethereum-eco" rel="nofollow noopener noreferrer" target="_blank">Cointelegraph publicatie</a>, Thomas Tang, de vice-president van investeringen Ryze Labs- crypto venture capital bedrijf- schrijft de populariteit van de Degen Memecoin toe aan het nut ervan in het Farcaster-ecosysteem. Hij <a href="https://cointelegraph.com/news/degen-chain-l3-tops-transaction-tps-charts-ethereum-eco" rel="nofollow noopener noreferrer" target="_blank">zei</a>, “Het heeft enorme populariteit gekregen omdat iedereen elkaar fooien geeft en iedereen het vasthoudt,”</p>
<p>Ten tweede heeft DEGEN geprofiteerd van de <a href="https://www.gate.io/learn/articles/degens-impact-on-memecoin-eco/2589" target="_blank">netwerkeffect met betrekking tot de memecoins</a>. Zoals u weet, is de Degen-token een van de Memecoins die nut heeft vanwege zijn functionaliteiten, zoals het ondersteunen van min-apps op de ketting. Al crypto-luminaries zoals Vitalik Buterin, mede-oprichter van Ethereum, hebben opgeroepen tot de ontwikkeling en promotie van meme-munten die nut hebben.</p>
<p>In dit opzicht, <a href="https://vitalik.eth.limo/general/2024/03/29/memecoins.html" rel="nofollow noopener noreferrer" target="_blank">Buterin zei</a> Ik wil graag meer hoogwaardige leuke projecten zien die positief bijdragen aan het ecosysteem en de wereld om hen heen (en niet alleen maar door het ‘binnenbrengen van gebruikers’) krijgen meer aandacht.</p>
<p>“Op zijn minst meer goede Memecoins dan slechte, idealiter diegenen die openbare goederen ondersteunen in plaats van alleen insiders en makers te verrijken. Maar ook idealiter het maken van games in plaats van munten, en het maken van projecten waar mensen graag aan deelnemen.” Degen en BONK zijn twee voorbeelden van Memecoins die nut hebben.</p>
<h2 id="h2-Prijsprestaties20van20de20DEGENtoken209429"><a name="Prijsprestaties van de DEGEN-token" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Prijsprestaties van de DEGEN-token</h2><p>Op dit moment wordt DEGEN verhandeld tegen $0,02634, met een marktkapitalisatie van $327.198.024, na een verlies van 8,6% in de afgelopen 24 uur. De prijs van Degen is echter met 39,8% gestegen in de afgelopen 30 dagen. Het is belangrijk om te beseffen dat sinds 11 april de prijs van het Degen-token schommelt tussen $0,02 en $0,04, zoals blijkt uit de volgende grafiek.<br><img src="https://gimg2.gateimg.com/image/article/17152203103.jpeg" alt=""><br>Degen Token Eén-Maand Prijs Grafiek – <a href="https://www.coingecko.com/en/coins/degen-base" rel="nofollow noopener noreferrer" target="_blank">CoinGecko</a></p>
<p>Wat ook het vermelden waard is van <a href="/price/the-graph-grt" rel="nofollow noopener noreferrer" target="_blank">De Grafiek</a> is de neerwaartse curve die de stijgende bearish momentum aangeeft. Het andere interessante feit is dat de token zijn all-time high van $0.058950 bereikte op 31 maart en een all-time low van $0.00002274 op 15 januari. Kijkend naar de toekomst is de marktconditie van Degen neutraal omdat het een RSI-stand van 40,22 heeft.</p>
<p>Desalniettemin is de neutrale marktomstandigheid niet alleen uniek voor Degen, aangezien ETH in dezelfde staat verkeert met een RSI-reading van 45,10. De huidige ETH-prijs is $3.113,47 na een verlies van 4,5% in de afgelopen twee weken. Sommige analytische platforms zoals CoinCodex geven echter aan dat de <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum prijs</a> kan tot het einde van mei vlak blijven zoals het volgende <a href="/price-prediction" rel="nofollow noopener noreferrer" target="_blank">prijsvoorspelling</a> grafiek geeft aan.<br><img src="https://gimg2.gateimg.com/image/article/17152203364.jpeg" alt=""><br>Grafiek voorspelling Ethereum-prijs - <a href="https://coincodex.com/crypto/ethereum/price-prediction/" rel="nofollow noopener noreferrer" target="_blank">CoinCodex</a><br>Zoals je kunt zien op de grafiek, kan de Ethereum prijs van half april tot eind mei fluctueren binnen een nauwe range.</p>
<h2 id="h2-Conclusie46794"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>De Degen Chain registreerde een indrukwekkend aantal transacties per seconde (TPS) tussen 18 en 19 april, waarmee het andere toonaangevende blockchains op het Ethereum-netwerk overtrof. Sommige analisten hebben echter gewaarschuwd dat het onverstandig is om de prestaties van een blockchain te beoordelen op basis van alleen de TPS, omdat dit geen rekening houdt met de rekenkundige omvang van elke transactie.</p>
<h2 id="h2-Veelgestelde20vragen20over20Degen20Chain12840"><a name="Veelgestelde vragen over Degen Chain" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Veelgestelde vragen over Degen Chain</h2><h3 id="h3-Waar20kan20ik20Degen20kopen298271"><a name="Waar kan ik Degen kopen?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Waar kan ik Degen kopen?</h3><p>Je kunt Degen Base kopen op verschillende gecentraliseerde en gedecentraliseerde beurzen zoals Gate.io, Bybit en <a href="/price/uniswap-uni" rel="nofollow noopener noreferrer" target="_blank">Uniswap</a>. Echter, de beste uitwisseling om <a href="https://www.gate.io/how-to-buy/degen-token-dgn" target="_blank">koop Degen Base is Gate.io</a> waar het gekoppeld is aan USDT.</p>
<h3 id="h3-Wat20is20Degen20Token576164"><a name="Wat is Degen Token?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wat is Degen Token?</h3><p>De Degen-token is een ERC20-token dat is gedistribueerd aan de Farcaster-gemeenschap waar het wordt gebruikt om actieve gebruikers en makers een fooi te geven. Aanvankelijk werd Degen gelanceerd op de Ethereum-blockchain, maar nu heeft het zijn eigen blockchain.</p>
<h3 id="h3-Hoe20Degen20Base20te20kopen128520"><a name="Hoe Degen Base te kopen?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Hoe Degen Base te kopen?</h3><p>Je kunt Degen Base eenvoudig kopen op verschillende beurzen zoals Gate.io, Bybit en Uniswap. <a href="https://www.gate.io/how-to-buy/degen--base--degen" target="_blank">Koop Degen Base op Gate.io</a>, open en verifieer uw account. Van daaruit kunt u alle toonaangevende cryptocurrencies omwisselen, zoals <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> en ETH naar Degen.</p>
<h3 id="h3-Hoeveel20is20Degen297383"><a name="Hoeveel is Degen?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Hoeveel is Degen?</h3><p>Op het moment van schrijven is Degen verhandeld tegen $0.02634. Het bereikte echter zijn hoogste punt ooit van $0.058950 op 31 maart en een dieptepunt van $0.00002274 op 15 januari 2024.</p>
<div class="blog-details-info"><br><div>Auteur: <strong> Mashell C. </strong>, Gate.io-onderzoeker<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 zal worden toegestaan mits Gate.io wordt vermeld. In alle glen zullen juridische stappen worden ondernomen vanwege inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div>