clodds 1.1.0

package/dist/agents/handlers/solana.js

@@ -0,0 +1,1530 @@
+"use strict";
+/**
+ * Solana DEX Handlers
+ *
+ * Platform handlers for Solana DEX protocols:
+ * - Jupiter (aggregator)
+ * - Raydium (AMM)
+ * - Orca (Whirlpools)
+ * - Meteora (DLMM)
+ * - Pump.fun (token launchpad)
+ * - Drift (perps + prediction markets)
+ */
+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.solanaHandlers = void 0;
+const types_1 = require("./types");
+// Lazy imports to avoid loading heavy SDKs unless needed
+const getSolanaModules = async () => {
+    const [wallet, jupiter, raydium, orca, meteora, pumpapi, drift, pools, tokenlist] = await Promise.all([
+        Promise.resolve().then(() => __importStar(require('../../solana/wallet'))),
+        Promise.resolve().then(() => __importStar(require('../../solana/jupiter'))),
+        Promise.resolve().then(() => __importStar(require('../../solana/raydium'))),
+        Promise.resolve().then(() => __importStar(require('../../solana/orca'))),
+        Promise.resolve().then(() => __importStar(require('../../solana/meteora'))),
+        Promise.resolve().then(() => __importStar(require('../../solana/pumpapi'))),
+        Promise.resolve().then(() => __importStar(require('../../solana/drift'))),
+        Promise.resolve().then(() => __importStar(require('../../solana/pools'))),
+        Promise.resolve().then(() => __importStar(require('../../solana/tokenlist'))),
+    ]);
+    return { wallet, jupiter, raydium, orca, meteora, pumpapi, drift, pools, tokenlist };
+};
+// ============================================================================
+// Wallet / Address
+// ============================================================================
+async function addressHandler() {
+    return (0, types_1.safeHandler)(async () => {
+        const { wallet } = await getSolanaModules();
+        const keypair = wallet.loadSolanaKeypair();
+        return { address: keypair.publicKey.toBase58() };
+    });
+}
+// ============================================================================
+// Jupiter Handlers
+// ============================================================================
+async function jupiterSwapHandler(toolInput) {
+    const inputMint = toolInput.input_mint;
+    const outputMint = toolInput.output_mint;
+    const amount = toolInput.amount;
+    const slippageBps = toolInput.slippage_bps;
+    const swapMode = toolInput.swap_mode;
+    const priorityFeeLamports = toolInput.priority_fee_lamports;
+    const onlyDirectRoutes = toolInput.only_direct_routes;
+    return (0, types_1.safeHandler)(async () => {
+        const { wallet, jupiter } = await getSolanaModules();
+        const keypair = wallet.loadSolanaKeypair();
+        const connection = wallet.getSolanaConnection();
+        return jupiter.executeJupiterSwap(connection, keypair, {
+            inputMint,
+            outputMint,
+            amount,
+            slippageBps,
+            swapMode,
+            priorityFeeLamports,
+            onlyDirectRoutes,
+        });
+    }, 'Jupiter swap failed. Set SOLANA_PRIVATE_KEY and SOLANA_RPC_URL.');
+}
+// ============================================================================
+// Raydium Handlers
+// ============================================================================
+async function raydiumSwapHandler(toolInput) {
+    return (0, types_1.safeHandler)(async () => {
+        const { wallet, raydium } = await getSolanaModules();
+        const keypair = wallet.loadSolanaKeypair();
+        const connection = wallet.getSolanaConnection();
+        return raydium.executeRaydiumSwap(connection, keypair, {
+            inputMint: toolInput.input_mint,
+            outputMint: toolInput.output_mint,
+            amount: toolInput.amount,
+            slippageBps: toolInput.slippage_bps,
+            swapMode: toolInput.swap_mode,
+            txVersion: toolInput.tx_version,
+            computeUnitPriceMicroLamports: toolInput.compute_unit_price_micro_lamports,
+        });
+    });
+}
+async function raydiumPoolsHandler(toolInput) {
+    return (0, types_1.safeHandler)(async () => {
+        const { raydium, tokenlist } = await getSolanaModules();
+        const tokenMints = toolInput.token_mints;
+        const tokenSymbols = toolInput.token_symbols;
+        const limit = toolInput.limit;
+        const resolvedMints = tokenMints && tokenMints.length > 0
+            ? tokenMints
+            : tokenSymbols && tokenSymbols.length > 0
+                ? await tokenlist.resolveTokenMints(tokenSymbols)
+                : undefined;
+        return raydium.listRaydiumPools({ tokenMints: resolvedMints, limit });
+    });
+}
+async function raydiumQuoteHandler(toolInput) {
+    return (0, types_1.safeHandler)(async () => {
+        const { raydium } = await getSolanaModules();
+        return raydium.getRaydiumQuote({
+            inputMint: toolInput.input_mint,
+            outputMint: toolInput.output_mint,
+            amount: toolInput.amount,
+            slippageBps: toolInput.slippage_bps,
+            swapMode: toolInput.swap_mode,
+        });
+    });
+}
+// ============================================================================
+// Orca Handlers
+// ============================================================================
+async function orcaSwapHandler(toolInput) {
+    return (0, types_1.safeHandler)(async () => {
+        const { wallet, orca } = await getSolanaModules();
+        const keypair = wallet.loadSolanaKeypair();
+        const connection = wallet.getSolanaConnection();
+        return orca.executeOrcaWhirlpoolSwap(connection, keypair, {
+            poolAddress: toolInput.pool_address,
+            inputMint: toolInput.input_mint,
+            amount: toolInput.amount,
+            slippageBps: toolInput.slippage_bps,
+        });
+    });
+}
+async function orcaPoolsHandler(toolInput) {
+    return (0, types_1.safeHandler)(async () => {
+        const { orca, tokenlist } = await getSolanaModules();
+        const tokenMints = toolInput.token_mints;
+        const tokenSymbols = toolInput.token_symbols;
+        const limit = toolInput.limit;
+        const resolvedMints = tokenMints && tokenMints.length > 0
+            ? tokenMints
+            : tokenSymbols && tokenSymbols.length > 0
+                ? await tokenlist.resolveTokenMints(tokenSymbols)
+                : undefined;
+        return orca.listOrcaWhirlpoolPools({ tokenMints: resolvedMints, limit });
+    });
+}
+async function orcaQuoteHandler(toolInput) {
+    return (0, types_1.safeHandler)(async () => {
+        const { orca } = await getSolanaModules();
+        return orca.getOrcaWhirlpoolQuote({
+            poolAddress: toolInput.pool_address,
+            inputMint: toolInput.input_mint,
+            amount: toolInput.amount,
+            slippageBps: toolInput.slippage_bps,
+        });
+    });
+}
+// ============================================================================
+// Meteora Handlers
+// ============================================================================
+async function meteoraSwapHandler(toolInput) {
+    return (0, types_1.safeHandler)(async () => {
+        const { wallet, meteora } = await getSolanaModules();
+        const keypair = wallet.loadSolanaKeypair();
+        const connection = wallet.getSolanaConnection();
+        return meteora.executeMeteoraDlmmSwap(connection, keypair, {
+            poolAddress: toolInput.pool_address,
+            inputMint: toolInput.input_mint,
+            outputMint: toolInput.output_mint,
+            inAmount: toolInput.in_amount,
+            slippageBps: toolInput.slippage_bps,
+            allowPartialFill: toolInput.allow_partial_fill,
+            maxExtraBinArrays: toolInput.max_extra_bin_arrays,
+        });
+    });
+}
+async function meteoraPoolsHandler(toolInput) {
+    return (0, types_1.safeHandler)(async () => {
+        const { wallet, meteora, tokenlist } = await getSolanaModules();
+        const connection = wallet.getSolanaConnection();
+        const tokenMints = toolInput.token_mints;
+        const tokenSymbols = toolInput.token_symbols;
+        const limit = toolInput.limit;
+        const resolvedMints = tokenMints && tokenMints.length > 0
+            ? tokenMints
+            : tokenSymbols && tokenSymbols.length > 0
+                ? await tokenlist.resolveTokenMints(tokenSymbols)
+                : undefined;
+        return meteora.listMeteoraDlmmPools(connection, { tokenMints: resolvedMints, limit, includeLiquidity: true });
+    });
+}
+async function meteoraQuoteHandler(toolInput) {
+    return (0, types_1.safeHandler)(async () => {
+        const { wallet, meteora } = await getSolanaModules();
+        const connection = wallet.getSolanaConnection();
+        return meteora.getMeteoraDlmmQuote(connection, {
+            poolAddress: toolInput.pool_address,
+            inputMint: toolInput.input_mint,
+            inAmount: toolInput.in_amount,
+            slippageBps: toolInput.slippage_bps,
+        });
+    });
+}
+// ============================================================================
+// Pump.fun Handlers
+// ============================================================================
+async function pumpfunTradeHandler(toolInput) {
+    const action = toolInput.action;
+    const mint = toolInput.mint;
+    const amountRaw = toolInput.amount;
+    const denominatedInSol = toolInput.denominated_in_sol;
+    const slippageBps = toolInput.slippage_bps;
+    const priorityFeeLamports = toolInput.priority_fee_lamports;
+    const pool = toolInput.pool;
+    const amountValue = amountRaw?.trim();
+    if (!amountValue) {
+        return JSON.stringify({ error: 'amount is required' });
+    }
+    return (0, types_1.safeHandler)(async () => {
+        const { wallet, pumpapi } = await getSolanaModules();
+        const keypair = wallet.loadSolanaKeypair();
+        const connection = wallet.getSolanaConnection();
+        return pumpapi.executePumpFunTrade(connection, keypair, {
+            action,
+            mint,
+            amount: amountValue,
+            denominatedInSol,
+            slippageBps,
+            priorityFeeLamports,
+            pool,
+        });
+    }, 'Ensure PUMPFUN_LOCAL_TX_URL is reachable and SOLANA_PRIVATE_KEY is set.');
+}
+const PUMPFUN_FRONTEND_API = 'https://frontend-api-v3.pump.fun';
+async function pumpFrontendRequest(endpoint) {
+    const response = await fetch(`${PUMPFUN_FRONTEND_API}${endpoint}`, {
+        headers: { 'Accept': 'application/json' },
+    });
+    if (!response.ok)
+        throw new Error(`Pump.fun API error: ${response.status}`);
+    return response.json();
+}
+async function pumpfunTrendingHandler() {
+    return (0, types_1.safeHandler)(async () => {
+        const tokens = await pumpFrontendRequest('/coins/top-runners');
+        return { tokens: tokens.slice(0, 20) };
+    });
+}
+async function pumpfunNewHandler() {
+    return (0, types_1.safeHandler)(async () => {
+        const tokens = await pumpFrontendRequest('/coins/currently-live?limit=20&sort=created_timestamp&order=desc');
+        return { tokens };
+    });
+}
+async function pumpfunLiveHandler() {
+    return (0, types_1.safeHandler)(async () => {
+        const tokens = await pumpFrontendRequest('/coins/currently-live?limit=20');
+        return { tokens };
+    });
+}
+async function pumpfunGraduatedHandler() {
+    return (0, types_1.safeHandler)(async () => {
+        const tokens = await pumpFrontendRequest('/coins/graduated?limit=20');
+        return { tokens };
+    });
+}
+async function pumpfunSearchHandler(toolInput) {
+    const query = toolInput.query;
+    return (0, types_1.safeHandler)(async () => {
+        const tokens = await pumpFrontendRequest(`/coins/search?query=${encodeURIComponent(query)}&limit=20`);
+        return { tokens };
+    });
+}
+async function pumpfunVolatileHandler() {
+    return (0, types_1.safeHandler)(async () => {
+        const tokens = await pumpFrontendRequest('/coins/volatile?limit=20');
+        return { tokens };
+    });
+}
+async function pumpfunTokenHandler(toolInput) {
+    const mint = toolInput.mint;
+    return (0, types_1.safeHandler)(async () => {
+        const token = await pumpFrontendRequest(`/coins/${mint}`);
+        return token;
+    });
+}
+async function pumpfunPriceHandler(toolInput) {
+    const mint = toolInput.mint;
+    return (0, types_1.safeHandler)(async () => {
+        const [token, ohlcv] = await Promise.all([
+            pumpFrontendRequest(`/coins/${mint}`),
+            pumpFrontendRequest(`/coins/${mint}/ohlcv?interval=1h&limit=24`).catch(() => null),
+        ]);
+        return { ...token, ohlcv };
+    });
+}
+async function pumpfunHoldersHandler(toolInput) {
+    const mint = toolInput.mint;
+    return (0, types_1.safeHandler)(async () => {
+        const holders = await pumpFrontendRequest(`/coins/${mint}/holders?limit=20`);
+        return { holders };
+    });
+}
+async function pumpfunTradesHandler(toolInput) {
+    const mint = toolInput.mint;
+    const limit = toolInput.limit || 20;
+    return (0, types_1.safeHandler)(async () => {
+        const trades = await pumpFrontendRequest(`/coins/${mint}/trades?limit=${limit}`);
+        return { trades };
+    });
+}
+async function pumpfunChartHandler(toolInput) {
+    const mint = toolInput.mint;
+    const interval = toolInput.interval || '1h';
+    const limit = toolInput.limit || 24;
+    return (0, types_1.safeHandler)(async () => {
+        const ohlcv = await pumpFrontendRequest(`/coins/${mint}/ohlcv?interval=${interval}&limit=${limit}`);
+        return { ohlcv };
+    });
+}
+async function pumpfunCreateHandler(toolInput) {
+    const name = toolInput.name;
+    const symbol = toolInput.symbol;
+    const description = toolInput.description;
+    const imageUrl = toolInput.image_url;
+    const twitter = toolInput.twitter;
+    const telegram = toolInput.telegram;
+    const website = toolInput.website;
+    const initialBuyLamports = toolInput.initial_buy_lamports;
+    return (0, types_1.safeHandler)(async () => {
+        const { wallet } = await getSolanaModules();
+        const keypair = wallet.loadSolanaKeypair();
+        const connection = wallet.getSolanaConnection();
+        const apiKey = process.env.PUMPPORTAL_API_KEY;
+        const url = apiKey
+            ? `https://pumpportal.fun/api/create?api-key=${apiKey}`
+            : 'https://pumpportal.fun/api/create';
+        const response = await fetch(url, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                publicKey: keypair.publicKey.toBase58(),
+                name, symbol, description, imageUrl, twitter, telegram, website, initialBuyLamports,
+            }),
+        });
+        if (!response.ok)
+            throw new Error(`Create failed: ${response.status}`);
+        const result = await response.json();
+        const { VersionedTransaction } = await Promise.resolve().then(() => __importStar(require('@solana/web3.js')));
+        const tx = VersionedTransaction.deserialize(Buffer.from(result.transaction, 'base64'));
+        tx.sign([keypair]);
+        const signature = await connection.sendRawTransaction(tx.serialize());
+        await connection.confirmTransaction(signature, 'confirmed');
+        return { mint: result.mint, signature };
+    }, 'Token creation failed. Ensure SOLANA_PRIVATE_KEY is set.');
+}
+async function pumpfunClaimHandler(toolInput) {
+    const mint = toolInput.mint;
+    return (0, types_1.safeHandler)(async () => {
+        const { wallet } = await getSolanaModules();
+        const keypair = wallet.loadSolanaKeypair();
+        const connection = wallet.getSolanaConnection();
+        const apiKey = process.env.PUMPPORTAL_API_KEY;
+        const url = apiKey
+            ? `https://pumpportal.fun/api/claim-fees?api-key=${apiKey}`
+            : 'https://pumpportal.fun/api/claim-fees';
+        const response = await fetch(url, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ publicKey: keypair.publicKey.toBase58(), mint }),
+        });
+        if (!response.ok)
+            throw new Error(`Claim failed: ${response.status}`);
+        const result = await response.json();
+        if (!result.transaction)
+            return { claimed: false, message: 'No fees to claim' };
+        const { VersionedTransaction } = await Promise.resolve().then(() => __importStar(require('@solana/web3.js')));
+        const tx = VersionedTransaction.deserialize(Buffer.from(result.transaction, 'base64'));
+        tx.sign([keypair]);
+        const signature = await connection.sendRawTransaction(tx.serialize());
+        await connection.confirmTransaction(signature, 'confirmed');
+        return { claimed: true, amount: result.amount, signature };
+    }, 'Fee claim failed. Ensure SOLANA_PRIVATE_KEY is set.');
+}
+async function pumpfunKothHandler() {
+    return (0, types_1.safeHandler)(async () => {
+        const tokens = await pumpFrontendRequest('/coins/king-of-the-hill');
+        return { tokens };
+    });
+}
+async function pumpfunForYouHandler() {
+    return (0, types_1.safeHandler)(async () => {
+        const tokens = await pumpFrontendRequest('/coins/for-you?limit=20');
+        return { tokens };
+    });
+}
+async function pumpfunSimilarHandler(toolInput) {
+    const mint = toolInput.mint;
+    return (0, types_1.safeHandler)(async () => {
+        const tokens = await pumpFrontendRequest(`/coins/similar?mint=${mint}&limit=20`);
+        return { tokens };
+    });
+}
+async function pumpfunUserCoinsHandler(toolInput) {
+    const address = toolInput.address;
+    return (0, types_1.safeHandler)(async () => {
+        const coins = await pumpFrontendRequest(`/coins/user-created-coins/${address}`);
+        return { coins };
+    });
+}
+async function pumpfunMetasHandler() {
+    return (0, types_1.safeHandler)(async () => {
+        const metas = await pumpFrontendRequest('/metas/current');
+        return { metas };
+    });
+}
+async function pumpfunLatestTradesHandler(toolInput) {
+    const limit = toolInput.limit || 50;
+    return (0, types_1.safeHandler)(async () => {
+        const trades = await pumpFrontendRequest(`/trades/latest?limit=${limit}`);
+        return { trades };
+    });
+}
+async function pumpfunSolPriceHandler() {
+    return (0, types_1.safeHandler)(async () => {
+        const result = await pumpFrontendRequest('/sol-price');
+        return result;
+    });
+}
+async function pumpfunIpfsUploadHandler(toolInput) {
+    const name = toolInput.name;
+    const symbol = toolInput.symbol;
+    const description = toolInput.description;
+    const imageUrl = toolInput.image_url;
+    const twitter = toolInput.twitter;
+    const telegram = toolInput.telegram;
+    const website = toolInput.website;
+    return (0, types_1.safeHandler)(async () => {
+        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 provided, fetch and attach as file
+        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 result;
+    });
+}
+// ============================================================================
+// Pump.fun Swarm Handlers
+// ============================================================================
+async function swarmWalletsHandler() {
+    return (0, types_1.safeHandler)(async () => {
+        const { getSwarm } = await Promise.resolve().then(() => __importStar(require('../../solana/pump-swarm')));
+        const swarm = getSwarm();
+        const wallets = swarm.getWallets();
+        return {
+            count: wallets.length,
+            wallets: wallets.map(w => ({
+                id: w.id,
+                publicKey: w.publicKey,
+                solBalance: w.solBalance,
+                enabled: w.enabled,
+                positionCount: w.positions.size,
+            })),
+        };
+    });
+}
+async function swarmBalancesHandler() {
+    return (0, types_1.safeHandler)(async () => {
+        const { getSwarm } = await Promise.resolve().then(() => __importStar(require('../../solana/pump-swarm')));
+        const swarm = getSwarm();
+        const balances = await swarm.refreshBalances();
+        const result = {};
+        for (const [id, balance] of balances) {
+            result[id] = balance;
+        }
+        return { balances: result, totalSol: Object.values(result).reduce((a, b) => a + b, 0) };
+    });
+}
+async function swarmBuyHandler(toolInput) {
+    const mint = toolInput.mint;
+    const amountPerWallet = toolInput.amount_per_wallet;
+    const walletIds = toolInput.wallet_ids;
+    const executionMode = toolInput.execution_mode;
+    const slippageBps = toolInput.slippage_bps;
+    const pool = toolInput.pool;
+    const presetName = toolInput.preset;
+    const dex = toolInput.dex;
+    const poolAddress = toolInput.pool_address;
+    return (0, types_1.safeHandler)(async () => {
+        const { getSwarm } = await Promise.resolve().then(() => __importStar(require('../../solana/pump-swarm')));
+        const swarm = getSwarm();
+        let finalMint = mint;
+        let finalAmount = amountPerWallet;
+        let finalSlippage = slippageBps;
+        let finalPool = pool;
+        let finalMode = executionMode;
+        let finalWalletIds = walletIds;
+        let finalDex = dex;
+        let finalPoolAddress = poolAddress;
+        // Apply preset if specified
+        if (presetName) {
+            const { getSwarmPresetService } = await Promise.resolve().then(() => __importStar(require('../../solana/swarm-presets')));
+            const presetService = getSwarmPresetService();
+            const preset = await presetService.get('agent_user', presetName);
+            if (preset) {
+                const config = preset.config;
+                if (config.mint && !mint)
+                    finalMint = config.mint;
+                if (config.amountPerWallet !== undefined && !amountPerWallet)
+                    finalAmount = config.amountPerWallet;
+                if (config.slippageBps !== undefined && !slippageBps)
+                    finalSlippage = config.slippageBps;
+                if (config.pool && !pool)
+                    finalPool = config.pool;
+                if (config.executionMode && !executionMode)
+                    finalMode = config.executionMode;
+                if (config.walletIds && config.walletIds.length > 0 && !walletIds)
+                    finalWalletIds = config.walletIds;
+            }
+        }
+        const result = await swarm.coordinatedBuy({
+            mint: finalMint,
+            action: 'buy',
+            amountPerWallet: finalAmount,
+            denominatedInSol: true,
+            slippageBps: finalSlippage,
+            pool: finalPool,
+            executionMode: finalMode,
+            walletIds: finalWalletIds,
+            dex: finalDex,
+            poolAddress: finalPoolAddress,
+        });
+        return {
+            success: result.success,
+            mint: result.mint,
+            totalSolSpent: result.totalSolSpent,
+            executionMode: result.executionMode,
+            executionTimeMs: result.executionTimeMs,
+            bundleIds: result.bundleIds,
+            presetApplied: presetName,
+            dex: finalDex || 'pumpfun',
+            walletResults: result.walletResults.map(wr => ({
+                walletId: wr.walletId,
+                success: wr.success,
+                signature: wr.signature,
+                error: wr.error,
+            })),
+        };
+    }, 'Swarm buy failed. Ensure SOLANA_PRIVATE_KEY and swarm keys are set.');
+}
+async function swarmSellHandler(toolInput) {
+    const mint = toolInput.mint;
+    const amountPerWallet = toolInput.amount_per_wallet;
+    const walletIds = toolInput.wallet_ids;
+    const executionMode = toolInput.execution_mode;
+    const slippageBps = toolInput.slippage_bps;
+    const pool = toolInput.pool;
+    const presetName = toolInput.preset;
+    const dex = toolInput.dex;
+    const poolAddress = toolInput.pool_address;
+    return (0, types_1.safeHandler)(async () => {
+        const { getSwarm } = await Promise.resolve().then(() => __importStar(require('../../solana/pump-swarm')));
+        const swarm = getSwarm();
+        let finalMint = mint;
+        let finalAmount = amountPerWallet;
+        let finalSlippage = slippageBps;
+        let finalPool = pool;
+        let finalMode = executionMode;
+        let finalWalletIds = walletIds;
+        let finalDex = dex;
+        let finalPoolAddress = poolAddress;
+        // Apply preset if specified
+        if (presetName) {
+            const { getSwarmPresetService } = await Promise.resolve().then(() => __importStar(require('../../solana/swarm-presets')));
+            const presetService = getSwarmPresetService();
+            const preset = await presetService.get('agent_user', presetName);
+            if (preset) {
+                const config = preset.config;
+                if (config.mint && !mint)
+                    finalMint = config.mint;
+                if (config.amountPerWallet !== undefined && !amountPerWallet)
+                    finalAmount = config.amountPerWallet;
+                if (config.slippageBps !== undefined && !slippageBps)
+                    finalSlippage = config.slippageBps;
+                if (config.pool && !pool)
+                    finalPool = config.pool;
+                if (config.executionMode && !executionMode)
+                    finalMode = config.executionMode;
+                if (config.walletIds && config.walletIds.length > 0 && !walletIds)
+                    finalWalletIds = config.walletIds;
+            }
+        }
+        const result = await swarm.coordinatedSell({
+            mint: finalMint,
+            action: 'sell',
+            amountPerWallet: finalAmount,
+            denominatedInSol: false,
+            slippageBps: finalSlippage,
+            pool: finalPool,
+            executionMode: finalMode,
+            walletIds: finalWalletIds,
+            dex: finalDex,
+            poolAddress: finalPoolAddress,
+        });
+        return {
+            success: result.success,
+            mint: result.mint,
+            totalTokens: result.totalTokens,
+            executionMode: result.executionMode,
+            executionTimeMs: result.executionTimeMs,
+            bundleIds: result.bundleIds,
+            presetApplied: presetName,
+            dex: finalDex || 'pumpfun',
+            walletResults: result.walletResults.map(wr => ({
+                walletId: wr.walletId,
+                success: wr.success,
+                signature: wr.signature,
+                error: wr.error,
+            })),
+        };
+    }, 'Swarm sell failed. Ensure SOLANA_PRIVATE_KEY and swarm keys are set.');
+}
+async function swarmPositionHandler(toolInput) {
+    const mint = toolInput.mint;
+    return (0, types_1.safeHandler)(async () => {
+        const { getSwarm } = await Promise.resolve().then(() => __importStar(require('../../solana/pump-swarm')));
+        const swarm = getSwarm();
+        const position = swarm.getSwarmPosition(mint);
+        const byWallet = {};
+        for (const [id, amount] of position.byWallet) {
+            byWallet[id] = amount;
+        }
+        return {
+            mint: position.mint,
+            totalTokens: position.totalTokens,
+            byWallet,
+            lastUpdated: position.lastUpdated,
+        };
+    });
+}
+async function swarmRefreshHandler(toolInput) {
+    const mint = toolInput.mint;
+    return (0, types_1.safeHandler)(async () => {
+        const { getSwarm } = await Promise.resolve().then(() => __importStar(require('../../solana/pump-swarm')));
+        const swarm = getSwarm();
+        const position = await swarm.refreshTokenPositions(mint);
+        const byWallet = {};
+        for (const [id, amount] of position.byWallet) {
+            byWallet[id] = amount;
+        }
+        return {
+            mint: position.mint,
+            totalTokens: position.totalTokens,
+            byWallet,
+            lastUpdated: position.lastUpdated,
+        };
+    });
+}
+async function swarmEnableHandler(toolInput) {
+    const walletId = toolInput.wallet_id;
+    return (0, types_1.safeHandler)(async () => {
+        const { getSwarm } = await Promise.resolve().then(() => __importStar(require('../../solana/pump-swarm')));
+        const swarm = getSwarm();
+        swarm.enableWallet(walletId);
+        return { success: true, walletId, enabled: true };
+    });
+}
+async function swarmDisableHandler(toolInput) {
+    const walletId = toolInput.wallet_id;
+    return (0, types_1.safeHandler)(async () => {
+        const { getSwarm } = await Promise.resolve().then(() => __importStar(require('../../solana/pump-swarm')));
+        const swarm = getSwarm();
+        swarm.disableWallet(walletId);
+        return { success: true, walletId, enabled: false };
+    });
+}
+// ============================================================================
+// Swarm Preset Handlers
+// ============================================================================
+async function swarmPresetSaveHandler(toolInput) {
+    const name = toolInput.name;
+    const type = toolInput.type || 'strategy';
+    const description = toolInput.description;
+    const config = toolInput.config;
+    const userId = toolInput.user_id || 'agent_user';
+    return (0, types_1.safeHandler)(async () => {
+        const { getSwarmPresetService } = await Promise.resolve().then(() => __importStar(require('../../solana/swarm-presets')));
+        const presetService = getSwarmPresetService();
+        const preset = await presetService.create(userId, {
+            name,
+            type: type,
+            description,
+            config: {
+                mint: config.mint,
+                amountPerWallet: config.amountPerWallet,
+                slippageBps: config.slippageBps,
+                pool: config.pool,
+                executionMode: config.executionMode,
+                walletIds: config.walletIds,
+                amountVariancePct: config.amountVariancePct,
+            },
+        });
+        return {
+            success: true,
+            preset: {
+                id: preset.id,
+                name: preset.name,
+                type: preset.type,
+                description: preset.description,
+                config: preset.config,
+            },
+        };
+    }, 'Failed to save preset.');
+}
+async function swarmPresetListHandler(toolInput) {
+    const type = toolInput.type;
+    const userId = toolInput.user_id || 'agent_user';
+    return (0, types_1.safeHandler)(async () => {
+        const { getSwarmPresetService } = await Promise.resolve().then(() => __importStar(require('../../solana/swarm-presets')));
+        const presetService = getSwarmPresetService();
+        const presets = await presetService.list(userId, type);
+        return {
+            count: presets.length,
+            presets: presets.map(p => ({
+                name: p.name,
+                type: p.type,
+                description: p.description,
+                isBuiltin: p.userId === 'system',
+                config: p.config,
+            })),
+        };
+    });
+}
+async function swarmPresetGetHandler(toolInput) {
+    const name = toolInput.name;
+    const userId = toolInput.user_id || 'agent_user';
+    return (0, types_1.safeHandler)(async () => {
+        const { getSwarmPresetService } = await Promise.resolve().then(() => __importStar(require('../../solana/swarm-presets')));
+        const presetService = getSwarmPresetService();
+        const preset = await presetService.get(userId, name);
+        if (!preset) {
+            return { found: false, name };
+        }
+        return {
+            found: true,
+            preset: {
+                id: preset.id,
+                name: preset.name,
+                type: preset.type,
+                description: preset.description,
+                isBuiltin: preset.userId === 'system',
+                config: preset.config,
+                createdAt: preset.createdAt.toISOString(),
+                updatedAt: preset.updatedAt.toISOString(),
+            },
+        };
+    });
+}
+async function swarmPresetDeleteHandler(toolInput) {
+    const name = toolInput.name;
+    const userId = toolInput.user_id || 'agent_user';
+    return (0, types_1.safeHandler)(async () => {
+        const { getSwarmPresetService } = await Promise.resolve().then(() => __importStar(require('../../solana/swarm-presets')));
+        const presetService = getSwarmPresetService();
+        const deleted = await presetService.delete(userId, name);
+        return { success: deleted, name };
+    }, 'Failed to delete preset.');
+}
+// ============================================================================
+// Drift Handlers
+// ============================================================================
+async function driftPlaceOrderHandler(toolInput) {
+    return (0, types_1.safeHandler)(async () => {
+        const { wallet, drift } = await getSolanaModules();
+        const keypair = wallet.loadSolanaKeypair();
+        const connection = wallet.getSolanaConnection();
+        return drift.executeDriftDirectOrder(connection, keypair, {
+            marketType: toolInput.market_type,
+            marketIndex: toolInput.market_index,
+            side: toolInput.side,
+            orderType: toolInput.order_type,
+            baseAmount: toolInput.base_amount,
+            price: toolInput.price,
+        });
+    });
+}
+async function driftCancelOrderHandler(toolInput) {
+    return (0, types_1.safeHandler)(async () => {
+        const { wallet, drift } = await getSolanaModules();
+        const keypair = wallet.loadSolanaKeypair();
+        const connection = wallet.getSolanaConnection();
+        return drift.cancelDriftOrder(connection, keypair, {
+            orderId: toolInput.order_id,
+            marketIndex: toolInput.market_index,
+            marketType: toolInput.market_type,
+        });
+    });
+}
+async function driftOrdersHandler(toolInput) {
+    return (0, types_1.safeHandler)(async () => {
+        const { wallet, drift } = await getSolanaModules();
+        const keypair = wallet.loadSolanaKeypair();
+        const connection = wallet.getSolanaConnection();
+        return drift.getDriftOrders(connection, keypair, toolInput.market_index, toolInput.market_type);
+    });
+}
+async function driftPositionsHandler(toolInput) {
+    return (0, types_1.safeHandler)(async () => {
+        const { wallet, drift } = await getSolanaModules();
+        const keypair = wallet.loadSolanaKeypair();
+        const connection = wallet.getSolanaConnection();
+        return drift.getDriftPositions(connection, keypair, toolInput.market_index);
+    });
+}
+async function driftBalanceHandler() {
+    return (0, types_1.safeHandler)(async () => {
+        const { wallet, drift } = await getSolanaModules();
+        const keypair = wallet.loadSolanaKeypair();
+        const connection = wallet.getSolanaConnection();
+        return drift.getDriftBalance(connection, keypair);
+    });
+}
+async function driftModifyOrderHandler(toolInput) {
+    return (0, types_1.safeHandler)(async () => {
+        const { wallet, drift } = await getSolanaModules();
+        const keypair = wallet.loadSolanaKeypair();
+        const connection = wallet.getSolanaConnection();
+        return drift.modifyDriftOrder(connection, keypair, {
+            orderId: toolInput.order_id,
+            newPrice: toolInput.new_price,
+            newBaseAmount: toolInput.new_base_amount,
+            reduceOnly: toolInput.reduce_only,
+        });
+    });
+}
+async function driftSetLeverageHandler(toolInput) {
+    return (0, types_1.safeHandler)(async () => {
+        const { wallet, drift } = await getSolanaModules();
+        const keypair = wallet.loadSolanaKeypair();
+        const connection = wallet.getSolanaConnection();
+        return drift.setDriftLeverage(connection, keypair, {
+            marketIndex: toolInput.market_index,
+            leverage: toolInput.leverage,
+        });
+    });
+}
+// ============================================================================
+// Auto-Routing Handlers (Best Pool Selection)
+// ============================================================================
+async function bestPoolHandler(toolInput) {
+    return (0, types_1.safeHandler)(async () => {
+        const { wallet, pools } = await getSolanaModules();
+        const connection = wallet.getSolanaConnection();
+        const result = await pools.selectBestPool(connection, {
+            tokenMints: toolInput.token_mints,
+            tokenSymbols: toolInput.token_symbols,
+            limit: toolInput.limit,
+            sortBy: toolInput.sort_by,
+            preferredDexes: toolInput.preferred_dexes,
+        });
+        return result ?? { error: 'No matching pools found' };
+    });
+}
+async function autoRouteHandler(toolInput) {
+    return (0, types_1.safeHandler)(async () => {
+        const { wallet, pools } = await getSolanaModules();
+        const connection = wallet.getSolanaConnection();
+        return pools.listAllPools(connection, {
+            tokenMints: toolInput.token_mints,
+            tokenSymbols: toolInput.token_symbols,
+            sortBy: toolInput.sort_by,
+            preferredDexes: toolInput.preferred_dexes,
+            limit: toolInput.limit ?? 20,
+        });
+    });
+}
+async function autoSwapHandler(toolInput) {
+    const amount = toolInput.amount;
+    const slippageBps = toolInput.slippage_bps;
+    const sortBy = toolInput.sort_by;
+    const preferredDexes = toolInput.preferred_dexes;
+    const inputMint = toolInput.input_mint;
+    const outputMint = toolInput.output_mint;
+    const tokenSymbols = toolInput.token_symbols;
+    return (0, types_1.safeHandler)(async () => {
+        const { wallet, pools, tokenlist, meteora, raydium, orca } = await getSolanaModules();
+        const connection = wallet.getSolanaConnection();
+        const keypair = wallet.loadSolanaKeypair();
+        const resolvedMints = inputMint && outputMint
+            ? [inputMint, outputMint]
+            : tokenSymbols && tokenSymbols.length >= 2
+                ? await tokenlist.resolveTokenMints(tokenSymbols.slice(0, 2))
+                : [];
+        if (resolvedMints.length < 2) {
+            return { error: 'Provide input_mint/output_mint or token_symbols with 2 entries.' };
+        }
+        const { pool } = await pools.selectBestPoolWithResolvedMints(connection, {
+            tokenMints: resolvedMints,
+            sortBy,
+            preferredDexes,
+        });
+        if (!pool) {
+            return { error: 'No matching pools found.' };
+        }
+        if (pool.dex === 'meteora') {
+            const result = await meteora.executeMeteoraDlmmSwap(connection, keypair, {
+                poolAddress: pool.address,
+                inputMint: resolvedMints[0],
+                outputMint: resolvedMints[1],
+                inAmount: amount,
+                slippageBps,
+            });
+            return { dex: pool.dex, pool, result };
+        }
+        if (pool.dex === 'raydium') {
+            const result = await raydium.executeRaydiumSwap(connection, keypair, {
+                inputMint: resolvedMints[0],
+                outputMint: resolvedMints[1],
+                amount,
+                slippageBps,
+            });
+            return { dex: pool.dex, pool, result };
+        }
+        if (pool.dex === 'orca') {
+            const result = await orca.executeOrcaWhirlpoolSwap(connection, keypair, {
+                poolAddress: pool.address,
+                inputMint: resolvedMints[0],
+                amount,
+                slippageBps,
+            });
+            return { dex: pool.dex, pool, result };
+        }
+        return { error: 'Unsupported pool type' };
+    });
+}
+async function autoQuoteHandler(toolInput) {
+    return (0, types_1.safeHandler)(async () => {
+        const { wallet, pools, meteora, raydium, orca } = await getSolanaModules();
+        const connection = wallet.getSolanaConnection();
+        const amount = toolInput.amount;
+        const slippageBps = toolInput.slippage_bps;
+        const allPools = await pools.listAllPools(connection, {
+            tokenMints: toolInput.token_mints,
+            tokenSymbols: toolInput.token_symbols,
+            sortBy: toolInput.sort_by,
+            preferredDexes: toolInput.preferred_dexes,
+            limit: 30,
+        });
+        const perDex = new Map();
+        for (const pool of allPools) {
+            const list = perDex.get(pool.dex) || [];
+            list.push(pool);
+            perDex.set(pool.dex, list);
+        }
+        const results = [];
+        for (const [dex, list] of perDex.entries()) {
+            const pool = list[0];
+            if (!pool)
+                continue;
+            try {
+                if (dex === 'meteora') {
+                    const quote = await meteora.getMeteoraDlmmQuote(connection, {
+                        poolAddress: pool.address,
+                        inputMint: pool.tokenMintA,
+                        inAmount: amount,
+                        slippageBps,
+                    });
+                    results.push({ dex, pool, quote });
+                }
+                else if (dex === 'raydium') {
+                    const quote = await raydium.getRaydiumQuote({
+                        inputMint: pool.tokenMintA,
+                        outputMint: pool.tokenMintB,
+                        amount,
+                        slippageBps,
+                    });
+                    results.push({ dex, pool, quote });
+                }
+                else if (dex === 'orca') {
+                    const quote = await orca.getOrcaWhirlpoolQuote({
+                        poolAddress: pool.address,
+                        inputMint: pool.tokenMintA,
+                        amount,
+                        slippageBps,
+                    });
+                    results.push({ dex, pool, quote });
+                }
+            }
+            catch {
+                // Skip failed quotes
+            }
+        }
+        return results;
+    });
+}
+// ============================================================================
+// Bags.fm Handlers - Complete API Coverage
+// ============================================================================
+const BAGS_API_BASE = 'https://public-api-v2.bags.fm/api/v1';
+async function bagsRequest(endpoint, options = {}) {
+    const apiKey = process.env.BAGS_API_KEY;
+    if (!apiKey)
+        throw new Error('BAGS_API_KEY not configured. Get one at dev.bags.fm');
+    const url = endpoint.startsWith('http') ? endpoint : `${BAGS_API_BASE}${endpoint}`;
+    const response = await fetch(url, {
+        ...options,
+        headers: {
+            'x-api-key': apiKey,
+            'Content-Type': 'application/json',
+            ...options.headers,
+        },
+    });
+    if (!response.ok) {
+        const error = await response.text();
+        throw new Error(`Bags API error: ${response.status} - ${error}`);
+    }
+    const json = await response.json();
+    if (json.success === false) {
+        throw new Error(`Bags API error: ${json.error || 'Unknown error'}`);
+    }
+    // Unwrap { success, response } envelope
+    return (json.response !== undefined ? json.response : json);
+}
+// Trading
+async function bagsQuoteHandler(toolInput) {
+    const inputMint = toolInput.input_mint;
+    const outputMint = toolInput.output_mint;
+    const amount = toolInput.amount;
+    return (0, types_1.safeHandler)(async () => {
+        const quote = await bagsRequest(`/trade/quote?inputMint=${inputMint}&outputMint=${outputMint}&amount=${amount}&slippageMode=auto`);
+        return quote;
+    });
+}
+async function bagsSwapHandler(toolInput) {
+    const inputMint = toolInput.input_mint;
+    const outputMint = toolInput.output_mint;
+    const amount = toolInput.amount;
+    return (0, types_1.safeHandler)(async () => {
+        const { wallet } = await getSolanaModules();
+        const keypair = wallet.loadSolanaKeypair();
+        const walletAddress = keypair.publicKey.toBase58();
+        const connection = wallet.getSolanaConnection();
+        // Step 1: Get quote
+        const quote = await bagsRequest(`/trade/quote?inputMint=${inputMint}&outputMint=${outputMint}&amount=${amount}&slippageMode=auto`);
+        // Step 2: Create swap from quote
+        const txResponse = await bagsRequest('/trade/swap', {
+            method: 'POST',
+            body: JSON.stringify({ quoteResponse: quote, userPublicKey: walletAddress }),
+        });
+        // Step 3: Sign and send (Base58 encoded)
+        const { VersionedTransaction } = await Promise.resolve().then(() => __importStar(require('@solana/web3.js')));
+        const { bs58 } = await Promise.resolve().then(() => __importStar(require('@coral-xyz/anchor/dist/cjs/utils/bytes')));
+        const txBuffer = bs58.decode(txResponse.swapTransaction);
+        const tx = VersionedTransaction.deserialize(txBuffer);
+        tx.sign([keypair]);
+        const signature = await connection.sendRawTransaction(tx.serialize());
+        await connection.confirmTransaction(signature, 'confirmed');
+        return { signature, inputMint, outputMint, amount };
+    }, 'Bags swap failed. Ensure BAGS_API_KEY and SOLANA_PRIVATE_KEY are set.');
+}
+// Discovery
+async function bagsPoolsHandler(toolInput) {
+    const limit = toolInput.limit || 50;
+    return (0, types_1.safeHandler)(async () => {
+        const pools = await bagsRequest('/solana/bags/pools');
+        return { pools: pools.slice(0, limit) };
+    });
+}
+async function bagsTrendingHandler() {
+    return (0, types_1.safeHandler)(async () => {
+        const pools = await bagsRequest('/solana/bags/pools?onlyMigrated=true');
+        return { pools };
+    });
+}
+async function bagsTokenHandler(toolInput) {
+    const mint = toolInput.mint;
+    return (0, types_1.safeHandler)(async () => {
+        const [creators, lifetimeFees] = await Promise.all([
+            bagsRequest(`/token-launch/creator/v3?tokenMint=${mint}`).catch(() => null),
+            bagsRequest(`/token-launch/lifetime-fees?tokenMint=${mint}`).catch(() => null),
+        ]);
+        return { creators, lifetimeFees: lifetimeFees ? { lamports: lifetimeFees, sol: Number(BigInt(lifetimeFees)) / 1e9 } : null };
+    });
+}
+async function bagsCreatorsHandler(toolInput) {
+    const mint = toolInput.mint;
+    return (0, types_1.safeHandler)(async () => {
+        const creators = await bagsRequest(`/token-launch/creator/v3?tokenMint=${mint}`);
+        return { creators };
+    });
+}
+async function bagsLifetimeFeesHandler(toolInput) {
+    const mint = toolInput.mint;
+    return (0, types_1.safeHandler)(async () => {
+        const lamports = await bagsRequest(`/token-launch/lifetime-fees?tokenMint=${mint}`);
+        return { lamports, sol: Number(BigInt(lamports)) / 1e9 };
+    });
+}
+// Fee Claiming
+async function bagsFeesHandler(toolInput) {
+    const wallet = toolInput.wallet;
+    return (0, types_1.safeHandler)(async () => {
+        const positions = await bagsRequest(`/token-launch/claimable-positions?wallet=${wallet}`);
+        return { positions };
+    });
+}
+async function bagsClaimHandler(toolInput) {
+    const walletArg = toolInput.wallet;
+    return (0, types_1.safeHandler)(async () => {
+        const { wallet: solWallet } = await getSolanaModules();
+        const keypair = solWallet.loadSolanaKeypair();
+        const walletAddress = walletArg || keypair.publicKey.toBase58();
+        const connection = solWallet.getSolanaConnection();
+        // Get claimable positions first
+        const positions = await bagsRequest(`/token-launch/claimable-positions?wallet=${walletAddress}`);
+        if (!positions?.length)
+            return { claimed: false, message: 'No fees to claim' };
+        const { VersionedTransaction, Transaction } = await Promise.resolve().then(() => __importStar(require('@solana/web3.js')));
+        const { bs58 } = await Promise.resolve().then(() => __importStar(require('@coral-xyz/anchor/dist/cjs/utils/bytes')));
+        const signatures = [];
+        // Claim per token using v3 endpoint
+        for (const pos of positions) {
+            if (pos.totalClaimableLamportsUserShare <= 0)
+                continue;
+            try {
+                const claimResult = await bagsRequest(`/token-launch/claim-txs/v3`, { method: 'POST', body: JSON.stringify({ feeClaimer: walletAddress, tokenMint: pos.baseMint }) });
+                for (const claimTx of claimResult) {
+                    const txBuffer = bs58.decode(claimTx.tx);
+                    try {
+                        const tx = VersionedTransaction.deserialize(txBuffer);
+                        tx.sign([keypair]);
+                        const sig = await connection.sendRawTransaction(tx.serialize());
+                        await connection.confirmTransaction(sig, 'confirmed');
+                        signatures.push(sig);
+                    }
+                    catch {
+                        const tx = Transaction.from(txBuffer);
+                        tx.sign(keypair);
+                        const sig = await connection.sendRawTransaction(tx.serialize());
+                        await connection.confirmTransaction(sig, 'confirmed');
+                        signatures.push(sig);
+                    }
+                }
+            }
+            catch { /* skip failed */ }
+        }
+        return { claimed: signatures.length > 0, signatures };
+    }, 'Claim failed. Ensure BAGS_API_KEY and SOLANA_PRIVATE_KEY are set.');
+}
+async function bagsClaimEventsHandler(toolInput) {
+    const mint = toolInput.mint;
+    const from = toolInput.from;
+    const to = toolInput.to;
+    return (0, types_1.safeHandler)(async () => {
+        let endpoint = `/fee-share/token/claim-events?tokenMint=${mint}`;
+        if (from || to) {
+            endpoint += '&mode=time';
+            if (from)
+                endpoint += `&from=${from}`;
+            if (to)
+                endpoint += `&to=${to}`;
+        }
+        const result = await bagsRequest(endpoint);
+        return result;
+    });
+}
+async function bagsClaimStatsHandler(toolInput) {
+    const mint = toolInput.mint;
+    return (0, types_1.safeHandler)(async () => {
+        const stats = await bagsRequest(`/token-launch/claim-stats?tokenMint=${mint}`);
+        return stats;
+    });
+}
+// Token Launch
+async function bagsLaunchHandler(toolInput) {
+    const name = toolInput.name;
+    const symbol = toolInput.symbol;
+    const description = toolInput.description;
+    const imageUrl = toolInput.image_url;
+    const twitter = toolInput.twitter;
+    const website = toolInput.website;
+    const telegram = toolInput.telegram;
+    const initialBuyLamports = Math.floor((toolInput.initial_sol || 0) * 1e9);
+    return (0, types_1.safeHandler)(async () => {
+        const { wallet } = await getSolanaModules();
+        const keypair = wallet.loadSolanaKeypair();
+        const walletAddress = keypair.publicKey.toBase58();
+        const connection = wallet.getSolanaConnection();
+        // Step 1: Create token info (multipart/form-data)
+        const apiKey = process.env.BAGS_API_KEY;
+        if (!apiKey)
+            throw new Error('BAGS_API_KEY not configured');
+        const formData = new FormData();
+        formData.append('name', name);
+        formData.append('symbol', symbol);
+        formData.append('description', description);
+        if (imageUrl)
+            formData.append('imageUrl', imageUrl);
+        if (twitter)
+            formData.append('twitter', twitter);
+        if (website)
+            formData.append('website', website);
+        if (telegram)
+            formData.append('telegram', telegram);
+        const tokenInfoRes = await fetch(`${BAGS_API_BASE}/token-launch/create-token-info`, {
+            method: 'POST',
+            headers: { 'x-api-key': apiKey },
+            body: formData,
+        });
+        if (!tokenInfoRes.ok)
+            throw new Error(`Token info failed: ${tokenInfoRes.status}`);
+        const tokenInfoJson = await tokenInfoRes.json();
+        if (!tokenInfoJson.success)
+            throw new Error(tokenInfoJson.error || 'Token info failed');
+        const tokenInfo = tokenInfoJson.response;
+        // Step 2: Create fee share config
+        const feeConfig = await bagsRequest('/token-launch/fee-share/create-config', {
+            method: 'POST',
+            body: JSON.stringify({ payer: walletAddress, baseMint: tokenInfo.tokenMint, feeClaimers: [{ user: walletAddress, userBps: 10000 }] }),
+        });
+        const { VersionedTransaction, Transaction } = await Promise.resolve().then(() => __importStar(require('@solana/web3.js')));
+        const { bs58 } = await Promise.resolve().then(() => __importStar(require('@coral-xyz/anchor/dist/cjs/utils/bytes')));
+        for (const txStr of feeConfig.transactions) {
+            const txBuffer = bs58.decode(txStr);
+            try {
+                const tx = VersionedTransaction.deserialize(txBuffer);
+                tx.sign([keypair]);
+                const sig = await connection.sendRawTransaction(tx.serialize());
+                await connection.confirmTransaction(sig, 'confirmed');
+            }
+            catch {
+                const tx = Transaction.from(txBuffer);
+                tx.sign(keypair);
+                const sig = await connection.sendRawTransaction(tx.serialize());
+                await connection.confirmTransaction(sig, 'confirmed');
+            }
+        }
+        // Step 3: Launch (correct field names: ipfs, wallet)
+        const launchTxStr = await bagsRequest('/token-launch/create-launch-transaction', {
+            method: 'POST',
+            body: JSON.stringify({ ipfs: tokenInfo.tokenMetadata, tokenMint: tokenInfo.tokenMint, wallet: walletAddress, initialBuyLamports, configKey: feeConfig.configKey }),
+        });
+        const launchTxBuffer = bs58.decode(launchTxStr);
+        let signature;
+        try {
+            const tx = VersionedTransaction.deserialize(launchTxBuffer);
+            tx.sign([keypair]);
+            signature = await connection.sendRawTransaction(tx.serialize());
+        }
+        catch {
+            const tx = Transaction.from(launchTxBuffer);
+            tx.sign(keypair);
+            signature = await connection.sendRawTransaction(tx.serialize());
+        }
+        await connection.confirmTransaction(signature, 'confirmed');
+        return { tokenMint: tokenInfo.tokenMint, metadataUrl: tokenInfo.tokenMetadata, signature };
+    }, 'Launch failed. Ensure BAGS_API_KEY and SOLANA_PRIVATE_KEY are set.');
+}
+// Fee Share Config
+async function bagsFeeConfigHandler(toolInput) {
+    const mint = toolInput.mint;
+    const feeClaimers = toolInput.fee_claimers;
+    return (0, types_1.safeHandler)(async () => {
+        const { wallet } = await getSolanaModules();
+        const keypair = wallet.loadSolanaKeypair();
+        const walletAddress = keypair.publicKey.toBase58();
+        const connection = wallet.getSolanaConnection();
+        const result = await bagsRequest('/token-launch/fee-share/create-config', {
+            method: 'POST',
+            body: JSON.stringify({ payer: walletAddress, baseMint: mint, feeClaimers }),
+        });
+        const { VersionedTransaction, Transaction } = await Promise.resolve().then(() => __importStar(require('@solana/web3.js')));
+        const { bs58 } = await Promise.resolve().then(() => __importStar(require('@coral-xyz/anchor/dist/cjs/utils/bytes')));
+        const signatures = [];
+        for (const txStr of result.transactions) {
+            const txBuffer = bs58.decode(txStr);
+            try {
+                const tx = VersionedTransaction.deserialize(txBuffer);
+                tx.sign([keypair]);
+                const sig = await connection.sendRawTransaction(tx.serialize());
+                await connection.confirmTransaction(sig, 'confirmed');
+                signatures.push(sig);
+            }
+            catch {
+                const tx = Transaction.from(txBuffer);
+                tx.sign(keypair);
+                const sig = await connection.sendRawTransaction(tx.serialize());
+                await connection.confirmTransaction(sig, 'confirmed');
+                signatures.push(sig);
+            }
+        }
+        return { configKey: result.configKey, signatures };
+    });
+}
+// Wallet Lookup
+async function bagsWalletLookupHandler(toolInput) {
+    const provider = toolInput.provider;
+    const username = toolInput.username;
+    return (0, types_1.safeHandler)(async () => {
+        const result = await bagsRequest(`/token-launch/fee-share/wallet/v2?provider=${provider}&username=${username}`);
+        return result;
+    });
+}
+async function bagsBulkWalletLookupHandler(toolInput) {
+    const provider = toolInput.provider;
+    const usernames = toolInput.usernames;
+    return (0, types_1.safeHandler)(async () => {
+        // Bulk endpoint expects items array with per-item provider
+        const items = usernames.map((username) => ({ username, provider }));
+        const result = await bagsRequest('/token-launch/fee-share/wallet/v2/bulk', {
+            method: 'POST',
+            body: JSON.stringify({ items }),
+        });
+        return result;
+    });
+}
+// Partner System
+async function bagsPartnerConfigHandler(toolInput) {
+    const mint = toolInput.mint;
+    return (0, types_1.safeHandler)(async () => {
+        const { wallet } = await getSolanaModules();
+        const keypair = wallet.loadSolanaKeypair();
+        const walletAddress = keypair.publicKey.toBase58();
+        const connection = wallet.getSolanaConnection();
+        const result = await bagsRequest('/token-launch/fee-share/partner/create-config', {
+            method: 'POST',
+            body: JSON.stringify({ payer: walletAddress, tokenMint: mint }),
+        });
+        const { VersionedTransaction, Transaction } = await Promise.resolve().then(() => __importStar(require('@solana/web3.js')));
+        const { bs58 } = await Promise.resolve().then(() => __importStar(require('@coral-xyz/anchor/dist/cjs/utils/bytes')));
+        const txBuffer = bs58.decode(result.transaction);
+        let signature;
+        try {
+            const tx = VersionedTransaction.deserialize(txBuffer);
+            tx.sign([keypair]);
+            signature = await connection.sendRawTransaction(tx.serialize());
+        }
+        catch {
+            const tx = Transaction.from(txBuffer);
+            tx.sign(keypair);
+            signature = await connection.sendRawTransaction(tx.serialize());
+        }
+        await connection.confirmTransaction(signature, 'confirmed');
+        return { partnerKey: result.partnerKey, signature };
+    });
+}
+async function bagsPartnerClaimHandler(toolInput) {
+    const walletArg = toolInput.wallet;
+    return (0, types_1.safeHandler)(async () => {
+        const { wallet: solWallet } = await getSolanaModules();
+        const keypair = solWallet.loadSolanaKeypair();
+        const walletAddress = walletArg || keypair.publicKey.toBase58();
+        const connection = solWallet.getSolanaConnection();
+        const claimTxs = await bagsRequest('/token-launch/fee-share/partner/claim', {
+            method: 'POST',
+            body: JSON.stringify({ wallet: walletAddress }),
+        });
+        if (!claimTxs.transactions?.length)
+            return { claimed: false, message: 'No partner fees to claim' };
+        const { VersionedTransaction, Transaction } = await Promise.resolve().then(() => __importStar(require('@solana/web3.js')));
+        const { bs58 } = await Promise.resolve().then(() => __importStar(require('@coral-xyz/anchor/dist/cjs/utils/bytes')));
+        const signatures = [];
+        for (const txStr of claimTxs.transactions) {
+            const txBuffer = bs58.decode(txStr);
+            try {
+                const tx = VersionedTransaction.deserialize(txBuffer);
+                tx.sign([keypair]);
+                const sig = await connection.sendRawTransaction(tx.serialize());
+                await connection.confirmTransaction(sig, 'confirmed');
+                signatures.push(sig);
+            }
+            catch {
+                const tx = Transaction.from(txBuffer);
+                tx.sign(keypair);
+                const sig = await connection.sendRawTransaction(tx.serialize());
+                await connection.confirmTransaction(sig, 'confirmed');
+                signatures.push(sig);
+            }
+        }
+        return { claimed: true, signatures };
+    });
+}
+async function bagsPartnerStatsHandler(toolInput) {
+    const partnerKey = toolInput.partner_key;
+    return (0, types_1.safeHandler)(async () => {
+        const stats = await bagsRequest(`/token-launch/fee-share/partner/stats?partnerKey=${partnerKey}`);
+        return stats;
+    });
+}
+// ============================================================================
+// Export All Handlers
+// ============================================================================
+exports.solanaHandlers = {
+    // Wallet
+    solana_address: addressHandler,
+    // Jupiter
+    solana_jupiter_swap: jupiterSwapHandler,
+    // Raydium
+    raydium_swap: raydiumSwapHandler,
+    raydium_pools: raydiumPoolsHandler,
+    raydium_quote: raydiumQuoteHandler,
+    // Orca
+    orca_whirlpool_swap: orcaSwapHandler,
+    orca_whirlpool_pools: orcaPoolsHandler,
+    orca_whirlpool_quote: orcaQuoteHandler,
+    // Meteora
+    meteora_dlmm_swap: meteoraSwapHandler,
+    meteora_dlmm_pools: meteoraPoolsHandler,
+    meteora_dlmm_quote: meteoraQuoteHandler,
+    // Pump.fun - Complete Coverage
+    pumpfun_trade: pumpfunTradeHandler,
+    pumpfun_trending: pumpfunTrendingHandler,
+    pumpfun_new: pumpfunNewHandler,
+    pumpfun_live: pumpfunLiveHandler,
+    pumpfun_graduated: pumpfunGraduatedHandler,
+    pumpfun_search: pumpfunSearchHandler,
+    pumpfun_volatile: pumpfunVolatileHandler,
+    pumpfun_token: pumpfunTokenHandler,
+    pumpfun_price: pumpfunPriceHandler,
+    pumpfun_holders: pumpfunHoldersHandler,
+    pumpfun_trades: pumpfunTradesHandler,
+    pumpfun_chart: pumpfunChartHandler,
+    pumpfun_create: pumpfunCreateHandler,
+    pumpfun_claim: pumpfunClaimHandler,
+    pumpfun_koth: pumpfunKothHandler,
+    pumpfun_for_you: pumpfunForYouHandler,
+    pumpfun_similar: pumpfunSimilarHandler,
+    pumpfun_user_coins: pumpfunUserCoinsHandler,
+    pumpfun_metas: pumpfunMetasHandler,
+    pumpfun_latest_trades: pumpfunLatestTradesHandler,
+    pumpfun_sol_price: pumpfunSolPriceHandler,
+    pumpfun_ipfs_upload: pumpfunIpfsUploadHandler,
+    // Pump.fun Swarm
+    swarm_wallets: swarmWalletsHandler,
+    swarm_balances: swarmBalancesHandler,
+    swarm_buy: swarmBuyHandler,
+    swarm_sell: swarmSellHandler,
+    swarm_position: swarmPositionHandler,
+    swarm_refresh: swarmRefreshHandler,
+    swarm_enable: swarmEnableHandler,
+    swarm_disable: swarmDisableHandler,
+    // Swarm Presets
+    swarm_preset_save: swarmPresetSaveHandler,
+    swarm_preset_list: swarmPresetListHandler,
+    swarm_preset_get: swarmPresetGetHandler,
+    swarm_preset_delete: swarmPresetDeleteHandler,
+    // Drift
+    drift_direct_place_order: driftPlaceOrderHandler,
+    drift_direct_cancel_order: driftCancelOrderHandler,
+    drift_direct_orders: driftOrdersHandler,
+    drift_direct_positions: driftPositionsHandler,
+    drift_direct_balance: driftBalanceHandler,
+    drift_direct_modify_order: driftModifyOrderHandler,
+    drift_direct_set_leverage: driftSetLeverageHandler,
+    // Auto-routing
+    solana_best_pool: bestPoolHandler,
+    solana_auto_route: autoRouteHandler,
+    solana_auto_swap: autoSwapHandler,
+    solana_auto_quote: autoQuoteHandler,
+    // Bags.fm - Complete Coverage
+    bags_quote: bagsQuoteHandler,
+    bags_swap: bagsSwapHandler,
+    bags_pools: bagsPoolsHandler,
+    bags_trending: bagsTrendingHandler,
+    bags_token: bagsTokenHandler,
+    bags_creators: bagsCreatorsHandler,
+    bags_lifetime_fees: bagsLifetimeFeesHandler,
+    bags_fees: bagsFeesHandler,
+    bags_claim: bagsClaimHandler,
+    bags_claim_events: bagsClaimEventsHandler,
+    bags_claim_stats: bagsClaimStatsHandler,
+    bags_launch: bagsLaunchHandler,
+    bags_fee_config: bagsFeeConfigHandler,
+    bags_wallet_lookup: bagsWalletLookupHandler,
+    bags_bulk_wallet_lookup: bagsBulkWalletLookupHandler,
+    bags_partner_config: bagsPartnerConfigHandler,
+    bags_partner_claim: bagsPartnerClaimHandler,
+    bags_partner_stats: bagsPartnerStatsHandler,
+};
+exports.default = exports.solanaHandlers;
+//# sourceMappingURL=solana.js.map