TUVNRSBnYWF0IHZpcmFhbCwgYW5hbHlzZWVyIGRlIGthbnNlbiB2b29yICdwdW1wZnVuJyBzcGVsZXJz

2024-09-12, 11:58

<p><img src="https://gimg2.gateimg.com/image/article/17261420171692587449analysis.jpeg" alt=""></p>
<h2 id="h2-TLDR698835"><a name="[TL;DR]:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL;DR]:</h2><p>Wanneer beide <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> ETF en <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> ETF’s worden goedgekeurd in 2024, Meme coin zal een nieuw groeipunt worden in het blockchain-ecosysteem.</p>
<p>Het succes van pump.fun heeft geleid tot de opkomst van verschillende imitaties op de markt, zoals SunPump op de <a href="/price/tron-trx" rel="nofollow noopener noreferrer" target="_blank">TRON</a> chain, EtherVista op <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> en Four.meme op de <a href="/price/bnb-bnb" rel="nofollow noopener noreferrer" target="_blank">BNB</a> ketting.</p>
<p>Deze platforms hebben het pump.fun-model overgenomen en geprobeerd gebruikers aan te trekken door de muntuitgifte drempel te verlagen en het operationele proces te vereenvoudigen, maar de meesten vinden het nog steeds moeilijk om de leidende positie van pump.fun te overtreffen.</p>
<h2 id="h2-Inleiding287540"><a name="Inleiding" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Inleiding</h2><p>Nadat BOME de trend van gedecentraliseerde muntuitgifte heeft aangewakkerd, is eenmalige muntuitgifte vertegenwoordigd door pump.fun een nieuwe trend geworden. In dit artikel zullen we diep ingaan op de huidige situatie en kansen van deze nieuwe Meme launchpad-platforms.</p>
<h2 id="h2-Ondersteuning20voor20het20met20n20klik20verzenden20van20Meme20pumpfun20om20de20topstream20te20worden636325"><a name="Ondersteuning voor het met één klik verzenden van Meme, pump.fun om de topstream te worden" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Ondersteuning voor het met één klik verzenden van Meme, pump.fun om de topstream te worden</h2><p>Ongetwijfeld heeft pump.fun al de top positie ingenomen als een platform voor uitgifte van meme munten in de <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> ecosysteem. In feite trok pump.fun pas vanaf medio maart veel aandacht, toen het snel opkwam met de Meme-muntgekte geleid door BOME in het Solana-ecosysteem, sinds de lancering in februari 2024.</p>
<p>De kerncompetitie van pump.fun ligt in zijn efficiënte activa-uitgiftemechanisme en eerlijke chipverdelingsmethode, waardoor het platform opvalt op de Meme-coinmarkt. Het platform beweert dat het token-uitgifteproces transparant is en geen pre-sales of teamopdrachten heeft. Hoewel deze bewering in de praktijk in twijfel is getrokken, heeft pump.fun nog steeds aanzienlijke waardeverovering bereikt via een op vergoedingen gebaseerd model.<img src="https://gimg2.gateimg.com/image/article/17261420811.jpg" alt=""><br>Bron: pump.fun</p>
<p>Op het gebied van inkomsten heeft pump.fun een verbazingwekkende groeimomentum laten zien. Begin april dit jaar genereerde het platform een omzet van maar liefst $5,2 miljoen binnen 38 dagen en steeg snel naar $30 miljoen begin juni. Begin juli stond de 24-uursomzet van pump.fun op de eerste plaats in de blockchainindustrie, met een bedrag van $1,99 miljoen. Momenteel heeft het platform een totale omzet gegenereerd van ongeveer 700.000 SOLs (ongeveer $94 miljoen). Vooral tijdens specifieke hete marktperioden, zoals de meme-muntuitgiftewoede die werd veroorzaakt door de conversatie van Musk met Trump, heeft pump.fun een groot aantal nieuwe tokens gecreëerd en in korte tijd hoge inkomsten behaald.<img src="https://gimg2.gateimg.com/image/article/17261420992.jpg" alt=""><br>Bron: DUNE</p>
<p>De ontwikkeling van pump.fun is echter niet zonder problemen verlopen. Het platform heeft te maken gehad met een bliksemleningaanval, wat resulteerde in een verlies van ongeveer $1,9 miljoen. Hoewel de beveiliging is hersteld door contractupgrades, heeft het ook veel risico’s aan het licht gebracht achter de bliksemsnelheid.</p>
<p>Kort gezegd vertrouwt pump.fun op Solana’s inherente Meme ecosysteemverkeer, de lage drempel en eerlijke en transparante token-uitgiftekenmerken, wat leidt tot een nieuwe trend in Meme-muntuitgifte. Als gevolg hiervan zijn verschillende imitaties van pump.fun ontstaan. We zullen ze hieronder één voor één delen.</p>
<h2 id="h2-SunPump20TRON20Chain20Trending20Meme20Launchpad915234"><a name="SunPump: TRON Chain Trending Meme Launchpad" class="reference-link"></a><span class="header-link octicon octicon-link"></span>SunPump: <a href="/price/tron-trx" target="_blank" class="blog_inner_link">TRON</a> Chain Trending Meme Launchpad</h2><p>SunPump is een Meme-muntenuitgifteplatform gebaseerd op de TRON-keten. Het heeft sinds de oprichting veel aandacht getrokken vanwege de invloed van Justin Sun.</p>
<p>Dit platform is vergelijkbaar met het pump.fun-model, maar heeft zijn eigen unieke kenmerken. In slechts 14 dagen heeft het een verbazingwekkende groei doorgemaakt, waarbij succesvol 31.986 Meme-munten zijn uitgegeven en een platformomzet van maximaal 12.810.000 TRX (ongeveer $2 miljoen) is behaald.<br><img src="https://gimg2.gateimg.com/image/article/17261421303.jpg" alt=""><br>Bron: SunPump</p>
<p>Bijzonder opmerkelijk is dat SunPump tijdens bepaalde perioden eind augustus vergelijkbare platformen zoals pump.fun heeft overtroffen in belangrijke statistieken zoals omzet en het aantal nieuwe tokens. Populaire gerelateerde tokens zijn onder andere SUNDOG, SUN, enz., die allemaal ondersteund worden op Gate.io.<img src="https://gimg2.gateimg.com/image/article/17261421494.jpg" alt=""><br>Bron: DUNE</p>
<h2 id="h2-EtherVista20Memelancering20en20DEXplatform20op20Ethereum362032"><a name="EtherVista: Meme-lancering en DEX-platform op Ethereum" class="reference-link"></a><span class="header-link octicon octicon-link"></span>EtherVista: Meme-lancering en DEX-platform op Ethereum</h2><p>EtherVista is een innovatieve DEX die specifiek is ontworpen voor het Ethereum-netwerk. Het heeft als doel om de normen voor tokenuitgifte en liquiditeitsbeheer te hervormen om een ​​veiligere, efficiëntere en transparantere handelservaring met digitale activa te bieden.</p>
<p>EtherVista streeft ernaar het probleem van het kortetermijnwinst streven dat veel voorkomt in het huidige model van de Automated Market Maker (AMM) op te lossen door middel van zijn unieke mechanismen, zoals het betalen van aangepaste kosten alleen met ETH, het benadrukken van langetermijnvoordelen verdelingsmodellen, en de deflatoire VISTA Token.<br><img src="https://gimg2.gateimg.com/image/article/17261421855.jpg" alt=""><br>Bron: ethervista.app</p>
<p>Dit platform beschikt over een uniek economisch model, met als belangrijkste hoogtepunten:</p>
<p>Deflatiemechanisme: VISTA beweert een ‘waarde samengestelde deflatoire valuta’ te zijn die zijn waarde behoudt door automatische terugkoop en verbranding van tokens. Momenteel is 2,17% van de totale voorraad verbrand.</p>
<p>Liquiditeitsvergrendeling: Het platform vereist een initiële liquiditeitsvergrendeling van 5 dagen om het vertrouwen van de markt te vergroten en kortetermijnarbitragegedrag te voorkomen.</p>
<p>Handelskostenverdeling: Transactiekosten worden uitgedrukt in ETH en rechtstreeks toegewezen aan liquiditeitsverschaffers (LP’s). Dit mechanisme heeft tot doel meer gebruikers te stimuleren om deel te nemen en liquiditeit te verschaffen.</p>
<p>Dit protocol heeft populaire memes voortgebracht zoals VISTADOG, VISTAPEPE, BONZI, enz. De platformgovernancetoken VISTA heeft sinds de lancering veel mensen aangetrokken met een stijging van 1.500%, en Gate.io ondersteunt momenteel de spot trading van deze munt.<br><img src="https://gimg2.gateimg.com/image/article/17261422136.jpg" alt=""><br>Bron: DUNE</p>
<p>EtherVista heeft plannen om zijn functies in de toekomst geleidelijk uit te breiden, waaronder het introduceren van ETH-BTC-USDC fondsenpools, het aanbieden van geavanceerde DeFi-diensten zoals zero-fee lightning loans en futures, en zich in te zetten voor het creëren van een gedecentraliseerd applicatie-ecosysteem dat meerdere functies integreert.</p>
<h2 id="h2-Fourme20Het20Meme20Lanceerplatform20voor20BNB20Chain991390"><a name="Four.me: Het Meme Lanceerplatform voor BNB Chain" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Four.me: Het Meme Lanceerplatform voor <a href="/price/bnb-bnb" target="_blank" class="blog_inner_link">BNB</a> Chain</h2><p>Four.me is ook een token uitgifteplatform gebaseerd op het pomptype Meme Launch protocol, dat interne en externe handel introduceert, Bonding Curve mechanisme heeft en de volgende unieke voordelen biedt:</p>
<p>Beperkte Aankoop: Om overmatige concentratie van tokens te voorkomen, kunnen token-uitgevers een maximumaankoopbedrag instellen voor investeerders.</p>
<p>Geplande release: Token-uitgevers kunnen de specifieke starttijd kiezen voor interne handel.</p>
<p>Lage handelskosten: De transactiekosten bedragen 0,5% (minimum 0,001 BNB), lager dan de 1% van de pomp.</p>
<p>Lage muntuitgiftekosten: De kosten voor het uitgeven van munten bedragen 0,005 BNB (ongeveer $2,85), wat voordeliger is dan de 0,02 SOL van de pomp (ongeveer $3,16).<br><img src="https://gimg2.gateimg.com/image/article/17261422527.jpg" alt=""><br>Bron: four.Meme</p>
<p>Bekende memes die verband houden met dit platform zijn onder andere binancedog, binancecat, bnbcat, FOUR, enzovoort.</p>
<p>Naast het eerder genoemde Meme-distributieplatform is er ook een op AI gebaseerde Memehub AI, die BNB, BAse, ETH, Blast, TON-ketens ondersteunt voor handel zonder liquiditeit te verstrekken, evenals Satspumpfun op basis van de Bitcoin-keten ondersteund door Fractal Bitcoin, STIX uitgegeven door Stickerly, ‘s werelds grootste Web2-gebruikersgegenereerde inhoudssticker-publicatieplatform, en Wonton.fun voor Meme en Snek.fun voor <a href="/price/cardano-ada" rel="nofollow noopener noreferrer" target="_blank">Cardano</a> Meme voor slechts 0.08 TON.</p>
<p>Volgens onvolledige statistieken zijn er sinds 2024 meer dan tien projecten geweest met Meme Launchpad of Meme Launchpad-functionaliteit op elke keten, vergelijkbaar met de situatie waarin verschillende openbare ketens aan het begin van het jaar iniemunten ondersteunden.</p>
<h2 id="h2-Samenvatting850902"><a name="Samenvatting" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Samenvatting</h2><p>Hoewel Meme in 2024 een nieuw groeipunt is geworden in het blockchain-ecosysteem, domineren Zhuyu’s one-click coin-uitgifteplatform op het Solana-netwerk en ecosysteemtoepassingen vertegenwoordigd door pump.fun nog steeds stevig. De werking van Meme-ecoen op verschillende ketens lijkt nog steeds imitatief maar mist vooruitgang. Hoewel ze proberen gebruikers aan te trekken door de muntuitgiftedrempel te verlagen en het bedieningsproces te vereenvoudigen, ontbreekt het hen aan duurzame welvaartseffecten en sterke liquiditeitssteun, waardoor deze inspanningen vaak ontoereikend zijn.</p>
<p>Er zijn maar weinig concurrenten op de markt die kunnen concurreren met pump.fun, niet omdat de technologie of het model van pump.fun onberispelijk is, maar vanwege de bijzondere aard van de Meme coin-markt. Gebruikers streven naar tastbare welvaartseffecten, gemeenschapsvoordelen met geconcentreerd verkeer en eenvoudige en kosteneffectieve oplossingen, in plaats van complexe functies of fantasierijke platformconcepten. Als het nieuwe platform geen incrementele liquiditeit kan aantrekken via innovatieve middelen, zal de functie ‘one-click coin issuance’ zijn kernwaarde verliezen en een luchtspiegeling worden.</p>
<p>Vooral in de huidige situatie van krappe liquiditeit kan de trend van de Meme-markt in plaats van een algemene stijging roteren, wat ongetwijfeld grote publieke ketens en ecoen dwingt om actief op zoek te gaan naar nieuwe doorbraken. TRON, met zijn oprichtersinvloed, zet grote stappen, BNB Chain en anderen verkennen ook nieuwe strategieën om gebruikers aan te trekken, en potentiële spelers zoals TON staan te popelen om het volgende strijdtoneel te worden voor de Meme coin-rage.</p>
<p>Kortom, de Meme coin rage kan blijven evolueren en nieuwe gebieden zoals TON kunnen ook opkomen. Maar ongeacht hoe de markt verandert, zouden investeerders vast moeten houden aan rationele analyse en voorzichtig deelnemen.</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 mening 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 zal worden toegestaan mits Gate.io wordt vermeld. In alle glen zullen juridische stappen worden ondernomen vanwege schending van het auteursrecht.<br></div><p></p><br></div></div></div></div>