clodds 1.1.0

package/dist/skills/bundled/pumpfun/index.js

@@ -0,0 +1,1400 @@
+"use strict";
+/**
+ * Pump.fun CLI Skill - Complete API Coverage
+ *
+ * Solana memecoin launchpad with bonding curve trading.
+ *
+ * Trading API: PumpPortal (pumpportal.fun)
+ * Data API: PumpPortal WebSocket + Pump.fun Frontend API
+ *
+ * Commands:
+ *
+ * TRADING:
+ * /pump buy <mint> <amount> [--pool <pool>] [--slippage <bps>] [--priority <lamports>]
+ * /pump sell <mint> <amount|%> [--pool <pool>] [--slippage <bps>]
+ * /pump quote <mint> <amount> <action>
+ *
+ * DISCOVERY:
+ * /pump trending - Top performing tokens
+ * /pump new - Recently created tokens
+ * /pump live - Currently trading tokens
+ * /pump graduated - Tokens migrated to Raydium
+ * /pump search <query> - Search tokens
+ * /pump volatile - High volatility tokens
+ * /pump koth - King of the Hill tokens (30-35K mcap)
+ *
+ * TOKEN DATA:
+ * /pump token <mint> - Full token info (metadata, price, holders, liquidity)
+ * /pump price <mint> - Current price and OHLCV
+ * /pump holders <mint> - Top holders
+ * /pump trades <mint> [--limit N] - Recent trades
+ * /pump chart <mint> [--interval 1m|5m|15m|1h|4h|1d] - Price chart data
+ *
+ * CREATION:
+ * /pump create <name> <symbol> <description> [--image <url>] [--twitter <url>]
+ * /pump claim <mint> - Claim creator fees
+ *
+ * MONITORING:
+ * /pump watch <mint> - Watch token for trades (WebSocket)
+ * /pump snipe <symbol> - Wait for token with symbol to launch
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.execute = execute;
+const PUMPPORTAL_API = 'https://pumpportal.fun/api';
+const PUMPFUN_FRONTEND_API = 'https://frontend-api-v3.pump.fun';
+const PUMPFUN_ADVANCED_API = 'https://advanced-api-v2.pump.fun';
+// ============================================================================
+// Helpers
+// ============================================================================
+function getSolanaModules() {
+    return Promise.all([
+        Promise.resolve().then(() => __importStar(require('../../../solana/wallet'))),
+        Promise.resolve().then(() => __importStar(require('../../../solana/pumpapi'))),
+    ]).then(([wallet, pumpapi]) => ({ wallet, pumpapi }));
+}
+function isConfigured() {
+    return !!(process.env.SOLANA_PRIVATE_KEY || process.env.SOLANA_KEYPAIR_PATH);
+}
+async function pumpPortalRequest(endpoint, options = {}) {
+    const apiKey = process.env.PUMPPORTAL_API_KEY;
+    const separator = endpoint.includes('?') ? '&' : '?';
+    const url = apiKey ? `${PUMPPORTAL_API}${endpoint}${separator}api-key=${apiKey}` : `${PUMPPORTAL_API}${endpoint}`;
+    const response = await fetch(url, {
+        ...options,
+        headers: {
+            'Content-Type': 'application/json',
+            ...options.headers,
+        },
+    });
+    if (!response.ok) {
+        const error = await response.text();
+        throw new Error(`PumpPortal error: ${response.status} - ${error}`);
+    }
+    return response.json();
+}
+async function pumpFrontendRequest(endpoint, baseUrl = PUMPFUN_FRONTEND_API) {
+    const jwt = process.env.PUMPFUN_JWT;
+    const headers = {
+        'Accept': 'application/json',
+        'Origin': 'https://pump.fun',
+    };
+    if (jwt) {
+        headers['Authorization'] = `Bearer ${jwt}`;
+    }
+    const response = await fetch(`${baseUrl}${endpoint}`, { headers });
+    if (!response.ok) {
+        throw new Error(`Pump.fun API error: ${response.status}`);
+    }
+    return response.json();
+}
+async function pumpAdvancedRequest(endpoint) {
+    return pumpFrontendRequest(endpoint, PUMPFUN_ADVANCED_API);
+}
+function intervalToTimeframe(interval) {
+    switch (interval) {
+        case '1m': return 60;
+        case '5m': return 300;
+        case '15m': return 900;
+        case '1h': return 3600;
+        case '4h': return 14400;
+        case '1d': return 86400;
+        default: return 3600;
+    }
+}
+function formatPrice(price) {
+    if (price < 0.000001)
+        return price.toExponential(2);
+    if (price < 0.01)
+        return price.toFixed(8);
+    if (price < 1)
+        return price.toFixed(6);
+    return price.toFixed(4);
+}
+function formatMarketCap(mcap) {
+    if (mcap >= 1_000_000)
+        return `$${(mcap / 1_000_000).toFixed(2)}M`;
+    if (mcap >= 1_000)
+        return `$${(mcap / 1_000).toFixed(1)}K`;
+    return `$${mcap.toFixed(0)}`;
+}
+// ============================================================================
+// Trading Handlers
+// ============================================================================
+async function handleBuy(args) {
+    if (!isConfigured()) {
+        return 'Pump.fun not configured. Set SOLANA_PRIVATE_KEY.';
+    }
+    if (args.length < 2) {
+        return `Usage: /pump buy <mint> <amount> [options]
+
+Options:
+  --pool <pool>       Pool: pump, raydium, pump-amm, launchlab, raydium-cpmm, bonk, auto (default: pump)
+  --slippage <bps>    Slippage in bps (default: 500 = 5%)
+  --priority <lamps>  Priority fee in lamports
+
+Examples:
+  /pump buy ABC123... 0.1
+  /pump buy ABC123... 0.5 --pool auto --slippage 1000`;
+    }
+    const mint = args[0];
+    const amount = args[1];
+    // Parse options
+    let pool = 'pump';
+    let slippageBps = 500;
+    let priorityFee;
+    for (let i = 2; i < args.length; i++) {
+        if (args[i] === '--pool' && args[i + 1]) {
+            pool = args[++i];
+        }
+        else if (args[i] === '--slippage' && args[i + 1]) {
+            slippageBps = parseInt(args[++i]);
+        }
+        else if (args[i] === '--priority' && args[i + 1]) {
+            priorityFee = parseInt(args[++i]);
+        }
+    }
+    try {
+        const { wallet, pumpapi } = await getSolanaModules();
+        const keypair = wallet.loadSolanaKeypair();
+        const connection = wallet.getSolanaConnection();
+        const result = await pumpapi.executePumpFunTrade(connection, keypair, {
+            action: 'buy',
+            mint,
+            amount,
+            denominatedInSol: true,
+            slippageBps,
+            priorityFeeLamports: priorityFee,
+            pool,
+        });
+        return `**Pump.fun Buy Complete**
+
+Token: \`${mint.slice(0, 20)}...\`
+SOL Spent: ${amount}
+Pool: ${pool}
+Slippage: ${slippageBps / 100}%
+TX: \`${result.signature}\``;
+    }
+    catch (error) {
+        return `Buy failed: ${error instanceof Error ? error.message : String(error)}`;
+    }
+}
+async function handleSell(args) {
+    if (!isConfigured()) {
+        return 'Pump.fun not configured. Set SOLANA_PRIVATE_KEY.';
+    }
+    if (args.length < 2) {
+        return `Usage: /pump sell <mint> <amount|%> [options]
+
+Amount can be:
+  - Token amount: 1000000
+  - Percentage: 50% or 100%
+
+Options:
+  --pool <pool>       Pool: pump, raydium, pump-amm, launchlab, raydium-cpmm, bonk, auto (default: pump)
+  --slippage <bps>    Slippage in bps (default: 1000 = 10%)
+
+Examples:
+  /pump sell ABC123... 1000000
+  /pump sell ABC123... 100%
+  /pump sell ABC123... 50% --slippage 1500`;
+    }
+    const mint = args[0];
+    let amount = args[1];
+    let pool = 'pump';
+    let slippageBps = 1000; // Higher default for sells
+    for (let i = 2; i < args.length; i++) {
+        if (args[i] === '--pool' && args[i + 1]) {
+            pool = args[++i];
+        }
+        else if (args[i] === '--slippage' && args[i + 1]) {
+            slippageBps = parseInt(args[++i]);
+        }
+    }
+    try {
+        const { wallet, pumpapi } = await getSolanaModules();
+        const keypair = wallet.loadSolanaKeypair();
+        const connection = wallet.getSolanaConnection();
+        const result = await pumpapi.executePumpFunTrade(connection, keypair, {
+            action: 'sell',
+            mint,
+            amount,
+            denominatedInSol: false,
+            slippageBps,
+            pool,
+        });
+        return `**Pump.fun Sell Complete**
+
+Token: \`${mint.slice(0, 20)}...\`
+Amount: ${amount}
+Pool: ${pool}
+TX: \`${result.signature}\``;
+    }
+    catch (error) {
+        return `Sell failed: ${error instanceof Error ? error.message : String(error)}`;
+    }
+}
+async function handleQuote(args) {
+    if (args.length < 3) {
+        return 'Usage: /pump quote <mint> <amount> <buy|sell>';
+    }
+    const [mint, amountStr, action] = args;
+    const amount = parseFloat(amountStr);
+    if (isNaN(amount) || amount <= 0) {
+        return 'Invalid amount. Must be a positive number.';
+    }
+    const actionUpper = action.toUpperCase();
+    try {
+        const { wallet, pumpapi } = await getSolanaModules();
+        const connection = wallet.getSolanaConnection();
+        // Try on-chain quote first (more accurate)
+        const state = await pumpapi.getBondingCurveState(connection, mint);
+        if (state && !state.complete) {
+            // Use on-chain bonding curve calculation
+            const BN = (await Promise.resolve().then(() => __importStar(require('bn.js')))).default;
+            const currentPrice = pumpapi.calculatePrice(state);
+            if (actionUpper === 'BUY') {
+                const solLamports = new BN(Math.floor(amount * 1e9));
+                const quote = pumpapi.calculateBuyQuote(state, solLamports, 100);
+                const tokensOut = quote.tokensOut.toNumber() / 1e6;
+                const feeSOL = quote.fee.toNumber() / 1e9;
+                return `**Pump.fun Quote (On-Chain)**
+
+Token: \`${mint.slice(0, 20)}...\`
+Action: BUY
+
+**Input:** ${amount} SOL
+**Output:** ${tokensOut.toLocaleString(undefined, { maximumFractionDigits: 2 })} tokens
+**Fee (1%):** ${feeSOL.toFixed(6)} SOL
+**Price Impact:** ${quote.priceImpact.toFixed(2)}%
+**Price After:** ${formatPrice(quote.newPrice)} SOL
+
+Current Price: ${formatPrice(currentPrice)} SOL`;
+            }
+            else {
+                const tokenLamports = new BN(Math.floor(amount * 1e6));
+                const quote = pumpapi.calculateSellQuote(state, tokenLamports, 100);
+                const solOut = quote.solOut.toNumber() / 1e9;
+                const feeSOL = quote.fee.toNumber() / 1e9;
+                return `**Pump.fun Quote (On-Chain)**
+
+Token: \`${mint.slice(0, 20)}...\`
+Action: SELL
+
+**Input:** ${amount.toLocaleString()} tokens
+**Output:** ${solOut.toFixed(6)} SOL
+**Fee (1%):** ${feeSOL.toFixed(6)} SOL
+**Price Impact:** ${quote.priceImpact.toFixed(2)}%
+**Price After:** ${formatPrice(quote.newPrice)} SOL
+
+Current Price: ${formatPrice(currentPrice)} SOL`;
+            }
+        }
+        // Fallback to API estimate for graduated tokens
+        const token = await pumpFrontendRequest(`/coins/${mint}?sync=true`);
+        if (!token?.price) {
+            return `Could not get price data for token \`${mint.slice(0, 20)}...\``;
+        }
+        const pricePerToken = token.price;
+        const feeRate = 0.005;
+        let inputDesc;
+        let outputDesc;
+        let outputAmount;
+        let fee;
+        if (actionUpper === 'BUY') {
+            fee = amount * feeRate;
+            const netSol = amount - fee;
+            outputAmount = pricePerToken > 0 ? netSol / pricePerToken : 0;
+            inputDesc = `${amount} SOL`;
+            outputDesc = `~${outputAmount.toLocaleString(undefined, { maximumFractionDigits: 2 })} ${token.symbol || 'tokens'}`;
+        }
+        else {
+            const grossSol = amount * pricePerToken;
+            fee = grossSol * feeRate;
+            outputAmount = grossSol - fee;
+            inputDesc = `${amount.toLocaleString()} ${token.symbol || 'tokens'}`;
+            outputDesc = `~${outputAmount.toFixed(6)} SOL`;
+        }
+        return `**Pump.fun Quote (Raydium - Graduated)**
+
+Token: **${token.symbol || '?'}** \`${mint.slice(0, 20)}...\`
+Action: ${actionUpper}
+Price: ${formatPrice(pricePerToken)} SOL${token.priceUsd ? ` ($${formatPrice(token.priceUsd)})` : ''}
+MCap: ${formatMarketCap(token.marketCap || 0)}
+
+Input: ${inputDesc}
+Output: ${outputDesc}
+Fee (0.5%): ${fee.toFixed(6)} SOL
+
+*Token has graduated to Raydium. Use Jupiter for best execution.*`;
+    }
+    catch (error) {
+        return `Quote failed: ${error instanceof Error ? error.message : String(error)}`;
+    }
+}
+// ============================================================================
+// Discovery Handlers
+// ============================================================================
+async function handleTrending() {
+    try {
+        const tokens = await pumpFrontendRequest('/coins/top-runners');
+        if (!tokens?.length)
+            return 'No trending tokens found.';
+        let output = '**Trending on Pump.fun**\n\n';
+        for (let i = 0; i < Math.min(tokens.length, 15); i++) {
+            const t = tokens[i];
+            output += `${i + 1}. **${t.symbol}** - ${t.name}\n`;
+            output += `   MCap: ${formatMarketCap(t.marketCap || 0)}`;
+            if (t.volume24h)
+                output += ` | Vol: ${formatMarketCap(t.volume24h)}`;
+            output += `\n   \`${t.mint.slice(0, 20)}...\`\n\n`;
+        }
+        return output;
+    }
+    catch (error) {
+        return `Error: ${error instanceof Error ? error.message : String(error)}`;
+    }
+}
+async function handleNew() {
+    try {
+        const tokens = await pumpFrontendRequest('/coins/currently-live?limit=20&offset=0&includeNsfw=false&order=DESC');
+        if (!tokens?.length)
+            return 'No new tokens found.';
+        let output = '**New Pump.fun Tokens**\n\n';
+        for (const t of tokens.slice(0, 15)) {
+            output += `**${t.symbol}** - ${t.name}\n`;
+            output += `  MCap: ${formatMarketCap(t.marketCap || 0)}`;
+            if (t.bondingCurveProgress !== undefined) {
+                output += ` | Bonding: ${(t.bondingCurveProgress * 100).toFixed(1)}%`;
+            }
+            output += `\n  \`${t.mint.slice(0, 20)}...\`\n\n`;
+        }
+        return output;
+    }
+    catch (error) {
+        return `Error: ${error instanceof Error ? error.message : String(error)}`;
+    }
+}
+async function handleLive() {
+    try {
+        const tokens = await pumpFrontendRequest('/coins/currently-live?limit=20&offset=0&includeNsfw=false');
+        if (!tokens?.length)
+            return 'No live tokens found.';
+        let output = '**Live on Pump.fun**\n\n';
+        for (const t of tokens.slice(0, 15)) {
+            output += `**${t.symbol}** - ${t.name}\n`;
+            output += `  MCap: ${formatMarketCap(t.marketCap || 0)}`;
+            if (t.holders)
+                output += ` | Holders: ${t.holders}`;
+            output += `\n  \`${t.mint.slice(0, 20)}...\`\n\n`;
+        }
+        return output;
+    }
+    catch (error) {
+        return `Error: ${error instanceof Error ? error.message : String(error)}`;
+    }
+}
+async function handleGraduated() {
+    try {
+        const tokens = await pumpFrontendRequest('/coins/graduated?limit=20&offset=0&includeNsfw=false');
+        if (!tokens?.length)
+            return 'No graduated tokens found.';
+        let output = '**Graduated to Raydium**\n\n';
+        for (const t of tokens.slice(0, 15)) {
+            output += `**${t.symbol}** - ${t.name}\n`;
+            output += `  MCap: ${formatMarketCap(t.marketCap || 0)}`;
+            if (t.liquidity)
+                output += ` | Liq: ${formatMarketCap(t.liquidity)}`;
+            output += `\n  \`${t.mint.slice(0, 20)}...\`\n\n`;
+        }
+        return output;
+    }
+    catch (error) {
+        return `Error: ${error instanceof Error ? error.message : String(error)}`;
+    }
+}
+async function handleSearch(query) {
+    if (!query) {
+        return 'Usage: /pump search <query>';
+    }
+    try {
+        const tokens = await pumpFrontendRequest(`/coins/search?query=${encodeURIComponent(query)}&limit=15&offset=0&includeNsfw=false`);
+        if (!tokens?.length)
+            return `No tokens found for "${query}".`;
+        let output = `**Search: "${query}"**\n\n`;
+        for (const t of tokens) {
+            output += `**${t.symbol}** - ${t.name}\n`;
+            output += `  MCap: ${formatMarketCap(t.marketCap || 0)}`;
+            if (t.graduated)
+                output += ' ✓ Graduated';
+            output += `\n  \`${t.mint}\`\n\n`;
+        }
+        return output;
+    }
+    catch (error) {
+        return `Error: ${error instanceof Error ? error.message : String(error)}`;
+    }
+}
+async function handleVolatile() {
+    try {
+        // Volatile endpoint may be on frontend API or advanced API — try both
+        let tokens = null;
+        try {
+            tokens = await pumpFrontendRequest('/coins/volatile?limit=15');
+        }
+        catch {
+            // Fall back to advanced API
+            try {
+                tokens = await pumpAdvancedRequest('/coins/volatile?limit=15');
+            }
+            catch { /* ignore */ }
+        }
+        if (!tokens?.length)
+            return 'No volatile tokens found.';
+        let output = '**High Volatility Tokens**\n\n';
+        for (const t of tokens) {
+            output += `**${t.symbol}** - ${t.name}\n`;
+            output += `  MCap: ${formatMarketCap(t.marketCap || 0)}`;
+            output += `\n  \`${t.mint.slice(0, 20)}...\`\n\n`;
+        }
+        return output;
+    }
+    catch (error) {
+        return `Error: ${error instanceof Error ? error.message : String(error)}`;
+    }
+}
+async function handleKOTH() {
+    try {
+        const token = await pumpFrontendRequest('/coins/king-of-the-hill?includeNsfw=false');
+        // Endpoint may return a single token or an array
+        const tokens = Array.isArray(token) ? token : [token];
+        if (!tokens?.length || !tokens[0]?.mint)
+            return 'No KOTH tokens found.';
+        let output = '**King of the Hill**\n\n';
+        for (const t of tokens) {
+            output += `**${t.symbol}** - ${t.name}\n`;
+            output += `  MCap: ${formatMarketCap(t.marketCap || 0)}`;
+            if (t.bondingCurveProgress !== undefined) {
+                output += ` | Progress: ${(t.bondingCurveProgress * 100).toFixed(1)}%`;
+            }
+            output += `\n  \`${t.mint.slice(0, 20)}...\`\n\n`;
+        }
+        return output;
+    }
+    catch (error) {
+        return `Error: ${error instanceof Error ? error.message : String(error)}`;
+    }
+}
+// ============================================================================
+// Token Data Handlers
+// ============================================================================
+async function handleToken(mint) {
+    if (!mint) {
+        return 'Usage: /pump token <mint>';
+    }
+    try {
+        const token = await pumpFrontendRequest(`/coins/${mint}?sync=true`);
+        let output = `**${token.symbol}** - ${token.name}\n\n`;
+        output += `Mint: \`${token.mint}\`\n`;
+        if (token.description)
+            output += `Description: ${token.description.slice(0, 150)}${token.description.length > 150 ? '...' : ''}\n`;
+        output += `\n**Market Data:**\n`;
+        if (token.price)
+            output += `  Price: ${formatPrice(token.price)} SOL`;
+        if (token.priceUsd)
+            output += ` ($${formatPrice(token.priceUsd)})`;
+        output += '\n';
+        if (token.marketCap)
+            output += `  Market Cap: ${formatMarketCap(token.marketCap)}\n`;
+        if (token.liquidity)
+            output += `  Liquidity: ${formatMarketCap(token.liquidity)}\n`;
+        if (token.volume24h)
+            output += `  24h Volume: ${formatMarketCap(token.volume24h)}\n`;
+        if (token.holders)
+            output += `  Holders: ${token.holders.toLocaleString()}\n`;
+        if (token.bondingCurveProgress !== undefined) {
+            output += `\n**Bonding Curve:** ${(token.bondingCurveProgress * 100).toFixed(1)}%`;
+            if (token.graduated)
+                output += ' ✓ Graduated to Raydium';
+            output += '\n';
+        }
+        if (token.creator)
+            output += `\nCreator: \`${token.creator.slice(0, 12)}...\`\n`;
+        if (token.twitter || token.telegram || token.website) {
+            output += '\n**Links:**\n';
+            if (token.twitter)
+                output += `  Twitter: ${token.twitter}\n`;
+            if (token.telegram)
+                output += `  Telegram: ${token.telegram}\n`;
+            if (token.website)
+                output += `  Website: ${token.website}\n`;
+        }
+        return output;
+    }
+    catch (error) {
+        return `Error: ${error instanceof Error ? error.message : String(error)}`;
+    }
+}
+async function handlePrice(mint) {
+    if (!mint) {
+        return 'Usage: /pump price <mint>';
+    }
+    try {
+        const [token, ohlcv] = await Promise.all([
+            pumpFrontendRequest(`/coins/${mint}?sync=true`),
+            pumpFrontendRequest(`/candlesticks/${mint}?offset=0&limit=24&timeframe=${intervalToTimeframe('1h')}`).catch(() => null),
+        ]);
+        let output = `**${token.symbol} Price**\n\n`;
+        output += `Current: ${formatPrice(token.price || 0)} SOL`;
+        if (token.priceUsd)
+            output += ` ($${formatPrice(token.priceUsd)})`;
+        output += '\n';
+        output += `Market Cap: ${formatMarketCap(token.marketCap || 0)}\n`;
+        if (ohlcv?.length) {
+            const first = ohlcv[0];
+            const last = ohlcv[ohlcv.length - 1];
+            const change = ((last.close - first.open) / first.open) * 100;
+            const high = Math.max(...ohlcv.map(c => c.high));
+            const low = Math.min(...ohlcv.map(c => c.low));
+            output += `\n**24h Stats:**\n`;
+            output += `  Change: ${change >= 0 ? '+' : ''}${change.toFixed(2)}%\n`;
+            output += `  High: ${formatPrice(high)} SOL\n`;
+            output += `  Low: ${formatPrice(low)} SOL\n`;
+            output += `  Volume: ${formatMarketCap(ohlcv.reduce((sum, c) => sum + c.volume, 0))}\n`;
+        }
+        return output;
+    }
+    catch (error) {
+        return `Error: ${error instanceof Error ? error.message : String(error)}`;
+    }
+}
+async function handleHolders(mint) {
+    if (!mint) {
+        return 'Usage: /pump holders <mint>';
+    }
+    try {
+        const holders = await pumpAdvancedRequest(`/coins/top-holders-and-sol-balance/${mint}`);
+        if (!holders?.length)
+            return 'No holder data available.';
+        let output = `**Top Holders**\n\nMint: \`${mint.slice(0, 20)}...\`\n\n`;
+        let totalPct = 0;
+        for (let i = 0; i < holders.length; i++) {
+            const h = holders[i];
+            output += `${i + 1}. \`${h.wallet.slice(0, 12)}...\` - ${h.percentage.toFixed(2)}%`;
+            if (h.isCreator)
+                output += ' (Creator)';
+            output += `\n   ${h.balance.toLocaleString()} tokens\n`;
+            totalPct += h.percentage;
+        }
+        output += `\n**Top ${holders.length} hold ${totalPct.toFixed(1)}%**`;
+        return output;
+    }
+    catch (error) {
+        return `Error: ${error instanceof Error ? error.message : String(error)}`;
+    }
+}
+async function handleTrades(args) {
+    if (!args[0]) {
+        return 'Usage: /pump trades <mint> [--limit N]';
+    }
+    const mint = args[0];
+    let limit = 20;
+    for (let i = 1; i < args.length; i++) {
+        if (args[i] === '--limit' && args[i + 1]) {
+            limit = parseInt(args[++i]);
+        }
+    }
+    try {
+        const trades = await pumpFrontendRequest(`/trades/all/${mint}?limit=${limit}&offset=0&minimumSize=0`);
+        if (!trades?.length)
+            return 'No trades found.';
+        let output = `**Recent Trades**\n\nMint: \`${mint.slice(0, 20)}...\`\n\n`;
+        for (const t of trades.slice(0, 15)) {
+            const action = t.type === 'buy' ? '🟢 BUY' : '🔴 SELL';
+            const time = new Date(t.timestamp * 1000).toLocaleTimeString();
+            output += `${action} ${t.solAmount.toFixed(4)} SOL @ ${formatPrice(t.pricePerToken)}\n`;
+            output += `  ${time} | \`${t.wallet.slice(0, 8)}...\`\n`;
+        }
+        return output;
+    }
+    catch (error) {
+        return `Error: ${error instanceof Error ? error.message : String(error)}`;
+    }
+}
+async function handleChart(args) {
+    if (!args[0]) {
+        return 'Usage: /pump chart <mint> [--interval 1m|5m|15m|1h|4h|1d]';
+    }
+    const mint = args[0];
+    let interval = '1h';
+    for (let i = 1; i < args.length; i++) {
+        if (args[i] === '--interval' && args[i + 1]) {
+            interval = args[++i];
+        }
+    }
+    try {
+        const ohlcv = await pumpFrontendRequest(`/candlesticks/${mint}?offset=0&limit=24&timeframe=${intervalToTimeframe(interval)}`);
+        if (!ohlcv?.length)
+            return 'No chart data available.';
+        let output = `**Price Chart (${interval})**\n\nMint: \`${mint.slice(0, 20)}...\`\n\n`;
+        output += '```\n';
+        output += 'Time       | Open     | High     | Low      | Close    | Vol\n';
+        output += '-----------+----------+----------+----------+----------+--------\n';
+        for (const c of ohlcv.slice(-12)) {
+            const time = new Date(c.timestamp * 1000).toLocaleTimeString().slice(0, 5);
+            output += `${time.padEnd(10)} | ${formatPrice(c.open).padEnd(8)} | ${formatPrice(c.high).padEnd(8)} | ${formatPrice(c.low).padEnd(8)} | ${formatPrice(c.close).padEnd(8)} | ${formatMarketCap(c.volume)}\n`;
+        }
+        output += '```';
+        return output;
+    }
+    catch (error) {
+        return `Error: ${error instanceof Error ? error.message : String(error)}`;
+    }
+}
+// ============================================================================
+// On-Chain Data Handlers
+// ============================================================================
+async function handleBalance(args) {
+    if (!args[0]) {
+        return 'Usage: /pump balance <mint> [wallet]';
+    }
+    const mint = args[0];
+    const owner = args[1]; // Optional, defaults to user's wallet
+    try {
+        const { wallet, pumpapi } = await getSolanaModules();
+        const connection = wallet.getSolanaConnection();
+        const ownerAddress = owner || (isConfigured() ? wallet.loadSolanaKeypair().publicKey.toBase58() : null);
+        if (!ownerAddress) {
+            return 'Wallet address required. Set SOLANA_PRIVATE_KEY or provide wallet address.';
+        }
+        const balance = await pumpapi.getTokenBalance(connection, ownerAddress, mint);
+        if (!balance || balance.balance === 0) {
+            return `**Token Balance**
+
+Mint: \`${mint.slice(0, 20)}...\`
+Wallet: \`${ownerAddress.slice(0, 12)}...\`
+Balance: 0 tokens`;
+        }
+        // Get token info for symbol
+        const token = await pumpFrontendRequest(`/coins/${mint}?sync=true`).catch(() => null);
+        const priceInfo = await pumpapi.getTokenPriceInfo(connection, mint).catch(() => null);
+        let output = `**Token Balance**
+
+Token: ${token?.symbol || '?'} \`${mint.slice(0, 20)}...\`
+Wallet: \`${ownerAddress.slice(0, 12)}...\`
+Balance: **${balance.balance.toLocaleString()}** tokens`;
+        if (priceInfo) {
+            const valueSOL = balance.balance * priceInfo.priceInSol;
+            output += `\nValue: ~${valueSOL.toFixed(4)} SOL`;
+        }
+        return output;
+    }
+    catch (error) {
+        return `Error: ${error instanceof Error ? error.message : String(error)}`;
+    }
+}
+async function handleHoldings(args) {
+    const owner = args[0]; // Optional
+    try {
+        const { wallet, pumpapi } = await getSolanaModules();
+        const connection = wallet.getSolanaConnection();
+        const ownerAddress = owner || (isConfigured() ? wallet.loadSolanaKeypair().publicKey.toBase58() : null);
+        if (!ownerAddress) {
+            return 'Wallet address required. Set SOLANA_PRIVATE_KEY or provide wallet address.';
+        }
+        const holdings = await pumpapi.getUserPumpTokens(connection, ownerAddress);
+        if (!holdings.length) {
+            return `**Pump.fun Holdings**
+
+Wallet: \`${ownerAddress.slice(0, 12)}...\`
+No Pump.fun tokens found.`;
+        }
+        let output = `**Pump.fun Holdings**
+
+Wallet: \`${ownerAddress.slice(0, 12)}...\`
+Tokens: ${holdings.length}
+
+`;
+        for (const h of holdings.slice(0, 15)) {
+            const token = await pumpFrontendRequest(`/coins/${h.mint}?sync=true`).catch(() => null);
+            const symbol = token?.symbol || '???';
+            output += `**${symbol}** - ${h.balance.toLocaleString()} tokens\n`;
+            output += `  \`${h.mint.slice(0, 20)}...\`\n`;
+        }
+        if (holdings.length > 15) {
+            output += `\n... and ${holdings.length - 15} more`;
+        }
+        return output;
+    }
+    catch (error) {
+        return `Error: ${error instanceof Error ? error.message : String(error)}`;
+    }
+}
+async function handleBonding(mint) {
+    if (!mint) {
+        return 'Usage: /pump bonding <mint>';
+    }
+    try {
+        const { wallet, pumpapi } = await getSolanaModules();
+        const connection = wallet.getSolanaConnection();
+        const state = await pumpapi.getBondingCurveState(connection, mint);
+        if (!state) {
+            return `Bonding curve not found for \`${mint.slice(0, 20)}...\`
+
+Token may not exist or has already graduated to Raydium.`;
+        }
+        const price = pumpapi.calculatePrice(state);
+        const progress = pumpapi.calculateBondingProgress(state);
+        const liquiditySOL = state.realSolReserves.toNumber() / 1e9;
+        const tokensRemaining = state.realTokenReserves.toNumber() / 1e6;
+        // Get token info for context
+        const token = await pumpFrontendRequest(`/coins/${mint}?sync=true`).catch(() => null);
+        let output = `**Bonding Curve State** ${state.complete ? '✅ GRADUATED' : '📈 ACTIVE'}
+
+Token: ${token?.symbol || '?'} \`${mint.slice(0, 20)}...\`
+${state.isMayhemMode ? '⚡ Mayhem Mode (Token2022)\n' : ''}
+**Reserves:**
+  Virtual SOL: ${(state.virtualSolReserves.toNumber() / 1e9).toFixed(4)}
+  Virtual Tokens: ${(state.virtualTokenReserves.toNumber() / 1e6).toLocaleString()}
+  Real SOL: ${liquiditySOL.toFixed(4)} SOL
+  Real Tokens: ${tokensRemaining.toLocaleString()}
+
+**Metrics:**
+  Price: ${formatPrice(price)} SOL
+  Progress: ${(progress * 100).toFixed(1)}%
+  Liquidity: ${liquiditySOL.toFixed(2)} SOL`;
+        if (state.complete) {
+            output += '\n\n*Token has graduated to Raydium. Use Jupiter for trading.*';
+        }
+        return output;
+    }
+    catch (error) {
+        return `Error: ${error instanceof Error ? error.message : String(error)}`;
+    }
+}
+async function handleBestPool(mint) {
+    if (!mint) {
+        return 'Usage: /pump best-pool <mint>';
+    }
+    try {
+        const { wallet, pumpapi } = await getSolanaModules();
+        const connection = wallet.getSolanaConnection();
+        const result = await pumpapi.getBestPool(connection, mint);
+        if (result.pool === 'raydium') {
+            return `**Best Execution Venue**
+
+Token: \`${mint.slice(0, 20)}...\`
+Status: ✅ Graduated
+Venue: **Raydium**
+${result.raydiumPool ? `Pool: \`${result.raydiumPool}\`` : ''}
+
+Use Jupiter aggregator for best execution on graduated tokens.`;
+        }
+        return `**Best Execution Venue**
+
+Token: \`${mint.slice(0, 20)}...\`
+Status: 📈 Active Bonding
+Venue: **Pump.fun**
+
+Trade directly on pump.fun bonding curve for best execution.`;
+    }
+    catch (error) {
+        return `Error: ${error instanceof Error ? error.message : String(error)}`;
+    }
+}
+// ============================================================================
+// Additional Discovery Handlers
+// ============================================================================
+async function handleForYou() {
+    try {
+        const tokens = await pumpFrontendRequest('/coins/for-you?limit=20&offset=0&includeNsfw=false');
+        if (!tokens?.length)
+            return 'No personalized recommendations available.';
+        let output = '**For You - Personalized Recommendations**\n\n';
+        for (const t of tokens.slice(0, 10)) {
+            output += `**${t.name}** (${t.symbol})\n`;
+            output += `  Mint: \`${t.mint.slice(0, 20)}...\`\n`;
+            if (t.marketCap)
+                output += `  MCap: ${formatMarketCap(t.marketCap)}`;
+            if (t.volume24h)
+                output += ` | Vol: ${formatMarketCap(t.volume24h)}`;
+            output += '\n\n';
+        }
+        return output;
+    }
+    catch (error) {
+        return `Error: ${error instanceof Error ? error.message : String(error)}`;
+    }
+}
+async function handleMetas() {
+    try {
+        const metas = await pumpFrontendRequest('/metas/current');
+        if (!metas?.length)
+            return 'No trending metas available.';
+        let output = '**Trending Metas/Narratives**\n\n';
+        for (const m of metas.slice(0, 20)) {
+            const trendIcon = m.trending ? '🔥 ' : '';
+            output += `${trendIcon}**${m.word}** - ${m.count} tokens\n`;
+        }
+        return output;
+    }
+    catch (error) {
+        return `Error: ${error instanceof Error ? error.message : String(error)}`;
+    }
+}
+async function handleSimilar(mint) {
+    if (!mint)
+        return 'Usage: /pump similar <mint>';
+    try {
+        const tokens = await pumpFrontendRequest(`/coins/similar?mint=${mint}&limit=10`);
+        if (!tokens?.length)
+            return 'No similar tokens found.';
+        let output = `**Similar Tokens**\n\nSource: \`${mint.slice(0, 20)}...\`\n\n`;
+        for (const t of tokens) {
+            output += `**${t.name}** (${t.symbol})\n`;
+            output += `  Mint: \`${t.mint.slice(0, 20)}...\`\n`;
+            if (t.marketCap)
+                output += `  MCap: ${formatMarketCap(t.marketCap)}\n`;
+            output += '\n';
+        }
+        return output;
+    }
+    catch (error) {
+        return `Error: ${error instanceof Error ? error.message : String(error)}`;
+    }
+}
+async function handleUserCoins(address) {
+    if (!address)
+        return 'Usage: /pump user-coins <wallet-address>';
+    try {
+        const coins = await pumpFrontendRequest(`/coins/user-created-coins/${address}`);
+        if (!coins?.length)
+            return 'No tokens created by this wallet.';
+        let output = `**Tokens Created by Wallet**\n\nWallet: \`${address.slice(0, 20)}...\`\n\n`;
+        for (const t of coins.slice(0, 15)) {
+            const status = t.graduated ? '🎓' : '📈';
+            output += `${status} **${t.name}** (${t.symbol})\n`;
+            output += `  Mint: \`${t.mint.slice(0, 20)}...\`\n`;
+            if (t.marketCap)
+                output += `  MCap: ${formatMarketCap(t.marketCap)}\n`;
+            output += '\n';
+        }
+        return output;
+    }
+    catch (error) {
+        return `Error: ${error instanceof Error ? error.message : String(error)}`;
+    }
+}
+async function handleIpfsUpload(args) {
+    if (args.length < 3) {
+        return `Usage: /pump ipfs-upload <name> <symbol> <description> [options]
+
+Options:
+  --image <url>      Image URL to upload
+  --twitter <url>    Twitter link
+  --telegram <url>   Telegram link
+  --website <url>    Website link
+
+Returns: metadataUri for use in token creation`;
+    }
+    const name = args[0];
+    const symbol = args[1];
+    const description = args.slice(2).join(' ').split('--')[0].trim();
+    let imageUrl;
+    let twitter;
+    let telegram;
+    let website;
+    for (let i = 0; i < args.length; i++) {
+        if (args[i] === '--image' && args[i + 1]) {
+            imageUrl = args[++i];
+        }
+        if (args[i] === '--twitter' && args[i + 1]) {
+            twitter = args[++i];
+        }
+        if (args[i] === '--telegram' && args[i + 1]) {
+            telegram = args[++i];
+        }
+        if (args[i] === '--website' && args[i + 1]) {
+            website = args[++i];
+        }
+    }
+    try {
+        const formData = new FormData();
+        formData.append('name', name);
+        formData.append('symbol', symbol);
+        formData.append('description', description);
+        if (twitter)
+            formData.append('twitter', twitter);
+        if (telegram)
+            formData.append('telegram', telegram);
+        if (website)
+            formData.append('website', website);
+        formData.append('showName', 'true');
+        if (imageUrl) {
+            const imgResponse = await fetch(imageUrl);
+            if (imgResponse.ok) {
+                const blob = await imgResponse.blob();
+                formData.append('file', blob, 'image.png');
+            }
+        }
+        const response = await fetch('https://pump.fun/api/ipfs', {
+            method: 'POST',
+            body: formData,
+        });
+        if (!response.ok)
+            throw new Error(`IPFS upload failed: ${response.status}`);
+        const result = await response.json();
+        return `**IPFS Upload Successful**
+
+Name: ${name}
+Symbol: ${symbol}
+Description: ${description.slice(0, 50)}...
+
+**Metadata URI:** \`${result.metadataUri}\`
+
+Use this URI when creating your token.`;
+    }
+    catch (error) {
+        return `Error: ${error instanceof Error ? error.message : String(error)}`;
+    }
+}
+// ============================================================================
+// Platform Data Handlers
+// ============================================================================
+async function handleLatestTrades(args) {
+    let limit = 20;
+    for (let i = 0; i < args.length; i++) {
+        if (args[i] === '--limit' && args[i + 1]) {
+            limit = parseInt(args[++i]);
+        }
+    }
+    try {
+        const trades = await pumpFrontendRequest(`/trades/latest?limit=${limit}&offset=0`);
+        if (!trades?.length)
+            return 'No recent trades.';
+        let output = '**Latest Trades (Platform-wide)**\n\n';
+        for (const t of trades.slice(0, 15)) {
+            const action = t.type === 'buy' ? '🟢' : '🔴';
+            const time = new Date(t.timestamp * 1000).toLocaleTimeString();
+            output += `${action} ${t.solAmount.toFixed(3)} SOL | \`${t.mint.slice(0, 12)}...\`\n`;
+            output += `   ${time} | \`${t.wallet.slice(0, 8)}...\`\n`;
+        }
+        return output;
+    }
+    catch (error) {
+        return `Error: ${error instanceof Error ? error.message : String(error)}`;
+    }
+}
+async function handleSolPrice() {
+    try {
+        const result = await pumpFrontendRequest('/sol-price');
+        return `**SOL Price**
+
+Price: $${result.priceUsd?.toFixed(2) || result.price?.toFixed(2) || 'N/A'}`;
+    }
+    catch (error) {
+        return `Error: ${error instanceof Error ? error.message : String(error)}`;
+    }
+}
+// ============================================================================
+// Creation Handlers
+// ============================================================================
+async function handleCreate(args) {
+    if (!isConfigured()) {
+        return 'Pump.fun not configured. Set SOLANA_PRIVATE_KEY.';
+    }
+    if (args.length < 3) {
+        return `Usage: /pump create <name> <symbol> <description> [options]
+
+Options:
+  --image <url>      Token image URL
+  --twitter <url>    Twitter link
+  --telegram <url>   Telegram link
+  --website <url>    Website link
+  --initial <SOL>    Initial buy amount (default: 0)
+  --slippage <pct>   Slippage percent (default: 10)
+  --priority <SOL>   Priority fee in SOL (default: 0.0005)
+
+Example:
+  /pump create "Moon Dog" MDOG "The moon-bound dog" --image https://i.imgur.com/abc.png --initial 0.5`;
+    }
+    const name = args[0];
+    const symbol = args[1];
+    const description = args[2];
+    let imageUrl;
+    let twitter;
+    let telegram;
+    let website;
+    let initialBuy = 0;
+    let slippage = 10;
+    let priorityFee = 0.0005;
+    for (let i = 3; i < args.length; i++) {
+        if (args[i] === '--image' && args[i + 1]) {
+            imageUrl = args[++i];
+        }
+        else if (args[i] === '--twitter' && args[i + 1]) {
+            twitter = args[++i];
+        }
+        else if (args[i] === '--telegram' && args[i + 1]) {
+            telegram = args[++i];
+        }
+        else if (args[i] === '--website' && args[i + 1]) {
+            website = args[++i];
+        }
+        else if (args[i] === '--initial' && args[i + 1]) {
+            initialBuy = parseFloat(args[++i]);
+        }
+        else if (args[i] === '--slippage' && args[i + 1]) {
+            slippage = parseInt(args[++i]);
+        }
+        else if (args[i] === '--priority' && args[i + 1]) {
+            priorityFee = parseFloat(args[++i]);
+        }
+    }
+    try {
+        const { wallet } = await getSolanaModules();
+        const walletKeypair = wallet.loadSolanaKeypair();
+        const connection = wallet.getSolanaConnection();
+        const { Keypair, VersionedTransaction } = await Promise.resolve().then(() => __importStar(require('@solana/web3.js')));
+        // Step 1: Upload metadata to IPFS
+        const formData = new FormData();
+        formData.append('name', name);
+        formData.append('symbol', symbol);
+        formData.append('description', description);
+        if (twitter)
+            formData.append('twitter', twitter);
+        if (telegram)
+            formData.append('telegram', telegram);
+        if (website)
+            formData.append('website', website);
+        formData.append('showName', 'true');
+        if (imageUrl) {
+            const imgResponse = await fetch(imageUrl);
+            if (imgResponse.ok) {
+                const blob = await imgResponse.blob();
+                formData.append('file', blob, 'image.png');
+            }
+            else {
+                return `Failed to download image from ${imageUrl}`;
+            }
+        }
+        const ipfsResponse = await fetch('https://pump.fun/api/ipfs', {
+            method: 'POST',
+            body: formData,
+        });
+        if (!ipfsResponse.ok) {
+            throw new Error(`IPFS upload failed: ${ipfsResponse.status} - ${await ipfsResponse.text()}`);
+        }
+        const ipfsResult = await ipfsResponse.json();
+        if (!ipfsResult.metadataUri) {
+            throw new Error('IPFS upload returned no metadataUri');
+        }
+        // Step 2: Generate a new mint keypair
+        const mintKeypair = Keypair.generate();
+        // Step 3: Create token via PumpPortal trade-local endpoint
+        const endpoint = process.env.PUMPFUN_LOCAL_TX_URL || 'https://pumpportal.fun/api/trade-local';
+        const createBody = {
+            publicKey: walletKeypair.publicKey.toBase58(),
+            action: 'create',
+            tokenMetadata: {
+                name,
+                symbol,
+                uri: ipfsResult.metadataUri,
+            },
+            mint: mintKeypair.publicKey.toBase58(),
+            denominatedInSol: 'true',
+            amount: initialBuy,
+            slippage,
+            priorityFee,
+            pool: 'pump',
+        };
+        const response = await fetch(endpoint, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(createBody),
+        });
+        if (!response.ok) {
+            const errorText = await response.text();
+            throw new Error(`PumpPortal create error: ${response.status} - ${errorText}`);
+        }
+        // Step 4: Deserialize, sign with BOTH keypairs, and send
+        const txBytes = new Uint8Array(await response.arrayBuffer());
+        const tx = VersionedTransaction.deserialize(txBytes);
+        tx.sign([mintKeypair, walletKeypair]);
+        const signature = await connection.sendRawTransaction(tx.serialize());
+        await connection.confirmTransaction(signature, 'confirmed');
+        return `**Token Created!**
+
+Name: ${name}
+Symbol: ${symbol}
+Mint: \`${mintKeypair.publicKey.toBase58()}\`
+Metadata: \`${ipfsResult.metadataUri}\`
+TX: \`${signature}\`
+
+Your token is now live on pump.fun!
+${initialBuy > 0 ? `Initial buy: ${initialBuy} SOL` : 'No initial buy.'}`;
+    }
+    catch (error) {
+        return `Creation failed: ${error instanceof Error ? error.message : String(error)}`;
+    }
+}
+async function handleClaim(mint) {
+    if (!isConfigured()) {
+        return 'Pump.fun not configured. Set SOLANA_PRIVATE_KEY.';
+    }
+    if (!mint) {
+        return 'Usage: /pump claim <mint>';
+    }
+    try {
+        const { wallet } = await getSolanaModules();
+        const keypair = wallet.loadSolanaKeypair();
+        const connection = wallet.getSolanaConnection();
+        // Try PumpPortal claim-fees endpoint (undocumented — may not exist)
+        const endpoint = process.env.PUMPFUN_LOCAL_TX_URL || 'https://pumpportal.fun/api/trade-local';
+        const response = await fetch(endpoint, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                publicKey: keypair.publicKey.toBase58(),
+                action: 'claim',
+                mint,
+            }),
+        });
+        if (!response.ok) {
+            const errorText = await response.text();
+            // If endpoint doesn't support claim action, provide guidance
+            if (response.status === 400 || response.status === 404) {
+                return `**Claim Fees**
+
+Creator fee claiming may not be supported via API.
+Visit https://pump.fun to claim fees for token:
+\`${mint}\`
+
+Alternatively, use the Pump.fun program directly via Solana CLI.`;
+            }
+            throw new Error(`Claim error: ${response.status} - ${errorText}`);
+        }
+        const txBytes = new Uint8Array(await response.arrayBuffer());
+        const { VersionedTransaction } = await Promise.resolve().then(() => __importStar(require('@solana/web3.js')));
+        const tx = VersionedTransaction.deserialize(txBytes);
+        tx.sign([keypair]);
+        const signature = await connection.sendRawTransaction(tx.serialize());
+        await connection.confirmTransaction(signature, 'confirmed');
+        return `**Fees Claimed**
+
+Token: \`${mint.slice(0, 20)}...\`
+TX: \`${signature}\``;
+    }
+    catch (error) {
+        return `Claim failed: ${error instanceof Error ? error.message : String(error)}`;
+    }
+}
+// ============================================================================
+// Monitoring Handlers
+// ============================================================================
+async function handleWatch(mint) {
+    if (!mint) {
+        return 'Usage: /pump watch <mint>\n\nStarts WebSocket subscription for real-time trades.';
+    }
+    return `**Watching Token**
+
+Mint: \`${mint}\`
+
+To monitor trades in real-time, connect to:
+\`wss://pumpportal.fun/api/data\`
+
+Subscribe with:
+\`{"method": "subscribeTokenTrade", "keys": ["${mint}"]}\`
+
+Trade events will stream in real-time.`;
+}
+async function handleSnipe(symbol) {
+    if (!symbol) {
+        return 'Usage: /pump snipe <symbol>\n\nWaits for a token with this symbol to launch.';
+    }
+    return `**Snipe Mode**
+
+Watching for: ${symbol.toUpperCase()}
+
+To snipe new tokens, connect to:
+\`wss://pumpportal.fun/api/data\`
+
+Subscribe with:
+\`{"method": "subscribeNewToken"}\`
+
+When a token with symbol "${symbol.toUpperCase()}" is detected, execute buy immediately.
+
+**Note:** Sniping is competitive. Use priority fees and fast RPC.`;
+}
+// ============================================================================
+// Main Execute Function
+// ============================================================================
+async function execute(args) {
+    const parts = args.trim().split(/\s+/);
+    const command = parts[0]?.toLowerCase() || 'help';
+    const rest = parts.slice(1);
+    switch (command) {
+        // Trading
+        case 'buy':
+            return handleBuy(rest);
+        case 'sell':
+            return handleSell(rest);
+        case 'quote':
+            return handleQuote(rest);
+        // Discovery
+        case 'trending':
+            return handleTrending();
+        case 'new':
+            return handleNew();
+        case 'live':
+            return handleLive();
+        case 'graduated':
+            return handleGraduated();
+        case 'search':
+            return handleSearch(rest.join(' '));
+        case 'volatile':
+            return handleVolatile();
+        case 'koth':
+            return handleKOTH();
+        // Token Data
+        case 'token':
+            return handleToken(rest[0]);
+        case 'price':
+            return handlePrice(rest[0]);
+        case 'holders':
+            return handleHolders(rest[0]);
+        case 'trades':
+            return handleTrades(rest);
+        case 'chart':
+            return handleChart(rest);
+        // On-Chain Data
+        case 'balance':
+            return handleBalance(rest);
+        case 'holdings':
+            return handleHoldings(rest);
+        case 'bonding':
+            return handleBonding(rest[0]);
+        case 'best-pool':
+            return handleBestPool(rest[0]);
+        // Creation
+        case 'create':
+            return handleCreate(rest);
+        case 'claim':
+            return handleClaim(rest[0]);
+        // Monitoring
+        case 'watch':
+            return handleWatch(rest[0]);
+        case 'snipe':
+            return handleSnipe(rest[0]);
+        // Additional Discovery
+        case 'for-you':
+            return handleForYou();
+        case 'metas':
+            return handleMetas();
+        case 'similar':
+            return handleSimilar(rest[0]);
+        // Creator Tools
+        case 'user-coins':
+            return handleUserCoins(rest[0]);
+        case 'ipfs-upload':
+            return handleIpfsUpload(rest);
+        // Platform Data
+        case 'latest-trades':
+            return handleLatestTrades(rest);
+        case 'sol-price':
+            return handleSolPrice();
+        case 'help':
+        default:
+            return `**Pump.fun - Complete API (26 Commands)**
+
+**Trading:**
+  /pump buy <mint> <SOL> [--pool X] [--slippage X]
+  /pump sell <mint> <amount|%> [--pool X]
+  /pump quote <mint> <amount> <buy|sell>  (on-chain accurate)
+
+**Discovery:**
+  /pump trending                    Top performing tokens
+  /pump new                         Recently created
+  /pump live                        Currently trading
+  /pump graduated                   Migrated to Raydium
+  /pump search <query>              Search tokens
+  /pump volatile                    High volatility
+  /pump koth                        King of the Hill (30-35K)
+  /pump for-you                     Personalized recommendations
+  /pump metas                       Trending narratives
+
+**Token Data:**
+  /pump token <mint>                Full token info
+  /pump price <mint>                Price + 24h stats
+  /pump holders <mint>              Top holders
+  /pump trades <mint> [--limit N]   Recent trades
+  /pump chart <mint> [--interval]   OHLCV chart
+  /pump similar <mint>              Find similar tokens
+
+**On-Chain Data:**
+  /pump balance <mint> [wallet]     Token balance
+  /pump holdings [wallet]           All pump.fun tokens held
+  /pump bonding <mint>              Bonding curve state
+  /pump best-pool <mint>            Best execution venue
+
+**Creator Tools:**
+  /pump user-coins <address>        Tokens created by wallet
+  /pump create <name> <symbol> <desc> [options]
+  /pump claim <mint>                Claim creator fees
+  /pump ipfs-upload <name> <sym> <desc>  Upload metadata
+
+**Platform:**
+  /pump latest-trades [--limit N]   Platform-wide trades
+  /pump sol-price                   Current SOL price
+
+**Monitoring:**
+  /pump watch <mint>                Watch for trades (WS info)
+  /pump snipe <symbol>              Wait for token launch (WS info)
+
+**Pools:** pump, raydium, pump-amm, launchlab, raydium-cpmm, bonk, auto
+
+**Setup:**
+  export SOLANA_PRIVATE_KEY="your-key"
+  export PUMPPORTAL_API_KEY="your-key"  # Optional
+  export PUMPFUN_JWT="your-jwt"         # Optional`;
+    }
+}
+exports.default = {
+    name: 'pumpfun',
+    description: 'Pump.fun Solana memecoin launchpad - trade, launch, and monitor tokens',
+    commands: ['/pumpfun', '/pump'],
+    handle: execute,
+};
+//# sourceMappingURL=index.js.map