TWV0IHdlbGtlIHBvcHVsYWlyZSBtZW1lLW11bnRlbiBpcyBWaXRhbGlrIGJldHJva2tlbiBnZXdlZXN0Pw==

2025-07-08, 10:05

<p><img src="https://gimg2.gateimg.com/image/moodeng202507081803198432543321.jpg" alt="">
</p><p>Toen Vitalik Buterin op 18 augustus 2024 het “dacc.eth” ENS-domein registreerde, kookte de markt onmiddellijk over. In minder dan 24 uur, <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> en de <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> De meme-munt genaamd D/ACC op de keten steeg met 956,5%, terwijl E/ACC bijna 960% steeg, wat blijkbaar opnieuw de vergaande “V God-effect” valideert.</p>
<p>Dit is slechts één scène uit de ontelbare Meme coin razernijen rond deze <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> medeoprichter in de afgelopen jaren. Van de 3660-voudige stijging van ZUZALU tot de 8124-voudige mythe van THE token, komen deze munten die met zijn naam of ideeën zijn geassocieerd vaak met markt euforie op het moment van hun ontstaan.</p>
<p>Maar Vitalik’s reactie was verrassend kalm - hij blijft de tokens “geduwd” door het projectteam verkopen en omzetten in liefdadigheidsfondsen, terwijl hij genadeloos de Meme-munten bekritiseert die beroemdheden als gimmick gebruiken, en stelt dat ze in wezen “instrumenten zijn om beroemdheden en vroege investeerders rijk te maken.”</p>
<h2 id="h2-De20Opkomst20en20Val20van20de20Vitalik20Concept20Meme20Coin895591"><a name="De Opkomst en Val van de Vitalik Concept Meme Coin" class="reference-link"></a><span class="header-link octicon octicon-link"></span>De Opkomst en Val van de Vitalik Concept Meme Coin</h2><p>Soortgelijke plots zijn herhaald in meerdere Vitalik-gerelateerde meme-projecten:</p>
<ul>
<li>ZUZALU: Oorspronkend uit het crypto city-experiment voorgesteld door Vitalik, steeg de token na de lancering tot een maximum van 3660 keer, met een marktwaarde van meer dan 33 miljoen USD, maar daalde vervolgens met 95,9%, waardoor er slechts een marktwaarde van 1,2 miljoen USD overbleef.</li><li>DE Protocol: Alleen omdat Vitalik in 2022 op Twitter suggereerde dat “iemand DE protocol zou moeten creëren,” is deze munt ontstaan, met een piektoename van 8124 keer, met een marktwaarde van bijna 40 miljoen USD, maar is nu met 99,5% gedaald.</li><li>TCATI (Groene Thee Kat): Genoemd naar de handtekening van Vitalik’s X-account, bood het ooit financiering voor zijn Zuzalu-experiment, dat met 519 keer steeg voordat het ook met 95,6% daalde.</li></ul>
<p>De trend van dit type token volgt bijna dezelfde traject: Vitalik’s woorden en acties trekken aandacht → de token wordt opgepomp → de marktwaarde piekt → een spirale afname naar een fractie van de piek. De markt creëert een bubbel in de razernij en laat een rommel achter na de explosie van de bubbel.</p>
<p>Als reactie op de voortdurende token airdrops van projectpartijen heeft Vitalik een unieke copingmechanisme ontwikkeld - het monetariseren van Meme coins en deze doneren aan goede doelen, waardoor markt speculatie wordt omgevormd tot publieke waarde.</p>
<p>In oktober 2024 monitorde het blockchain-analysebedrijf Spot On Chain dat Vitalik een reeks operaties in korte tijd uitvoerde: hij transfereerde Moo Deng (MOODENG) ter waarde van $982.800, Monsterra (MSTR) ter waarde van $231.000 en $183.000. <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">ETHEREUM</a> IS GOOD（EBULL）uitwisseling naar Ethereum.</p>
<p>Dit is nog maar het topje van de ijsberg. Volgens gegevensstatistieken heeft Vitalik alleen al in de afgelopen negen dagen Meme-munten ter waarde van 2,78 miljoen dollar omgezet in Ethereum en 884.000 dollar aan goede doelen gedoneerd.</p>
<p>Zijn donatiedoelen zijn zeer gericht:</p>
<ul>
<li>10 miljard verschillende soorten Meme-munten → Ondersteun organisaties die werken aan technologieën voor luchtgedragen ziekten</li><li>Alle dieren-thema Meme-munten die in de afgelopen 12 maanden zijn ontvangen → Effectieve Altruïsme-fondsen voor dierenwelzijnsprojecten</li><li>$60 miljoen waard aan tokens zoals SHIB verkocht in 2021 → Financiering van levensduuronderzoek, AI-allianties en instellingen voor pandemisch onderzoek</li></ul>
<p>Hoewel hij er zeker van is dat de projectpartij goede bedoelingen heeft door zijn donaties, heeft hij herhaaldelijk publiekelijk gezegd: “In plaats van naar mijn adres over te maken, zou het beter zijn om rechtstreeks aan de liefdadigheid te doneren.”</p>
<h2 id="h2-Rationale20Critici20Dialectische20Inzichten20in20de20Essentie20van20Meme20Coins808098"><a name="Rationale Critici: Dialectische Inzichten in de Essentie van Meme Coins" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Rationale Critici: Dialectische Inzichten in de Essentie van Meme Coins</h2><p>Met bijna $900 miljoen aan crypto-activa (voornamelijk 240.000 ETH) heeft Vitalik een diepgaande dialectische kijk op Meme-munten. Hij bevestigt de potentiële sociale waarde van Meme-munten en gelooft dat ze “positief kunnen bijdragen aan de samenleving door belangrijke publieke projecten te financieren en zelfs mensen in lage-inkomenslanden te helpen rond te komen.” Echter, hij uit scherpe kritiek op Meme-munten die afhankelijk zijn van de hype rond beroemdheden, en wijst erop dat het doel van dergelijke tokens puur is om “beroemdheden en vroege investeerders te verrijken.”</p>
<p>Aan het begin van 2025 veroorzaakte zijn kritiek op Meme coin-uitgiftelplatformen zoals Pump.fun opschudding in de industrie. In een openbare discussie op Farcaster beschuldigde Vitalik dergelijke platformen ervan geworteld te zijn in een “gebrekkige sociale filosofie”, die gericht zijn op het maximaliseren van winst op korte termijn zonder ecologische verantwoordelijkheid.</p>
<p>Zijn kritiek is direct:</p>
<ul>
<li>Platformkosten blijven <a href="/price/flow-flow" rel="nofollow noopener noreferrer" target="_blank">stroom</a> uit naar gecentraliseerde beurzen in plaats van te profiteren van het ecosysteem.</li><li>Het gebrek aan controle over de kwaliteit van tokens heeft geleid tot een stijging van de kosten voor gebruikers om te experimenteren.</li><li>Er is een gebrek aan mechanismen die langdurige waarde ondersteunen.</li></ul>
<p>In tegenstelling daarmee erkent hij platforms zoals LetsBONK.fun die duurzame genen hebben. Dit platform kent de transactiekosten duidelijk toe aan drie delen: ondersteuning van de eigen ontwikkeling en operatie, staking om de beveiliging van de <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> netwerk, en het terugkopen en vernietigen van munten om de waarde voor houders te verhogen.</p>
<h2 id="h2-Industrie20Paradigma20Vormers20Diepe20Impact20Voorbij20Trends527004"><a name="Industrie Paradigma Vormers, Diepe Impact Voorbij Trends" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Industrie Paradigma Vormers, Diepe Impact Voorbij Trends</h2><p>Vitalik’s interactie met meme coins verandert stilletjes de regels van de industrie. Hij demonstreert een mogelijkheid via on-chain operaties: een haalbaar pad om speculatieve activa om te zetten in publieke welzijnsfondsen. Dit model creëert een ripple-effect. Naarmate steeds meer gebruikers aandacht besteden aan zijn wallet-bewegingen, wordt het gedrag van projectteams die proberen “de golf te berijden” niet langer simpelweg gedreven door markt-speculatie, maar staat het ook voor de diepere vraag “of het werkelijk publieke welzijnswaarde heeft.”</p>
<p>Zijn kritiek op het Meme coin-platform heeft vergelijkbaar reflectie binnen de industrie uitgelokt. Terwijl Pump.fun onder de loep werd genomen voor het overdragen van $15 miljoen in SOL naar CEX voor cashing out, koos LetsBONK.fun ervoor om transactiekosten te gebruiken om de infrastructuur van publieke ketens te ondersteunen, wat een ander ontwikkelingsparadigma biedt voor Meme coin-uitgifteplatforms. Deze acties zijn consistent met zijn gedachten als technologiefilosoof—toen hij voor het eerst het concept van d/acc voorstelde, benadrukte hij dat “een defensieve wereld een betere wereld is”, een filosofie die nu ook toepasbaar is op zijn houding ten opzichte van financiële experimenten: verantwoordelijkheidsmechanismen inbedden binnen open innovatie.</p>
<p>Deze houding, die innovatie en verantwoordelijkheid in balans houdt, heeft zelfs geleid tot het feit dat economen hem hebben genoemd als kandidaat voor de Nobelprijs voor de Economie. Zoals econoom Tyler Cowen zei: “Vitalik heeft een platform gebouwd en een munt gecreëerd, waarmee hij Mises’ regressietheorema weerlegt in het proces.”</p>
<p>De acties van Vitalik zijn nog steeds aan de gang. Begin 2025 houdt zijn openbare portemonnee nog steeds tokens ter waarde van $2,4 miljoen in MOODENG, $144.000 in NEIRO en anderen. Achter deze cijfers schuilen talloze “heat legacies” die wachten om omgezet te worden in publieke welzijnsfondsen. De crypto-industrie heroverweegt ook de waardelogica van Meme-munten. Wanneer platforms zoals LetsBONK.fun beginnen met het toewijzen van transactiekosten aan staking van publieke chain knooppunten en token terugkoop en verbranding, en de focus van de markt verschuift van “vermenigvuldigen van stijging” naar “ecologische feedback”, ondergaan Meme-munten een transformatie van pure speculatie naar waarde co-creatie. Ongetwijfeld dienen Vitalik’s kritiek en acties als een katalysator voor deze transformatie.</p>
<div class="blog-details-info"><br><div>Auteur: <strong>Blogteam</strong><br><div class="info-tips"><em>De inhoud hier vormt geen aanbod, sollicitatie of aanbeveling. U dient altijd onafhankelijk professioneel advies in te winnen voordat u investeringsbeslissingen neemt.<br><div></div>Houd er rekening mee dat Gate het gebruik van alle of een deel van de Diensten vanuit Beperkte Locaties kan beperken of verbieden. Voor meer informatie, lees de Gebruikersovereenkomst via <a href="https://www.gate.com/legal/user-agreement" data-index="6">https://www.gate.com/legal/user-agreement</a>.<br><p></p><br></em></div></div></div>