UHVtcC5GdW4gVG9rZW4gU2FsZTogUmV0YWls4oCZcyBHb3VkZW4gS2FucyBvZiBPbmRlcmdhbmc/

2025-06-25, 06:01

<p><img src="https://gimg2.gateimg.com/image/20250625-141449202506251415019551693077.jpeg" alt="">
</p><p>Gelanceerd in het begin van 2024, pionierde pumpdotfun het concept van memecoin-lanceerplatforms. Tot leven gebracht met als doel een veiliger, eerlijker en leuker systeem te creëren voor zowel gebruikers als makers, maakte het platform het mogelijk voor gebruikers om bijna direct verhandelbare tokens te lanceren, met weinig tot geen vereiste technische kennis en kosten. Dit vereenvoudigde proces, gecombineerd met het gebruik van een bonding curve-model en een eerlijk lanceringsmechanisme, zou pump.fun naar de voorhoede van de hele cryptobranche stuwen en het tot een hoeksteen maken binnen de Solhet Ana-ecosysteem in de komende maanden uitbreiden en binnen slechts een half jaar meer dan $50 miljoen aan cumulatieve omzet overtreffen.</p>
<p>Sindsdien heeft pump.fun zich ontwikkeld tot een volledige product suite (memecoin launchpad, API, DEX en streaming platform) en is verantwoordelijk voor meer dan 11 miljoen tokens gelanceerd op Solana. Dit is buiten de tokens die gelanceerd zijn door concurrenten zoals boopdotfun en bonk_fun, die in hun voetsporen zijn getreden en hebben geprobeerd alternatieven en verbeteringen te bieden voor het model van pump.fun.</p>
<p>Ondanks dit alles hebben particuliere gebruikers en handelaren nooit een middel gehad om rechtstreeks blootstelling te krijgen en te profiteren van het grote succes en de groei van het platform. Dat wil zeggen, tot nu toe.</p>
<h2 id="h2-PUMP20Token20Verkoop929511"><a name="$PUMP Token Verkoop" class="reference-link"></a><span class="header-link octicon octicon-link"></span>$PUMP Token Verkoop</h2><p>Tijdens een Twitter Space op 19 oktober vorig jaar bracht medeoprichter van pump.fun - sapijiju verrassend plannen voor een airdrop ter sprake, wat de eerste keer markeerde dat er ooit een token werd geïmpliceerd voor het platform. Hoewel er in de maanden daarna geen aanvullende informatie werd vrijgegeven, zouden meerdere bronnen (The Block, Blockworks etc.) plotseling begin deze maand melden van de plannen van pump.fun voor een $1 miljard tokenverkoop tegen een enorme $4 miljard FDV.</p>
<p>Hoewel de tokenomics van $PUMP nog niet officieel zijn bevestigd door het team, zijn er verschillende details in omloop. Deze omvatten:</p>
<ul>
<li>Totale aanbod: 1 biljoen</li><li>Airdrop: 100 miljard (10%)</li><li>Token verkoop: 250 miljard (25%)</li><li>100% ontgrendeld voor deelnemers aan de token verkoop</li></ul>
<p>Bronnen hebben ook gesuggereerd dat het platform een inkomstendelingsmechanisme overweegt voor $PUMP, en 25% van de protocolopbrengsten gebruikt voor het uitvoeren van reguliere token-inkoopacties.</p>
<h2 id="h2-Onderschat20of20niet675479"><a name="Onderschat of niet?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Onderschat of niet?</h2><p>De aankondiging van de tokenverkoop van de memecoin launchpad behemoth heeft een verscheidenheid aan reacties opgeroepen van CT, waarbij het zijn deel van zowel stieren- als berenargumenten, naast steun en kritiek, heeft ontvangen. Hieronder presenteren we enkele van elke kant in de hoop een evenwichtig beeld te bieden.</p>
<h3 id="h3-Stier20Argumenten676834"><a name="Stier Argumenten" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Stier Argumenten</h3><p><strong>Actief inkomsten genererend:</strong> Pump.fun is een van de weinige en topopbrengende protocollen, die tot nu toe bijna $700 m heeft gegenereerd en een top 5-positie inneemt onder alle projecten op basis van 30-daagse opbrengst.<br><img src="https://gimg2.gateimg.com/image/1202506251415552715051058.jpeg" alt="">
</p><p><strong>Aanzienlijk marktaandeel en activiteit:</strong> Momenteel is het de top memecoin launchpad op basis van dagelijks ingezette tokens, en de top DEX op basis van dagelijkse volume op Solana, ondanks de aanwezigheid en opkomst van recente concurrenten. Houdt ook 2 plekken in de top 5 voor applicaties en contracten op basis van 30d gasvergoedingen betaald, wat bijdraagt aan het grootste aandeel van activiteit door een applicatie op Solana.<br><img src="https://gimg2.gateimg.com/image/2202506251416293927911138.jpeg" alt=""><img src="https://gimg2.gateimg.com/image/3202506251416460683671020.jpeg" alt=""><img src="https://gimg2.gateimg.com/image/4202506251417036087285141.jpeg" alt="">
</p><p><strong>Koopdruk gedreven door inkoopacties:</strong> Indien bevestigd, zullen terugkopen met een aandeel van de protocolopbrengsten bijdragen aan aanzienlijke en constante koopdruk na TGE.<br>Blootstelling aan mememunten met een lager risico: Zou gezien kunnen worden als een handige en minder risicovolle vorm van blootstelling aan Sola, vergelijkbaar met een indexfonds.door veel investeerders in memecoins.
</p><h3 id="h3-Bear20Argumenten904854"><a name="Bear Argumenten" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Bear Argumenten</h3><p><strong>Beperkt opwaarts potentieel:</strong> Ongeacht de inkomstencijfers beperkt een enorme waardering van $4 miljard het opwaartse potentieel aanzienlijk voor de deelnemers. De omvang van het beoogde op te halen bedrag heeft ook twijfel doen rijzen over de bedoelingen van het team, waarbij sommige particuliere deelnemers zich zorgen maken dat ze worden gebruikt als exit-liquiditeit.</p>
<p><strong>Volatiliteit na TGE: </strong> Als de geruchten waar zijn, kan een volledige ontgrendeling bij TGE samen met mogelijke winstnemingen van vroege investeerders en airdrop-ontvangers ($400 mln waard volgens de tokenverkoopwaardering) leiden tot grote volatiliteit in het begin. Het zou voordelig kunnen zijn voor particuliere deelnemers om aan de zijlijn te blijven totdat de koersactie stabieler is.</p>
<p><strong>Duurzaamheid van inkomsten:</strong> Het dagelijkse protocolinkomen is al gedaald van de hoogtepunten (eind 24’ - begin 25’), het gebruik van inkomsten en potentiële terugkopen bij waarderings overwegingen zou misschien te optimistisch kunnen zijn gezien de onzekerheid rond de duurzaamheid ervan.<br><img src="https://gimg2.gateimg.com/image/5202506251418028081901739.jpeg" alt="">
</p><p><strong>Regelgevingsonzekerheid:</strong> Hoewel het Amerikaanse regelgevingskader onlangs zijn crypto-gerelateerde beleid heeft versoepeld, is dit grotendeels beperkt gebleven tot stablecoins en DeFi-protocollen. Memecoin lanceerplatforms zoals pump.fun bevinden zich nog steeds grotendeels in een regelgevend grijs gebied.</p>
<h3 id="h3-Waarderingen20en20toekomstperspectief701358"><a name="Waarderingen en toekomstperspectief" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Waarderingen en toekomstperspectief</h3><p>Naast stieren- en berenargumenten kunnen we ook verwijzen naar het gedrag voor openingstijd en waarderingsvergelijkingen.</p>
<p>Aevo heeft al pre-launch trading mogelijk gemaakt voor $PUMP, en de token wordt momenteel verhandeld tegen een FDV van $5.85 miljard. Dit zou kunnen aangeven dat de meerderheid van de handelaren de token als ondergewaardeerd beschouwt ten opzichte van de FDV van $4 miljard bij de tokenverkoop. Andere teams hebben ook modellen gebouwd om de token te waarderen op basis van bestaande en geprojecteerde statistieken.</p>
<p>De positionering van Pump.fun ten opzichte van streaming platforms zou ook enkele onbenutte mogelijkheden kunnen bieden. Door het opnieuw invoeren van livestreams en het implementeren van deelnamekosten voor makers, zou het platform mogelijk grote streaming platforms zoals Twitch en TikTok kunnen verstoren naarmate de adoptie toeneemt.</p>
<p>De USP’s? Het toestaan van makers om vanaf dag 1 geld te verdienen, rechtstreeks via tokens en het delen van kosten. Bovendien kunnen nieuwe makers profiteren van handelaren die het platform scannen op nieuwe lanceringen als vroege kijkers.<br><img src="https://gimg2.gateimg.com/image/6202506251418299761108623.jpeg" alt="">
</p><p>Volledig gelanceerd in het midden van februari, heeft de mobiele app van pump.fun ook het actieve streven van het team getoond om de toegankelijkheid en gebruikerservaring te verbeteren, uitgerust met tabbladen waarmee gebruikers door trending lanceringen, het laatste nieuws en live creators kunnen navigeren. Nu beschikbaar voor download in zowel de Apple App Store als de Google Play Store, zou dit kunnen dienen als een potentiële katalysator voor mainstream adoptie en zijn pad naar het verstoren van traditionele platforms.</p>
<h3 id="h3-Andere20overwegingen591243"><a name="Andere overwegingen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Andere overwegingen</h3><p>Last but not least, men moet ook rekening houden met gebieden waar onzekerheid en twijfels nog bestaan. Deze omvatten:</p>
<ul>
<li>Definitieve tokenomics en airdrop-toewijzingen</li><li>Ontgrendelings/vestingvoorwaarden voor openbare en particuliere verkoopdeelnemers, en airdrop-ontvangers</li><li>Definitieve details van tokenverkoop en exclusieve deelnamecriteria indien van toepassing</li><li>Mogelijkheid voor CEX-noteringen</li><li>Toekomstige routekaart</li></ul>
<h2 id="h2-Conclusie571744"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p><img src="https://gimg2.gateimg.com/image/7202506251418460158412384.png" alt=""><br>Over het algemeen biedt de $PUMP-tokenverkoop een aantrekkelijke kans voor de detailhandel om blootstelling te krijgen aan niet alleen een sterk inkomstengenererend platform, maar ook aan een platform dat tot nu toe is uitgegroeid tot een dominante marktleider in niet één, maar twee sectoren. Met dat gezegd te hebben, is dit niet zonder risico’s. Men moet extreme volatiliteit verwachten bij TGE, tenzij er in de komende dagen meer details worden vrijgegeven over de ontgrendelingstranches en de airdrop.
</p><p>Het zal ook interessant zijn om te zien hoe de $PUMP TGE van invloed is op onchain-markten. Hoewel een airdrop ter waarde van naar schatting $400m een enorme liquiditeitsinjectie is, zouden grote schommelingen in prijs ook veel retaildeelnemers kunnen verbranden.</p>
<div class="blog-details-info"><br><div>Auteur: <strong>DWF Ventures</strong><br><div class="info-tips"><em>De inhoud hiervan vormt geen aanbod, verzoek of aanbeveling. U dient altijd onafhankelijk professioneel advies in te winnen alvorens tot beleggingsbeslissingen over te gaan.<br><div></div>Houd er rekening mee dat Gate het gebruik van alle of een deel van de diensten van Beperkte Locaties kan beperken of verbieden. Voor meer informatie, lees de Gebruikersovereenkomst via <a href="https://www.gate.com/legal/user-agreement" data-index="1">https://www.gate.com/legal/gebruikersovereenkomst</a>.<br><p></p><br></em></div></div></div>