QmFzZSBMaW5rIG5lZW10IFNvbCBDaGFpbiBvdmVyLCBpcyBkaXQgZWVuIG5pZXV3ZSByb25kZSB2YW4gTUVNRS1jYXJuYXZhbD8=

2024-04-02, 08:50

<p><img src="https://gimg2.gateimg.com/image/article/1690791857hotspot.jpeg" alt=""></p>
<h2 id="h2-TLDR581963"><a name="[TL;DR]:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL;DR]:</h2><p>Onlangs is er geen twijfel dat Base Chain de hot spot sector heeft overgenomen, met een reeks memes vertegenwoordigd door DEGEN, BRETT, en MFER die een razernij van speculatie veroorzaken.</p>
<p>De reden waarom Base Chain zo populair is, is voornamelijk te wijten aan de verkeersondersteuning van Coinbase en de bruikbaarheid van de portemonnee, evenals de innovatieve DAPP en het gecombineerde effect van een sterke MEME-cultuur en genen.</p>
<p>De basisketen kan potentieel nieuwe MEME en gerelateerde sociale producten voortbrengen en wordt verwacht uit te groeien tot een uniek L2-platform in de <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> ecosysteem.</p>
<h2 id="h2-Kennismaking305886"><a name="Kennismaking" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Kennismaking</h2><p>De recente trend van MEME in de <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> het ecosysteem is beëindigd, terwijl de Base Chain MEME-rage geleidelijk opkomt, wat wijst op een mogelijke overdracht.</p>
<p>Zowel traditionele memes, zoals DEGEN en BRETT, als de opkomende MFER, zijn de laatste tijd snel opgekomen op de markt met een raketachtige stijging, wat enthousiaste aandacht en discussie in de markt heeft aangetrokken. Dit duidt erop dat de Base chain geleidelijk opkomt en een potentiële hotspot wordt voor welvaartsgroei.</p>
<p>Investeerders speculeren of de Base Chain zijn gouden tijdperk ingaat, en dit artikel zal er dieper op ingaan.</p>
<h2 id="h2-De20drie20belangrijkste20mememunten20die20populair20zijn20geworden20DEGEN20BRETT20en20MFER250773"><a name="De drie belangrijkste meme-munten die populair zijn geworden: DEGEN, BRETT en MFER" class="reference-link"></a><span class="header-link octicon octicon-link"></span>De drie belangrijkste meme-munten die populair zijn geworden: DEGEN, BRETT en MFER</h2><p>Het lijkt erop dat elke openbare keten zijn eigen meme creëert om meer verkeer aan te trekken. Echter, gebaseerd op historische ervaring, hebben alleen <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> en <a href="/price/solana-sol" target="_blank" class="blog_inner_link">Solana</a> dit bereikt. Onlangs heeft Base Chain ongetwijfeld de leiding genomen, en een reeks meme coins vertegenwoordigd door DEGEN, BRETT, en MERF hebben voor opwinding gezorgd.</p>
<h3 id="h3-DEGEN20Dogecoin20op20Farcaster739051"><a name="DEGEN: Dogecoin op Farcaster" class="reference-link"></a><span class="header-link octicon octicon-link"></span>DEGEN: <a href="/price/dogecoin-doge" target="_blank" class="blog_inner_link">Dogecoin</a> op Farcaster</h3><p>Als een van de tokenleiders op de Base-keten heeft Degen zijn kernpositie in het ecosysteem aangetoond.</p>
<p>Deze token verscheen aanvankelijk als een MEME-munt, maar is nu getransformeerd tot een functionele token voor het hele ecosysteem, met tal van projecten eromheen gebouwd, waaronder het gebruik ervan voor fooien of als handelsdoelwit.<img src="https://gimg2.gateimg.com/image/article/17120475041.jpg" alt=""><br>Bron: Gate.io</p>
<p>In Farcaster speelt Degen een cruciale rol, het meest populaire sociale toepassingsprotocol op de basischain.</p>
<p>Warpcast, als een officieel product gemaakt door Farcaster, is een kerngebied voor sociale bijeenkomsten op de Base chain, waar projectmarketing en muntuitgifte worden uitgevoerd op zijn platform. In Warpcast’s Degen kanaal kunnen gebruikers Degen-tokenbeloningen ontvangen door actieve gedragingen zoals spreken, waardoor de popularisering en toepassing van Degen in het ecosysteem verder worden bevorderd.</p>
<p>Bovendien hebben DEGEN-munten hun invloed snel uitgebreid door middel van innovatieve airdrop-gameplay (tipping) en nichegemeenschapsverspreiding.</p>
<p>In slechts een paar maanden is de marktwaarde ervan gestegen van $10 miljoen tot $1 miljard, waardoor een verbazingwekkende groei is bereikt.</p>
<h3 id="h3-BRETT20Stripfiguur20met20dezelfde20oorsprong20als20PEPE295368"><a name="BRETT: Stripfiguur met dezelfde oorsprong als PEPE" class="reference-link"></a><span class="header-link octicon octicon-link"></span>BRETT: Stripfiguur met dezelfde oorsprong als PEPE</h3><p>Brett, een karakter uit de strip Boys Club uit 2005, is ook een van de zeer verwachte memes op de Base Chain.</p>
<p>Deze manga werd oorspronkelijk gepubliceerd door Matt Furie op zijn blog en vertelt een reeks spannende verhalen tussen Pepe, een kikker, en zijn drie vrienden, waaronder Brett, die van dans, mode en hoeden houdt.<br><img src="https://gimg2.gateimg.com/image/article/17120475572.jpg" alt=""><br>Bron: Gate.io</p>
<p>Echter, met Pepe die misbruikt wordt als symbool van haat, uitte de oorspronkelijke auteur, Furie, sterke ontevredenheid. Op 6 mei 2017 hield Furie een begrafenis voor Pepe in een andere van zijn stripboeken, “Het Grootste Cartoonkarakter ter Wereld.” Dit stripfiguur, dat honderdduizenden fans had, is ‘overleden’ onder de pen van de maker.</p>
<p>Tegenwoordig zijn Bretts emoji’s niet ongewoon op sociale media, en ze zijn een intuïtieve en duidelijke manier geworden voor mensen om hun emoties uit te drukken. Naarmate emoticons geleidelijk evolueren tot een cultureel fenomeen, wordt het begrip van elk personage geleidelijk vastgesteld, en Brett is daar een van.</p>
<h3 id="h3-MFER206uur20100x20OG20Meme20Coin141952"><a name="MFER: 6-uur 100x OG Meme Coin" class="reference-link"></a><span class="header-link octicon octicon-link"></span>MFER: 6-uur 100x OG Meme Coin</h3><p>Voor beginners op het gebied van NFT is mfer misschien nog een onbekende naam, maar onder ervaren spelers op dit gebied heeft het al een geweldige reputatie opgebouwd.</p>
<p>MFER leidde ooit de NFT-rage naast blue-chipprojecten zoals Azuki en Cool Cats. De promotor erachter, Sartoshi, is een anonieme NFT-verzamelaar en meme-kunstenaar wiens pseudoniem overeenkomsten vertoont met Satoshi Nakamoto, de vader van <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a>.</p>
<p>Echter, toen MFER opkwam, trok Sartoshi zich plotseling terug uit het NFT-veld, wat zorgde voor een schok op de markt. Na een lange stilte keerde hij terug en lanceerde de Memecoin op basis van het Coinbase Layer 2-netwerk Base - MFERCOIN.<img src="https://gimg2.gateimg.com/image/article/17120476063.jpg" alt=""><br>Bron: Gate.io</p>
<p>Nadat deze token werd gelanceerd, werd deze al snel het middelpunt van de markt en vestigde het een record van een 100-voudige stijging binnen 6 uur na opening, waardoor het onlangs een populaire meme-munt werd op de Base-keten.</p>
<h2 id="h2-De20ondersteunende20factoren20voor20de20start20van20de20basisketen773802"><a name="De ondersteunende factoren voor de start van de basisketen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>De ondersteunende factoren voor de start van de basisketen</h2><p>Wij geloven dat de populariteit van Base Chain niet los kan worden gezien van de volgende punten:</p>
<ol>
<li><p>Lage kosten: Sinds Ethereum de Cancun-upgrade heeft voltooid, is de kost van Gas op de basis chain sterk gedaald, wat een basis biedt voor gebruikers om het op grote schaal te gebruiken.</p>
</li><li><p>Volledige ondersteuning van Coinbase: De Base Chain heeft volledige ondersteuning gekregen van Coinbase, wat het enorme fondsen en gebruikersbronnen oplevert. De geïntegreerde AA-portemonnee verlaagt de drempel voor gebruikers om deel te nemen aan on-chain operaties aanzienlijk, en het niet uitgeven van governance-tokens maakt het ook meer in lijn met praktische nalevingsvereisten.</p>
</li><li><p>Toepassingsinnovatie: De toepassingen op de Base-chain zijn innovatief, vooral op sociaal gebied. In vergelijking met andere DeFi-projecten legt de toepassing op de Base-chain meer nadruk op sociale typen en richt het projectteam zich meer op langetermijnopbouw en innovatie.</p>
</li><li><p>sterke MEME-cultuur en genen: de Base Chain deelt vergelijkbare Europese en Amerikaanse culturele kenmerken met Solana, wat leidt tot een reeks zeer verwachte MEME-munten zoals BALD en BRETT vanwege factoren zoals zelfspot, graffiti, cult en fooi. De explosieve prestaties van deze MEME-munten versterken verder de zichtbaarheid en invloed van de Base Chain, waardoor meer gebruikers en fondsen toetreden.</p>
</li><li><p>Actieve gemeenschap en ontwikkelaarsecosysteem: Het toenemende aantal actieve adressen op de Base Chain geeft aan dat de gemeenschap en het ontwikkelaarsecosysteem zeer actief zijn. Dit is natuurlijk te wijten aan de uitgebreide ondersteuning en subsidies die Coinbase biedt aan ontwikkelaars.</p>
</li></ol>
<p>Kortom, de reden waarom Base Chain populair is, is omdat het volledige steun heeft gekregen van Coinbase, innovatieve toepassingen, en het gecombineerde effect van een sterke MEME-cultuur en genen.</p>
<p>Deze factoren maken de Base chain opvallen tussen vele L2’s, zoals blijkt uit gegevens zoals TVL $3.2B, wat op één na alleen Arbitrum overtreft en <a href="/price/optimism-op" rel="nofollow noopener noreferrer" target="_blank">Optimisme</a> op de Basisketen.<img src="https://gimg2.gateimg.com/image/article/17120477014.jpg" alt=""><br>Bron: L2BEAT</p>
<h2 id="h2-Base20Chain20richt20zich20op20het20sociale20domein20rond20MEME478695"><a name="Base Chain richt zich op het sociale domein rond MEME" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Base Chain richt zich op het sociale domein rond MEME</h2><p>Het Meme-project is een ideale keuze geworden voor de ontwikkelingsstrategie van het Base-team vanwege de eenvoudige logica en enorme groeipotentie. In de L2 openbare keten zal militaire concurrentie onvermijdelijk een witheet stadium ingaan, en de populariteit van MEME heeft een belangrijk ticket voor Base veiliggesteld.</p>
<p>Terugkijkend op de cryptocurrency-cyclus van 2020 tot 2022, vertegenwoordigde de totale marktwaarde van Meme eens ongeveer 5% van de totale marktwaarde van cryptocurrency, wat zijn sterke marktpotentieel aantoont. Vooruitkijkend, als de totale marktwaarde van cryptocurrencies tussen 2023 en 2025 6 biljoen yuan bereikt en het marktaandeel van Meme kan toenemen tot 2%, zal de Meme-markt naar verwachting een verbluffende schaal van $120 miljard bereiken.</p>
<p>In deze context zullen DEGEN, BRETT, en andere potentiële MEME-projecten op de Base chain blijven schitteren door meer sociale toepassingen te ondersteunen.<br><img src="https://gimg2.gateimg.com/image/article/17120477345.jpg" alt=""><br>Bron: @degentokenbase</p>
<p>Het is vermeldenswaard dat Meme-projecten op de Base-keten mogelijk unieke voordelen hebben in culturele genen.</p>
<p>In vergelijking met vroege MEME’s zoals Doge, hebben Brett en Pepe brede steun in zowel de Oosterse als de Westerse culturen, wat hun kernconsensuspositie in de menselijke beschaving aantoont. Deze interculturele integratie maakt Meme-projecten op de Base-keten aantrekkelijker en heeft marktpotentie.</p>
<p>We moeten echter ook duidelijk zijn over de huidige ontwikkelingsstatus van de Baseketen. Vergeleken met volwassen ketens zoals Solana hebben Baseketens nog steeds aanzienlijke lacunes in liquiditeit en financiering. Het Memecoin-ecosysteem op de Baseketen is nog niet volwassen en er is nog steeds een aanzienlijk verschil tussen de marktwaarde en actieve adressen van topprojecten en Memecoin-projecten in het Solana-ecosysteem. Dit betekent dat het handelsgedrag op de Baseketen meer wordt gemanifesteerd als on-chain PVP-games, met een relatief kleine marktcapaciteit.</p>
<p>Desalniettemin zijn we nog steeds vol verwachtingen voor de toekomst van de Base Chain. In de komende cryptocurrency-markt worden meerdere gunstige factoren verwacht, zoals de adoptie van ETF’s, BTC-halvering, ETH Prague-upgrade en de toestroom van meer gebruikers, die nieuwe ontwikkelingsmogelijkheden voor de Base Chain met zich mee kunnen brengen. We zijn benieuwd of Base Chain deze drijvende krachten kan benutten om zijn Meme-projecten te stimuleren en investeerders te verrassen met meer verrassingen.</p>
<p>In de toekomst, met de voortdurende veranderingen in de marktomgeving en de geleidelijke verbetering van het Base Chain-ecosysteem, hebben we reden om te geloven dat het Base Chain een plaats zal innemen op de cryptocurrency-markt. En verschillende tekenen geven aan dat het Base Chain krachtige MEME en gerelateerde sociale producten kan voortbrengen, en naar verwachting zal uitgroeien tot een uniek L2-platform in het Ethereum-ecosysteem.</p>
<div class="blog-details-info"><br><div>Auteur:<strong>Carl Y.</strong>, Gate.io Onderzoeker<br><div>Vertaler: Joy Z.<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de opvattingen van de onderzoeker en vormt geen beleggingsadvies.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het opnieuw plaatsen van het artikel is toegestaan mits Gate.io wordt vermeld. In alle glen zal er juridische actie worden ondernomen vanwege schending van het auteursrecht.<br></div><p></p><br></div></div></div></div>