clodds 1.6.26 → 1.7.1

package/dist/gateway/launch-routes.js

@@ -0,0 +1,772 @@
+"use strict";
+/**
+ * Launch API Routes — REST endpoints for one-call Solana token launches.
+ *
+ * Mounted as an Express Router via httpGateway.setLaunchRouter().
+ * All endpoints are prefixed with /api/launch by the caller.
+ *
+ * Built on Meteora Dynamic Bonding Curves with automatic graduation
+ * to DAMM v2 AMM. 90/10 fee split — creator keeps 90%.
+ */
+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.createLaunchRouter = createLaunchRouter;
+const express_1 = require("express");
+const web3_js_1 = require("@solana/web3.js");
+const fs_1 = require("fs");
+const path_1 = require("path");
+const logger_js_1 = require("../utils/logger.js");
+const registry_js_1 = require("../acp/registry.js");
+const STATE_DIR = process.env.CLODDS_STATE_DIR || (0, path_1.join)(process.cwd(), '.clodds');
+const LAUNCHES_FILE = (0, path_1.join)(STATE_DIR, 'launches.json');
+function loadLaunches() {
+    try {
+        if ((0, fs_1.existsSync)(LAUNCHES_FILE)) {
+            return JSON.parse((0, fs_1.readFileSync)(LAUNCHES_FILE, 'utf-8'));
+        }
+    }
+    catch {
+        logger_js_1.logger.warn('Launch registry: Failed to load launches.json, starting fresh');
+    }
+    return [];
+}
+function saveLaunches(launches) {
+    try {
+        const dir = (0, path_1.dirname)(LAUNCHES_FILE);
+        if (!(0, fs_1.existsSync)(dir))
+            (0, fs_1.mkdirSync)(dir, { recursive: true });
+        (0, fs_1.writeFileSync)(LAUNCHES_FILE, JSON.stringify(launches, null, 2));
+    }
+    catch (err) {
+        logger_js_1.logger.warn({ err }, 'Launch registry: Failed to save launches.json');
+    }
+}
+const launchRegistry = loadLaunches();
+// ── IPFS / Metadata ──────────────────────────────────────────────────────────
+/**
+ * Build a minimal JSON metadata blob and upload to a public IPFS gateway.
+ * Falls back through multiple providers so we don't depend on any single service.
+ */
+async function uploadMetadata(params) {
+    // Build standard SPL token metadata JSON (Metaplex-compatible)
+    const metadata = {
+        name: params.name,
+        symbol: params.symbol,
+        description: params.description ?? params.name,
+        showName: true,
+    };
+    if (params.imageUrl)
+        metadata.image = params.imageUrl;
+    if (params.twitter)
+        metadata.twitter = params.twitter;
+    if (params.telegram)
+        metadata.telegram = params.telegram;
+    if (params.website) {
+        metadata.website = params.website;
+        metadata.external_url = params.website;
+    }
+    // Strategy: try multiple IPFS upload services in order
+    const providers = [
+        uploadViaPumpFun,
+        uploadViaNftStorage,
+    ];
+    for (const provider of providers) {
+        try {
+            const uri = await provider(params, metadata);
+            if (uri)
+                return uri;
+        }
+        catch (err) {
+            logger_js_1.logger.warn({ err, provider: provider.name }, 'Launch API: IPFS provider failed, trying next');
+        }
+    }
+    throw new Error('All metadata upload providers failed. Provide a pre-uploaded uri instead.');
+}
+/** Upload via pump.fun IPFS (fast, free, but third-party) */
+async function uploadViaPumpFun(params, _metadata) {
+    const formData = new FormData();
+    formData.append('name', params.name);
+    formData.append('symbol', params.symbol);
+    formData.append('description', params.description ?? params.name);
+    if (params.twitter)
+        formData.append('twitter', params.twitter);
+    if (params.telegram)
+        formData.append('telegram', params.telegram);
+    if (params.website)
+        formData.append('website', params.website);
+    formData.append('showName', 'true');
+    if (params.imageUrl) {
+        const imgBlob = await fetchImageSafe(params.imageUrl);
+        if (imgBlob)
+            formData.append('file', imgBlob, 'image.png');
+    }
+    const response = await fetch('https://pump.fun/api/ipfs', {
+        method: 'POST',
+        body: formData,
+        signal: AbortSignal.timeout(15_000),
+    });
+    if (!response.ok)
+        return '';
+    const result = await response.json();
+    return result.metadataUri ?? '';
+}
+/** Upload via nft.storage (decentralized, free tier) */
+async function uploadViaNftStorage(_params, metadata) {
+    const nftStorageKey = process.env.NFT_STORAGE_API_KEY;
+    if (!nftStorageKey)
+        return '';
+    const response = await fetch('https://api.nft.storage/upload', {
+        method: 'POST',
+        headers: {
+            'Authorization': `Bearer ${nftStorageKey}`,
+            'Content-Type': 'application/json',
+        },
+        body: JSON.stringify(metadata),
+        signal: AbortSignal.timeout(15_000),
+    });
+    if (!response.ok)
+        return '';
+    const result = await response.json();
+    const cid = result.value?.cid;
+    return cid ? `https://nftstorage.link/ipfs/${cid}` : '';
+}
+/**
+ * Safely fetch an image URL. Blocks internal/private IPs to prevent SSRF.
+ */
+async function fetchImageSafe(url) {
+    try {
+        const parsed = new URL(url);
+        // Block non-HTTP(S) schemes
+        if (parsed.protocol !== 'https:' && parsed.protocol !== 'http:')
+            return null;
+        // Block internal hostnames
+        const hostname = parsed.hostname.toLowerCase();
+        if (hostname === 'localhost' ||
+            hostname === '127.0.0.1' ||
+            hostname === '0.0.0.0' ||
+            hostname === '::1' ||
+            hostname.endsWith('.local') ||
+            hostname.startsWith('10.') ||
+            hostname.startsWith('192.168.') ||
+            /^172\.(1[6-9]|2\d|3[01])\./.test(hostname) ||
+            hostname.startsWith('169.254.')) {
+            logger_js_1.logger.warn({ url }, 'Launch API: Blocked SSRF attempt on imageUrl');
+            return null;
+        }
+        const response = await fetch(url, {
+            signal: AbortSignal.timeout(10_000),
+            redirect: 'follow',
+        });
+        if (!response.ok)
+            return null;
+        // Cap image size at 10MB
+        const contentLength = response.headers.get('content-length');
+        if (contentLength && parseInt(contentLength, 10) > 10 * 1024 * 1024)
+            return null;
+        return await response.blob();
+    }
+    catch {
+        return null;
+    }
+}
+// ── Validation ───────────────────────────────────────────────────────────────
+const VALID_DECIMALS = new Set([6, 7, 8, 9]);
+function validateLaunchRequest(body) {
+    if (!body || typeof body !== 'object') {
+        return { valid: false, error: 'Request body must be a JSON object' };
+    }
+    const b = body;
+    // Required fields
+    if (!b.name || typeof b.name !== 'string') {
+        return { valid: false, error: 'Required: name (string, max 32 chars)' };
+    }
+    if (b.name.length > 32) {
+        return { valid: false, error: 'name must be 32 characters or fewer' };
+    }
+    if (!b.symbol || typeof b.symbol !== 'string') {
+        return { valid: false, error: 'Required: symbol (string, max 10 chars)' };
+    }
+    if (b.symbol.length > 10) {
+        return { valid: false, error: 'symbol must be 10 characters or fewer' };
+    }
+    if (!b.uri && !b.imageUrl && !b.description) {
+        return { valid: false, error: 'Provide either uri (metadata URI) or imageUrl + description for auto-upload' };
+    }
+    // Validate creatorWallet is a valid Solana pubkey
+    if (b.creatorWallet !== undefined) {
+        if (typeof b.creatorWallet !== 'string') {
+            return { valid: false, error: 'creatorWallet must be a string (Solana public key)' };
+        }
+        try {
+            new web3_js_1.PublicKey(b.creatorWallet);
+        }
+        catch {
+            return { valid: false, error: 'creatorWallet is not a valid Solana public key' };
+        }
+    }
+    // Numeric fields — check both type AND NaN (typeof NaN === 'number' trap)
+    if (b.initialMarketCap !== undefined) {
+        if (typeof b.initialMarketCap !== 'number' || Number.isNaN(b.initialMarketCap) || b.initialMarketCap <= 0) {
+            return { valid: false, error: 'initialMarketCap must be a positive number (SOL)' };
+        }
+    }
+    if (b.graduationMarketCap !== undefined) {
+        if (typeof b.graduationMarketCap !== 'number' || Number.isNaN(b.graduationMarketCap) || b.graduationMarketCap <= 0) {
+            return { valid: false, error: 'graduationMarketCap must be a positive number (SOL)' };
+        }
+    }
+    // graduationMarketCap must be > initialMarketCap
+    const initMcap = (typeof b.initialMarketCap === 'number' && !Number.isNaN(b.initialMarketCap)) ? b.initialMarketCap : 30;
+    const gradMcap = (typeof b.graduationMarketCap === 'number' && !Number.isNaN(b.graduationMarketCap)) ? b.graduationMarketCap : 500;
+    if (gradMcap <= initMcap) {
+        return { valid: false, error: `graduationMarketCap (${gradMcap}) must be greater than initialMarketCap (${initMcap})` };
+    }
+    if (b.totalSupply !== undefined) {
+        if (typeof b.totalSupply !== 'number' || Number.isNaN(b.totalSupply) || b.totalSupply <= 0 || !Number.isFinite(b.totalSupply)) {
+            return { valid: false, error: 'totalSupply must be a positive finite number' };
+        }
+    }
+    if (b.decimals !== undefined) {
+        if (typeof b.decimals !== 'number' || !VALID_DECIMALS.has(b.decimals)) {
+            return { valid: false, error: 'decimals must be 6, 7, 8, or 9' };
+        }
+    }
+    if (b.creatorFeePercent !== undefined) {
+        if (typeof b.creatorFeePercent !== 'number' || Number.isNaN(b.creatorFeePercent) || b.creatorFeePercent < 0 || b.creatorFeePercent > 100) {
+            return { valid: false, error: 'creatorFeePercent must be 0-100' };
+        }
+    }
+    if (b.antiSniperFeeBps !== undefined) {
+        if (typeof b.antiSniperFeeBps !== 'number' || Number.isNaN(b.antiSniperFeeBps) || b.antiSniperFeeBps < 0 || b.antiSniperFeeBps > 10000) {
+            return { valid: false, error: 'antiSniperFeeBps must be 0-10000' };
+        }
+    }
+    if (b.endingFeeBps !== undefined) {
+        if (typeof b.endingFeeBps !== 'number' || Number.isNaN(b.endingFeeBps) || b.endingFeeBps < 0 || b.endingFeeBps > 10000) {
+            return { valid: false, error: 'endingFeeBps must be 0-10000' };
+        }
+    }
+    if (b.feeDecayDurationSec !== undefined) {
+        if (typeof b.feeDecayDurationSec !== 'number' || Number.isNaN(b.feeDecayDurationSec) || b.feeDecayDurationSec < 0) {
+            return { valid: false, error: 'feeDecayDurationSec must be a non-negative number' };
+        }
+    }
+    if (b.initialBuySol !== undefined) {
+        if (typeof b.initialBuySol !== 'number' || Number.isNaN(b.initialBuySol) || b.initialBuySol < 0) {
+            return { valid: false, error: 'initialBuySol must be a non-negative number' };
+        }
+    }
+    if (b.slippageBps !== undefined) {
+        if (typeof b.slippageBps !== 'number' || Number.isNaN(b.slippageBps) || b.slippageBps < 0 || b.slippageBps > 10000) {
+            return { valid: false, error: 'slippageBps must be 0-10000' };
+        }
+    }
+    // antiSniper starting fee should be >= ending fee
+    const startFee = typeof b.antiSniperFeeBps === 'number' ? b.antiSniperFeeBps : 500;
+    const endFee = typeof b.endingFeeBps === 'number' ? b.endingFeeBps : 100;
+    if (endFee > startFee) {
+        return { valid: false, error: `endingFeeBps (${endFee}) cannot be greater than antiSniperFeeBps (${startFee})` };
+    }
+    return { valid: true, params: b };
+}
+// ── SOL conversion helper ────────────────────────────────────────────────────
+/**
+ * Convert SOL to lamports using string math to avoid floating-point precision loss.
+ * e.g. 1.5 SOL -> "1500000000"
+ */
+function solToLamports(sol) {
+    const str = sol.toFixed(9); // max 9 decimal places for lamports
+    const [whole, frac = ''] = str.split('.');
+    const padded = frac.padEnd(9, '0').slice(0, 9);
+    const raw = (whole + padded).replace(/^0+/, '') || '0';
+    return raw;
+}
+// ── Router factory ───────────────────────────────────────────────────────────
+function createLaunchRouter(connection, keypair) {
+    const router = (0, express_1.Router)();
+    // ── GET /api/launch/info ─────────────────────────────────────────────────
+    // Service info + pricing (free, no auth)
+    router.get('/info', (_req, res) => {
+        res.json({
+            ok: true,
+            data: {
+                service: 'Clodds Launch API',
+                version: '1.0.0',
+                description: 'One-call Solana token launches with bonding curves and automatic AMM graduation.',
+                feeSplit: '90/10 — creator keeps 90% of trading fees',
+                chain: 'Solana',
+                technology: 'Meteora Dynamic Bonding Curves → DAMM v2 AMM',
+                features: [
+                    'One API call to launch a token',
+                    '90/10 fee split (creator keeps 90%)',
+                    'Anti-sniper fee protection (decaying high fees at launch)',
+                    'Automatic AMM graduation at target market cap',
+                    'Optional initial creator buy at launch with slippage protection',
+                    'SPL and Token2022 support',
+                    'Auto metadata upload (or bring your own URI)',
+                    'Creator wallet support — fees go to your wallet',
+                    'Configurable bonding curve parameters',
+                ],
+                defaults: {
+                    initialMarketCap: '30 SOL',
+                    graduationMarketCap: '500 SOL',
+                    totalSupply: '1,000,000,000',
+                    decimals: 6,
+                    creatorFeePercent: 90,
+                    antiSniperFeeBps: 500,
+                    endingFeeBps: 100,
+                    feeDecayDuration: '1 hour',
+                    slippageBps: 500,
+                },
+                pricing: {
+                    launchFee: '$1.00 USDC (via x402)',
+                    swapFee: '$0.10 USDC (via x402)',
+                    claimFees: '$0.10 USDC (via x402)',
+                    statusCheck: 'free',
+                    quoteCheck: 'free',
+                },
+                exampleRequest: {
+                    name: 'My Token',
+                    symbol: 'MTK',
+                    description: 'A token launched via Clodds',
+                    imageUrl: 'https://example.com/logo.png',
+                    creatorWallet: '<your-solana-pubkey>',
+                    initialBuySol: 0.5,
+                },
+            },
+        });
+    });
+    // ── GET /api/launch/list ────────────────────────────────────────────────
+    // Public directory of all tokens launched via Clodds (free, no auth)
+    router.get('/list', (_req, res) => {
+        res.json({
+            ok: true,
+            data: {
+                total: launchRegistry.length,
+                launches: launchRegistry.slice().reverse(), // newest first
+            },
+        });
+    });
+    // ── POST /api/launch/token ───────────────────────────────────────────────
+    // Launch a token — requires a registered Clodds agent
+    router.post('/token', async (req, res) => {
+        // ── Agent gate: only registered Clodds agents can launch ──────────
+        const agentId = req.headers['x-agent-id'] ?? req.body?.agentId;
+        if (!agentId || typeof agentId !== 'string') {
+            res.status(401).json({
+                ok: false,
+                error: 'Launching requires a registered Clodds agent. Provide agentId in request body or X-Agent-Id header.',
+            });
+            return;
+        }
+        let agentProfile;
+        try {
+            const registry = (0, registry_js_1.getRegistryService)();
+            agentProfile = await registry.getAgent(agentId);
+        }
+        catch {
+            // Registry not initialized yet — fall through
+        }
+        if (!agentProfile || agentProfile.status !== 'active') {
+            res.status(403).json({
+                ok: false,
+                error: `Agent "${agentId}" is not a registered active Clodds agent. Register at /api/acp/agents first.`,
+            });
+            return;
+        }
+        const validation = validateLaunchRequest(req.body);
+        if (!validation.valid) {
+            res.status(400).json({ ok: false, error: validation.error });
+            return;
+        }
+        const params = validation.params;
+        try {
+            // Step 1: Resolve metadata URI
+            let uri = params.uri;
+            if (!uri) {
+                logger_js_1.logger.info({ name: params.name, symbol: params.symbol }, 'Launch API: Uploading metadata');
+                uri = await uploadMetadata({
+                    name: params.name,
+                    symbol: params.symbol,
+                    description: params.description,
+                    imageUrl: params.imageUrl,
+                    twitter: params.twitter,
+                    telegram: params.telegram,
+                    website: params.website,
+                });
+            }
+            // Step 2: Build bonding curve config
+            const creatorFee = params.creatorFeePercent ?? 90;
+            const graduationMcap = params.graduationMarketCap ?? 500;
+            const creatorWallet = params.creatorWallet ?? keypair.publicKey.toBase58();
+            const config = {
+                totalTokenSupply: params.totalSupply ?? 1_000_000_000,
+                tokenDecimals: params.decimals ?? 6,
+                initialMarketCap: params.initialMarketCap ?? 30,
+                migrationMarketCap: graduationMcap,
+                migrationOption: 1, // DAMM v2
+                startingFeeBps: params.antiSniperFeeBps ?? 500,
+                endingFeeBps: params.endingFeeBps ?? 100,
+                feeDecayPeriods: 10,
+                feeDecayDurationSec: params.feeDecayDurationSec ?? 3600,
+                dynamicFeeEnabled: true,
+                creatorTradingFeePercent: creatorFee,
+                creatorLiquidityPct: 5,
+                creatorLockedPct: 45,
+                partnerLiquidityPct: 0,
+                partnerLockedPct: 50,
+                tokenType: params.token2022 ? 1 : 0,
+                collectFeeMode: 0,
+                migrationFeeOption: 6,
+                migrationFeePercentage: 15,
+                creatorMigrationFeePercentage: 50,
+                // Route fees to the creator's wallet, not the server
+                feeClaimer: creatorWallet,
+                leftoverReceiver: creatorWallet,
+            };
+            // Step 3: Launch token
+            let result;
+            if (params.initialBuySol && params.initialBuySol > 0) {
+                const { createDbcPoolWithFirstBuy } = await Promise.resolve().then(() => __importStar(require('../solana/meteora-dbc.js')));
+                const buyLamports = solToLamports(params.initialBuySol);
+                const r = await createDbcPoolWithFirstBuy(connection, keypair, {
+                    name: params.name,
+                    symbol: params.symbol,
+                    uri,
+                    config,
+                    buyAmountLamports: buyLamports,
+                });
+                result = { ...r, signatures: r.signatures };
+            }
+            else {
+                const { createDbcPool } = await Promise.resolve().then(() => __importStar(require('../solana/meteora-dbc.js')));
+                const r = await createDbcPool(connection, keypair, {
+                    name: params.name,
+                    symbol: params.symbol,
+                    uri,
+                    config,
+                });
+                result = { ...r, signatures: [r.signature] };
+            }
+            const response = {
+                mint: result.baseMint,
+                pool: result.poolAddress,
+                config: result.configAddress,
+                signatures: result.signatures,
+                explorer: `https://solscan.io/token/${result.baseMint}`,
+                feeSplit: `${creatorFee}/${100 - creatorFee} — creator keeps ${creatorFee}%`,
+                graduationMarketCap: graduationMcap,
+                creatorWallet,
+            };
+            // Record in public launch registry
+            const record = {
+                id: launchRegistry.length + 1,
+                mint: result.baseMint,
+                pool: result.poolAddress,
+                name: params.name,
+                symbol: params.symbol,
+                description: params.description,
+                creatorWallet,
+                agentId,
+                creatorFeePercent: creatorFee,
+                graduationMarketCap: graduationMcap,
+                launchedAt: new Date().toISOString(),
+                explorer: `https://solscan.io/token/${result.baseMint}`,
+                imageUrl: params.imageUrl,
+                website: params.website,
+                twitter: params.twitter,
+                telegram: params.telegram,
+                feeDelegates: [],
+            };
+            launchRegistry.push(record);
+            saveLaunches(launchRegistry);
+            logger_js_1.logger.info({
+                launchId: record.id,
+                mint: result.baseMint,
+                pool: result.poolAddress,
+                name: params.name,
+                symbol: params.symbol,
+                creatorFee,
+                creatorWallet,
+            }, 'Launch API: Token launched successfully');
+            res.json({ ok: true, data: { ...response, launchId: record.id } });
+        }
+        catch (err) {
+            logger_js_1.logger.warn({ err, name: params.name, symbol: params.symbol }, 'Launch API: Token launch failed');
+            const message = err instanceof Error ? err.message : String(err);
+            res.status(500).json({ ok: false, error: message });
+        }
+    });
+    // ── GET /api/launch/status/:mint ─────────────────────────────────────────
+    // Check pool status, graduation progress, fees (free)
+    router.get('/status/:mint', async (req, res) => {
+        const { mint } = req.params;
+        if (!mint || typeof mint !== 'string') {
+            res.status(400).json({ ok: false, error: 'Required: mint address in URL' });
+            return;
+        }
+        // Validate it looks like a base58 pubkey (32-44 chars, no special chars)
+        if (!/^[1-9A-HJ-NP-Za-km-z]{32,44}$/.test(mint)) {
+            res.status(400).json({ ok: false, error: 'Invalid mint address format' });
+            return;
+        }
+        try {
+            const { getDbcPoolStatus } = await Promise.resolve().then(() => __importStar(require('../solana/meteora-dbc.js')));
+            const status = await getDbcPoolStatus(connection, mint);
+            if (!status.found) {
+                res.status(404).json({ ok: false, error: 'Pool not found for this mint' });
+                return;
+            }
+            res.json({
+                ok: true,
+                data: {
+                    mint,
+                    pool: status.poolAddress,
+                    config: status.configAddress,
+                    creator: status.creator,
+                    graduated: status.isMigrated,
+                    graduationProgress: `${status.progressPercent}%`,
+                    quoteReserve: status.quoteReserve,
+                    migrationThreshold: status.migrationThreshold,
+                    fees: status.fees,
+                    explorer: `https://solscan.io/token/${mint}`,
+                },
+            });
+        }
+        catch (err) {
+            logger_js_1.logger.warn({ err, mint }, 'Launch API: Status check failed');
+            res.status(500).json({ ok: false, error: 'Failed to fetch pool status' });
+        }
+    });
+    // ── GET /api/launch/quote/:pool ──────────────────────────────────────────
+    // Get a swap quote for a bonding curve pool (free)
+    router.get('/quote/:pool', async (req, res) => {
+        const { pool } = req.params;
+        const { amountIn, side } = req.query;
+        if (!pool || typeof pool !== 'string' || !/^[1-9A-HJ-NP-Za-km-z]{32,44}$/.test(pool)) {
+            res.status(400).json({ ok: false, error: 'Required: valid pool address in URL' });
+            return;
+        }
+        if (!amountIn || typeof amountIn !== 'string') {
+            res.status(400).json({ ok: false, error: 'Required: amountIn query param (lamports)' });
+            return;
+        }
+        const parsedAmount = parseInt(amountIn, 10);
+        if (Number.isNaN(parsedAmount) || parsedAmount <= 0 || !Number.isFinite(parsedAmount)) {
+            res.status(400).json({ ok: false, error: 'amountIn must be a positive integer (lamports)' });
+            return;
+        }
+        try {
+            const { getDbcSwapQuote } = await Promise.resolve().then(() => __importStar(require('../solana/meteora-dbc.js')));
+            const quote = await getDbcSwapQuote(connection, {
+                poolAddress: pool,
+                amountIn: String(parsedAmount),
+                swapBaseForQuote: side === 'sell',
+            });
+            res.json({ ok: true, data: quote });
+        }
+        catch (err) {
+            logger_js_1.logger.warn({ err, pool }, 'Launch API: Quote failed');
+            res.status(500).json({ ok: false, error: 'Failed to get quote' });
+        }
+    });
+    // ── POST /api/launch/swap ────────────────────────────────────────────────
+    // Buy or sell on a bonding curve pool
+    router.post('/swap', async (req, res) => {
+        const { pool: poolAddress, amountIn, side, slippageBps } = req.body;
+        if (!poolAddress || typeof poolAddress !== 'string' || !/^[1-9A-HJ-NP-Za-km-z]{32,44}$/.test(poolAddress)) {
+            res.status(400).json({ ok: false, error: 'Required: pool (valid Solana address)' });
+            return;
+        }
+        if (!amountIn || typeof amountIn !== 'string') {
+            res.status(400).json({ ok: false, error: 'Required: amountIn (string, lamports)' });
+            return;
+        }
+        if (!side || (side !== 'buy' && side !== 'sell')) {
+            res.status(400).json({ ok: false, error: 'Required: side ("buy" or "sell")' });
+            return;
+        }
+        const parsedAmount = parseInt(amountIn, 10);
+        if (Number.isNaN(parsedAmount) || parsedAmount <= 0 || !Number.isFinite(parsedAmount)) {
+            res.status(400).json({ ok: false, error: 'amountIn must be a positive integer (lamports)' });
+            return;
+        }
+        // Slippage protection: default 5% (500 bps), require quote first for zero-slippage
+        const slippage = (typeof slippageBps === 'number' && !Number.isNaN(slippageBps) && slippageBps >= 0)
+            ? slippageBps
+            : 500;
+        try {
+            // Get quote first to calculate minimumAmountOut with slippage
+            const { getDbcSwapQuote, swapOnDbcPool } = await Promise.resolve().then(() => __importStar(require('../solana/meteora-dbc.js')));
+            const quote = await getDbcSwapQuote(connection, {
+                poolAddress,
+                amountIn: String(parsedAmount),
+                swapBaseForQuote: side === 'sell',
+            });
+            const expectedOut = BigInt(quote.amountOut || '0');
+            const minOut = expectedOut - (expectedOut * BigInt(slippage) / 10000n);
+            const minimumAmountOut = minOut > 0n ? minOut.toString() : '0';
+            const result = await swapOnDbcPool(connection, keypair, {
+                poolAddress,
+                amountIn: String(parsedAmount),
+                minimumAmountOut,
+                swapBaseForQuote: side === 'sell',
+            });
+            res.json({
+                ok: true,
+                data: {
+                    signature: result.signature,
+                    direction: result.direction,
+                    expectedAmountOut: quote.amountOut,
+                    minimumAmountOut,
+                    slippageBps: slippage,
+                    explorer: `https://solscan.io/tx/${result.signature}`,
+                },
+            });
+        }
+        catch (err) {
+            logger_js_1.logger.warn({ err, pool: poolAddress, side }, 'Launch API: Swap failed');
+            const message = err instanceof Error ? err.message : String(err);
+            res.status(500).json({ ok: false, error: message });
+        }
+    });
+    // ── POST /api/launch/claim-fees ──────────────────────────────────────────
+    // Claim creator trading fees — only the launching agent or a fee delegate
+    router.post('/claim-fees', async (req, res) => {
+        const { pool: poolAddress } = req.body;
+        const callerAgentId = req.headers['x-agent-id'] ?? req.body?.agentId;
+        if (!poolAddress || typeof poolAddress !== 'string' || !/^[1-9A-HJ-NP-Za-km-z]{32,44}$/.test(poolAddress)) {
+            res.status(400).json({ ok: false, error: 'Required: pool (valid Solana address)' });
+            return;
+        }
+        // Find the launch record for this pool
+        const launch = launchRegistry.find((l) => l.pool === poolAddress);
+        if (launch) {
+            // Auth: only the creator agent or an authorized delegate can claim
+            if (!callerAgentId || typeof callerAgentId !== 'string') {
+                res.status(401).json({ ok: false, error: 'Provide agentId in request body or X-Agent-Id header to claim fees.' });
+                return;
+            }
+            const isCreator = launch.agentId === callerAgentId;
+            const isDelegate = launch.feeDelegates?.includes(callerAgentId) ?? false;
+            // Also check if the caller's wallet address matches a delegate wallet
+            let isDelegateByWallet = false;
+            if (!isCreator && !isDelegate) {
+                try {
+                    const registry = (0, registry_js_1.getRegistryService)();
+                    const callerAgent = await registry.getAgent(callerAgentId);
+                    if (callerAgent && launch.feeDelegates?.includes(callerAgent.address)) {
+                        isDelegateByWallet = true;
+                    }
+                }
+                catch { /* registry unavailable */ }
+            }
+            if (!isCreator && !isDelegate && !isDelegateByWallet) {
+                res.status(403).json({
+                    ok: false,
+                    error: `Only the creator agent (${launch.agentId}) or an authorized fee delegate can claim fees for this pool.`,
+                });
+                return;
+            }
+        }
+        // If no launch record found (e.g. pre-registry launch), allow claim (backward compat)
+        try {
+            const { claimDbcCreatorFees } = await Promise.resolve().then(() => __importStar(require('../solana/meteora-dbc.js')));
+            const result = await claimDbcCreatorFees(connection, keypair, poolAddress);
+            res.json({
+                ok: true,
+                data: {
+                    signature: result.signature,
+                    explorer: `https://solscan.io/tx/${result.signature}`,
+                },
+            });
+        }
+        catch (err) {
+            logger_js_1.logger.warn({ err, pool: poolAddress }, 'Launch API: Fee claim failed');
+            const message = err instanceof Error ? err.message : String(err);
+            res.status(500).json({ ok: false, error: message });
+        }
+    });
+    // ── POST /api/launch/delegate ──────────────────────────────────────────
+    // Add or remove a fee delegate for a launched token
+    router.post('/delegate', async (req, res) => {
+        const { pool: poolAddress, delegateId, action } = req.body;
+        const callerAgentId = req.headers['x-agent-id'] ?? req.body?.agentId;
+        if (!poolAddress || typeof poolAddress !== 'string' || !/^[1-9A-HJ-NP-Za-km-z]{32,44}$/.test(poolAddress)) {
+            res.status(400).json({ ok: false, error: 'Required: pool (valid Solana address)' });
+            return;
+        }
+        if (!delegateId || typeof delegateId !== 'string') {
+            res.status(400).json({ ok: false, error: 'Required: delegateId (agent ID or wallet address to delegate to)' });
+            return;
+        }
+        if (!callerAgentId || typeof callerAgentId !== 'string') {
+            res.status(401).json({ ok: false, error: 'Provide agentId in request body or X-Agent-Id header.' });
+            return;
+        }
+        const launch = launchRegistry.find((l) => l.pool === poolAddress);
+        if (!launch) {
+            res.status(404).json({ ok: false, error: 'No launch record found for this pool' });
+            return;
+        }
+        // Only the creator agent can manage delegates
+        if (launch.agentId !== callerAgentId) {
+            res.status(403).json({
+                ok: false,
+                error: `Only the creator agent (${launch.agentId}) can manage fee delegates.`,
+            });
+            return;
+        }
+        if (!launch.feeDelegates)
+            launch.feeDelegates = [];
+        if (action === 'remove') {
+            launch.feeDelegates = launch.feeDelegates.filter((d) => d !== delegateId);
+            saveLaunches(launchRegistry);
+            logger_js_1.logger.info({ pool: poolAddress, delegateId, action }, 'Launch API: Fee delegate removed');
+            res.json({ ok: true, data: { pool: poolAddress, feeDelegates: launch.feeDelegates } });
+            return;
+        }
+        // Default action: add
+        if (!launch.feeDelegates.includes(delegateId)) {
+            launch.feeDelegates.push(delegateId);
+            saveLaunches(launchRegistry);
+            logger_js_1.logger.info({ pool: poolAddress, delegateId, action: 'add' }, 'Launch API: Fee delegate added');
+        }
+        res.json({ ok: true, data: { pool: poolAddress, feeDelegates: launch.feeDelegates } });
+    });
+    logger_js_1.logger.info('Launch API routes initialized');
+    return router;
+}
+//# sourceMappingURL=launch-routes.js.map