R3VpZGF0aSBkYSBGQVJUQ09JTjogVW5vIHNndWFyZG8gYWxsZSBtaWdsaW9yaSBtb25ldGUgbWVtZSBkaSBQdW1wLmZ1bg==

2025-06-20, 06:21

<p><img src="https://gimg2.gateimg.com/image/pump202506201420072658567562.png" alt="">
</p><p>Nella <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> L’ecosistema, Pump.fun è come una instancabile macchina da stampa di meme coin. Dalla sua lancio nel gennaio 2024, ha permesso a chiunque di creare e scambiare token a un costo di 0,02 SOL (circa 2 USD) in meno di un minuto. Questo meccanismo di creazione di ricchezza (o sogni) senza soglie ha attratto oltre 11 milioni di token a nascere qui. Tuttavia, dati severi rivelano che solo l’1,4% dei token può “laurearsi” con successo su exchange decentralizzati, e quelli che superano il miliardo di dollari di capitalizzazione di mercato sono ancora più rari.</p>
<h2 id="h2-Top20Pumpfun20Meme20Coins20Un20Festival20per20i20Pochi20Vincitori219123"><a name="Top Pump.fun Meme Coins: Un Festival per i Pochi Vincitori" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Top Pump.fun Meme Coins: Un Festival per i Pochi Vincitori</h2><p>Nonostante un tasso di successo estremamente basso, alcuni progetti hanno comunque creato un effetto di ricchezza straordinario su Pump.fun:</p>
<ol>
<li>Fartcoin (FARTCOIN): Originato dall’esperimento AI di Truth Terminal, con “scherzi sulle flatulenze” come nucleo culturale, ogni transazione attiva un effetto sonoro unico. La capitalizzazione di mercato di FARTCOIN ha superato i 2 miliardi di USD, diventando il più abbagliante “mito della creazione di ricchezza” su Pump.fun. Sebbene il prezzo sia fluttuato bruscamente da allora, attualmente occupa ancora il primo posto nell’ecosistema con una capitalizzazione di mercato di 1,04 miliardi di USD.</li><li>Would (WOULD): Un token di esperimento sociale basato sul concetto di “gioco delle scelte”, che determina il <a href="/price/flow-flow" rel="nofollow noopener noreferrer" target="_blank">flusso</a> di fondi (come la distruzione o l’iniezione di liquidità) tramite votazione della comunità 5. Il token WOULD, con il suo concetto unico di gioco di scelta, ha raggiunto una capitalizzazione di mercato di 670 milioni di dollari al suo picco, attualmente riporta una capitalizzazione di mercato di 514 milioni di dollari.</li><li>Peanut lo scoiattolo (PNUT): L’aumento di PNUT è radicato in un evento sociale: lo scoiattolo famoso su internet “Peanut” è stato sequestrato e giustiziato dal Dipartimento della Conservazione Ambientale di New York (DEC), scatenando rapidamente l’indignazione pubblica per l’eccesso di potere del governo. Questo incidente è aumentato a causa delle numerose critiche di Musk sulla piattaforma X, con la sua continua attenzione che ha direttamente acceso l’entusiasmo del mercato. PNUT ha raggiunto una capitalizzazione di mercato di 1,8 miliardi di dollari nel novembre 2024, e la sua attuale capitalizzazione di mercato è riportata a 223 milioni di dollari, una diminuzione di quasi il 90% rispetto al suo picco.</li><li>Moodengsol.com (MOODENG): La celebrità di internet thailandese ippopotamo Meme, che è stata visitata personalmente da <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> il fondatore Vitalik. Il valore di mercato di MOODENG ha raggiunto brevemente 610 milioni di USD alla fine del 2024, e il valore di mercato attuale è riportato essere 150 milioni di USD.</li></ol>
<p>Dietro a queste storie di successo c’è il crollo del 99% dei progetti. I dati di Dune mostrano che tra quasi 600.000 portafogli attivi a maggio, solo lo 0,0045% degli utenti ha realizzato profitti superiori a 100.000$, mentre il 52,5% degli utenti ha subito perdite ed è uscito.</p>
<h2 id="h2-Il20meccanismo20dietro20il20successo20lancio20equo20e20automazione20della20liquidit414595"><a name="Il meccanismo dietro il successo: lancio equo e automazione della liquidità" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Il meccanismo dietro il successo: lancio equo e automazione della liquidità</h2><p>Il progetto ad alta valutazione di Pump.fun non è una coincidenza; il suo meccanismo centrale è progettato con “giustizia limitata”:</p>
<ul>
<li>Nessuna prenotazione, circolazione completa: I creatori rinunciano al diritto di coniare, e tutti i token entrano nel mercato pubblico, eliminando il “trading di topo”.</li><li>Lancio della curva congiunta: Il prezzo del token sale automaticamente con l’importo d’acquisto, e i partecipanti precoci possono ricevere alti premi.</li><li>Listaggio automatico su DEX: Dopo aver raggiunto un valore di mercato di $69.000, la liquidità viene automaticamente depositata in Raydium e i token LP vengono bruciati, bloccando la liquidità per prevenire i rug pull.<br>Questo meccanismo è stato una volta confezionato come uno “strumento anti-raccolta”, ma in realtà è diventato uno strumento di arbitraggio per pochi giocatori esperti. Ad esempio, il token TEST, i primi acquirenti hanno accumulato il 50% dell’offerta per gonfiare il prezzo e poi hanno venduto, portando gli investitori al dettaglio a essere raccolti.</li></ul>
<h2 id="h2-Il20boom20svanisce20sia20la20piattaforma20che20il20mercato20si20stanno20raffreddando238446"><a name="Il boom svanisce: sia la piattaforma che il mercato si stanno raffreddando." class="reference-link"></a><span class="header-link octicon octicon-link"></span>Il boom svanisce: sia la piattaforma che il mercato si stanno raffreddando.</h2><p>Nel 2025, Pump.fun entra in una profonda correzione in sintonia con il mercato delle meme coin:</p>
<ul>
<li>I ricavi della piattaforma crollano: il reddito giornaliero scende da un picco di $15 milioni a diversi milioni di dollari, con un calo del volume di scambi dell’80%.</li><li>L’emissione di token si riduce: la creazione giornaliera di nuove monete scende da 70.000 a 30.000, e l’interesse degli utenti diminuisce notevolmente.</li><li><a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> I meme coin crollano: i token come TRUMP sono diminuiti dell’85% dal loro picco, con FARTCOIN, PENGU e altri che hanno anche subito cali a doppia cifra.</li></ul>
<p>I rischi normativi e di contenzioso stanno aumentando simultaneamente. Nel gennaio 2025, gli investitori americani hanno intentato una causa contro Pump.fun per le perdite subite a causa dell’investimento in PNUT, accusandola di operare come un “exchange di titoli non registrato.”</p>
<h2 id="h2-Controversia20e20Futuro20Una20valutazione20di20420miliardi2020una20bolla20o20una20sottovalutazione834130"><a name="Controversia e Futuro: Una valutazione di 4 miliardi è una bolla o una sottovalutazione?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Controversia e Futuro: Una valutazione di 4 miliardi è una bolla o una sottovalutazione?</h2><p>Di fronte a un calo, Pump.fun prevede di raccogliere 1 miliardo di dollari con una valutazione di 4 miliardi di dollari per emettere token della piattaforma. Il mercato è nettamente diviso su questo:</p>
<ul>
<li>I scettici credono che la valutazione sia assurda. I ricercatori evidenziano la sua mancanza di un vantaggio competitivo, l’eccessiva dipendenza da FOMO a breve termine e un rapporto FDV/entrate così alto come 64, che supera di gran lunga i progetti DeFi maturi come <a href="/price/pancakeswap-cake" rel="nofollow noopener noreferrer" target="_blank">PancakeSwap</a> .</li><li>È considerato dai sostenitori come l’”iPhone on-chain”. I KOL della comunità sottolineano che il suo rapporto prezzo/utili è solo 5 volte, e ha semplificato l’intero processo dall’emissione del token al listing su CEX, rendendolo un vincitore nell’economia dell’attenzione.</li></ul>
<h2 id="h2-Conclusione20Il20paradosso20del20gioco20del20sopravvissuto20e20dellecologia62470"><a name="Conclusione: Il paradosso del gioco del sopravvissuto e dell’ecologia" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusione: Il paradosso del gioco del sopravvissuto e dell’ecologia</h2><p>Il progetto principale di Pump.fun convalida il potenziale di creazione di ricchezza delle meme coin, ma un tasso di successo dell’1,4% sembra più un brutale gioco di sopravvivenza. Mentre la liquidità del mercato si restringe e le regolamentazioni si inaspriscono, il piano di finanziamento dei token da 4 miliardi di dollari della piattaforma diventerà un punto di riferimento: se sarà in grado di costruire un ecosistema Meme sostenibile, potrebbe davvero diventare il “iPhone on-chain”; se si tratta solo di un’ultima fase di raccolta di liquidità, potrebbe accelerare il collasso della bolla.</p>
<p>Come ha detto il commentatore di criptovalute Bunjil: “Pump.fun non ha distrutto i meme coin; ha solo rivelato quanto sia facile crearli.” Quando tutti possono facilmente coniare monete, la scarsità di valore emergerà solo attraverso un processo di selezione più brutale.</p>
<div class="blog-details-info"><br><div>Autore: <strong>Team del Blog</strong><br><div class="info-tips"><em>Il contenuto qui non costituisce alcuna offerta, sollecitazione o raccomandazione. Dovresti sempre cercare un consiglio professionale indipendente prima di prendere decisioni di investimento.<br><div></div>Si prega di notare che Gate potrebbe limitare o vietare l'uso di tutti o di una parte dei Servizi da Località Vietate. Per ulteriori informazioni, si prega di leggere il Contratto Utente tramite <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>