clodds 1.1.0

package/dist/solana/pump-swarm.js

@@ -0,0 +1,1663 @@
+"use strict";
+/**
+ * Pump.fun Swarm Trading System
+ *
+ * Coordinates up to 20 wallets to execute trades simultaneously on Pump.fun tokens.
+ *
+ * Execution modes:
+ * - Parallel: All wallets execute simultaneously (fastest, default for >5 wallets)
+ * - Jito Bundle: Atomic execution for up to 5 wallets per bundle
+ * - Multi-Bundle: Multiple Jito bundles in parallel for >5 wallets
+ * - Sequential: Staggered execution with delays (for stealth)
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PumpFunSwarm = void 0;
+exports.loadWalletsFromEnv = loadWalletsFromEnv;
+exports.getSwarm = getSwarm;
+exports.createSwarm = createSwarm;
+exports.resetSwarm = resetSwarm;
+const web3_js_1 = require("@solana/web3.js");
+const events_1 = require("events");
+const bs58_1 = __importDefault(require("bs58"));
+// ============================================================================
+// Builder Imports
+// ============================================================================
+const swarm_builders_1 = require("./swarm-builders");
+// ============================================================================
+// Constants
+// ============================================================================
+const PUMPFUN_FRONTEND_API = 'https://frontend-api-v3.pump.fun';
+const JITO_BLOCK_ENGINE = 'https://mainnet.block-engine.jito.wtf';
+const JITO_TIP_ACCOUNTS = [
+    '96gYZGLnJYVFmbjzopPSU6QiEV5fGqZNyN9nmNhvrZU5',
+    'HFqU5x63VTqvQss8hp11i4bVmkdzeF3DY3kfvJf3hXba',
+    'Cw8CFyM9FkoMi7K7Crf6HNQqf4uEMzpKw6QNghXLvLkY',
+    'ADaUMid9yfUytqMBgopwjb2DTLSokTSzL1zt6iGPaS49',
+    'DfXygSm4jCyNCybVYYK6DwvWqjKee8pbDmJGcLWNDXjh',
+    'ADuUkR4vqLUMWXxW9gh6D6L8pMSawimctcNZ5pGwDcEt',
+    'DttWaMuVvTiduZRnguLF7jNxTgiMBZ1hyAumKUiL2KRL',
+    '3AVi9Tg9Uo68tJfuvoKvqKNWKkC5wPdSSdeBnizKZ6jT',
+];
+const MAX_BUNDLE_SIZE = 5; // Jito limit
+const MAX_WALLETS = 20;
+// ============================================================================
+// Wallet Pool Management
+// ============================================================================
+function loadWalletsFromEnv() {
+    const wallets = [];
+    // Load SOLANA_PRIVATE_KEY as wallet 0
+    const mainKey = process.env.SOLANA_PRIVATE_KEY;
+    if (mainKey) {
+        try {
+            const keypair = loadKeypairFromString(mainKey);
+            wallets.push(createWallet('wallet_0', keypair));
+        }
+        catch (e) {
+            console.error('Failed to load SOLANA_PRIVATE_KEY:', e);
+        }
+    }
+    // Load SOLANA_SWARM_KEY_1 through SOLANA_SWARM_KEY_20
+    for (let i = 1; i <= MAX_WALLETS; i++) {
+        const key = process.env[`SOLANA_SWARM_KEY_${i}`];
+        if (!key)
+            continue;
+        try {
+            const keypair = loadKeypairFromString(key);
+            wallets.push(createWallet(`wallet_${i}`, keypair));
+        }
+        catch (e) {
+            console.error(`Failed to load SOLANA_SWARM_KEY_${i}:`, e);
+        }
+    }
+    return wallets;
+}
+function createWallet(id, keypair) {
+    return {
+        id,
+        keypair,
+        publicKey: keypair.publicKey.toBase58(),
+        solBalance: 0,
+        positions: new Map(),
+        lastTradeAt: 0,
+        enabled: true,
+    };
+}
+function loadKeypairFromString(keyStr) {
+    // Try base58
+    try {
+        const decoded = bs58_1.default.decode(keyStr);
+        if (decoded.length === 64)
+            return web3_js_1.Keypair.fromSecretKey(decoded);
+    }
+    catch { }
+    // Try JSON array
+    try {
+        const arr = JSON.parse(keyStr);
+        if (Array.isArray(arr))
+            return web3_js_1.Keypair.fromSecretKey(Uint8Array.from(arr));
+    }
+    catch { }
+    // Try hex
+    try {
+        const hex = keyStr.replace(/^0x/, '');
+        const bytes = Buffer.from(hex, 'hex');
+        if (bytes.length === 64)
+            return web3_js_1.Keypair.fromSecretKey(bytes);
+    }
+    catch { }
+    throw new Error('Invalid key format');
+}
+// ============================================================================
+// PumpFun Swarm Class
+// ============================================================================
+class PumpFunSwarm extends events_1.EventEmitter {
+    connection;
+    wallets;
+    config;
+    constructor(config = {}) {
+        super();
+        const rpcUrl = config.rpcUrl || process.env.SOLANA_RPC_URL || 'https://api.mainnet-beta.solana.com';
+        this.connection = new web3_js_1.Connection(rpcUrl, 'confirmed');
+        const loadedWallets = config.wallets || loadWalletsFromEnv();
+        this.wallets = new Map(loadedWallets.map(w => [w.id, w]));
+        this.config = {
+            rpcUrl,
+            wallets: loadedWallets,
+            maxWallets: config.maxWallets ?? MAX_WALLETS,
+            rateLimitMs: config.rateLimitMs ?? 5000,
+            bundleEnabled: config.bundleEnabled ?? true,
+            jitoTipLamports: config.jitoTipLamports ?? 10000,
+            defaultSlippageBps: config.defaultSlippageBps ?? 500,
+            staggerDelayMs: config.staggerDelayMs ?? 200,
+            amountVariancePct: config.amountVariancePct ?? 5,
+            minSolBalance: config.minSolBalance ?? 0.01,
+            confirmTimeoutMs: config.confirmTimeoutMs ?? 60000,
+            parallelBatches: config.parallelBatches ?? 4,
+        };
+    }
+    // --------------------------------------------------------------------------
+    // Public API - Wallet Management
+    // --------------------------------------------------------------------------
+    getWallets() {
+        return Array.from(this.wallets.values());
+    }
+    getWallet(id) {
+        return this.wallets.get(id);
+    }
+    getEnabledWallets() {
+        return this.getWallets().filter(w => w.enabled);
+    }
+    enableWallet(id) {
+        const wallet = this.wallets.get(id);
+        if (wallet)
+            wallet.enabled = true;
+    }
+    disableWallet(id) {
+        const wallet = this.wallets.get(id);
+        if (wallet)
+            wallet.enabled = false;
+    }
+    enableAll() {
+        for (const wallet of this.wallets.values()) {
+            wallet.enabled = true;
+        }
+    }
+    disableAll() {
+        for (const wallet of this.wallets.values()) {
+            wallet.enabled = false;
+        }
+    }
+    getWalletCount() {
+        const all = this.getWallets();
+        return {
+            total: all.length,
+            enabled: all.filter(w => w.enabled).length,
+        };
+    }
+    // --------------------------------------------------------------------------
+    // Public API - Balance & Position Fetching
+    // --------------------------------------------------------------------------
+    async refreshBalances() {
+        const balances = new Map();
+        const wallets = this.getWallets();
+        // Fetch all balances in parallel
+        const results = await Promise.allSettled(wallets.map(async (wallet) => {
+            const balance = await this.connection.getBalance(wallet.keypair.publicKey);
+            return { id: wallet.id, balance: balance / 1e9 };
+        }));
+        for (let i = 0; i < results.length; i++) {
+            const result = results[i];
+            const wallet = wallets[i];
+            if (result.status === 'fulfilled') {
+                wallet.solBalance = result.value.balance;
+                balances.set(wallet.id, result.value.balance);
+            }
+            else {
+                balances.set(wallet.id, wallet.solBalance);
+            }
+        }
+        return balances;
+    }
+    async refreshTokenPositions(mint) {
+        const mintPubkey = new web3_js_1.PublicKey(mint);
+        const byWallet = new Map();
+        let totalTokens = 0;
+        const wallets = this.getWallets();
+        // Fetch all token balances in parallel
+        const results = await Promise.allSettled(wallets.map(async (wallet) => {
+            const balance = await this.getTokenBalance(wallet.keypair.publicKey, mintPubkey);
+            return { id: wallet.id, balance };
+        }));
+        for (let i = 0; i < results.length; i++) {
+            const result = results[i];
+            const wallet = wallets[i];
+            if (result.status === 'fulfilled' && result.value.balance > 0) {
+                wallet.positions.set(mint, result.value.balance);
+                byWallet.set(wallet.id, result.value.balance);
+                totalTokens += result.value.balance;
+            }
+            else {
+                wallet.positions.delete(mint);
+            }
+        }
+        return { mint, totalTokens, byWallet, lastUpdated: Date.now() };
+    }
+    async getTokenBalance(owner, mint) {
+        const accounts = await this.connection.getTokenAccountsByOwner(owner, { mint });
+        if (accounts.value.length === 0)
+            return 0;
+        let total = 0;
+        for (const acc of accounts.value) {
+            const data = acc.account.data;
+            const amount = data.readBigUInt64LE(64);
+            total += Number(amount);
+        }
+        return total;
+    }
+    getSwarmPosition(mint) {
+        const byWallet = new Map();
+        let totalTokens = 0;
+        for (const wallet of this.wallets.values()) {
+            const amount = wallet.positions.get(mint) || 0;
+            if (amount > 0) {
+                byWallet.set(wallet.id, amount);
+                totalTokens += amount;
+            }
+        }
+        return { mint, totalTokens, byWallet, lastUpdated: Date.now() };
+    }
+    // --------------------------------------------------------------------------
+    // Coordinated Trading - Main Entry Points
+    // --------------------------------------------------------------------------
+    async coordinatedBuy(params) {
+        const startTime = Date.now();
+        const errors = [];
+        // Refresh balances first
+        await this.refreshBalances();
+        // Select and filter wallets
+        let wallets = this.selectWallets(params.walletIds);
+        const solNeeded = typeof params.amountPerWallet === 'number'
+            ? params.amountPerWallet
+            : parseFloat(params.amountPerWallet);
+        wallets = wallets.filter(w => {
+            if (w.solBalance < solNeeded + this.config.minSolBalance) {
+                errors.push(`${w.id}: insufficient SOL (${w.solBalance.toFixed(4)})`);
+                return false;
+            }
+            return true;
+        });
+        if (wallets.length === 0) {
+            return this.emptyResult(params, 'buy', startTime, errors, 'No wallets with sufficient balance');
+        }
+        const mode = this.selectExecutionMode(params, wallets.length);
+        return this.executeWithMode(mode, params, wallets, startTime, errors);
+    }
+    async coordinatedSell(params) {
+        const startTime = Date.now();
+        const errors = [];
+        // Fetch actual token positions from chain
+        await this.refreshTokenPositions(params.mint);
+        // Select wallets with positions
+        let wallets = this.selectWallets(params.walletIds);
+        wallets = wallets.filter(w => {
+            const pos = w.positions.get(params.mint) || 0;
+            if (pos <= 0) {
+                errors.push(`${w.id}: no position`);
+                return false;
+            }
+            return true;
+        });
+        if (wallets.length === 0) {
+            return this.emptyResult(params, 'sell', startTime, errors, 'No wallets with positions');
+        }
+        const mode = this.selectExecutionMode(params, wallets.length);
+        return this.executeWithMode(mode, params, wallets, startTime, errors);
+    }
+    // --------------------------------------------------------------------------
+    // Execution Mode Selection & Dispatch
+    // --------------------------------------------------------------------------
+    selectExecutionMode(params, walletCount) {
+        // User specified mode takes priority
+        if (params.executionMode)
+            return params.executionMode;
+        // Default logic:
+        // - 1 wallet: parallel (just one)
+        // - 2-5 wallets: bundle (atomic)
+        // - 6-20 wallets: multi-bundle (multiple atomic bundles in parallel)
+        // - If bundles disabled: parallel
+        if (!this.config.bundleEnabled)
+            return 'parallel';
+        if (walletCount <= 1)
+            return 'parallel';
+        if (walletCount <= MAX_BUNDLE_SIZE)
+            return 'bundle';
+        return 'multi-bundle';
+    }
+    async executeWithMode(mode, params, wallets, startTime, errors) {
+        switch (mode) {
+            case 'bundle':
+                return this.executeSingleBundle(params, wallets, startTime, errors);
+            case 'multi-bundle':
+                return this.executeMultiBundles(params, wallets, startTime, errors);
+            case 'sequential':
+                return this.executeSequential(params, wallets, startTime, errors);
+            case 'parallel':
+            default:
+                return this.executeParallel(params, wallets, startTime, errors);
+        }
+    }
+    // --------------------------------------------------------------------------
+    // Execution Mode: PARALLEL (All at once, no bundles)
+    // --------------------------------------------------------------------------
+    async executeParallel(params, wallets, startTime, errors) {
+        // Build all transactions in parallel
+        const txPromises = wallets.map(async (wallet) => {
+            try {
+                const amount = this.calculateAmount(params.amountPerWallet, wallet, params.mint);
+                if (amount <= 0)
+                    return { wallet, tx: null, amount, error: 'Amount is zero' };
+                const tx = await this.buildTransaction(wallet, params, amount);
+                return { wallet, tx, amount, error: null };
+            }
+            catch (e) {
+                return { wallet, tx: null, amount: 0, error: e instanceof Error ? e.message : String(e) };
+            }
+        });
+        const txResults = await Promise.all(txPromises);
+        // Sign all transactions
+        for (const result of txResults) {
+            if (result.tx) {
+                result.tx.sign([result.wallet.keypair]);
+            }
+        }
+        // Send all transactions in parallel
+        const sendPromises = txResults.map(async (result) => {
+            if (!result.tx) {
+                return {
+                    walletId: result.wallet.id,
+                    publicKey: result.wallet.publicKey,
+                    success: false,
+                    error: result.error || 'No transaction',
+                };
+            }
+            try {
+                const signature = await this.connection.sendRawTransaction(result.tx.serialize(), {
+                    skipPreflight: true,
+                    maxRetries: 3,
+                });
+                return {
+                    walletId: result.wallet.id,
+                    publicKey: result.wallet.publicKey,
+                    success: true,
+                    signature,
+                    solAmount: params.action === 'buy' ? result.amount : undefined,
+                    tokenAmount: params.action === 'sell' ? result.amount : undefined,
+                };
+            }
+            catch (e) {
+                return {
+                    walletId: result.wallet.id,
+                    publicKey: result.wallet.publicKey,
+                    success: false,
+                    error: e instanceof Error ? e.message : String(e),
+                };
+            }
+        });
+        const walletResults = await Promise.all(sendPromises);
+        // Confirm all successful sends in parallel (don't wait for full confirmation to return)
+        this.confirmAllAsync(walletResults.filter(r => r.success && r.signature).map(r => r.signature));
+        // Schedule position refresh
+        setTimeout(() => this.refreshTokenPositions(params.mint), 5000);
+        return this.buildResult(params, walletResults, startTime, errors, 'parallel');
+    }
+    // --------------------------------------------------------------------------
+    // Execution Mode: SINGLE BUNDLE (Atomic, up to 5 wallets)
+    // --------------------------------------------------------------------------
+    async executeSingleBundle(params, wallets, startTime, errors) {
+        const { signedTxs, walletResults, tipWallet } = await this.buildAndSignTransactions(params, wallets, errors);
+        if (signedTxs.length === 0) {
+            return this.buildResult(params, walletResults, startTime, errors, 'bundle');
+        }
+        // Add tip transaction
+        try {
+            const tipTx = await this.buildTipTransaction(tipWallet);
+            tipTx.sign([tipWallet.keypair]);
+            signedTxs.push(tipTx);
+        }
+        catch (e) {
+            errors.push(`Tip failed: ${e instanceof Error ? e.message : String(e)}`);
+        }
+        // Submit bundle
+        try {
+            const bundleId = await this.submitJitoBundle(signedTxs);
+            // Mark all as successful
+            for (const result of walletResults) {
+                if (!result.error)
+                    result.success = true;
+            }
+            setTimeout(() => this.refreshTokenPositions(params.mint), 5000);
+            return this.buildResult(params, walletResults, startTime, errors, 'bundle', [bundleId]);
+        }
+        catch (e) {
+            errors.push(`Bundle failed: ${e instanceof Error ? e.message : String(e)}`);
+            // Fallback to parallel
+            return this.executeParallel(params, wallets, startTime, errors);
+        }
+    }
+    // --------------------------------------------------------------------------
+    // Execution Mode: MULTI-BUNDLE (Multiple bundles in parallel for >5 wallets)
+    // --------------------------------------------------------------------------
+    async executeMultiBundles(params, wallets, startTime, errors) {
+        // Split wallets into chunks of MAX_BUNDLE_SIZE
+        const chunks = this.chunkArray(wallets, MAX_BUNDLE_SIZE);
+        const bundleIds = [];
+        const allWalletResults = [];
+        // Execute all bundles in parallel
+        const bundlePromises = chunks.map(async (chunk, index) => {
+            const chunkErrors = [];
+            const { signedTxs, walletResults, tipWallet } = await this.buildAndSignTransactions(params, chunk, chunkErrors);
+            if (signedTxs.length === 0) {
+                return { walletResults, bundleId: null, errors: chunkErrors };
+            }
+            // Add tip transaction
+            try {
+                const tipTx = await this.buildTipTransaction(tipWallet);
+                tipTx.sign([tipWallet.keypair]);
+                signedTxs.push(tipTx);
+            }
+            catch (e) {
+                chunkErrors.push(`Chunk ${index} tip failed`);
+            }
+            // Submit bundle
+            try {
+                const bundleId = await this.submitJitoBundle(signedTxs);
+                for (const result of walletResults) {
+                    if (!result.error)
+                        result.success = true;
+                }
+                return { walletResults, bundleId, errors: chunkErrors };
+            }
+            catch (e) {
+                chunkErrors.push(`Chunk ${index} bundle failed: ${e instanceof Error ? e.message : String(e)}`);
+                // Try parallel for this chunk
+                const parallelResults = await this.executeParallelForChunk(params, chunk);
+                return { walletResults: parallelResults, bundleId: null, errors: chunkErrors };
+            }
+        });
+        const results = await Promise.all(bundlePromises);
+        for (const result of results) {
+            allWalletResults.push(...result.walletResults);
+            if (result.bundleId)
+                bundleIds.push(result.bundleId);
+            errors.push(...result.errors);
+        }
+        setTimeout(() => this.refreshTokenPositions(params.mint), 5000);
+        return this.buildResult(params, allWalletResults, startTime, errors, 'multi-bundle', bundleIds);
+    }
+    async executeParallelForChunk(params, wallets) {
+        const results = [];
+        const promises = wallets.map(async (wallet) => {
+            try {
+                const amount = this.calculateAmount(params.amountPerWallet, wallet, params.mint);
+                if (amount <= 0) {
+                    return { walletId: wallet.id, publicKey: wallet.publicKey, success: false, error: 'Zero amount' };
+                }
+                const tx = await this.buildTransaction(wallet, params, amount);
+                if (!tx) {
+                    return { walletId: wallet.id, publicKey: wallet.publicKey, success: false, error: 'Build failed' };
+                }
+                tx.sign([wallet.keypair]);
+                const signature = await this.connection.sendRawTransaction(tx.serialize(), {
+                    skipPreflight: true,
+                    maxRetries: 3,
+                });
+                return {
+                    walletId: wallet.id,
+                    publicKey: wallet.publicKey,
+                    success: true,
+                    signature,
+                    solAmount: params.action === 'buy' ? amount : undefined,
+                    tokenAmount: params.action === 'sell' ? amount : undefined,
+                };
+            }
+            catch (e) {
+                return {
+                    walletId: wallet.id,
+                    publicKey: wallet.publicKey,
+                    success: false,
+                    error: e instanceof Error ? e.message : String(e),
+                };
+            }
+        });
+        return Promise.all(promises);
+    }
+    // --------------------------------------------------------------------------
+    // Execution Mode: SEQUENTIAL (Staggered, for stealth)
+    // --------------------------------------------------------------------------
+    async executeSequential(params, wallets, startTime, errors) {
+        const walletResults = [];
+        for (let i = 0; i < wallets.length; i++) {
+            const wallet = wallets[i];
+            // Rate limiting
+            const timeSinceLastTrade = Date.now() - wallet.lastTradeAt;
+            if (timeSinceLastTrade < this.config.rateLimitMs) {
+                await sleep(this.config.rateLimitMs - timeSinceLastTrade);
+            }
+            // Stagger delay
+            if (i > 0) {
+                const delay = this.config.staggerDelayMs + Math.random() * this.config.staggerDelayMs;
+                await sleep(delay);
+            }
+            try {
+                const amount = this.calculateAmount(params.amountPerWallet, wallet, params.mint);
+                if (amount <= 0) {
+                    walletResults.push({ walletId: wallet.id, publicKey: wallet.publicKey, success: false, error: 'Zero amount' });
+                    continue;
+                }
+                const result = await this.executeSingleTrade(wallet, params, amount);
+                walletResults.push(result);
+                wallet.lastTradeAt = Date.now();
+                this.emit('trade', { wallet: wallet.id, ...result });
+            }
+            catch (e) {
+                errors.push(`${wallet.id}: ${e instanceof Error ? e.message : String(e)}`);
+                walletResults.push({
+                    walletId: wallet.id,
+                    publicKey: wallet.publicKey,
+                    success: false,
+                    error: e instanceof Error ? e.message : String(e),
+                });
+            }
+        }
+        setTimeout(() => this.refreshTokenPositions(params.mint), 5000);
+        return this.buildResult(params, walletResults, startTime, errors, 'sequential');
+    }
+    async executeSingleTrade(wallet, params, amount) {
+        const tx = await this.buildTransaction(wallet, params, amount);
+        if (!tx) {
+            return { walletId: wallet.id, publicKey: wallet.publicKey, success: false, error: 'Build failed' };
+        }
+        tx.sign([wallet.keypair]);
+        const signature = await this.connection.sendRawTransaction(tx.serialize(), {
+            skipPreflight: true,
+            maxRetries: 3,
+        });
+        try {
+            await this.confirmWithTimeout(signature, this.config.confirmTimeoutMs);
+        }
+        catch (e) {
+            return {
+                walletId: wallet.id,
+                publicKey: wallet.publicKey,
+                success: false,
+                signature,
+                error: `Confirm failed: ${e instanceof Error ? e.message : String(e)}`,
+            };
+        }
+        return {
+            walletId: wallet.id,
+            publicKey: wallet.publicKey,
+            success: true,
+            signature,
+            solAmount: params.action === 'buy' ? amount : undefined,
+            tokenAmount: params.action === 'sell' ? amount : undefined,
+        };
+    }
+    // --------------------------------------------------------------------------
+    // Transaction Building & Jito
+    // --------------------------------------------------------------------------
+    async buildAndSignTransactions(params, wallets, errors) {
+        const signedTxs = [];
+        const walletResults = [];
+        for (const wallet of wallets) {
+            try {
+                const amount = this.calculateAmount(params.amountPerWallet, wallet, params.mint);
+                if (amount <= 0) {
+                    walletResults.push({ walletId: wallet.id, publicKey: wallet.publicKey, success: false, error: 'Zero amount' });
+                    continue;
+                }
+                const tx = await this.buildTransaction(wallet, params, amount);
+                if (tx) {
+                    tx.sign([wallet.keypair]);
+                    signedTxs.push(tx);
+                    walletResults.push({
+                        walletId: wallet.id,
+                        publicKey: wallet.publicKey,
+                        success: false,
+                        solAmount: params.action === 'buy' ? amount : undefined,
+                        tokenAmount: params.action === 'sell' ? amount : undefined,
+                    });
+                }
+            }
+            catch (e) {
+                const errMsg = e instanceof Error ? e.message : String(e);
+                errors.push(`${wallet.id}: ${errMsg}`);
+                walletResults.push({ walletId: wallet.id, publicKey: wallet.publicKey, success: false, error: errMsg });
+            }
+        }
+        return { signedTxs, walletResults, tipWallet: wallets[0] };
+    }
+    async buildTransaction(wallet, params, amount) {
+        // Get the appropriate builder for the DEX
+        const dex = params.dex ?? 'pumpfun';
+        const builder = (0, swarm_builders_1.getBuilder)(dex);
+        const options = {
+            slippageBps: params.slippageBps ?? this.config.defaultSlippageBps,
+            priorityFeeLamports: params.priorityFeeLamports,
+            poolAddress: params.poolAddress,
+            pool: params.pool,
+        };
+        // Cast wallet to builder's expected type (they're compatible)
+        const builderWallet = wallet;
+        if (params.action === 'buy') {
+            return builder.buildBuyTransaction(this.connection, builderWallet, params.mint, amount, options);
+        }
+        else {
+            return builder.buildSellTransaction(this.connection, builderWallet, params.mint, amount, options);
+        }
+    }
+    async buildTipTransaction(wallet) {
+        const tipAccount = new web3_js_1.PublicKey(JITO_TIP_ACCOUNTS[Math.floor(Math.random() * JITO_TIP_ACCOUNTS.length)]);
+        const { blockhash } = await this.connection.getLatestBlockhash();
+        const instruction = web3_js_1.SystemProgram.transfer({
+            fromPubkey: wallet.keypair.publicKey,
+            toPubkey: tipAccount,
+            lamports: this.config.jitoTipLamports,
+        });
+        const messageV0 = new web3_js_1.TransactionMessage({
+            payerKey: wallet.keypair.publicKey,
+            recentBlockhash: blockhash,
+            instructions: [instruction],
+        }).compileToV0Message();
+        return new web3_js_1.VersionedTransaction(messageV0);
+    }
+    async submitJitoBundle(transactions) {
+        const serializedTxs = transactions.map(tx => bs58_1.default.encode(tx.serialize()));
+        const response = await fetch(`${JITO_BLOCK_ENGINE}/api/v1/bundles`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                jsonrpc: '2.0',
+                id: 1,
+                method: 'sendBundle',
+                params: [serializedTxs],
+            }),
+        });
+        if (!response.ok) {
+            const text = await response.text();
+            throw new Error(`Jito ${response.status}: ${text}`);
+        }
+        const result = await response.json();
+        if (result.error)
+            throw new Error(`Jito: ${result.error.message}`);
+        return result.result || 'bundle_submitted';
+    }
+    // --------------------------------------------------------------------------
+    // Helpers
+    // --------------------------------------------------------------------------
+    selectWallets(walletIds) {
+        if (walletIds && walletIds.length > 0) {
+            return walletIds
+                .map(id => this.wallets.get(id))
+                .filter((w) => w !== undefined && w.enabled);
+        }
+        return this.getEnabledWallets();
+    }
+    calculateAmount(baseAmount, wallet, mint) {
+        let amount;
+        if (typeof baseAmount === 'string' && baseAmount.endsWith('%')) {
+            const pct = parseFloat(baseAmount) / 100;
+            const position = wallet.positions.get(mint) || 0;
+            amount = Math.floor(position * pct);
+        }
+        else {
+            amount = typeof baseAmount === 'string' ? parseFloat(baseAmount) : baseAmount;
+        }
+        // Apply variance (only for buys)
+        if (this.config.amountVariancePct > 0 && !(typeof baseAmount === 'string' && baseAmount.endsWith('%'))) {
+            const variance = amount * (this.config.amountVariancePct / 100);
+            amount += (Math.random() - 0.5) * 2 * variance;
+        }
+        return Math.max(0, amount);
+    }
+    async confirmWithTimeout(signature, timeoutMs) {
+        const start = Date.now();
+        while (Date.now() - start < timeoutMs) {
+            const status = await this.connection.getSignatureStatus(signature);
+            if (status.value?.confirmationStatus === 'confirmed' || status.value?.confirmationStatus === 'finalized') {
+                if (status.value.err)
+                    throw new Error(`TX failed: ${JSON.stringify(status.value.err)}`);
+                return;
+            }
+            await sleep(1000);
+        }
+        throw new Error('Timeout');
+    }
+    confirmAllAsync(signatures) {
+        // Fire and forget - confirms in background
+        for (const sig of signatures) {
+            this.confirmWithTimeout(sig, this.config.confirmTimeoutMs).catch(() => { });
+        }
+    }
+    chunkArray(array, size) {
+        const chunks = [];
+        for (let i = 0; i < array.length; i += size) {
+            chunks.push(array.slice(i, i + size));
+        }
+        return chunks;
+    }
+    emptyResult(params, action, startTime, errors, defaultError) {
+        return {
+            success: false,
+            mint: params.mint,
+            action,
+            walletResults: [],
+            executionTimeMs: Date.now() - startTime,
+            executionMode: 'parallel',
+            errors: errors.length > 0 ? errors : [defaultError],
+        };
+    }
+    buildResult(params, walletResults, startTime, errors, mode, bundleIds) {
+        const successCount = walletResults.filter(r => r.success).length;
+        const totalSol = walletResults
+            .filter(r => r.success && r.solAmount)
+            .reduce((sum, r) => sum + (r.solAmount || 0), 0);
+        return {
+            success: successCount > 0,
+            mint: params.mint,
+            action: params.action,
+            walletResults,
+            bundleIds: bundleIds && bundleIds.length > 0 ? bundleIds : undefined,
+            totalSolSpent: params.action === 'buy' ? totalSol : undefined,
+            executionTimeMs: Date.now() - startTime,
+            executionMode: mode,
+            errors: errors.length > 0 ? errors : undefined,
+        };
+    }
+    // --------------------------------------------------------------------------
+    // SOL Distribution & Consolidation
+    // --------------------------------------------------------------------------
+    /**
+     * Distribute SOL from main wallet to all other wallets
+     */
+    async distributeSOL(amountPerWallet, fromWalletId = 'wallet_0') {
+        const fromWallet = this.wallets.get(fromWalletId);
+        if (!fromWallet) {
+            return {
+                success: false,
+                fromWallet: fromWalletId,
+                totalDistributed: 0,
+                distributions: [],
+                errors: [`Wallet ${fromWalletId} not found`],
+            };
+        }
+        // Refresh balances first
+        await this.refreshBalances();
+        const targetWallets = this.getWallets().filter(w => w.id !== fromWalletId && w.enabled);
+        if (targetWallets.length === 0) {
+            return {
+                success: false,
+                fromWallet: fromWalletId,
+                totalDistributed: 0,
+                distributions: [],
+                errors: ['No target wallets available'],
+            };
+        }
+        const totalNeeded = amountPerWallet * targetWallets.length;
+        if (fromWallet.solBalance < totalNeeded + 0.01) {
+            return {
+                success: false,
+                fromWallet: fromWalletId,
+                totalDistributed: 0,
+                distributions: [],
+                errors: [`Insufficient balance. Need ${totalNeeded.toFixed(4)} SOL, have ${fromWallet.solBalance.toFixed(4)}`],
+            };
+        }
+        const distributions = [];
+        const errors = [];
+        let totalDistributed = 0;
+        // Build and send transfer transactions
+        for (const targetWallet of targetWallets) {
+            try {
+                const { blockhash } = await this.connection.getLatestBlockhash();
+                const lamports = Math.floor(amountPerWallet * 1e9);
+                const instruction = web3_js_1.SystemProgram.transfer({
+                    fromPubkey: fromWallet.keypair.publicKey,
+                    toPubkey: targetWallet.keypair.publicKey,
+                    lamports,
+                });
+                const messageV0 = new web3_js_1.TransactionMessage({
+                    payerKey: fromWallet.keypair.publicKey,
+                    recentBlockhash: blockhash,
+                    instructions: [instruction],
+                }).compileToV0Message();
+                const tx = new web3_js_1.VersionedTransaction(messageV0);
+                tx.sign([fromWallet.keypair]);
+                const signature = await this.connection.sendRawTransaction(tx.serialize(), {
+                    skipPreflight: true,
+                    maxRetries: 3,
+                });
+                distributions.push({
+                    toWallet: targetWallet.id,
+                    amount: amountPerWallet,
+                    signature,
+                });
+                totalDistributed += amountPerWallet;
+                // Small delay between transfers
+                await sleep(100);
+            }
+            catch (e) {
+                const errMsg = e instanceof Error ? e.message : String(e);
+                distributions.push({
+                    toWallet: targetWallet.id,
+                    amount: amountPerWallet,
+                    error: errMsg,
+                });
+                errors.push(`${targetWallet.id}: ${errMsg}`);
+            }
+        }
+        // Refresh balances after distribution
+        setTimeout(() => this.refreshBalances(), 3000);
+        return {
+            success: distributions.some(d => d.signature),
+            fromWallet: fromWalletId,
+            totalDistributed,
+            distributions,
+            errors: errors.length > 0 ? errors : undefined,
+        };
+    }
+    /**
+     * Consolidate SOL from all wallets to one wallet
+     */
+    async consolidateSOL(toWalletId = 'wallet_0', leaveAmount = 0.005) {
+        const toWallet = this.wallets.get(toWalletId);
+        if (!toWallet) {
+            return {
+                success: false,
+                toWallet: toWalletId,
+                totalConsolidated: 0,
+                consolidations: [],
+                errors: [`Wallet ${toWalletId} not found`],
+            };
+        }
+        await this.refreshBalances();
+        const sourceWallets = this.getWallets().filter(w => w.id !== toWalletId && w.solBalance > leaveAmount + 0.001);
+        if (sourceWallets.length === 0) {
+            return {
+                success: false,
+                toWallet: toWalletId,
+                totalConsolidated: 0,
+                consolidations: [],
+                errors: ['No wallets with sufficient balance to consolidate'],
+            };
+        }
+        const consolidations = [];
+        const errors = [];
+        let totalConsolidated = 0;
+        for (const sourceWallet of sourceWallets) {
+            try {
+                const amountToSend = sourceWallet.solBalance - leaveAmount;
+                if (amountToSend <= 0)
+                    continue;
+                const { blockhash } = await this.connection.getLatestBlockhash();
+                const lamports = Math.floor(amountToSend * 1e9);
+                const instruction = web3_js_1.SystemProgram.transfer({
+                    fromPubkey: sourceWallet.keypair.publicKey,
+                    toPubkey: toWallet.keypair.publicKey,
+                    lamports,
+                });
+                const messageV0 = new web3_js_1.TransactionMessage({
+                    payerKey: sourceWallet.keypair.publicKey,
+                    recentBlockhash: blockhash,
+                    instructions: [instruction],
+                }).compileToV0Message();
+                const tx = new web3_js_1.VersionedTransaction(messageV0);
+                tx.sign([sourceWallet.keypair]);
+                const signature = await this.connection.sendRawTransaction(tx.serialize(), {
+                    skipPreflight: true,
+                    maxRetries: 3,
+                });
+                consolidations.push({
+                    fromWallet: sourceWallet.id,
+                    amount: amountToSend,
+                    signature,
+                });
+                totalConsolidated += amountToSend;
+                await sleep(100);
+            }
+            catch (e) {
+                const errMsg = e instanceof Error ? e.message : String(e);
+                consolidations.push({
+                    fromWallet: sourceWallet.id,
+                    amount: sourceWallet.solBalance - leaveAmount,
+                    error: errMsg,
+                });
+                errors.push(`${sourceWallet.id}: ${errMsg}`);
+            }
+        }
+        setTimeout(() => this.refreshBalances(), 3000);
+        return {
+            success: consolidations.some(c => c.signature),
+            toWallet: toWalletId,
+            totalConsolidated,
+            consolidations,
+            errors: errors.length > 0 ? errors : undefined,
+        };
+    }
+    /**
+     * Consolidate all tokens of a specific mint to one wallet
+     */
+    async consolidateTokens(mint, toWalletId = 'wallet_0', options) {
+        const toWallet = this.wallets.get(toWalletId);
+        if (!toWallet) {
+            return {
+                success: false,
+                toWallet: toWalletId,
+                totalConsolidated: 0,
+                consolidations: [],
+                errors: [`Wallet ${toWalletId} not found`],
+            };
+        }
+        // Refresh positions first
+        await this.refreshTokenPositions(mint);
+        const sourceWallets = this.getWallets().filter(w => {
+            const pos = w.positions.get(mint) || 0;
+            return w.id !== toWalletId && pos > 0;
+        });
+        if (sourceWallets.length === 0) {
+            return {
+                success: false,
+                toWallet: toWalletId,
+                totalConsolidated: 0,
+                consolidations: [],
+                errors: ['No wallets with token positions to consolidate'],
+            };
+        }
+        const consolidations = [];
+        const errors = [];
+        let totalConsolidated = 0;
+        // For tokens, we need to sell from source and buy to target
+        // This is done through the trading mechanism
+        for (const sourceWallet of sourceWallets) {
+            const tokenAmount = sourceWallet.positions.get(mint) || 0;
+            if (tokenAmount <= 0)
+                continue;
+            try {
+                // Execute sell from this wallet
+                const sellResult = await this.executeSingleTrade(sourceWallet, {
+                    mint,
+                    action: 'sell',
+                    amountPerWallet: tokenAmount,
+                    denominatedInSol: false,
+                    slippageBps: this.config.defaultSlippageBps,
+                    dex: options?.dex,
+                    poolAddress: options?.poolAddress,
+                }, tokenAmount);
+                if (sellResult.success) {
+                    consolidations.push({
+                        fromWallet: sourceWallet.id,
+                        amount: tokenAmount,
+                        signature: sellResult.signature,
+                    });
+                    totalConsolidated += tokenAmount;
+                }
+                else {
+                    consolidations.push({
+                        fromWallet: sourceWallet.id,
+                        amount: tokenAmount,
+                        error: sellResult.error || 'Sell failed',
+                    });
+                    errors.push(`${sourceWallet.id}: ${sellResult.error}`);
+                }
+                await sleep(500);
+            }
+            catch (e) {
+                const errMsg = e instanceof Error ? e.message : String(e);
+                consolidations.push({
+                    fromWallet: sourceWallet.id,
+                    amount: tokenAmount,
+                    error: errMsg,
+                });
+                errors.push(`${sourceWallet.id}: ${errMsg}`);
+            }
+        }
+        setTimeout(() => this.refreshTokenPositions(mint), 5000);
+        return {
+            success: consolidations.some(c => c.signature),
+            toWallet: toWalletId,
+            totalConsolidated,
+            consolidations,
+            errors: errors.length > 0 ? errors : undefined,
+        };
+    }
+    // --------------------------------------------------------------------------
+    // Status & Monitoring
+    // --------------------------------------------------------------------------
+    /**
+     * Get comprehensive swarm status
+     */
+    async getSwarmStatus(mints) {
+        await this.refreshBalances();
+        const balanceByWallet = new Map();
+        let totalSolBalance = 0;
+        for (const wallet of this.wallets.values()) {
+            balanceByWallet.set(wallet.id, wallet.solBalance);
+            totalSolBalance += wallet.solBalance;
+        }
+        const positions = new Map();
+        if (mints && mints.length > 0) {
+            for (const mint of mints) {
+                const pos = await this.refreshTokenPositions(mint);
+                positions.set(mint, pos);
+            }
+        }
+        return {
+            totalWallets: this.wallets.size,
+            enabledWallets: this.getEnabledWallets().length,
+            totalSolBalance,
+            balanceByWallet,
+            positions,
+            lastUpdated: Date.now(),
+        };
+    }
+    // --------------------------------------------------------------------------
+    // Quotes & Simulation
+    // --------------------------------------------------------------------------
+    /**
+     * Get quotes for a coordinated trade without executing
+     */
+    async coordinatedQuote(params) {
+        const wallets = this.selectWallets(params.walletIds);
+        const quotes = [];
+        let totalInput = 0;
+        let totalOutput = 0;
+        let totalPriceImpact = 0;
+        let priceImpactCount = 0;
+        // Get the builder for the specified DEX
+        const dex = params.dex ?? 'pumpfun';
+        const builder = (0, swarm_builders_1.getBuilder)(dex);
+        for (const wallet of wallets) {
+            try {
+                const amount = this.calculateAmount(params.amountPerWallet, wallet, params.mint);
+                if (amount <= 0) {
+                    quotes.push({ walletId: wallet.id, inputAmount: 0, outputAmount: 0, error: 'Zero amount' });
+                    continue;
+                }
+                // Use builder's getQuote if available, otherwise fallback to estimate
+                if (builder.getQuote) {
+                    try {
+                        const quoteResult = await builder.getQuote(this.connection, params.mint, amount, params.action === 'buy', {
+                            slippageBps: params.slippageBps ?? this.config.defaultSlippageBps,
+                            poolAddress: params.poolAddress,
+                            pool: params.pool,
+                        });
+                        quotes.push({
+                            walletId: wallet.id,
+                            inputAmount: quoteResult.inputAmount,
+                            outputAmount: quoteResult.outputAmount,
+                            priceImpact: quoteResult.priceImpact,
+                        });
+                        totalInput += quoteResult.inputAmount;
+                        totalOutput += quoteResult.outputAmount;
+                        if (quoteResult.priceImpact !== undefined) {
+                            totalPriceImpact += quoteResult.priceImpact;
+                            priceImpactCount++;
+                        }
+                    }
+                    catch (quoteError) {
+                        quotes.push({
+                            walletId: wallet.id,
+                            inputAmount: amount,
+                            outputAmount: 0,
+                            error: `Quote failed: ${quoteError instanceof Error ? quoteError.message : String(quoteError)}`,
+                        });
+                        totalInput += amount;
+                    }
+                }
+                else {
+                    // Builder doesn't support quotes, use input amount as estimate
+                    quotes.push({ walletId: wallet.id, inputAmount: amount, outputAmount: 0, error: 'Quotes not supported for this DEX' });
+                    totalInput += amount;
+                }
+            }
+            catch (e) {
+                quotes.push({
+                    walletId: wallet.id,
+                    inputAmount: 0,
+                    outputAmount: 0,
+                    error: e instanceof Error ? e.message : String(e)
+                });
+            }
+        }
+        return {
+            mint: params.mint,
+            action: params.action,
+            quotes,
+            totalInput,
+            totalOutput,
+            avgPriceImpact: priceImpactCount > 0 ? totalPriceImpact / priceImpactCount : undefined,
+        };
+    }
+    /**
+     * Simulate a trade without executing
+     */
+    async simulate(params) {
+        const warnings = [];
+        const errors = [];
+        // Refresh data
+        await this.refreshBalances();
+        if (params.action === 'sell') {
+            await this.refreshTokenPositions(params.mint);
+        }
+        // Select wallets
+        let wallets = this.selectWallets(params.walletIds);
+        const originalCount = wallets.length;
+        if (wallets.length === 0) {
+            errors.push('No enabled wallets available');
+            return {
+                wouldSucceed: false,
+                params,
+                walletsUsed: 0,
+                estimatedTotalSol: 0,
+                estimatedFees: 0,
+                warnings,
+                errors,
+            };
+        }
+        // Filter based on action
+        if (params.action === 'buy') {
+            const solNeeded = typeof params.amountPerWallet === 'number'
+                ? params.amountPerWallet
+                : parseFloat(params.amountPerWallet);
+            wallets = wallets.filter(w => {
+                if (w.solBalance < solNeeded + this.config.minSolBalance) {
+                    warnings.push(`${w.id}: insufficient SOL (${w.solBalance.toFixed(4)})`);
+                    return false;
+                }
+                return true;
+            });
+        }
+        else {
+            wallets = wallets.filter(w => {
+                const pos = w.positions.get(params.mint) || 0;
+                if (pos <= 0) {
+                    warnings.push(`${w.id}: no position`);
+                    return false;
+                }
+                return true;
+            });
+        }
+        if (wallets.length < originalCount) {
+            warnings.push(`${originalCount - wallets.length} wallets filtered out`);
+        }
+        // Calculate estimates
+        let estimatedTotalSol = 0;
+        let estimatedTotalTokens = 0;
+        for (const wallet of wallets) {
+            const amount = this.calculateAmount(params.amountPerWallet, wallet, params.mint);
+            if (params.action === 'buy') {
+                estimatedTotalSol += amount;
+            }
+            else {
+                estimatedTotalTokens += amount;
+            }
+        }
+        // Estimate fees (priority fee + Jito tip if bundled)
+        const mode = this.selectExecutionMode(params, wallets.length);
+        let estimatedFees = wallets.length * (params.priorityFeeLamports || 10000) / 1e9;
+        if (mode === 'bundle' || mode === 'multi-bundle') {
+            const bundleCount = mode === 'bundle' ? 1 : Math.ceil(wallets.length / MAX_BUNDLE_SIZE);
+            estimatedFees += bundleCount * this.config.jitoTipLamports / 1e9;
+        }
+        return {
+            wouldSucceed: wallets.length > 0 && errors.length === 0,
+            params,
+            walletsUsed: wallets.length,
+            estimatedTotalSol: params.action === 'buy' ? estimatedTotalSol : 0,
+            estimatedTotalTokens: params.action === 'sell' ? estimatedTotalTokens : undefined,
+            estimatedFees,
+            warnings,
+            errors,
+        };
+    }
+    /**
+     * Estimate fees for a trade
+     */
+    estimateFees(walletCount, mode) {
+        const effectiveMode = mode || this.selectExecutionMode({ mint: '', action: 'buy', amountPerWallet: 0 }, walletCount);
+        let fees = walletCount * 10000 / 1e9; // Base priority fee
+        if (effectiveMode === 'bundle') {
+            fees += this.config.jitoTipLamports / 1e9;
+        }
+        else if (effectiveMode === 'multi-bundle') {
+            const bundleCount = Math.ceil(walletCount / MAX_BUNDLE_SIZE);
+            fees += bundleCount * this.config.jitoTipLamports / 1e9;
+        }
+        return fees;
+    }
+    // --------------------------------------------------------------------------
+    // Stop Loss & Take Profit
+    // --------------------------------------------------------------------------
+    stopLossConfigs = new Map();
+    takeProfitConfigs = new Map();
+    priceMonitorInterval = null;
+    /**
+     * Set up a stop loss for a token
+     */
+    setStopLoss(config) {
+        const key = `sl_${config.mint}`;
+        this.stopLossConfigs.set(key, config);
+        this.startPriceMonitor();
+        this.emit('stopLossSet', config);
+    }
+    /**
+     * Remove a stop loss
+     */
+    removeStopLoss(mint) {
+        const key = `sl_${mint}`;
+        const existed = this.stopLossConfigs.delete(key);
+        if (this.stopLossConfigs.size === 0 && this.takeProfitConfigs.size === 0) {
+            this.stopPriceMonitor();
+        }
+        return existed;
+    }
+    /**
+     * Get all stop loss configs
+     */
+    getStopLossConfigs() {
+        return Array.from(this.stopLossConfigs.values());
+    }
+    /**
+     * Set up a take profit for a token
+     */
+    setTakeProfit(config) {
+        const key = `tp_${config.mint}`;
+        this.takeProfitConfigs.set(key, config);
+        this.startPriceMonitor();
+        this.emit('takeProfitSet', config);
+    }
+    /**
+     * Remove a take profit
+     */
+    removeTakeProfit(mint) {
+        const key = `tp_${mint}`;
+        const existed = this.takeProfitConfigs.delete(key);
+        if (this.stopLossConfigs.size === 0 && this.takeProfitConfigs.size === 0) {
+            this.stopPriceMonitor();
+        }
+        return existed;
+    }
+    /**
+     * Get all take profit configs
+     */
+    getTakeProfitConfigs() {
+        return Array.from(this.takeProfitConfigs.values());
+    }
+    startPriceMonitor() {
+        if (this.priceMonitorInterval)
+            return;
+        this.priceMonitorInterval = setInterval(async () => {
+            await this.checkPriceTriggers();
+        }, 5000); // Check every 5 seconds
+    }
+    stopPriceMonitor() {
+        if (this.priceMonitorInterval) {
+            clearInterval(this.priceMonitorInterval);
+            this.priceMonitorInterval = null;
+        }
+    }
+    async checkPriceTriggers() {
+        // Collect all mints we need to check
+        const mints = new Set();
+        for (const config of this.stopLossConfigs.values()) {
+            if (config.enabled)
+                mints.add(config.mint);
+        }
+        for (const config of this.takeProfitConfigs.values()) {
+            if (config.enabled)
+                mints.add(config.mint);
+        }
+        for (const mint of mints) {
+            try {
+                // Get current price from Pump.fun frontend API
+                const priceHeaders = {
+                    'Accept': 'application/json',
+                    'Origin': 'https://pump.fun',
+                };
+                const jwt = process.env.PUMPFUN_JWT;
+                if (jwt) {
+                    priceHeaders['Authorization'] = `Bearer ${jwt}`;
+                }
+                const response = await fetch(`${PUMPFUN_FRONTEND_API}/coins/${mint}`, { headers: priceHeaders });
+                if (!response.ok)
+                    continue;
+                const data = await response.json();
+                // Estimate price from reserves: price ≈ solReserves / tokenReserves
+                const solReserves = data.virtual_sol_reserves ?? 0;
+                const tokenReserves = data.virtual_token_reserves ?? 0;
+                const currentPrice = (solReserves > 0 && tokenReserves > 0) ? solReserves / tokenReserves : undefined;
+                if (!currentPrice)
+                    continue;
+                // Check stop loss
+                const slConfig = this.stopLossConfigs.get(`sl_${mint}`);
+                if (slConfig && slConfig.enabled && currentPrice <= slConfig.triggerPrice) {
+                    this.emit('stopLossTriggered', { mint, price: currentPrice, config: slConfig });
+                    slConfig.enabled = false; // Disable after triggering
+                    // Execute sell
+                    await this.coordinatedSell({
+                        mint,
+                        action: 'sell',
+                        amountPerWallet: `${slConfig.sellPercent}%`,
+                        walletIds: slConfig.walletIds,
+                        slippageBps: 1000, // Higher slippage for stop loss
+                        dex: slConfig.dex,
+                        poolAddress: slConfig.poolAddress,
+                    });
+                }
+                // Check take profit
+                const tpConfig = this.takeProfitConfigs.get(`tp_${mint}`);
+                if (tpConfig && tpConfig.enabled && currentPrice >= tpConfig.triggerPrice) {
+                    this.emit('takeProfitTriggered', { mint, price: currentPrice, config: tpConfig });
+                    tpConfig.enabled = false; // Disable after triggering
+                    // Execute sell
+                    await this.coordinatedSell({
+                        mint,
+                        action: 'sell',
+                        amountPerWallet: `${tpConfig.sellPercent}%`,
+                        walletIds: tpConfig.walletIds,
+                        slippageBps: 500,
+                        dex: tpConfig.dex,
+                        poolAddress: tpConfig.poolAddress,
+                    });
+                }
+            }
+            catch (e) {
+                // Silently continue on errors
+            }
+        }
+    }
+    // --------------------------------------------------------------------------
+    // DCA (Dollar Cost Averaging)
+    // --------------------------------------------------------------------------
+    dcaConfigs = new Map();
+    dcaIntervals = new Map();
+    /**
+     * Schedule a DCA buy strategy
+     */
+    scheduleDCA(config) {
+        const id = `dca_${config.mint}_${Date.now()}`;
+        const fullConfig = {
+            ...config,
+            id,
+            completedIntervals: 0,
+            nextExecutionAt: Date.now() + config.intervalMs,
+        };
+        this.dcaConfigs.set(id, fullConfig);
+        if (fullConfig.enabled) {
+            this.startDCAInterval(fullConfig);
+        }
+        this.emit('dcaScheduled', fullConfig);
+        return fullConfig;
+    }
+    /**
+     * Cancel a DCA schedule
+     */
+    cancelDCA(id) {
+        const config = this.dcaConfigs.get(id);
+        if (!config)
+            return false;
+        const interval = this.dcaIntervals.get(id);
+        if (interval) {
+            clearInterval(interval);
+            this.dcaIntervals.delete(id);
+        }
+        this.dcaConfigs.delete(id);
+        this.emit('dcaCancelled', { id });
+        return true;
+    }
+    /**
+     * Pause a DCA schedule
+     */
+    pauseDCA(id) {
+        const config = this.dcaConfigs.get(id);
+        if (!config)
+            return false;
+        config.enabled = false;
+        const interval = this.dcaIntervals.get(id);
+        if (interval) {
+            clearInterval(interval);
+            this.dcaIntervals.delete(id);
+        }
+        return true;
+    }
+    /**
+     * Resume a paused DCA schedule
+     */
+    resumeDCA(id) {
+        const config = this.dcaConfigs.get(id);
+        if (!config)
+            return false;
+        config.enabled = true;
+        config.nextExecutionAt = Date.now() + config.intervalMs;
+        this.startDCAInterval(config);
+        return true;
+    }
+    /**
+     * Get all DCA configs
+     */
+    getDCAConfigs() {
+        return Array.from(this.dcaConfigs.values());
+    }
+    startDCAInterval(config) {
+        const interval = setInterval(async () => {
+            if (!config.enabled)
+                return;
+            if (config.completedIntervals >= config.totalIntervals) {
+                this.cancelDCA(config.id);
+                return;
+            }
+            try {
+                const result = await this.coordinatedBuy({
+                    mint: config.mint,
+                    action: 'buy',
+                    amountPerWallet: config.amountPerInterval,
+                    denominatedInSol: true,
+                    walletIds: config.walletIds,
+                    executionMode: config.executionMode,
+                    dex: config.dex,
+                    poolAddress: config.poolAddress,
+                });
+                config.completedIntervals++;
+                config.nextExecutionAt = Date.now() + config.intervalMs;
+                this.emit('dcaExecuted', { config, result });
+                if (config.completedIntervals >= config.totalIntervals) {
+                    this.emit('dcaCompleted', { config });
+                    this.cancelDCA(config.id);
+                }
+            }
+            catch (e) {
+                this.emit('dcaError', { config, error: e instanceof Error ? e.message : String(e) });
+            }
+        }, config.intervalMs);
+        this.dcaIntervals.set(config.id, interval);
+    }
+    // --------------------------------------------------------------------------
+    // Trade History
+    // --------------------------------------------------------------------------
+    tradeHistory = [];
+    maxHistorySize = 1000;
+    /**
+     * Record a trade in history
+     */
+    recordTrade(entry) {
+        this.tradeHistory.unshift(entry);
+        if (this.tradeHistory.length > this.maxHistorySize) {
+            this.tradeHistory = this.tradeHistory.slice(0, this.maxHistorySize);
+        }
+    }
+    /**
+     * Get trade history
+     */
+    getTradeHistory(options) {
+        let history = this.tradeHistory;
+        if (options?.mint) {
+            history = history.filter(h => h.mint === options.mint);
+        }
+        if (options?.walletId) {
+            history = history.filter(h => h.walletId === options.walletId);
+        }
+        if (options?.action) {
+            history = history.filter(h => h.action === options.action);
+        }
+        if (options?.since) {
+            const sinceTime = options.since;
+            history = history.filter(h => h.timestamp >= sinceTime);
+        }
+        return history.slice(0, options?.limit || 100);
+    }
+    /**
+     * Clear trade history
+     */
+    clearTradeHistory() {
+        this.tradeHistory = [];
+    }
+    // --------------------------------------------------------------------------
+    // Rebalancing
+    // --------------------------------------------------------------------------
+    /**
+     * Rebalance token positions across wallets to target equal distribution
+     */
+    async rebalance(mint, targetWalletIds, options) {
+        await this.refreshTokenPositions(mint);
+        const wallets = targetWalletIds
+            ? targetWalletIds.map(id => this.wallets.get(id)).filter((w) => w !== undefined)
+            : this.getEnabledWallets();
+        if (wallets.length < 2) {
+            return {
+                success: false,
+                mint,
+                transfers: [],
+                errors: ['Need at least 2 wallets to rebalance'],
+            };
+        }
+        // Calculate current positions and target
+        const positions = wallets.map(w => ({
+            wallet: w,
+            amount: w.positions.get(mint) || 0,
+        }));
+        const totalTokens = positions.reduce((sum, p) => sum + p.amount, 0);
+        if (totalTokens === 0) {
+            return {
+                success: false,
+                mint,
+                transfers: [],
+                errors: ['No tokens to rebalance'],
+            };
+        }
+        const targetAmount = totalTokens / wallets.length;
+        const threshold = targetAmount * 0.05; // 5% threshold
+        // Find wallets that need to send and receive
+        const senders = positions.filter(p => p.amount > targetAmount + threshold)
+            .sort((a, b) => b.amount - a.amount);
+        const receivers = positions.filter(p => p.amount < targetAmount - threshold)
+            .sort((a, b) => a.amount - b.amount);
+        if (senders.length === 0 || receivers.length === 0) {
+            return {
+                success: true,
+                mint,
+                transfers: [],
+                errors: ['Positions already balanced'],
+            };
+        }
+        const transfers = [];
+        const errors = [];
+        // Execute rebalancing trades
+        // This is done by selling from senders and buying to receivers
+        for (const sender of senders) {
+            const excessAmount = sender.amount - targetAmount;
+            if (excessAmount <= 0)
+                continue;
+            try {
+                const sellResult = await this.executeSingleTrade(sender.wallet, {
+                    mint,
+                    action: 'sell',
+                    amountPerWallet: Math.floor(excessAmount),
+                    denominatedInSol: false,
+                    slippageBps: this.config.defaultSlippageBps,
+                    dex: options?.dex,
+                    poolAddress: options?.poolAddress,
+                }, Math.floor(excessAmount));
+                if (sellResult.success) {
+                    // Find a receiver for this amount
+                    const receiver = receivers.find(r => r.amount < targetAmount);
+                    if (receiver) {
+                        const deficit = targetAmount - receiver.amount;
+                        const solToSpend = (sellResult.solAmount || 0) * (deficit / excessAmount);
+                        // Buy for the receiver
+                        const buyResult = await this.executeSingleTrade(receiver.wallet, {
+                            mint,
+                            action: 'buy',
+                            amountPerWallet: solToSpend,
+                            denominatedInSol: true,
+                            slippageBps: this.config.defaultSlippageBps,
+                            dex: options?.dex,
+                            poolAddress: options?.poolAddress,
+                        }, solToSpend);
+                        transfers.push({
+                            fromWallet: sender.wallet.id,
+                            toWallet: receiver.wallet.id,
+                            amount: Math.floor(excessAmount),
+                            signature: buyResult.signature,
+                            error: buyResult.success ? undefined : buyResult.error,
+                        });
+                        receiver.amount += deficit;
+                    }
+                }
+                else {
+                    transfers.push({
+                        fromWallet: sender.wallet.id,
+                        toWallet: 'N/A',
+                        amount: Math.floor(excessAmount),
+                        error: sellResult.error,
+                    });
+                    errors.push(`${sender.wallet.id}: ${sellResult.error}`);
+                }
+            }
+            catch (e) {
+                const errMsg = e instanceof Error ? e.message : String(e);
+                errors.push(`${sender.wallet.id}: ${errMsg}`);
+            }
+            await sleep(500);
+        }
+        setTimeout(() => this.refreshTokenPositions(mint), 5000);
+        return {
+            success: transfers.some(t => t.signature),
+            mint,
+            transfers,
+            errors: errors.length > 0 ? errors : undefined,
+        };
+    }
+    // --------------------------------------------------------------------------
+    // Cleanup
+    // --------------------------------------------------------------------------
+    /**
+     * Cleanup resources (intervals, monitors)
+     */
+    cleanup() {
+        this.stopPriceMonitor();
+        for (const interval of this.dcaIntervals.values()) {
+            clearInterval(interval);
+        }
+        this.dcaIntervals.clear();
+        this.dcaConfigs.clear();
+        this.stopLossConfigs.clear();
+        this.takeProfitConfigs.clear();
+    }
+}
+exports.PumpFunSwarm = PumpFunSwarm;
+// ============================================================================
+// Utilities
+// ============================================================================
+function sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+// ============================================================================
+// Factory
+// ============================================================================
+let swarmInstance = null;
+function getSwarm(config) {
+    if (!swarmInstance || config) {
+        swarmInstance = new PumpFunSwarm(config);
+    }
+    return swarmInstance;
+}
+function createSwarm(config) {
+    return new PumpFunSwarm(config);
+}
+function resetSwarm() {
+    swarmInstance = null;
+}
+//# sourceMappingURL=pump-swarm.js.map