R2VsZWlkIGRvb3IgRkFSVENPSU46IEVlbiBLaWprIG5hYXIgZGUgVG9wIFB1bXAuZnVuIE1lbWUgQ29pbnM=

2025-06-20, 06:21

<p><img src="https://gimg2.gateimg.com/image/pump202506201420072658567562.png" alt="">
</p><p>In de <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> ecosysteem, Pump.fun is als een onvermoeibare meme coin drukmachine. Sinds de lancering in januari 2024 heeft het iedereen in staat gesteld om tokens te creëren en te verhandelen tegen een kostprijs van 0,02 SOL (ongeveer 2 USD) binnen één minuut. Dit nul-drempel rijkdom (of droom) creatiemechanisme heeft meer dan 11 miljoen tokens aangetrokken die hier zijn geboren. Echter, harde gegevens onthullen dat slechts 1,4% van de tokens succesvol kan “afstuderen” naar gedecentraliseerde exchanges, en degenen die de miljard dollar marktwaarde doorbreken zijn nog zeldzamer.</p>
<h2 id="h2-Top20Pumpfun20Meme20Coins20Een20Festival20voor20de20Weinige20Winnaars899951"><a name="Top Pump.fun Meme Coins: Een Festival voor de Weinige Winnaars" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Top Pump.fun Meme Coins: Een Festival voor de Weinige Winnaars</h2><p>Ondanks een extreem lage slagingskans hebben enkele projecten toch een verbazingwekkend welvaatseffect gecreëerd op Pump.fun:</p>
<ol>
<li>Fartcoin (FARTCOIN): Oorspronkelijk voortkomend uit het AI-experiment van Truth Terminal, met “fartgrappen” als culturele kern, activeert elke transactie een uniek geluids effect. De marktkapitalisatie van FARTCOIN overschreed ooit 2 miljard USD, waardoor het de meest schitterende “vermogenscreatie-mythe” op Pump.fun werd. Hoewel de prijs sindsdien sterk is fluctuatie, staat het momenteel nog steeds op de eerste plaats in het ecosysteem met een marktkapitalisatie van 1,04 miljard USD.</li><li>Would (WOULD): Een sociaal experimenttoken gebaseerd op het concept van “keuze spel,” dat bepaalt de <a href="/price/flow-flow" rel="nofollow noopener noreferrer" target="_blank">stroom</a> van fondsen (zoals verbranden of liquiditeitsinjectie) door middel van gemeenschapsstemmen 5. De WOULD-token, met zijn unieke keuze spelconcept, bereikte een marktkapitalisatie van 670 miljoen dollar op zijn hoogtepunt, momenteel met een marktkapitalisatie van 514 miljoen dollar.</li><li>Pinda de eekhoorn (PNUT): De stijging van PNUT is geworteld in een sociaal evenement: de internet-bekende eekhoorn “Pinda” werd in beslag genomen en geëuthanaseerd door het New York Department of Environmental Conservation (DEC), wat snel leidde tot publieke verontwaardiging over overheidsoverschrijding. Dit incident escaleerde door de meerdere kritiek van Musk op het X-platform, waarbij zijn voortdurende aandacht de markenthousiasme direct aanwakkerde. PNUT bereikte in november 2024 een marktkapitalisatie van 1,8 miljard dollar, en de huidige marktkapitalisatie wordt gerapporteerd op 223 miljoen dollar, een daling van bijna 90% ten opzichte van de piek.</li><li>Moodengsol.com (MOODENG): De Thaise internetberoemde nijlpaard Meme, die persoonlijk is bezocht door <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> oprichter Vitalik. De markwaarde van MOODENG bereikte eind 2024 even kort 610 miljoen USD, en de huidige markwaarde wordt gerapporteerd op 150 miljoen USD.</li></ol>
<p>Achter deze succesverhalen ligt het verval van 99% van de projecten. Dune-gegevens tonen aan dat van de bijna 600.000 actieve wallets in mei, slechts 0,0045% van de gebruikers winst maakte van meer dan $100.000, terwijl 52,5% van de gebruikers verliezen leed en uitstapte.</p>
<h2 id="h2-De20mechanismen20achter20succes20eerlijke20lancering20en20liquiditeitsautomatisering683954"><a name="De mechanismen achter succes: eerlijke lancering en liquiditeitsautomatisering" class="reference-link"></a><span class="header-link octicon octicon-link"></span>De mechanismen achter succes: eerlijke lancering en liquiditeitsautomatisering</h2><p>Het hoge waarderingsproject van Pump.fun is geen toeval; de kernmechanisme is ontworpen met “beperkte eerlijkheid”:</p>
<ul>
<li>Geen reservering, volledige circulatie: De makers geven het recht om te minten op en alle tokens komen op de openbare markt, waardoor “rat trading” wordt geëlimineerd.</li><li>Gezamenlijke curve lancering: De tokenprijs stijgt automatisch met het aankoopbedrag, en vroege deelnemers kunnen hoge premies ontvangen.</li><li>Automatische lijst op DEX: Na het bereiken van een marktwaarde van $69.000 wordt de liquiditeit automatisch gestort in Raydium en worden LP-tokens verbrand, waardoor liquiditeit wordt vergrendeld om rug pulls te voorkomen.<br>Dit mechanisme werd ooit verpakt als een “anti-harvesting tool”, maar in werkelijkheid werd het een arbitrage-instrument voor enkele slimme spelers. Bijvoorbeeld, de token TEST, vroege kopers hamsteren 50% van de voorraad om de prijs op te drijven en verkochten daarna, wat leidde tot het oogsten van particuliere investeerders.</li></ul>
<h2 id="h2-De20hausse20vervaagt20Zowel20het20platform20als20de20markt20koelen20af91919"><a name="De hausse vervaagt: Zowel het platform als de markt koelen af." class="reference-link"></a><span class="header-link octicon octicon-link"></span>De hausse vervaagt: Zowel het platform als de markt koelen af.</h2><p>In 2025, Pump.fun komt in een diepe correctie in sync met de meme coin-markt:</p>
<ul>
<li>Platforminkomsten kelderen: Dagelijkse inkomsten dalen van een piek van $15 miljoen naar enkele miljoenen dollars, met een handelsvolume dat met 80% afneemt.</li><li>Tokenuitgifte krimpt: Dagelijkse nieuwe muntencreatie daalt van 70.000 naar 30.000, en de interesse van gebruikers neemt aanzienlijk af.</li><li><a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> Meme coins duiken: Tokens zoals TRUMP zijn met 85% gedaald ten opzichte van hun piek, met FARTCOIN, PENGU en anderen die ook dubbele cijfers dalingen ervaren.</li></ul>
<p>De regelgeving en rechtszaken nemen gelijktijdig toe. In januari 2025 dienden Amerikaanse investeerders een rechtszaak in tegen Pump.fun voor verliezen die zijn geleden door te investeren in PNUT, en beschuldigden het ervan te opereren als een “niet-geregistreerde effectenbeurs.”</p>
<h2 id="h2-Controverse20en20Toekomst20Is20een20waardering20van20420miljard20een20bubbel20of20een20onderwaardering855328"><a name="Controverse en Toekomst: Is een waardering van 4 miljard een bubbel of een onderwaardering?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Controverse en Toekomst: Is een waardering van 4 miljard een bubbel of een onderwaardering?</h2><p>In het licht van een neergang is Pump.fun van plan om $1 miljard op te halen met een waardering van $4 miljard om platformtokens uit te geven. De markt is sterk verdeeld hierover:</p>
<ul>
<li>De sceptici geloven dat de waardering absurd is. Onderzoekers wijzen op het gebrek aan een competitieve voorsprong, de buitensporige afhankelijkheid van kortetermijn FOMO, en een FDV/omzetverhouding zo hoog als 64, ver boven die van volwassen DeFi-projecten zoals <a href="/price/pancakeswap-cake" rel="nofollow noopener noreferrer" target="_blank">PancakeSwap</a> .</li><li>Het wordt door supporters beschouwd als de “on-chain iPhone”. Community KOLs wijzen erop dat de koers-winstverhouding slechts 5 keer bedraagt, en het heeft het hele proces van tokenuitgifte tot CEX-notering gestroomlijnd, waardoor het een winnaar is in de aandachtseconomie.</li></ul>
<h2 id="h2-Conclusie20De20Paradox20van20het20Overlevingsspel20en20Ecologie755043"><a name="Conclusie: De Paradox van het Overlevingsspel en Ecologie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie: De Paradox van het Overlevingsspel en Ecologie</h2><p>Het topproject van Pump.fun valideert het potentieel voor vermogenscreatie van Meme-munten, maar een succespercentage van 1,4% voelt meer als een brute overlevingsspel. Terwijl de marktliquiditeit krimpt en de regelgeving verscherpt, zal het tokenfinancieringsplan van $4 miljard van het platform een toetssteen worden—als het erin slaagt een duurzaam Meme-ecosysteem op te bouwen, kan het echt de “on-chain iPhone” worden; als het slechts een laatste ronde van liquiditeitsverzameling is, kan het de ineenstorting van de bubbel versnellen.</p>
<p>Zoals crypto-commentator Bunjil zei: “Pump.fun heeft meme coins niet vernietigd; het heeft gewoon onthuld hoe gemakkelijk het is om ze te creëren.” Wanneer iedereen gemakkelijk munten kan maken, zal de schaarste van waarde alleen ontstaan door een brutaler selectieproces.</p>
<div class="blog-details-info"><br><div>Auteur: <strong>Blogteam</strong><br><div class="info-tips"><em>De inhoud hierin 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>