clodds 1.1.0

package/dist/trading/bots/index.js

@@ -0,0 +1,688 @@
+"use strict";
+/**
+ * Trading Bot Framework
+ *
+ * Create and manage automated trading strategies
+ *
+ * Features:
+ * - Strategy definition (entry/exit rules)
+ * - Live execution with auto-logging
+ * - Backtesting on historical data
+ * - Performance tracking
+ * - Risk management integration
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createBotManager = createBotManager;
+exports.createMeanReversionStrategy = createMeanReversionStrategy;
+exports.createMomentumStrategy = createMomentumStrategy;
+exports.createArbitrageStrategy = createArbitrageStrategy;
+const eventemitter3_1 = require("eventemitter3");
+const logger_1 = require("../../utils/logger");
+const logger_2 = require("../logger");
+function createBotManager(db, config = {}) {
+    const emitter = new eventemitter3_1.EventEmitter();
+    const tradeLogger = config.tradeLogger ?? (0, logger_2.createTradeLogger)(db);
+    const strategies = new Map();
+    const botIntervals = new Map();
+    const botStatuses = new Map();
+    const defaultIntervalMs = config.defaultIntervalMs || 60000; // 1 minute
+    // Initialize database for bot state
+    db.run(`
+    CREATE TABLE IF NOT EXISTS bot_state (
+      strategy_id TEXT PRIMARY KEY,
+      status TEXT NOT NULL,
+      started_at TEXT,
+      last_check TEXT,
+      last_signal_json TEXT,
+      last_error TEXT,
+      config_json TEXT
+    )
+  `);
+    // Build context for strategy evaluation
+    async function buildContext(strategy, isBacktest = false) {
+        const portfolio = config.getPortfolio
+            ? await config.getPortfolio()
+            : { value: 10000, balance: 10000, positions: [] };
+        const positions = new Map();
+        for (const pos of portfolio.positions) {
+            positions.set(`${pos.platform}:${pos.marketId}:${pos.outcome}`, {
+                shares: pos.shares,
+                avgPrice: pos.avgPrice,
+                currentPrice: pos.currentPrice,
+            });
+        }
+        const recentTrades = tradeLogger.getTrades({
+            strategyId: strategy.config.id,
+            limit: 100,
+        });
+        return {
+            portfolioValue: portfolio.value,
+            availableBalance: portfolio.balance,
+            positions,
+            recentTrades,
+            markets: new Map(),
+            priceHistory: new Map(),
+            timestamp: new Date(),
+            isBacktest,
+        };
+    }
+    // Execute signals
+    async function executeSignals(strategy, signals) {
+        for (const signal of signals) {
+            if (signal.type === 'hold')
+                continue;
+            // Check risk limits
+            const cfg = strategy.config;
+            if (cfg.maxPositionSize && signal.size && signal.size > cfg.maxPositionSize) {
+                logger_1.logger.warn({ strategyId: cfg.id, size: signal.size, max: cfg.maxPositionSize }, 'Signal exceeds max position size');
+                signal.size = cfg.maxPositionSize;
+            }
+            // Execute order
+            if (cfg.dryRun) {
+                logger_1.logger.info({ strategyId: cfg.id, signal }, 'Signal (dry run)');
+                // Log as dry-run trade
+                tradeLogger.logTrade({
+                    platform: signal.platform,
+                    marketId: signal.marketId,
+                    outcome: signal.outcome,
+                    side: signal.type === 'buy' ? 'buy' : 'sell',
+                    orderType: signal.price ? 'limit' : 'market',
+                    price: signal.price || 0.5,
+                    size: signal.size || 100,
+                    filled: signal.size || 100,
+                    cost: (signal.price || 0.5) * (signal.size || 100),
+                    status: 'filled',
+                    strategyId: cfg.id,
+                    strategyName: cfg.name,
+                    meta: { dryRun: true, confidence: signal.confidence, reason: signal.reason },
+                });
+            }
+            else if (config.executeOrder) {
+                try {
+                    const trade = await config.executeOrder(signal, cfg.id);
+                    if (trade) {
+                        strategy.onTrade?.(trade);
+                        emitter.emit('trade', { strategyId: cfg.id, trade });
+                    }
+                }
+                catch (err) {
+                    logger_1.logger.error({ err, strategyId: cfg.id, signal }, 'Failed to execute signal');
+                    updateBotStatus(cfg.id, { lastError: String(err) });
+                }
+            }
+        }
+    }
+    // Update bot status
+    function updateBotStatus(strategyId, updates) {
+        const current = botStatuses.get(strategyId);
+        if (!current)
+            return;
+        Object.assign(current, updates);
+        // Persist to DB
+        db.run(`UPDATE bot_state SET status = ?, last_check = ?, last_signal_json = ?, last_error = ?
+       WHERE strategy_id = ?`, [
+            current.status,
+            current.lastCheck?.toISOString() || null,
+            current.lastSignal ? JSON.stringify(current.lastSignal) : null,
+            current.lastError || null,
+            strategyId,
+        ]);
+    }
+    // Run one evaluation cycle
+    async function runEvaluation(strategy) {
+        const status = botStatuses.get(strategy.config.id);
+        if (!status || status.status !== 'running')
+            return [];
+        try {
+            const ctx = await buildContext(strategy);
+            const signals = await strategy.evaluate(ctx);
+            updateBotStatus(strategy.config.id, {
+                lastCheck: new Date(),
+                lastSignal: signals[0],
+                lastError: undefined,
+            });
+            if (signals.length > 0) {
+                emitter.emit('signals', { strategyId: strategy.config.id, signals });
+                await executeSignals(strategy, signals);
+            }
+            return signals;
+        }
+        catch (err) {
+            logger_1.logger.error({ err, strategyId: strategy.config.id }, 'Strategy evaluation failed');
+            updateBotStatus(strategy.config.id, {
+                status: 'error',
+                lastError: String(err),
+            });
+            return [];
+        }
+    }
+    // Attach methods
+    Object.assign(emitter, {
+        registerStrategy(strategy) {
+            strategies.set(strategy.config.id, strategy);
+            // Initialize status
+            const stats = tradeLogger.getStats({ strategyId: strategy.config.id });
+            botStatuses.set(strategy.config.id, {
+                id: strategy.config.id,
+                name: strategy.config.name,
+                status: 'stopped',
+                tradesCount: stats.totalTrades,
+                totalPnL: stats.totalPnL,
+                winRate: stats.winRate,
+            });
+            // Persist config
+            db.run(`INSERT OR REPLACE INTO bot_state (strategy_id, status, config_json) VALUES (?, ?, ?)`, [strategy.config.id, 'stopped', JSON.stringify(strategy.config)]);
+            logger_1.logger.info({ strategyId: strategy.config.id, name: strategy.config.name }, 'Strategy registered');
+            emitter.emit('strategyRegistered', strategy.config);
+        },
+        unregisterStrategy(strategyId) {
+            const strategy = strategies.get(strategyId);
+            if (!strategy)
+                return;
+            // Stop if running
+            emitter.stopBot(strategyId);
+            strategies.delete(strategyId);
+            botStatuses.delete(strategyId);
+            logger_1.logger.info({ strategyId }, 'Strategy unregistered');
+        },
+        async startBot(strategyId) {
+            const strategy = strategies.get(strategyId);
+            if (!strategy) {
+                logger_1.logger.error({ strategyId }, 'Strategy not found');
+                return false;
+            }
+            const status = botStatuses.get(strategyId);
+            if (status?.status === 'running') {
+                logger_1.logger.warn({ strategyId }, 'Bot already running');
+                return false;
+            }
+            // Initialize strategy
+            if (strategy.init) {
+                const ctx = await buildContext(strategy);
+                await strategy.init(ctx);
+            }
+            // Update status
+            updateBotStatus(strategyId, {
+                status: 'running',
+                startedAt: new Date(),
+                lastError: undefined,
+            });
+            // Start evaluation loop
+            const intervalMs = strategy.config.intervalMs || defaultIntervalMs;
+            const interval = setInterval(() => {
+                runEvaluation(strategy);
+            }, intervalMs);
+            botIntervals.set(strategyId, interval);
+            // Run initial evaluation
+            runEvaluation(strategy);
+            logger_1.logger.info({ strategyId, intervalMs }, 'Bot started');
+            emitter.emit('botStarted', strategyId);
+            return true;
+        },
+        async stopBot(strategyId) {
+            const interval = botIntervals.get(strategyId);
+            if (interval) {
+                clearInterval(interval);
+                botIntervals.delete(strategyId);
+            }
+            const strategy = strategies.get(strategyId);
+            if (strategy?.cleanup) {
+                await strategy.cleanup();
+            }
+            updateBotStatus(strategyId, { status: 'stopped' });
+            logger_1.logger.info({ strategyId }, 'Bot stopped');
+            emitter.emit('botStopped', strategyId);
+        },
+        pauseBot(strategyId) {
+            updateBotStatus(strategyId, { status: 'paused' });
+            logger_1.logger.info({ strategyId }, 'Bot paused');
+        },
+        resumeBot(strategyId) {
+            const status = botStatuses.get(strategyId);
+            if (status?.status === 'paused') {
+                updateBotStatus(strategyId, { status: 'running' });
+                logger_1.logger.info({ strategyId }, 'Bot resumed');
+            }
+        },
+        getBotStatus(strategyId) {
+            return botStatuses.get(strategyId) || null;
+        },
+        getAllBotStatuses() {
+            return Array.from(botStatuses.values());
+        },
+        getStrategies() {
+            return Array.from(strategies.values()).map((s) => s.config);
+        },
+        getStrategy(strategyId) {
+            return strategies.get(strategyId) ?? null;
+        },
+        updateStrategyConfig(strategyId, updates) {
+            const strategy = strategies.get(strategyId);
+            if (!strategy)
+                return false;
+            Object.assign(strategy.config, updates);
+            db.run(`UPDATE bot_state SET config_json = ? WHERE strategy_id = ?`, [JSON.stringify(strategy.config), strategyId]);
+            return true;
+        },
+        async evaluateNow(strategyId) {
+            const strategy = strategies.get(strategyId);
+            if (!strategy)
+                return [];
+            const ctx = await buildContext(strategy);
+            return strategy.evaluate(ctx);
+        },
+        getTradeLogger() {
+            return tradeLogger;
+        },
+        async backtest(strategyId, startDate, endDate, initialCapital) {
+            const strategy = strategies.get(strategyId);
+            if (!strategy) {
+                throw new Error(`Strategy ${strategyId} not found`);
+            }
+            // Simplified backtest (would need historical data in production)
+            const result = {
+                strategyId,
+                startDate,
+                endDate,
+                initialCapital,
+                finalCapital: initialCapital,
+                totalReturn: 0,
+                totalReturnPct: 0,
+                trades: [],
+                maxDrawdown: 0,
+                maxDrawdownPct: 0,
+                sharpeRatio: 0,
+                winRate: 0,
+                profitFactor: 0,
+                avgTrade: 0,
+                dailyReturns: [],
+            };
+            logger_1.logger.info({ strategyId, startDate, endDate }, 'Backtest started');
+            // In production, iterate through historical data and simulate trades
+            // For now, return empty result
+            logger_1.logger.info({ strategyId, result: { finalCapital: result.finalCapital, winRate: result.winRate } }, 'Backtest completed');
+            return result;
+        },
+    });
+    return emitter;
+}
+// =============================================================================
+// BUILT-IN STRATEGIES
+// =============================================================================
+/**
+ * Simple mean reversion strategy
+ */
+function createMeanReversionStrategy(config = {}) {
+    const fullConfig = {
+        id: config.id || 'mean-reversion',
+        name: config.name || 'Mean Reversion',
+        description: 'Buy when price drops below average, sell when above',
+        platforms: config.platforms || ['polymarket'],
+        intervalMs: config.intervalMs || 60000,
+        maxPositionSize: config.maxPositionSize || 100,
+        stopLossPct: config.stopLossPct || 10,
+        takeProfitPct: config.takeProfitPct || 20,
+        enabled: config.enabled ?? true,
+        dryRun: config.dryRun ?? true,
+        params: {
+            lookbackPeriod: 20,
+            entryThreshold: 2, // Standard deviations
+            exitThreshold: 0.5,
+            ...config.params,
+        },
+    };
+    const priceHistory = new Map();
+    return {
+        config: fullConfig,
+        async evaluate(ctx) {
+            const signals = [];
+            const params = fullConfig.params;
+            const lookback = params.lookbackPeriod;
+            const entryThreshold = params.entryThreshold;
+            for (const [key, position] of ctx.positions) {
+                const [platform, marketId, outcome] = key.split(':');
+                const history = priceHistory.get(key) || [];
+                // Add current price to history
+                history.push(position.currentPrice);
+                if (history.length > lookback)
+                    history.shift();
+                priceHistory.set(key, history);
+                if (history.length < lookback)
+                    continue;
+                // Calculate mean and std dev
+                const mean = history.reduce((a, b) => a + b, 0) / history.length;
+                const variance = history.reduce((a, b) => a + (b - mean) ** 2, 0) / history.length;
+                const stdDev = Math.sqrt(variance);
+                const zScore = (position.currentPrice - mean) / stdDev;
+                // Entry signals
+                if (position.shares === 0) {
+                    if (zScore < -entryThreshold) {
+                        signals.push({
+                            type: 'buy',
+                            platform: platform,
+                            marketId,
+                            outcome,
+                            price: position.currentPrice,
+                            sizePct: 5,
+                            confidence: Math.min(1, Math.abs(zScore) / 3),
+                            reason: `Price ${zScore.toFixed(2)} std devs below mean`,
+                        });
+                    }
+                }
+                // Exit signals
+                if (position.shares > 0) {
+                    const pnlPct = ((position.currentPrice - position.avgPrice) / position.avgPrice) * 100;
+                    if (pnlPct <= -(fullConfig.stopLossPct || 10)) {
+                        signals.push({
+                            type: 'sell',
+                            platform: platform,
+                            marketId,
+                            outcome,
+                            size: position.shares,
+                            reason: `Stop loss triggered (${pnlPct.toFixed(1)}%)`,
+                        });
+                    }
+                    else if (pnlPct >= (fullConfig.takeProfitPct || 20)) {
+                        signals.push({
+                            type: 'sell',
+                            platform: platform,
+                            marketId,
+                            outcome,
+                            size: position.shares,
+                            reason: `Take profit triggered (${pnlPct.toFixed(1)}%)`,
+                        });
+                    }
+                    else if (zScore > params.exitThreshold) {
+                        signals.push({
+                            type: 'sell',
+                            platform: platform,
+                            marketId,
+                            outcome,
+                            size: position.shares,
+                            reason: `Mean reversion exit (z=${zScore.toFixed(2)})`,
+                        });
+                    }
+                }
+            }
+            return signals;
+        },
+    };
+}
+/**
+ * Momentum strategy
+ */
+function createMomentumStrategy(config = {}) {
+    const fullConfig = {
+        id: config.id || 'momentum',
+        name: config.name || 'Momentum',
+        description: 'Follow price trends',
+        platforms: config.platforms || ['polymarket'],
+        intervalMs: config.intervalMs || 60000,
+        maxPositionSize: config.maxPositionSize || 100,
+        stopLossPct: config.stopLossPct || 15,
+        takeProfitPct: config.takeProfitPct || 30,
+        enabled: config.enabled ?? true,
+        dryRun: config.dryRun ?? true,
+        params: {
+            shortPeriod: 5,
+            longPeriod: 20,
+            minMomentum: 0.05, // 5% change
+            ...config.params,
+        },
+    };
+    const priceHistory = new Map();
+    return {
+        config: fullConfig,
+        async evaluate(ctx) {
+            const signals = [];
+            const params = fullConfig.params;
+            const shortPeriod = params.shortPeriod;
+            const longPeriod = params.longPeriod;
+            const minMomentum = params.minMomentum;
+            for (const [key, position] of ctx.positions) {
+                const [platform, marketId, outcome] = key.split(':');
+                const history = priceHistory.get(key) || [];
+                history.push(position.currentPrice);
+                if (history.length > longPeriod)
+                    history.shift();
+                priceHistory.set(key, history);
+                if (history.length < longPeriod)
+                    continue;
+                // Calculate short and long moving averages
+                const shortMA = history.slice(-shortPeriod).reduce((a, b) => a + b, 0) / shortPeriod;
+                const longMA = history.reduce((a, b) => a + b, 0) / history.length;
+                const momentum = (shortMA - longMA) / longMA;
+                // Entry: short MA crosses above long MA with sufficient momentum
+                if (position.shares === 0 && momentum > minMomentum) {
+                    signals.push({
+                        type: 'buy',
+                        platform: platform,
+                        marketId,
+                        outcome,
+                        price: position.currentPrice,
+                        sizePct: 5,
+                        confidence: Math.min(1, momentum / (minMomentum * 2)),
+                        reason: `Bullish momentum (${(momentum * 100).toFixed(1)}%)`,
+                    });
+                }
+                // Exit: momentum reverses or stop/take profit
+                if (position.shares > 0) {
+                    const pnlPct = ((position.currentPrice - position.avgPrice) / position.avgPrice) * 100;
+                    if (pnlPct <= -(fullConfig.stopLossPct || 15)) {
+                        signals.push({
+                            type: 'sell',
+                            platform: platform,
+                            marketId,
+                            outcome,
+                            size: position.shares,
+                            reason: `Stop loss (${pnlPct.toFixed(1)}%)`,
+                        });
+                    }
+                    else if (pnlPct >= (fullConfig.takeProfitPct || 30)) {
+                        signals.push({
+                            type: 'sell',
+                            platform: platform,
+                            marketId,
+                            outcome,
+                            size: position.shares,
+                            reason: `Take profit (${pnlPct.toFixed(1)}%)`,
+                        });
+                    }
+                    else if (momentum < -minMomentum) {
+                        signals.push({
+                            type: 'sell',
+                            platform: platform,
+                            marketId,
+                            outcome,
+                            size: position.shares,
+                            reason: `Momentum reversal (${(momentum * 100).toFixed(1)}%)`,
+                        });
+                    }
+                }
+            }
+            return signals;
+        },
+    };
+}
+/**
+ * Arbitrage strategy across platforms
+ *
+ * Finds markets with similar questions across platforms and
+ * generates signals when there's a significant price discrepancy.
+ */
+function createArbitrageStrategy(config = {}) {
+    const fullConfig = {
+        id: config.id || 'arbitrage',
+        name: config.name || 'Cross-Platform Arbitrage',
+        description: 'Exploit price differences across platforms',
+        platforms: config.platforms || ['polymarket', 'kalshi'],
+        intervalMs: config.intervalMs || 10000,
+        maxPositionSize: config.maxPositionSize || 500,
+        enabled: config.enabled ?? true,
+        dryRun: config.dryRun ?? true,
+        params: {
+            minSpreadPct: 3, // Minimum 3% spread to trigger
+            maxExposure: 1000, // Maximum total exposure
+            minConfidence: 0.7, // Minimum confidence for match
+            maxPositionsPerPair: 1, // Only one position per arb pair
+            ...config.params,
+        },
+    };
+    // Track matched market pairs (canonicalId -> markets by platform)
+    const matchedPairs = new Map();
+    // Normalize question text for matching
+    function normalizeQuestion(q) {
+        return q.toLowerCase()
+            .replace(/[^a-z0-9\s]/g, '')
+            .replace(/\s+/g, ' ')
+            .trim();
+    }
+    // Extract key entities for matching
+    function extractEntities(question) {
+        const yearMatch = question.match(/\b(20[2-3]\d)\b/);
+        const personMatch = question.match(/\b(trump|biden|harris|desantis|musk|powell)\b/i);
+        const thresholdMatch = question.match(/\$?([\d,.]+)\s*(k|m|b|%|percent)?/i);
+        return {
+            year: yearMatch?.[1],
+            person: personMatch?.[1]?.toLowerCase(),
+            threshold: thresholdMatch?.[0],
+        };
+    }
+    // Generate a canonical ID for matching across platforms
+    function generateCanonicalId(market) {
+        const q = normalizeQuestion(market.question);
+        const entities = extractEntities(market.question);
+        // Key patterns for well-known market types
+        if (q.includes('bitcoin') || q.includes('btc')) {
+            const priceMatch = market.question.match(/\$?([\d,]+)\s*(k)?/i);
+            if (priceMatch) {
+                const price = priceMatch[1].replace(/,/g, '') + (priceMatch[2] ? '000' : '');
+                return `btc_price_${price}`;
+            }
+        }
+        if (q.includes('president') || q.includes('election')) {
+            if (entities.year && entities.person) {
+                return `election_${entities.year}_${entities.person}`;
+            }
+        }
+        if (q.includes('fed') && q.includes('rate')) {
+            const dateMatch = q.match(/(jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec)\w*\s*\d*/i);
+            if (dateMatch) {
+                return `fed_rate_${dateMatch[0].toLowerCase().replace(/\s+/g, '_')}`;
+            }
+        }
+        // Generic fallback - first 5 significant words
+        const words = q.split(' ').filter(w => w.length > 3).slice(0, 5);
+        if (words.length >= 3) {
+            return `generic_${words.join('_')}`;
+        }
+        return null;
+    }
+    return {
+        config: fullConfig,
+        async evaluate(ctx) {
+            const signals = [];
+            const { minSpreadPct, maxExposure, minConfidence, maxPositionsPerPair } = fullConfig.params;
+            // Group markets by canonical ID
+            const marketGroups = new Map();
+            for (const [marketId, market] of ctx.markets) {
+                const canonicalId = generateCanonicalId(market);
+                if (!canonicalId)
+                    continue;
+                // Get current price (YES outcome price)
+                const price = market.outcomes?.find(o => o.name.toLowerCase() === 'yes' || o.name.toLowerCase() === market.outcomes[0].name.toLowerCase())?.price;
+                if (price === undefined || price <= 0 || price >= 1)
+                    continue;
+                const group = marketGroups.get(canonicalId) || [];
+                group.push({
+                    platform: market.platform,
+                    market,
+                    price,
+                });
+                marketGroups.set(canonicalId, group);
+            }
+            // Find arbitrage opportunities
+            for (const [canonicalId, group] of marketGroups) {
+                // Need at least 2 platforms
+                if (group.length < 2)
+                    continue;
+                // Check if we have markets from different platforms
+                const platforms = new Set(group.map(g => g.platform));
+                if (platforms.size < 2)
+                    continue;
+                // Find best bid and ask across platforms
+                const sorted = [...group].sort((a, b) => a.price - b.price);
+                const lowestPrice = sorted[0];
+                const highestPrice = sorted[sorted.length - 1];
+                // Must be different platforms
+                if (lowestPrice.platform === highestPrice.platform)
+                    continue;
+                // Calculate spread
+                const spread = highestPrice.price - lowestPrice.price;
+                const spreadPct = (spread / lowestPrice.price) * 100;
+                if (spreadPct < minSpreadPct)
+                    continue;
+                // Check current exposure
+                let currentExposure = 0;
+                for (const [, pos] of ctx.positions) {
+                    currentExposure += pos.shares * pos.avgPrice;
+                }
+                if (currentExposure >= maxExposure)
+                    continue;
+                // Calculate position size based on available capital and spread
+                const confidence = Math.min(1, spreadPct / 10); // Higher spread = higher confidence
+                if (confidence < minConfidence)
+                    continue;
+                const maxSize = Math.min(fullConfig.maxPositionSize || 500, (maxExposure - currentExposure) / 2, // Split between buy and sell sides
+                ctx.availableBalance / 2);
+                if (maxSize < 10)
+                    continue; // Minimum $10 position
+                // Generate BUY signal on lower-priced platform
+                signals.push({
+                    type: 'buy',
+                    platform: lowestPrice.platform,
+                    marketId: lowestPrice.market.id,
+                    outcome: 'YES',
+                    price: lowestPrice.price,
+                    size: maxSize,
+                    confidence,
+                    reason: `Arb: Buy at ${(lowestPrice.price * 100).toFixed(1)}¢ on ${lowestPrice.platform}, spread ${spreadPct.toFixed(1)}%`,
+                    meta: {
+                        canonicalId,
+                        spreadPct,
+                        counterpartPlatform: highestPrice.platform,
+                        counterpartPrice: highestPrice.price,
+                    },
+                });
+                // Generate SELL (or buy NO) signal on higher-priced platform
+                signals.push({
+                    type: 'sell',
+                    platform: highestPrice.platform,
+                    marketId: highestPrice.market.id,
+                    outcome: 'YES',
+                    price: highestPrice.price,
+                    size: maxSize,
+                    confidence,
+                    reason: `Arb: Sell at ${(highestPrice.price * 100).toFixed(1)}¢ on ${highestPrice.platform}, spread ${spreadPct.toFixed(1)}%`,
+                    meta: {
+                        canonicalId,
+                        spreadPct,
+                        counterpartPlatform: lowestPrice.platform,
+                        counterpartPrice: lowestPrice.price,
+                    },
+                });
+                logger_1.logger.info({
+                    canonicalId,
+                    buyPlatform: lowestPrice.platform,
+                    buyPrice: lowestPrice.price,
+                    sellPlatform: highestPrice.platform,
+                    sellPrice: highestPrice.price,
+                    spreadPct,
+                    size: maxSize,
+                }, 'Arbitrage opportunity detected');
+            }
+            return signals;
+        },
+    };
+}
+//# sourceMappingURL=index.js.map