clodds 1.1.0

package/dist/execution/index.js

@@ -0,0 +1,2532 @@
+"use strict";
+/**
+ * Execution Service - Native TypeScript order execution
+ *
+ * Features:
+ * - Limit orders (GTC, GTD)
+ * - Market orders (FOK)
+ * - Maker orders (GTC with postOnly flag)
+ * - Order cancellation
+ * - Open orders management
+ *
+ * Supports: Polymarket, Kalshi
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.POLYMARKET_EXCHANGES = void 0;
+exports.checkPolymarketNegRisk = checkPolymarketNegRisk;
+exports.getPolymarketExchange = getPolymarketExchange;
+exports.getPolymarketTickSize = getPolymarketTickSize;
+exports.validatePriceTickSize = validatePriceTickSize;
+exports.getPolymarketNegRiskCached = getPolymarketNegRiskCached;
+exports.getPolymarketFeeRate = getPolymarketFeeRate;
+exports.getPolymarketOrderbookCached = getPolymarketOrderbookCached;
+exports.validatePostOnly = validatePostOnly;
+exports.getPolymarketBalance = getPolymarketBalance;
+exports.getPolymarketPositions = getPolymarketPositions;
+exports.getPolymarketTrades = getPolymarketTrades;
+exports.calculateOrderbookImbalance = calculateOrderbookImbalance;
+exports.getOrderbookImbalance = getOrderbookImbalance;
+exports.createExecutionService = createExecutionService;
+const crypto_1 = require("crypto");
+const logger_1 = require("../utils/logger");
+const polymarket_auth_1 = require("../utils/polymarket-auth");
+const polymarket_order_signer_1 = require("../utils/polymarket-order-signer");
+const kalshi_auth_1 = require("../utils/kalshi-auth");
+const opinion = __importStar(require("../exchanges/opinion"));
+const predictfun = __importStar(require("../exchanges/predictfun"));
+const user_ws_1 = require("../feeds/polymarket/user-ws");
+// =============================================================================
+// POLYMARKET EXECUTION
+// =============================================================================
+// API URLs (configurable for testnet)
+const POLY_CLOB_URL = process.env.POLY_CLOB_URL || 'https://clob.polymarket.com';
+// Exchange contract addresses (configurable via env for testnet support)
+// Mainnet (default):
+//   CTF: 0x4bFb41d5B3570DeFd03C39a9A4D8dE6Bd8B8982E
+//   NEG_RISK: 0xC5d563A36AE78145C45a50134d48A1215220f80a
+// Amoy Testnet:
+//   POLY_CLOB_URL=https://clob.polymarket.com (same)
+//   POLY_CTF_EXCHANGE=0xdFE02Eb6733538f8Ea35D585af8DE5958AD99E40
+//   POLY_NEG_RISK_CTF_EXCHANGE=0xd91E80cF2E7be2e162c6513ceD06f1dD0dA35296
+const POLY_CTF_EXCHANGE = process.env.POLY_CTF_EXCHANGE || '0x4bFb41d5B3570DeFd03C39a9A4D8dE6Bd8B8982E';
+const POLY_NEG_RISK_CTF_EXCHANGE = process.env.POLY_NEG_RISK_CTF_EXCHANGE || '0xC5d563A36AE78145C45a50134d48A1215220f80a';
+/**
+ * Retry helper with exponential backoff for Polymarket REST API calls
+ * Retries on: network errors, 5xx server errors, 429 rate limit
+ * Does NOT retry on: 4xx client errors (bad request, unauthorized, etc.)
+ */
+async function polymarketRetryWithBackoff(operation, maxAttempts = 3, baseDelayMs = 1000) {
+    let lastError = null;
+    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+        try {
+            const result = await operation();
+            // Retry on 5xx or 429
+            if (result.response.status >= 500 || result.response.status === 429) {
+                if (attempt < maxAttempts) {
+                    const delay = baseDelayMs * Math.pow(2, attempt - 1);
+                    logger_1.logger.warn({ status: result.response.status, attempt, delay }, 'Polymarket API error, retrying...');
+                    await new Promise(resolve => setTimeout(resolve, delay));
+                    continue;
+                }
+            }
+            return result;
+        }
+        catch (error) {
+            lastError = error instanceof Error ? error : new Error(String(error));
+            if (attempt < maxAttempts) {
+                const delay = baseDelayMs * Math.pow(2, attempt - 1);
+                logger_1.logger.warn({ error: lastError.message, attempt, delay }, 'Polymarket API network error, retrying...');
+                await new Promise(resolve => setTimeout(resolve, delay));
+            }
+        }
+    }
+    throw lastError || new Error('Polymarket API request failed after retries');
+}
+/**
+ * Check if a token is a negative risk market (crypto 15-min markets)
+ */
+async function checkPolymarketNegRisk(tokenId) {
+    try {
+        const response = await fetch(`${POLY_CLOB_URL}/neg-risk?token_id=${tokenId}`);
+        if (!response.ok) {
+            return false;
+        }
+        const data = (await response.json());
+        return data.neg_risk === true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Get the appropriate exchange address for a market
+ */
+function getPolymarketExchange(negRisk) {
+    return negRisk ? POLY_NEG_RISK_CTF_EXCHANGE : POLY_CTF_EXCHANGE;
+}
+// Cache for tick sizes, neg risk status, fee rates, and orderbooks
+const tickSizeCache = new Map();
+const negRiskCache = new Map();
+const feeRateCache = new Map();
+const orderbookCache = new Map();
+const CACHE_TTL_MS = 60 * 60 * 1000; // 1 hour for static data
+const ORDERBOOK_CACHE_TTL_MS = 5000; // 5 seconds for orderbook (needs to be fresh)
+// Nonce tracking to prevent duplicate orders
+// Uses atomic counter to avoid race conditions in concurrent async operations
+// Format: timestamp_base + counter ensures uniqueness across restarts and within process
+const nonceBase = BigInt(Date.now()) * 1000000n; // Timestamp * 1M for counter space
+let nonceCounter = 0n;
+function getNextNonce() {
+    // Atomic increment - JavaScript is single-threaded so this is safe
+    // but we use BigInt to avoid Number precision issues at high counts
+    nonceCounter += 1n;
+    return (nonceBase + nonceCounter).toString();
+}
+/**
+ * Get tick size for a token (from orderbook endpoint)
+ * Valid tick sizes: "0.1", "0.01", "0.001", "0.0001"
+ */
+async function getPolymarketTickSize(tokenId) {
+    // Check cache
+    const cached = tickSizeCache.get(tokenId);
+    if (cached && Date.now() - cached.cachedAt < CACHE_TTL_MS) {
+        return cached.tickSize;
+    }
+    try {
+        const response = await fetch(`${POLY_CLOB_URL}/book?token_id=${tokenId}`);
+        if (!response.ok) {
+            return '0.01'; // Default tick size
+        }
+        const data = await response.json();
+        const tickSize = data.tick_size || '0.01';
+        tickSizeCache.set(tokenId, { tickSize, cachedAt: Date.now() });
+        return tickSize;
+    }
+    catch {
+        return '0.01';
+    }
+}
+/**
+ * Validate price against tick size
+ * Returns error message if invalid, null if valid
+ */
+function validatePriceTickSize(price, tickSize) {
+    const tick = parseFloat(tickSize);
+    if (tick <= 0)
+        return null; // Skip validation if tick size invalid
+    // Check if price is a multiple of tick size (with floating point tolerance)
+    const remainder = Math.abs((price * 10000) % (tick * 10000)) / 10000;
+    const tolerance = tick / 100; // 1% of tick size tolerance for floating point
+    if (remainder > tolerance && remainder < tick - tolerance) {
+        return `Price ${price} is not a valid tick size increment. Must be multiple of ${tickSize}`;
+    }
+    return null;
+}
+/**
+ * Get neg risk status with caching
+ */
+async function getPolymarketNegRiskCached(tokenId) {
+    // Check cache
+    const cached = negRiskCache.get(tokenId);
+    if (cached && Date.now() - cached.cachedAt < CACHE_TTL_MS) {
+        return cached.negRisk;
+    }
+    const negRisk = await checkPolymarketNegRisk(tokenId);
+    negRiskCache.set(tokenId, { negRisk, cachedAt: Date.now() });
+    return negRisk;
+}
+/**
+ * Get fee rate in basis points for a token
+ * Crypto 15-min markets have higher fees due to negative risk
+ */
+async function getPolymarketFeeRate(tokenId) {
+    // Check cache
+    const cached = feeRateCache.get(tokenId);
+    if (cached && Date.now() - cached.cachedAt < CACHE_TTL_MS) {
+        return cached.feeRateBps;
+    }
+    try {
+        // Fee rate depends on neg_risk status
+        // Standard markets: 0 bps maker, ~2% taker
+        // Neg risk (crypto): higher fees
+        const negRisk = await getPolymarketNegRiskCached(tokenId);
+        // Polymarket fee formula for neg risk: shares × 0.25 × (price × (1 - price))²
+        // Simplified: ~0-50 bps depending on price
+        const feeRateBps = negRisk ? 25 : 0; // Approximate - actual varies by price
+        feeRateCache.set(tokenId, { feeRateBps, cachedAt: Date.now() });
+        return feeRateBps;
+    }
+    catch {
+        return 0;
+    }
+}
+/**
+ * Get orderbook with caching (5 second TTL)
+ */
+async function getPolymarketOrderbookCached(tokenId) {
+    // Check cache
+    const cached = orderbookCache.get(tokenId);
+    if (cached && Date.now() - cached.cachedAt < ORDERBOOK_CACHE_TTL_MS) {
+        return cached.data;
+    }
+    try {
+        const response = await fetch(`${POLY_CLOB_URL}/book?token_id=${tokenId}`);
+        if (!response.ok)
+            return null;
+        const data = await response.json();
+        const bids = (data.bids || [])
+            .map((b) => [parseFloat(b.price), parseFloat(b.size)])
+            .sort((a, b) => b[0] - a[0]); // Highest bid first
+        const asks = (data.asks || [])
+            .map((a) => [parseFloat(a.price), parseFloat(a.size)])
+            .sort((a, b) => a[0] - b[0]); // Lowest ask first
+        const bestBid = bids[0]?.[0] ?? 0;
+        const bestAsk = asks[0]?.[0] ?? 0.99;
+        const midPrice = (bestBid + bestAsk) / 2;
+        const orderbook = { bids, asks, midPrice };
+        orderbookCache.set(tokenId, { data: orderbook, cachedAt: Date.now() });
+        return orderbook;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Validate post-only order won't take liquidity
+ * Returns error message if order would cross the spread
+ */
+async function validatePostOnly(tokenId, side, price) {
+    const orderbook = await getPolymarketOrderbookCached(tokenId);
+    if (!orderbook)
+        return null; // Can't validate, let server decide
+    if (side === 'buy') {
+        // Buy order: price must be < best ask to be maker-only
+        const bestAsk = orderbook.asks[0]?.[0];
+        if (bestAsk && price >= bestAsk) {
+            return `Post-only buy at ${price} would cross spread (best ask: ${bestAsk}). Use price < ${bestAsk}`;
+        }
+    }
+    else {
+        // Sell order: price must be > best bid to be maker-only
+        const bestBid = orderbook.bids[0]?.[0];
+        if (bestBid && price <= bestBid) {
+            return `Post-only sell at ${price} would cross spread (best bid: ${bestBid}). Use price > ${bestBid}`;
+        }
+    }
+    return null;
+}
+/**
+ * Parse Polymarket error response into structured error
+ */
+function parsePolymarketError(errorMsg, status) {
+    if (!errorMsg) {
+        return { code: 'UNKNOWN', message: `HTTP ${status}` };
+    }
+    const msg = errorMsg.toLowerCase();
+    if (msg.includes('price') && (msg.includes('invalid') || msg.includes('tick'))) {
+        return { code: 'INVALID_TICK_SIZE', message: errorMsg };
+    }
+    if (msg.includes('balance') || msg.includes('insufficient')) {
+        return { code: 'INSUFFICIENT_BALANCE', message: errorMsg };
+    }
+    if (msg.includes('size') && msg.includes('invalid')) {
+        return { code: 'INVALID_SIZE', message: errorMsg };
+    }
+    if (msg.includes('nonce')) {
+        return { code: 'INVALID_NONCE', message: errorMsg };
+    }
+    if (msg.includes('halt') || msg.includes('closed')) {
+        return { code: 'MARKET_HALTED', message: errorMsg };
+    }
+    if (msg.includes('match') || msg.includes('cross')) {
+        return { code: 'ORDER_WOULD_MATCH', message: errorMsg };
+    }
+    return { code: 'UNKNOWN', message: errorMsg };
+}
+/**
+ * Get USDC balance for an address
+ */
+async function getPolymarketBalance(auth, address) {
+    const walletAddress = address || auth.address;
+    const url = `${POLY_CLOB_URL}/balance?address=${walletAddress}`;
+    const headers = (0, polymarket_auth_1.buildPolymarketHeadersForUrl)(auth, 'GET', url);
+    try {
+        const response = await fetch(url, { headers });
+        if (!response.ok) {
+            throw new Error(`HTTP ${response.status}`);
+        }
+        const data = await response.json();
+        return {
+            balance: parseFloat(data.balance || '0'),
+            allowance: parseFloat(data.allowance || '0'),
+        };
+    }
+    catch (error) {
+        logger_1.logger.error({ error, walletAddress }, 'Failed to fetch Polymarket balance');
+        return { balance: 0, allowance: 0 };
+    }
+}
+/**
+ * Get positions for an address
+ */
+async function getPolymarketPositions(auth, address) {
+    const walletAddress = address || auth.address;
+    const url = `${POLY_CLOB_URL}/positions?address=${walletAddress}`;
+    const headers = (0, polymarket_auth_1.buildPolymarketHeadersForUrl)(auth, 'GET', url);
+    try {
+        const response = await fetch(url, { headers });
+        if (!response.ok) {
+            throw new Error(`HTTP ${response.status}`);
+        }
+        const data = await response.json();
+        return data.map(p => ({
+            tokenId: p.asset_id || '',
+            conditionId: p.condition_id || '',
+            size: parseFloat(p.size || '0'),
+            avgPrice: parseFloat(p.avg_price || '0'),
+            currentPrice: parseFloat(p.cur_price || '0'),
+            unrealizedPnl: parseFloat(p.unrealized_pnl || '0'),
+        }));
+    }
+    catch (error) {
+        logger_1.logger.error({ error, walletAddress }, 'Failed to fetch Polymarket positions');
+        return [];
+    }
+}
+/**
+ * Get trade history for an address
+ */
+async function getPolymarketTrades(auth, limit = 100) {
+    const url = `${POLY_CLOB_URL}/trades?limit=${limit}`;
+    const headers = (0, polymarket_auth_1.buildPolymarketHeadersForUrl)(auth, 'GET', url);
+    try {
+        const response = await fetch(url, { headers });
+        if (!response.ok) {
+            throw new Error(`HTTP ${response.status}`);
+        }
+        const data = await response.json();
+        return data.map(t => ({
+            id: t.id || '',
+            tokenId: t.asset_id || '',
+            side: (t.side?.toUpperCase() || 'BUY'),
+            price: parseFloat(t.price || '0'),
+            size: parseFloat(t.size || '0'),
+            timestamp: new Date(t.timestamp || Date.now()),
+            transactionHash: t.transaction_hash,
+        }));
+    }
+    catch (error) {
+        logger_1.logger.error({ error }, 'Failed to fetch Polymarket trades');
+        return [];
+    }
+}
+/**
+ * Calculate orderbook imbalance metrics for directional signals
+ *
+ * @param orderbook - Raw orderbook data
+ * @param depthLevels - Number of price levels to analyze (default: 5)
+ * @param depthDollars - Optional: analyze orders within this dollar amount of best price
+ * @returns Imbalance metrics including directional signal
+ */
+function calculateOrderbookImbalance(orderbook, depthLevels = 5, depthDollars) {
+    const { bids, asks, midPrice } = orderbook;
+    // Filter to depth levels or dollar depth
+    let filteredBids = bids.slice(0, depthLevels);
+    let filteredAsks = asks.slice(0, depthLevels);
+    if (depthDollars !== undefined && depthDollars > 0) {
+        const bestBid = bids[0]?.[0] ?? 0;
+        const bestAsk = asks[0]?.[0] ?? 0.99;
+        filteredBids = bids.filter(([price]) => bestBid - price <= depthDollars);
+        filteredAsks = asks.filter(([price]) => price - bestAsk <= depthDollars);
+    }
+    // Calculate total volumes
+    const totalBidVolume = filteredBids.reduce((sum, [, size]) => sum + size, 0);
+    const totalAskVolume = filteredAsks.reduce((sum, [, size]) => sum + size, 0);
+    // Calculate VWAP for each side
+    const bidCost = filteredBids.reduce((sum, [price, size]) => sum + price * size, 0);
+    const askCost = filteredAsks.reduce((sum, [price, size]) => sum + price * size, 0);
+    const vwapBid = totalBidVolume > 0 ? bidCost / totalBidVolume : 0;
+    const vwapAsk = totalAskVolume > 0 ? askCost / totalAskVolume : 1;
+    // Calculate bid/ask ratio
+    const bidAskRatio = totalAskVolume > 0 ? totalBidVolume / totalAskVolume :
+        totalBidVolume > 0 ? Infinity : 1;
+    // Normalized imbalance score: (bid - ask) / (bid + ask)
+    // Ranges from -1 (all asks) to +1 (all bids)
+    const totalVolume = totalBidVolume + totalAskVolume;
+    const imbalanceScore = totalVolume > 0
+        ? (totalBidVolume - totalAskVolume) / totalVolume
+        : 0;
+    // Best prices and spread
+    const bestBid = bids[0]?.[0] ?? 0;
+    const bestAsk = asks[0]?.[0] ?? 0.99;
+    const spread = bestAsk - bestBid;
+    const spreadPct = midPrice > 0 ? spread / midPrice : 0;
+    // Determine directional signal
+    // Thresholds tuned for prediction markets (typically 0.01-0.99 range)
+    let signal = 'neutral';
+    if (imbalanceScore > 0.15) {
+        signal = 'bullish'; // Significantly more bid volume
+    }
+    else if (imbalanceScore < -0.15) {
+        signal = 'bearish'; // Significantly more ask volume
+    }
+    // Confidence based on:
+    // 1. Total volume (more volume = more reliable signal)
+    // 2. Spread (tighter spread = more reliable)
+    // 3. Imbalance magnitude (stronger imbalance = more confident)
+    const volumeScore = Math.min(1, totalVolume / 10000); // Normalize to ~$10k
+    const spreadScore = Math.max(0, 1 - spreadPct * 10); // Penalty for wide spreads
+    const imbalanceMagnitude = Math.abs(imbalanceScore);
+    const confidence = (volumeScore * 0.4 + spreadScore * 0.3 + imbalanceMagnitude * 0.3);
+    return {
+        bidAskRatio,
+        imbalanceScore,
+        vwapBid,
+        vwapAsk,
+        totalBidVolume,
+        totalAskVolume,
+        spread,
+        spreadPct,
+        signal,
+        confidence: Math.min(1, Math.max(0, confidence)),
+        bestBid,
+        bestAsk,
+        midPrice,
+    };
+}
+/**
+ * Fetch and analyze orderbook imbalance for a market
+ */
+async function getOrderbookImbalance(platform, marketIdOrTokenId, depthLevels) {
+    try {
+        let orderbook = null;
+        if (platform === 'polymarket') {
+            orderbook = await fetchPolymarketOrderbook(marketIdOrTokenId);
+        }
+        else if (platform === 'kalshi') {
+            orderbook = await fetchKalshiOrderbook(marketIdOrTokenId);
+        }
+        else if (platform === 'opinion') {
+            orderbook = await fetchOpinionOrderbook(marketIdOrTokenId);
+        }
+        if (!orderbook || (orderbook.bids.length === 0 && orderbook.asks.length === 0)) {
+            return null;
+        }
+        return calculateOrderbookImbalance(orderbook, depthLevels);
+    }
+    catch (error) {
+        logger_1.logger.warn({ error, platform, marketIdOrTokenId }, 'Failed to get orderbook imbalance');
+        return null;
+    }
+}
+/**
+ * Fetch Polymarket orderbook for a token
+ */
+async function fetchPolymarketOrderbook(tokenId) {
+    try {
+        const response = await fetch(`${POLY_CLOB_URL}/book?token_id=${tokenId}`);
+        if (!response.ok)
+            return null;
+        const data = await response.json();
+        const bids = (data.bids || [])
+            .map(b => [parseFloat(b.price), parseFloat(b.size)])
+            .sort((a, b) => b[0] - a[0]); // Sort bids descending by price
+        const asks = (data.asks || [])
+            .map(a => [parseFloat(a.price), parseFloat(a.size)])
+            .sort((a, b) => a[0] - b[0]); // Sort asks ascending by price
+        const bestBid = bids[0]?.[0] ?? 0;
+        const bestAsk = asks[0]?.[0] ?? 0.99;
+        const midPrice = (bestBid + bestAsk) / 2;
+        return { bids, asks, midPrice };
+    }
+    catch (error) {
+        logger_1.logger.warn({ error, tokenId }, 'Failed to fetch Polymarket orderbook');
+        return null;
+    }
+}
+const KALSHI_URL = 'https://trading-api.kalshi.com/trade-api/v2';
+/**
+ * Fetch Kalshi orderbook for a market
+ */
+async function fetchKalshiOrderbook(marketId) {
+    try {
+        const response = await fetch(`${KALSHI_URL}/markets/${marketId}/orderbook`);
+        if (!response.ok)
+            return null;
+        const data = await response.json();
+        // Kalshi returns [price_cents, contracts] for yes and no sides
+        const yesOrders = data.orderbook?.yes || [];
+        const noOrders = data.orderbook?.no || [];
+        // For YES: bids are buy yes orders, asks are from sell yes / buy no
+        const bids = yesOrders
+            .map(([priceCents, size]) => [priceCents / 100, size])
+            .sort((a, b) => b[0] - a[0]);
+        // For asks, use complementary no price (1 - no_price = yes_ask)
+        const asks = noOrders
+            .map(([priceCents, size]) => [1 - priceCents / 100, size])
+            .sort((a, b) => a[0] - b[0]);
+        const bestBid = bids[0]?.[0] ?? 0;
+        const bestAsk = asks[0]?.[0] ?? 0.99;
+        const midPrice = (bestBid + bestAsk) / 2;
+        return { bids, asks, midPrice };
+    }
+    catch (error) {
+        logger_1.logger.warn({ error, marketId }, 'Failed to fetch Kalshi orderbook');
+        return null;
+    }
+}
+/**
+ * Calculate average fill price by walking through orderbook
+ */
+function calculateFillFromOrderbook(orders, // [price, size] sorted appropriately
+targetSize, side) {
+    let totalFilled = 0;
+    let totalCost = 0;
+    for (const [price, size] of orders) {
+        const fillableAtThisLevel = Math.min(size, targetSize - totalFilled);
+        if (fillableAtThisLevel <= 0)
+            break;
+        totalFilled += fillableAtThisLevel;
+        totalCost += fillableAtThisLevel * price;
+        if (totalFilled >= targetSize)
+            break;
+    }
+    if (totalFilled === 0) {
+        // No liquidity, return worst-case price
+        return {
+            avgFillPrice: side === 'buy' ? 1 : 0,
+            totalFilled: 0,
+        };
+    }
+    return {
+        avgFillPrice: totalCost / totalFilled,
+        totalFilled,
+    };
+}
+async function placePolymarketOrder(auth, tokenId, side, price, size, orderType = 'GTC', negRisk, postOnly) {
+    // Validate tick size
+    const tickSize = await getPolymarketTickSize(tokenId);
+    const tickError = validatePriceTickSize(price, tickSize);
+    if (tickError) {
+        return { success: false, error: tickError };
+    }
+    // Validate post-only won't cross spread
+    if (postOnly) {
+        const postOnlyError = await validatePostOnly(tokenId, side, price);
+        if (postOnlyError) {
+            return { success: false, error: postOnlyError };
+        }
+    }
+    // Auto-detect negRisk if not provided
+    const actualNegRisk = negRisk ?? await getPolymarketNegRiskCached(tokenId);
+    // Get fee rate for this token
+    const feeRateBps = await getPolymarketFeeRate(tokenId);
+    // If private key available, use EIP-712 signed order (required for real CLOB)
+    if (auth.privateKey) {
+        const signedAuth = { ...auth, privateKey: auth.privateKey };
+        return placeSignedPolymarketOrder(signedAuth, tokenId, side, price, size, orderType, actualNegRisk, postOnly, feeRateBps);
+    }
+    // Fallback: simplified payload (may not work with real CLOB without signing)
+    const url = `${POLY_CLOB_URL}/order`;
+    const order = {
+        tokenID: tokenId,
+        side: side.toUpperCase(),
+        price: price.toString(),
+        size: size.toString(),
+        orderType: orderType,
+        feeRateBps: feeRateBps.toString(),
+        negRisk: actualNegRisk,
+        nonce: getNextNonce(),
+    };
+    if (postOnly === true)
+        order.postOnly = true;
+    const headers = (0, polymarket_auth_1.buildPolymarketHeadersForUrl)(auth, 'POST', url, order);
+    try {
+        const response = await fetch(url, {
+            method: 'POST',
+            headers: { ...headers, 'Content-Type': 'application/json' },
+            body: JSON.stringify(order),
+        });
+        const data = (await response.json());
+        if (!response.ok || data.errorMsg) {
+            const { code, message } = parsePolymarketError(data.errorMsg, response.status);
+            logger_1.logger.error({ status: response.status, errorCode: code, error: message }, 'Polymarket order failed');
+            return { success: false, error: `[${code}] ${message}` };
+        }
+        const orderId = data.orderID || data.order_id;
+        logger_1.logger.info({ orderId, tokenId, side, price, size, feeRateBps }, 'Polymarket order placed');
+        return { success: true, orderId, status: 'open', transactionHash: data.transactionsHashes?.[0] };
+    }
+    catch (error) {
+        logger_1.logger.error({ error }, 'Error placing Polymarket order');
+        return { success: false, error: error instanceof Error ? error.message : 'Unknown error' };
+    }
+}
+/**
+ * Place a single EIP-712 signed order on Polymarket CLOB.
+ * Uses POST /order with the full signed order payload.
+ */
+async function placeSignedPolymarketOrder(auth, tokenId, side, price, size, orderType = 'GTC', negRisk, postOnly, feeRateBps) {
+    const url = `${POLY_CLOB_URL}/order`;
+    const signerCfg = {
+        privateKey: auth.privateKey,
+        funderAddress: auth.funderAddress,
+        signatureType: auth.signatureType,
+    };
+    const postOrder = (0, polymarket_order_signer_1.buildSignedOrder)({
+        tokenId,
+        price,
+        size,
+        side: side === 'buy' ? 'buy' : 'sell',
+        negRisk,
+        feeRateBps,
+        nonce: getNextNonce(),
+    }, signerCfg);
+    // Set owner to API key (required by Polymarket CLOB)
+    postOrder.owner = auth.apiKey;
+    postOrder.orderType = orderType;
+    if (postOnly)
+        postOrder.postOnly = true;
+    try {
+        const { response, data } = await polymarketRetryWithBackoff(async () => {
+            // Build headers fresh for each attempt (timestamp-based HMAC)
+            const headers = (0, polymarket_auth_1.buildPolymarketHeadersForUrl)(auth, 'POST', url, postOrder);
+            const resp = await fetch(url, {
+                method: 'POST',
+                headers: { ...headers, 'Content-Type': 'application/json' },
+                body: JSON.stringify(postOrder),
+            });
+            const json = (await resp.json());
+            return { response: resp, data: json };
+        });
+        if (!response.ok || data.errorMsg) {
+            const { code, message } = parsePolymarketError(data.errorMsg, response.status);
+            logger_1.logger.error({ status: response.status, errorCode: code, error: message }, 'Polymarket signed order failed');
+            return { success: false, error: `[${code}] ${message}` };
+        }
+        const orderId = data.orderID || data.order_id;
+        logger_1.logger.info({ orderId, tokenId, side, price, size, feeRateBps }, 'Polymarket signed order placed');
+        return { success: true, orderId, status: 'open', transactionHash: data.transactionsHashes?.[0] };
+    }
+    catch (error) {
+        logger_1.logger.error({ error }, 'Error placing Polymarket signed order after retries');
+        return { success: false, error: error instanceof Error ? error.message : 'Unknown error' };
+    }
+}
+async function cancelPolymarketOrder(auth, orderId) {
+    const url = `${POLY_CLOB_URL}/order/${orderId}`;
+    try {
+        const { response } = await polymarketRetryWithBackoff(async () => {
+            const headers = (0, polymarket_auth_1.buildPolymarketHeadersForUrl)(auth, 'DELETE', url);
+            const resp = await fetch(url, {
+                method: 'DELETE',
+                headers: {
+                    ...headers,
+                    'Content-Type': 'application/json',
+                },
+            });
+            return { response: resp, data: null };
+        });
+        if (!response.ok) {
+            logger_1.logger.error({ status: response.status, orderId }, 'Failed to cancel Polymarket order');
+            return false;
+        }
+        logger_1.logger.info({ orderId }, 'Polymarket order cancelled');
+        return true;
+    }
+    catch (error) {
+        logger_1.logger.error({ error, orderId }, 'Error cancelling Polymarket order after retries');
+        return false;
+    }
+}
+async function cancelAllPolymarketOrders(auth, marketId) {
+    let url = `${POLY_CLOB_URL}/cancel-all`;
+    if (marketId) {
+        url += `?market=${marketId}`;
+    }
+    const headers = (0, polymarket_auth_1.buildPolymarketHeadersForUrl)(auth, 'DELETE', url);
+    try {
+        const response = await fetch(url, {
+            method: 'DELETE',
+            headers: {
+                ...headers,
+                'Content-Type': 'application/json',
+            },
+        });
+        if (!response.ok) {
+            logger_1.logger.error({ status: response.status }, 'Failed to cancel all Polymarket orders');
+            return 0;
+        }
+        const data = (await response.json());
+        const count = data.canceled || 0;
+        logger_1.logger.info({ count, marketId }, 'Cancelled Polymarket orders');
+        return count;
+    }
+    catch (error) {
+        logger_1.logger.error({ error }, 'Error cancelling all Polymarket orders');
+        return 0;
+    }
+}
+/**
+ * Place multiple Polymarket orders in a single batch request.
+ *
+ * If private key is available, uses POST /orders with EIP-712 signed orders
+ * (up to 15 per request). Otherwise falls back to parallel single-order calls.
+ */
+async function placePolymarketOrdersBatch(auth, orders) {
+    if (orders.length === 0)
+        return [];
+    // If no private key, fall back to parallel individual calls
+    if (!auth.privateKey) {
+        const results = await Promise.all(orders.map(o => placePolymarketOrder(auth, o.tokenId, o.side, o.price, o.size, 'GTC', o.negRisk, o.postOnly)
+            .catch(err => ({ success: false, error: err instanceof Error ? err.message : 'Order failed' }))));
+        logger_1.logger.info({ total: orders.length, successful: results.filter(r => r.success).length }, 'Polymarket parallel orders placed');
+        return results;
+    }
+    // Build all signed orders
+    const signerCfg = {
+        privateKey: auth.privateKey,
+        funderAddress: auth.funderAddress,
+        signatureType: auth.signatureType,
+    };
+    const postOrders = (0, polymarket_order_signer_1.buildSignedOrders)(orders.map(o => ({
+        tokenId: o.tokenId,
+        price: o.price,
+        size: o.size,
+        side: o.side === 'buy' ? 'buy' : 'sell',
+        negRisk: o.negRisk,
+    })), signerCfg);
+    // Set owner to API key on all orders (required by Polymarket CLOB)
+    for (const po of postOrders) {
+        po.owner = auth.apiKey;
+    }
+    // Apply postOnly flag
+    for (let i = 0; i < postOrders.length; i++) {
+        if (orders[i].postOnly)
+            postOrders[i].postOnly = true;
+    }
+    // Send in chunks of 15 (Polymarket batch limit)
+    const results = [];
+    for (let i = 0; i < postOrders.length; i += 15) {
+        const chunk = postOrders.slice(i, i + 15);
+        const url = `${POLY_CLOB_URL}/orders`;
+        const headers = (0, polymarket_auth_1.buildPolymarketHeadersForUrl)(auth, 'POST', url, chunk);
+        try {
+            const response = await fetch(url, {
+                method: 'POST',
+                headers: { ...headers, 'Content-Type': 'application/json' },
+                body: JSON.stringify(chunk),
+            });
+            if (!response.ok) {
+                const error = await response.text();
+                logger_1.logger.error({ status: response.status, error, count: chunk.length }, 'Polymarket batch order failed');
+                results.push(...chunk.map(() => ({ success: false, error: `HTTP ${response.status}` })));
+                continue;
+            }
+            const data = (await response.json());
+            logger_1.logger.info({ count: chunk.length, successful: data.filter(r => r.orderID || r.order_id).length }, 'Polymarket batch orders placed');
+            for (const r of data) {
+                results.push({
+                    success: !r.errorMsg,
+                    orderId: r.orderID || r.order_id,
+                    error: r.errorMsg,
+                    status: r.errorMsg ? 'rejected' : 'open',
+                    transactionHash: r.transactionsHashes?.[0],
+                });
+            }
+        }
+        catch (error) {
+            logger_1.logger.error({ error }, 'Error placing Polymarket batch orders');
+            results.push(...chunk.map(() => ({
+                success: false,
+                error: error instanceof Error ? error.message : 'Batch order failed',
+            })));
+        }
+    }
+    logger_1.logger.info({ total: orders.length, successful: results.filter(r => r.success).length }, 'Polymarket batch orders completed');
+    return results;
+}
+/**
+ * Cancel multiple Polymarket orders concurrently.
+ *
+ * NOTE: The true batch cancel endpoint (DELETE /orders) accepts an array of
+ * order IDs. It uses L2 HMAC auth (same as other endpoints), so we can use
+ * it directly. Falls back to parallel individual cancels on error.
+ */
+async function cancelPolymarketOrdersBatch(auth, orderIds) {
+    if (orderIds.length === 0)
+        return [];
+    // DELETE /orders with array of IDs uses L2 HMAC auth (no order signing needed)
+    const url = `${POLY_CLOB_URL}/orders`;
+    const headers = (0, polymarket_auth_1.buildPolymarketHeadersForUrl)(auth, 'DELETE', url, orderIds);
+    try {
+        const response = await fetch(url, {
+            method: 'DELETE',
+            headers: { ...headers, 'Content-Type': 'application/json' },
+            body: JSON.stringify(orderIds),
+        });
+        if (!response.ok) {
+            logger_1.logger.warn({ status: response.status, count: orderIds.length }, 'Polymarket batch cancel failed, falling back to individual');
+            // Fallback to parallel individual cancels
+            return Promise.all(orderIds.map(async (orderId) => ({
+                orderId,
+                success: await cancelPolymarketOrder(auth, orderId).catch(() => false),
+            })));
+        }
+        const data = (await response.json());
+        const canceledSet = new Set(data.canceled || []);
+        logger_1.logger.info({ total: orderIds.length, canceled: canceledSet.size, notCanceled: Object.keys(data.not_canceled || {}).length }, 'Polymarket batch cancel completed');
+        return orderIds.map(orderId => ({ orderId, success: canceledSet.has(orderId) }));
+    }
+    catch (error) {
+        logger_1.logger.error({ error }, 'Error in Polymarket batch cancel, falling back to individual');
+        return Promise.all(orderIds.map(async (orderId) => ({
+            orderId,
+            success: await cancelPolymarketOrder(auth, orderId).catch(() => false),
+        })));
+    }
+}
+async function getPolymarketOpenOrders(auth) {
+    const url = `${POLY_CLOB_URL}/orders?state=OPEN`;
+    const headers = (0, polymarket_auth_1.buildPolymarketHeadersForUrl)(auth, 'GET', url);
+    try {
+        const response = await fetch(url, {
+            method: 'GET',
+            headers: {
+                ...headers,
+                'Content-Type': 'application/json',
+            },
+        });
+        if (!response.ok) {
+            logger_1.logger.error({ status: response.status }, 'Failed to fetch Polymarket orders');
+            return [];
+        }
+        const data = (await response.json());
+        return data.map((o) => ({
+            orderId: o.id,
+            platform: 'polymarket',
+            marketId: o.market,
+            tokenId: o.asset_id,
+            side: o.side.toLowerCase(),
+            price: parseFloat(o.price),
+            originalSize: parseFloat(o.original_size),
+            remainingSize: parseFloat(o.original_size) - parseFloat(o.size_matched),
+            filledSize: parseFloat(o.size_matched),
+            orderType: o.order_type || 'GTC',
+            status: o.status.toLowerCase(),
+            createdAt: new Date(o.created_at),
+            expiration: o.expiration ? new Date(o.expiration) : undefined,
+        }));
+    }
+    catch (error) {
+        logger_1.logger.error({ error }, 'Error fetching Polymarket orders');
+        return [];
+    }
+}
+// =============================================================================
+// KALSHI EXECUTION
+// =============================================================================
+const KALSHI_API_URL = 'https://api.elections.kalshi.com/trade-api/v2';
+/**
+ * Retry helper with exponential backoff for Kalshi API calls
+ * Retries on: network errors, 5xx server errors, 429 rate limit
+ * Does NOT retry on: 4xx client errors (bad request, unauthorized, etc.)
+ */
+async function kalshiRetryWithBackoff(operation, maxAttempts = 3, baseDelayMs = 1000) {
+    let lastError = null;
+    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+        try {
+            const result = await operation();
+            // Retry on 5xx or 429
+            if (result.response.status >= 500 || result.response.status === 429) {
+                if (attempt < maxAttempts) {
+                    const delay = baseDelayMs * Math.pow(2, attempt - 1);
+                    logger_1.logger.warn({ status: result.response.status, attempt, delay }, 'Kalshi API error, retrying...');
+                    await new Promise(resolve => setTimeout(resolve, delay));
+                    continue;
+                }
+            }
+            return result;
+        }
+        catch (error) {
+            lastError = error instanceof Error ? error : new Error(String(error));
+            if (attempt < maxAttempts) {
+                const delay = baseDelayMs * Math.pow(2, attempt - 1);
+                logger_1.logger.warn({ error: lastError.message, attempt, delay }, 'Kalshi API network error, retrying...');
+                await new Promise(resolve => setTimeout(resolve, delay));
+            }
+        }
+    }
+    throw lastError || new Error('Kalshi API request failed after retries');
+}
+async function placeKalshiOrder(auth, ticker, side, action, price, count, orderType = 'GTC', maxSlippage) {
+    const url = `${KALSHI_API_URL}/portfolio/orders`;
+    // Slippage protection for market orders
+    let effectivePrice = price;
+    if (orderType === 'FOK' && maxSlippage !== undefined) {
+        try {
+            const orderbook = await fetchKalshiOrderbook(ticker);
+            if (orderbook) {
+                // For buy: look at asks; for sell: look at bids
+                const relevantSide = action === 'buy' ? orderbook.asks : orderbook.bids;
+                const { avgFillPrice, totalFilled } = calculateFillFromOrderbook(relevantSide, count, action);
+                if (totalFilled < count * 0.5) {
+                    return {
+                        success: false,
+                        error: `Insufficient liquidity: only ${totalFilled}/${count} contracts available`,
+                    };
+                }
+                // Calculate slippage from mid price
+                const slippage = action === 'buy'
+                    ? (avgFillPrice - orderbook.midPrice) / orderbook.midPrice
+                    : (orderbook.midPrice - avgFillPrice) / orderbook.midPrice;
+                if (slippage > maxSlippage) {
+                    return {
+                        success: false,
+                        error: `Slippage ${(slippage * 100).toFixed(2)}% exceeds max ${(maxSlippage * 100).toFixed(2)}%`,
+                    };
+                }
+                // Use limit order instead of market to cap slippage
+                // Add buffer to expected price for fill certainty
+                const buffer = action === 'buy' ? 0.01 : -0.01;
+                effectivePrice = Math.max(0.01, Math.min(0.99, avgFillPrice + buffer));
+                logger_1.logger.info({ ticker, action, count, avgFillPrice, effectivePrice, slippage }, 'Kalshi market order converted to limit with slippage protection');
+            }
+        }
+        catch (err) {
+            logger_1.logger.warn({ err, ticker }, 'Failed to check slippage, proceeding with market order');
+        }
+    }
+    const order = {
+        ticker,
+        side,
+        action,
+        type: orderType === 'FOK' && maxSlippage !== undefined ? 'limit' : (orderType === 'FOK' ? 'market' : 'limit'),
+        yes_price: side === 'yes' ? Math.round(effectivePrice * 100) : undefined,
+        no_price: side === 'no' ? Math.round(effectivePrice * 100) : undefined,
+        count,
+    };
+    try {
+        const { response, data } = await kalshiRetryWithBackoff(async () => {
+            // Build headers fresh for each attempt (timestamp-based)
+            const headers = (0, kalshi_auth_1.buildKalshiHeadersForUrl)(auth, 'POST', url);
+            const resp = await fetch(url, {
+                method: 'POST',
+                headers: {
+                    ...headers,
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify(order),
+            });
+            const json = (await resp.json());
+            return { response: resp, data: json };
+        });
+        if (!response.ok || data.error) {
+            logger_1.logger.error({ status: response.status, error: data.error }, 'Kalshi order failed');
+            return {
+                success: false,
+                error: data.error?.message || `HTTP ${response.status}`,
+            };
+        }
+        logger_1.logger.info({ orderId: data.order?.order_id, ticker, side, action, price, count }, 'Kalshi order placed');
+        return {
+            success: true,
+            orderId: data.order?.order_id,
+            status: data.order?.status || 'open',
+            filledSize: data.order?.filled_count,
+            avgFillPrice: data.order?.yes_price != null ? data.order.yes_price / 100 :
+                data.order?.no_price != null ? data.order.no_price / 100 : undefined,
+        };
+    }
+    catch (error) {
+        logger_1.logger.error({ error }, 'Error placing Kalshi order after retries');
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : 'Unknown error',
+        };
+    }
+}
+async function cancelKalshiOrder(auth, orderId) {
+    const url = `${KALSHI_API_URL}/portfolio/orders/${orderId}`;
+    try {
+        const { response } = await kalshiRetryWithBackoff(async () => {
+            const headers = (0, kalshi_auth_1.buildKalshiHeadersForUrl)(auth, 'DELETE', url);
+            const resp = await fetch(url, {
+                method: 'DELETE',
+                headers: {
+                    ...headers,
+                    'Content-Type': 'application/json',
+                },
+            });
+            return { response: resp, data: null };
+        });
+        if (!response.ok) {
+            logger_1.logger.error({ status: response.status, orderId }, 'Failed to cancel Kalshi order');
+            return false;
+        }
+        logger_1.logger.info({ orderId }, 'Kalshi order cancelled');
+        return true;
+    }
+    catch (error) {
+        logger_1.logger.error({ error, orderId }, 'Error cancelling Kalshi order after retries');
+        return false;
+    }
+}
+async function getKalshiOpenOrders(auth) {
+    const url = `${KALSHI_API_URL}/portfolio/orders?status=resting`;
+    try {
+        const { response, data } = await kalshiRetryWithBackoff(async () => {
+            const headers = (0, kalshi_auth_1.buildKalshiHeadersForUrl)(auth, 'GET', url);
+            const resp = await fetch(url, {
+                method: 'GET',
+                headers: {
+                    ...headers,
+                    'Content-Type': 'application/json',
+                },
+            });
+            const json = (await resp.json());
+            return { response: resp, data: json };
+        });
+        if (!response.ok) {
+            logger_1.logger.error({ status: response.status }, 'Failed to fetch Kalshi orders');
+            return [];
+        }
+        return (data.orders || []).map((o) => {
+            const price = (o.side === 'yes' ? o.yes_price : o.no_price) / 100;
+            return {
+                orderId: o.order_id,
+                platform: 'kalshi',
+                marketId: o.ticker,
+                outcome: o.side,
+                side: o.action,
+                price,
+                originalSize: o.count,
+                remainingSize: o.remaining_count,
+                filledSize: o.count - o.remaining_count,
+                orderType: o.type === 'market' ? 'FOK' : 'GTC',
+                status: o.status,
+                createdAt: new Date(o.created_time),
+                expiration: o.expiration_time ? new Date(o.expiration_time) : undefined,
+            };
+        });
+    }
+    catch (error) {
+        logger_1.logger.error({ error }, 'Error fetching Kalshi orders after retries');
+        return [];
+    }
+}
+/**
+ * Place multiple Kalshi orders in a single batch request.
+ * Kalshi supports up to 20 orders per batch via POST /portfolio/orders/batched.
+ */
+async function placeKalshiOrdersBatch(auth, orders) {
+    if (orders.length === 0)
+        return [];
+    const results = [];
+    // Chunk into batches of 20 (Kalshi limit)
+    for (let i = 0; i < orders.length; i += 20) {
+        const chunk = orders.slice(i, i + 20);
+        const url = `${KALSHI_API_URL}/portfolio/orders/batched`;
+        const headers = (0, kalshi_auth_1.buildKalshiHeadersForUrl)(auth, 'POST', url);
+        const body = {
+            orders: chunk.map(o => ({
+                ticker: o.ticker,
+                side: o.side,
+                action: o.action,
+                type: o.orderType === 'FOK' ? 'market' : 'limit',
+                yes_price: o.side === 'yes' ? Math.round(o.price * 100) : undefined,
+                no_price: o.side === 'no' ? Math.round(o.price * 100) : undefined,
+                count: o.count,
+            })),
+        };
+        try {
+            const response = await fetch(url, {
+                method: 'POST',
+                headers: { ...headers, 'Content-Type': 'application/json' },
+                body: JSON.stringify(body),
+            });
+            if (!response.ok) {
+                const error = await response.text();
+                logger_1.logger.error({ status: response.status, error, count: chunk.length }, 'Kalshi batch order failed');
+                results.push(...chunk.map(() => ({ success: false, error: `HTTP ${response.status}` })));
+                continue;
+            }
+            const data = (await response.json());
+            const respOrders = data.orders || [];
+            for (let j = 0; j < chunk.length; j++) {
+                const r = respOrders[j];
+                if (r?.order_id) {
+                    results.push({
+                        success: true,
+                        orderId: r.order_id,
+                        status: r.status || 'open',
+                        filledSize: r.filled_count,
+                    });
+                }
+                else {
+                    results.push({ success: false, error: 'No order_id in response' });
+                }
+            }
+            logger_1.logger.info({ count: chunk.length, successful: respOrders.filter(r => r?.order_id).length }, 'Kalshi batch orders placed');
+        }
+        catch (error) {
+            logger_1.logger.error({ error }, 'Error placing Kalshi batch orders');
+            results.push(...chunk.map(() => ({
+                success: false,
+                error: error instanceof Error ? error.message : 'Batch order failed',
+            })));
+        }
+    }
+    return results;
+}
+/**
+ * Cancel multiple Kalshi orders in a single batch request.
+ * Kalshi supports up to 20 cancels per batch via DELETE /portfolio/orders/batched.
+ */
+async function cancelKalshiOrdersBatch(auth, orderIds) {
+    if (orderIds.length === 0)
+        return [];
+    const results = [];
+    for (let i = 0; i < orderIds.length; i += 20) {
+        const chunk = orderIds.slice(i, i + 20);
+        const url = `${KALSHI_API_URL}/portfolio/orders/batched`;
+        const headers = (0, kalshi_auth_1.buildKalshiHeadersForUrl)(auth, 'DELETE', url);
+        const body = {
+            orders: chunk.map(id => ({ order_id: id })),
+        };
+        try {
+            const response = await fetch(url, {
+                method: 'DELETE',
+                headers: { ...headers, 'Content-Type': 'application/json' },
+                body: JSON.stringify(body),
+            });
+            if (!response.ok) {
+                logger_1.logger.error({ status: response.status, count: chunk.length }, 'Kalshi batch cancel failed');
+                results.push(...chunk.map(id => ({ orderId: id, success: false })));
+                continue;
+            }
+            logger_1.logger.info({ count: chunk.length }, 'Kalshi batch cancel completed');
+            results.push(...chunk.map(id => ({ orderId: id, success: true })));
+        }
+        catch (error) {
+            logger_1.logger.error({ error }, 'Error batch cancelling Kalshi orders');
+            results.push(...chunk.map(id => ({ orderId: id, success: false })));
+        }
+    }
+    return results;
+}
+/**
+ * Amend a Kalshi order (change price and/or count without losing queue position).
+ * POST /portfolio/orders/{order_id}/amend
+ */
+async function amendKalshiOrder(auth, orderId, updates) {
+    const url = `${KALSHI_API_URL}/portfolio/orders/${orderId}/amend`;
+    const headers = (0, kalshi_auth_1.buildKalshiHeadersForUrl)(auth, 'POST', url);
+    const body = {};
+    if (updates.price != null && updates.side) {
+        if (updates.side === 'yes') {
+            body.yes_price = Math.round(updates.price * 100);
+        }
+        else {
+            body.no_price = Math.round(updates.price * 100);
+        }
+    }
+    if (updates.count != null) {
+        body.count = updates.count;
+    }
+    try {
+        const response = await fetch(url, {
+            method: 'POST',
+            headers: { ...headers, 'Content-Type': 'application/json' },
+            body: JSON.stringify(body),
+        });
+        const data = (await response.json());
+        if (!response.ok) {
+            logger_1.logger.error({ status: response.status, orderId }, 'Kalshi order amend failed');
+            return { success: false, error: `HTTP ${response.status}` };
+        }
+        logger_1.logger.info({ orderId, updates }, 'Kalshi order amended');
+        return {
+            success: true,
+            orderId: data.order?.order_id || orderId,
+            status: data.order?.status || 'open',
+        };
+    }
+    catch (error) {
+        logger_1.logger.error({ error, orderId }, 'Error amending Kalshi order');
+        return { success: false, error: error instanceof Error ? error.message : 'Unknown error' };
+    }
+}
+// =============================================================================
+// OPINION.TRADE EXECUTION (delegates to exchange module with EIP-712 signing)
+// =============================================================================
+/**
+ * Convert ExecutionConfig opinion fields to OpinionConfig for the exchange module.
+ * The exchange module uses the unofficial-opinion-clob-sdk which handles
+ * EIP-712 order signing internally — raw REST calls skip signing entirely.
+ */
+function toOpinionConfig(auth) {
+    return {
+        apiKey: auth.apiKey,
+        privateKey: auth.privateKey || '',
+        vaultAddress: auth.multiSigAddress || '',
+        rpcUrl: auth.rpcUrl,
+    };
+}
+async function placeOpinionOrder(auth, tokenId, side, price, size, orderType = 'GTC') {
+    if (!auth.privateKey) {
+        return { success: false, error: 'Opinion privateKey required for order signing' };
+    }
+    if (!auth.multiSigAddress) {
+        return { success: false, error: 'Opinion multiSigAddress (vaultAddress) required for trading' };
+    }
+    const config = toOpinionConfig(auth);
+    // Extract marketId from tokenId (Opinion tokens use format: marketId-outcomeIndex)
+    const marketId = parseInt(tokenId.split('-')[0], 10) || 0;
+    const result = await opinion.placeOrder(config, marketId, tokenId, side === 'buy' ? 'BUY' : 'SELL', price, size, orderType === 'FOK' ? 'MARKET' : 'LIMIT');
+    return {
+        success: result.success,
+        orderId: result.orderId,
+        status: result.status,
+        error: result.error,
+    };
+}
+async function cancelOpinionOrder(auth, orderId) {
+    const config = toOpinionConfig(auth);
+    return opinion.cancelOrder(config, orderId);
+}
+async function getOpinionOpenOrders(auth) {
+    const config = toOpinionConfig(auth);
+    try {
+        const orders = await opinion.getOpenOrders(config);
+        return orders.map((o) => ({
+            orderId: o.orderId,
+            platform: 'opinion',
+            marketId: o.marketId?.toString() || '',
+            tokenId: o.orderId, // tokenId not directly available from getOpenOrders
+            side: o.side.toLowerCase(),
+            price: parseFloat(o.price),
+            originalSize: parseFloat(o.orderShares),
+            remainingSize: parseFloat(o.orderShares) - parseFloat(o.filledShares || '0'),
+            filledSize: parseFloat(o.filledShares || '0'),
+            orderType: 'GTC',
+            status: o.status.toLowerCase(),
+            createdAt: new Date(o.createdAt),
+        }));
+    }
+    catch (error) {
+        logger_1.logger.error({ error }, 'Error fetching Opinion orders');
+        return [];
+    }
+}
+async function placeOpinionOrdersBatch(auth, orders) {
+    if (!auth.privateKey || !auth.multiSigAddress) {
+        return orders.map(() => ({
+            success: false,
+            error: 'Opinion privateKey and multiSigAddress required for order signing',
+        }));
+    }
+    const config = toOpinionConfig(auth);
+    const results = await opinion.placeOrdersBatch(config, orders);
+    return results.map(r => ({
+        success: r.success,
+        orderId: r.orderId,
+        error: r.error,
+    }));
+}
+async function cancelOpinionOrdersBatch(auth, orderIds) {
+    const config = toOpinionConfig(auth);
+    return opinion.cancelOrdersBatch(config, orderIds);
+}
+async function cancelAllOpinionOrders(auth, marketId) {
+    const config = toOpinionConfig(auth);
+    const result = await opinion.cancelAllOrders(config, marketId ? parseInt(marketId, 10) : undefined);
+    return result.cancelled;
+}
+// =============================================================================
+// PREDICTFUN EXECUTION
+// =============================================================================
+async function placePredictFunOrder(config, tokenId, side, price, size, marketId) {
+    try {
+        const result = await predictfun.createOrder({ ...config, dryRun: false }, {
+            marketId,
+            tokenId,
+            side: side.toUpperCase(),
+            price,
+            quantity: size,
+            isYieldBearing: true, // Default to yield-bearing
+        });
+        if (!result.success) {
+            return {
+                success: false,
+                error: result.error || 'Order placement failed',
+            };
+        }
+        logger_1.logger.info({ orderHash: result.orderHash, tokenId, side, price, size }, 'PredictFun order placed');
+        return {
+            success: true,
+            orderId: result.orderHash,
+            status: 'open',
+        };
+    }
+    catch (error) {
+        logger_1.logger.error({ error }, 'Error placing PredictFun order');
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : 'Unknown error',
+        };
+    }
+}
+async function cancelPredictFunOrder(config, orderHash) {
+    try {
+        // We need to figure out if it's negRisk/yieldBearing by fetching orders first
+        const orders = await predictfun.getOpenOrders(config);
+        const order = orders.find(o => o.orderHash === orderHash);
+        if (!order) {
+            logger_1.logger.warn({ orderHash }, 'Order not found for cancellation');
+            return false;
+        }
+        const result = await predictfun.cancelOrders(config, [orderHash], { isNegRisk: order.isNegRisk, isYieldBearing: order.isYieldBearing });
+        if (!result.success) {
+            logger_1.logger.error({ orderHash, error: result.error }, 'Failed to cancel PredictFun order');
+            return false;
+        }
+        logger_1.logger.info({ orderHash }, 'PredictFun order cancelled');
+        return true;
+    }
+    catch (error) {
+        logger_1.logger.error({ error, orderHash }, 'Error cancelling PredictFun order');
+        return false;
+    }
+}
+async function cancelAllPredictFunOrders(config) {
+    try {
+        const result = await predictfun.cancelAllOrders(config);
+        return result.cancelled;
+    }
+    catch (error) {
+        logger_1.logger.error({ error }, 'Error cancelling all PredictFun orders');
+        return 0;
+    }
+}
+async function getPredictFunOpenOrders(config) {
+    try {
+        const orders = await predictfun.getOpenOrders(config);
+        return orders.map((o) => ({
+            orderId: o.orderHash,
+            platform: 'predictfun',
+            marketId: o.marketId,
+            tokenId: o.orderHash, // Use hash as tokenId fallback
+            side: o.side.toLowerCase(),
+            price: parseFloat(o.price),
+            originalSize: parseFloat(o.size),
+            remainingSize: parseFloat(o.size) - parseFloat(o.filled),
+            filledSize: parseFloat(o.filled),
+            orderType: 'GTC',
+            status: o.status.toLowerCase(),
+            createdAt: new Date(o.createdAt),
+        }));
+    }
+    catch (error) {
+        logger_1.logger.error({ error }, 'Error fetching PredictFun orders');
+        return [];
+    }
+}
+/**
+ * Fetch PredictFun orderbook for slippage calculation
+ */
+async function fetchPredictFunOrderbook(config, marketId) {
+    try {
+        const data = await predictfun.getOrderbook(config, marketId);
+        if (!data)
+            return null;
+        const bids = (data.bids || [])
+            .map(b => [parseFloat(b.price), parseFloat(b.size)])
+            .filter(([price, size]) => !isNaN(price) && !isNaN(size))
+            .sort((a, b) => b[0] - a[0]);
+        const asks = (data.asks || [])
+            .map(a => [parseFloat(a.price), parseFloat(a.size)])
+            .filter(([price, size]) => !isNaN(price) && !isNaN(size))
+            .sort((a, b) => a[0] - b[0]);
+        const bestBid = bids[0]?.[0] ?? 0;
+        const bestAsk = asks[0]?.[0] ?? 0.99;
+        const midPrice = (bestBid + bestAsk) / 2;
+        return { bids, asks, midPrice };
+    }
+    catch (error) {
+        logger_1.logger.warn({ error, marketId }, 'Failed to fetch PredictFun orderbook');
+        return null;
+    }
+}
+/**
+ * Fetch Opinion orderbook for slippage calculation
+ */
+async function fetchOpinionOrderbook(tokenId) {
+    try {
+        const response = await fetch(`https://proxy.opinion.trade:8443/openapi/token/orderbook?tokenId=${encodeURIComponent(tokenId)}`);
+        if (!response.ok)
+            return null;
+        const data = await response.json();
+        const orderbook = data.orderbook || data;
+        const bids = (orderbook.bids || [])
+            .map(b => [parseFloat(b.price), parseFloat(b.size)])
+            .filter(([price, size]) => !isNaN(price) && !isNaN(size))
+            .sort((a, b) => b[0] - a[0]);
+        const asks = (orderbook.asks || [])
+            .map(a => [parseFloat(a.price), parseFloat(a.size)])
+            .filter(([price, size]) => !isNaN(price) && !isNaN(size))
+            .sort((a, b) => a[0] - b[0]);
+        const bestBid = bids[0]?.[0] ?? 0;
+        const bestAsk = asks[0]?.[0] ?? 0.99;
+        const midPrice = (bestBid + bestAsk) / 2;
+        return { bids, asks, midPrice };
+    }
+    catch (error) {
+        logger_1.logger.warn({ error, tokenId }, 'Failed to fetch Opinion orderbook');
+        return null;
+    }
+}
+// =============================================================================
+// POLYMARKET SETTLEMENT & APPROVAL
+// =============================================================================
+// USDC contract address on Polygon
+const POLY_USDC_ADDRESS = process.env.POLY_USDC_ADDRESS || '0x2791Bca1f2de4661ED88A30C99A7a9449Aa84174';
+// Conditional Token Framework address
+const POLY_CTF_ADDRESS = process.env.POLY_CTF_ADDRESS || '0x4D97DCd97eC945f40cF65F87097ACe5EA0476045';
+/**
+ * Get pending settlements for resolved markets
+ */
+async function getPolymarketPendingSettlements(auth, funderAddress) {
+    const address = funderAddress || auth.address;
+    const url = `${POLY_CLOB_URL}/positions?address=${address}`;
+    const headers = (0, polymarket_auth_1.buildPolymarketHeadersForUrl)(auth, 'GET', url);
+    try {
+        const response = await fetch(url, { headers });
+        if (!response.ok) {
+            throw new Error(`HTTP ${response.status}`);
+        }
+        const positions = await response.json();
+        // Filter to resolved positions with claimable amounts
+        return positions
+            .filter(p => p.resolved && parseFloat(p.claimable || '0') > 0)
+            .map(p => ({
+            marketId: p.market_id || p.condition_id || '',
+            conditionId: p.condition_id || '',
+            tokenId: p.asset_id || '',
+            outcome: (p.outcome?.toLowerCase() || 'yes'),
+            size: parseFloat(p.size || '0'),
+            claimable: parseFloat(p.claimable || '0'),
+            resolutionStatus: 'resolved',
+            resolvedAt: undefined, // API doesn't return resolution time
+        }));
+    }
+    catch (error) {
+        logger_1.logger.error({ error, address }, 'Failed to fetch pending settlements');
+        return [];
+    }
+}
+/**
+ * Approve USDC spending for CTF exchange (required before first trade)
+ * This requires a transaction signing - returns the approval status
+ */
+async function approvePolymarketUSDC(privateKey, spender, amount = Number.MAX_SAFE_INTEGER) {
+    try {
+        const { Wallet, Contract, JsonRpcProvider, MaxUint256 } = await Promise.resolve().then(() => __importStar(require('ethers')));
+        const rpcUrl = process.env.POLYGON_RPC_URL || 'https://polygon-rpc.com';
+        const provider = new JsonRpcProvider(rpcUrl);
+        const wallet = new Wallet(privateKey, provider);
+        // USDC on Polygon
+        const USDC_ADDRESS = '0x2791Bca1f2de4661ED88A30C99A7a9449Aa84174';
+        const ERC20_ABI = ['function approve(address spender, uint256 amount) returns (bool)'];
+        const usdc = new Contract(USDC_ADDRESS, ERC20_ABI, wallet);
+        const tx = await usdc.approve(spender, MaxUint256);
+        const receipt = await tx.wait();
+        logger_1.logger.info({ txHash: receipt.hash, spender }, 'USDC approval confirmed');
+        return { success: true, txHash: receipt.hash };
+    }
+    catch (error) {
+        logger_1.logger.error({ error, spender }, 'USDC approval failed');
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : 'Approval failed',
+        };
+    }
+}
+/**
+ * Get current USDC allowance for trading
+ */
+async function getPolymarketUSDCAllowance(ownerAddress, spenderAddress) {
+    try {
+        // ERC20 allowance check via RPC
+        // This is a read-only call that doesn't require signing
+        const allowanceSelector = '0xdd62ed3e'; // allowance(address,address)
+        const paddedOwner = ownerAddress.slice(2).toLowerCase().padStart(64, '0');
+        const paddedSpender = spenderAddress.slice(2).toLowerCase().padStart(64, '0');
+        const data = `${allowanceSelector}${paddedOwner}${paddedSpender}`;
+        const rpcUrl = process.env.POLYGON_RPC_URL || 'https://polygon-rpc.com';
+        const response = await fetch(rpcUrl, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                jsonrpc: '2.0',
+                method: 'eth_call',
+                params: [{ to: POLY_USDC_ADDRESS, data }, 'latest'],
+                id: 1,
+            }),
+        });
+        const result = await response.json();
+        if (!result.result || result.result === '0x') {
+            return 0;
+        }
+        // USDC has 6 decimals
+        const allowanceWei = BigInt(result.result);
+        return Number(allowanceWei) / 1e6;
+    }
+    catch (error) {
+        logger_1.logger.warn({ error, ownerAddress }, 'Failed to fetch USDC allowance');
+        return 0;
+    }
+}
+/**
+ * Batch fetch orderbooks for multiple tokens
+ */
+async function getPolymarketOrderbooksBatch(tokenIds) {
+    const results = new Map();
+    // Fetch in parallel with concurrency limit
+    const BATCH_SIZE = 10;
+    for (let i = 0; i < tokenIds.length; i += BATCH_SIZE) {
+        const batch = tokenIds.slice(i, i + BATCH_SIZE);
+        const promises = batch.map(async (tokenId) => {
+            try {
+                const response = await fetch(`${POLY_CLOB_URL}/book?token_id=${tokenId}`);
+                if (!response.ok) {
+                    results.set(tokenId, null);
+                    return;
+                }
+                const data = await response.json();
+                const bids = (data.bids || [])
+                    .map((b) => [parseFloat(b.price), parseFloat(b.size)])
+                    .sort((a, b) => b[0] - a[0]);
+                const asks = (data.asks || [])
+                    .map((a) => [parseFloat(a.price), parseFloat(a.size)])
+                    .sort((a, b) => a[0] - b[0]);
+                const bestBid = bids[0]?.[0] ?? 0;
+                const bestAsk = asks[0]?.[0] ?? 0.99;
+                const midPrice = (bestBid + bestAsk) / 2;
+                results.set(tokenId, { bids, asks, midPrice });
+            }
+            catch {
+                results.set(tokenId, null);
+            }
+        });
+        await Promise.all(promises);
+    }
+    return results;
+}
+// =============================================================================
+// EXECUTION SERVICE
+// =============================================================================
+function createExecutionService(config) {
+    const maxOrderSize = config.maxOrderSize || 1000; // Default $1000 max
+    // ==========================================================================
+    // REAL-TIME FILL TRACKING (Polymarket WebSocket)
+    // ==========================================================================
+    let userWs = null;
+    const trackedFills = new Map();
+    const trackedOrders = new Map();
+    const fillCallbacks = new Set();
+    const orderCallbacks = new Set();
+    const fillWaiters = new Map();
+    // Circuit breaker integration
+    let circuitBreaker = null;
+    function handleFillEvent(event) {
+        const fill = {
+            orderId: event.orderId,
+            marketId: event.marketId,
+            tokenId: event.tokenId,
+            side: event.side.toLowerCase(),
+            size: event.size,
+            price: event.price,
+            status: event.status,
+            transactionHash: event.transactionHash,
+            timestamp: event.timestamp,
+            receivedAt: Date.now(),
+        };
+        // Update or insert (only if higher priority status)
+        const existing = trackedFills.get(event.orderId);
+        if (!existing || getStatusPriority(fill.status) > getStatusPriority(existing.status)) {
+            trackedFills.set(event.orderId, fill);
+            logger_1.logger.info({ fill }, 'Fill tracked via WebSocket');
+            // Notify subscribers
+            for (const callback of fillCallbacks) {
+                try {
+                    callback(fill);
+                }
+                catch (err) {
+                    logger_1.logger.error({ err }, 'Fill callback error');
+                }
+            }
+            // Resolve waiters if CONFIRMED or FAILED
+            if (fill.status === 'CONFIRMED' || fill.status === 'FAILED') {
+                const waiters = fillWaiters.get(event.orderId);
+                if (waiters) {
+                    for (const resolve of waiters) {
+                        resolve(fill);
+                    }
+                    fillWaiters.delete(event.orderId);
+                }
+            }
+        }
+    }
+    function handleOrderEvent(event) {
+        const order = {
+            orderId: event.orderId,
+            marketId: event.marketId,
+            tokenId: event.tokenId,
+            type: event.type,
+            side: event.side.toLowerCase(),
+            price: event.price,
+            originalSize: event.originalSize,
+            sizeMatched: event.sizeMatched,
+            timestamp: event.timestamp,
+            receivedAt: Date.now(),
+        };
+        trackedOrders.set(event.orderId, order);
+        logger_1.logger.info({ order }, 'Order event tracked via WebSocket');
+        // Notify subscribers
+        for (const callback of orderCallbacks) {
+            try {
+                callback(order);
+            }
+            catch (err) {
+                logger_1.logger.error({ err }, 'Order callback error');
+            }
+        }
+    }
+    function getStatusPriority(status) {
+        switch (status) {
+            case 'MATCHED': return 1;
+            case 'MINED': return 2;
+            case 'CONFIRMED': return 3;
+            case 'FAILED': return 0;
+            default: return -1;
+        }
+    }
+    async function connectFillsWebSocket() {
+        if (!config.polymarket) {
+            throw new Error('Polymarket not configured');
+        }
+        if (userWs?.isConnected()) {
+            return;
+        }
+        const userId = config.polymarket.funderAddress || config.polymarket.apiKey;
+        userWs = (0, user_ws_1.createUserWebSocket)(userId, {
+            privateKey: config.polymarket.privateKey || '',
+            apiKey: config.polymarket.apiKey,
+            apiSecret: config.polymarket.apiSecret,
+            apiPassphrase: config.polymarket.apiPassphrase,
+            funderAddress: config.polymarket.funderAddress || '',
+        });
+        userWs.on('fill', handleFillEvent);
+        userWs.on('order', handleOrderEvent);
+        userWs.on('error', (err) => {
+            logger_1.logger.error({ err }, 'Fills WebSocket error');
+        });
+        await userWs.connect();
+        logger_1.logger.info('Fills WebSocket connected - real-time order confirmations enabled');
+    }
+    function disconnectFillsWebSocket() {
+        if (userWs) {
+            userWs.disconnect();
+            userWs = null;
+            logger_1.logger.info('Fills WebSocket disconnected');
+        }
+    }
+    // ==========================================================================
+    // ORDER HEARTBEAT (Polymarket - orders cancelled if no heartbeat within 10s)
+    // ==========================================================================
+    let heartbeatId = null;
+    let heartbeatInterval = null;
+    const HEARTBEAT_INTERVAL_MS = 8000; // 8s to be safe (10s timeout)
+    async function postHeartbeat(existingId) {
+        if (!config.polymarket) {
+            throw new Error('Polymarket not configured');
+        }
+        const url = `${POLY_CLOB_URL}/heartbeat`;
+        const body = existingId ? { heartbeat_id: existingId } : {};
+        const headers = (0, polymarket_auth_1.buildPolymarketHeadersForUrl)({
+            address: config.polymarket.funderAddress || '',
+            apiKey: config.polymarket.apiKey,
+            apiSecret: config.polymarket.apiSecret,
+            apiPassphrase: config.polymarket.apiPassphrase,
+        }, 'POST', url);
+        const response = await fetch(url, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                ...headers,
+            },
+            body: JSON.stringify(body),
+        });
+        if (!response.ok) {
+            const text = await response.text();
+            throw new Error(`Heartbeat failed: ${response.status} ${text}`);
+        }
+        const data = await response.json();
+        return data.heartbeat_id || existingId || '';
+    }
+    async function startHeartbeat() {
+        if (heartbeatInterval) {
+            // Already running, just return current ID
+            if (heartbeatId)
+                return heartbeatId;
+        }
+        // Initial heartbeat
+        heartbeatId = await postHeartbeat();
+        logger_1.logger.info({ heartbeatId }, 'Polymarket heartbeat started');
+        // Start recurring heartbeat
+        heartbeatInterval = setInterval(async () => {
+            try {
+                heartbeatId = await postHeartbeat(heartbeatId || undefined);
+                logger_1.logger.debug({ heartbeatId }, 'Heartbeat sent');
+            }
+            catch (err) {
+                logger_1.logger.error({ err }, 'Heartbeat failed - orders may be cancelled');
+            }
+        }, HEARTBEAT_INTERVAL_MS);
+        return heartbeatId;
+    }
+    async function sendHeartbeat(id) {
+        heartbeatId = await postHeartbeat(id);
+        return heartbeatId;
+    }
+    function stopHeartbeat() {
+        if (heartbeatInterval) {
+            clearInterval(heartbeatInterval);
+            heartbeatInterval = null;
+        }
+        heartbeatId = null;
+        logger_1.logger.info('Polymarket heartbeat stopped');
+    }
+    function isHeartbeatActive() {
+        return heartbeatInterval !== null;
+    }
+    function waitForFill(orderId, timeoutMs = 60000) {
+        // Check if already have a confirmed/failed fill
+        const existing = trackedFills.get(orderId);
+        if (existing && (existing.status === 'CONFIRMED' || existing.status === 'FAILED')) {
+            return Promise.resolve(existing);
+        }
+        return new Promise((resolve) => {
+            // Set up timeout
+            const timeout = setTimeout(() => {
+                const waiters = fillWaiters.get(orderId);
+                if (waiters) {
+                    const idx = waiters.indexOf(resolve);
+                    if (idx !== -1)
+                        waiters.splice(idx, 1);
+                    if (waiters.length === 0)
+                        fillWaiters.delete(orderId);
+                }
+                resolve(null); // Timeout - return null
+            }, timeoutMs);
+            // Add to waiters
+            const resolveWrapper = (fill) => {
+                clearTimeout(timeout);
+                resolve(fill);
+            };
+            if (!fillWaiters.has(orderId)) {
+                fillWaiters.set(orderId, []);
+            }
+            fillWaiters.get(orderId).push(resolveWrapper);
+        });
+    }
+    // ==========================================================================
+    function validateOrder(request) {
+        // Circuit breaker check - block orders when tripped
+        if (circuitBreaker && !circuitBreaker.canTrade()) {
+            const state = circuitBreaker.getState();
+            return `Trading blocked by circuit breaker: ${state.tripReason || 'tripped'}. Reset at: ${state.resetAt?.toISOString() || 'manual reset required'}`;
+        }
+        const notional = request.price * request.size;
+        if (notional > maxOrderSize) {
+            return `Order size $${notional.toFixed(2)} exceeds max $${maxOrderSize}`;
+        }
+        if (request.price < 0.01 || request.price > 0.99) {
+            return `Price ${request.price} out of range [0.01, 0.99]`;
+        }
+        if (request.size <= 0) {
+            return `Invalid size: ${request.size}`;
+        }
+        return null;
+    }
+    /**
+     * Record order result to circuit breaker (if enabled)
+     * Note: P&L is calculated when position is closed, not on order placement
+     */
+    function recordOrderToCircuitBreaker(result, sizeUsd) {
+        if (!circuitBreaker)
+            return;
+        // Record as trade (P&L = 0 for now, actual P&L tracked on fills/closes)
+        circuitBreaker.recordTrade({
+            pnlUsd: 0, // P&L unknown at order time
+            success: result.success,
+            sizeUsd,
+            error: result.error,
+        });
+        // Record error if order failed
+        if (!result.success && result.error) {
+            circuitBreaker.recordError(result.error);
+        }
+    }
+    async function executeOrder(request) {
+        // Validate
+        const error = validateOrder(request);
+        if (error) {
+            return { success: false, error };
+        }
+        // Security shield pre-trade check (runs before dry-run so security is always enforced)
+        if (request.destination) {
+            try {
+                const { getSecurityShield } = await Promise.resolve().then(() => __importStar(require('../security/shield.js')));
+                const shield = getSecurityShield();
+                const check = await shield.validateTx({
+                    destination: request.destination,
+                    amount: request.size,
+                    token: request.token,
+                });
+                if (!check.allowed) {
+                    return { success: false, error: `Security blocked: ${check.flags.join(', ')}` };
+                }
+            }
+            catch (err) {
+                // Shield not loaded or RPC failure — log but don't block
+                logger_1.logger.debug({ err }, 'Security shield check skipped');
+            }
+        }
+        // Dry run mode
+        if (config.dryRun) {
+            logger_1.logger.info({ ...request, dryRun: true }, 'Dry run order');
+            return {
+                success: true,
+                orderId: `dry_${(0, crypto_1.randomBytes)(8).toString('hex')}`,
+                status: 'open',
+            };
+        }
+        // Execute on appropriate platform
+        if (request.platform === 'polymarket') {
+            if (!config.polymarket) {
+                return { success: false, error: 'Polymarket not configured' };
+            }
+            if (!request.tokenId) {
+                return { success: false, error: 'tokenId required for Polymarket' };
+            }
+            const result = await placePolymarketOrder(config.polymarket, request.tokenId, request.side, request.price, request.size, request.orderType, request.negRisk, request.postOnly);
+            // Auto-start heartbeat for GTC/GTD orders (orders that stay on the book)
+            // Polymarket cancels orders if no heartbeat received within 10 seconds
+            if (result.success && (request.orderType === 'GTC' || request.orderType === 'GTD')) {
+                if (!isHeartbeatActive()) {
+                    try {
+                        await startHeartbeat();
+                        logger_1.logger.info('Heartbeat auto-started for GTC order');
+                    }
+                    catch (err) {
+                        logger_1.logger.warn({ err }, 'Failed to auto-start heartbeat (order placed but heartbeat not started)');
+                    }
+                }
+            }
+            return result;
+        }
+        if (request.platform === 'kalshi') {
+            if (!config.kalshi) {
+                return { success: false, error: 'Kalshi not configured' };
+            }
+            const outcome = request.outcome?.toLowerCase() || 'yes';
+            return placeKalshiOrder(config.kalshi, request.marketId, outcome, request.side, request.price, request.size, request.orderType, request.maxSlippage);
+        }
+        if (request.platform === 'opinion') {
+            if (!config.opinion) {
+                return { success: false, error: 'Opinion not configured' };
+            }
+            if (!request.tokenId) {
+                return { success: false, error: 'tokenId required for Opinion' };
+            }
+            return placeOpinionOrder(config.opinion, request.tokenId, request.side, request.price, request.size, request.orderType);
+        }
+        if (request.platform === 'predictfun') {
+            if (!config.predictfun) {
+                return { success: false, error: 'PredictFun not configured' };
+            }
+            if (!request.tokenId) {
+                return { success: false, error: 'tokenId required for PredictFun' };
+            }
+            return placePredictFunOrder(config.predictfun, request.tokenId, request.side, request.price, request.size, request.marketId);
+        }
+        return { success: false, error: `Unknown platform: ${request.platform}` };
+    }
+    const service = {
+        async buyLimit(request) {
+            const result = await executeOrder({ ...request, side: 'buy', orderType: request.orderType || 'GTC' });
+            recordOrderToCircuitBreaker(result, request.price * request.size);
+            return result;
+        },
+        async sellLimit(request) {
+            const result = await executeOrder({ ...request, side: 'sell', orderType: request.orderType || 'GTC' });
+            recordOrderToCircuitBreaker(result, request.price * request.size);
+            return result;
+        },
+        async marketBuy(request) {
+            // Market orders use FOK (Fill or Kill)
+            // Price is set to max (0.99) to ensure fill
+            const result = await executeOrder({ ...request, side: 'buy', price: 0.99, orderType: 'FOK' });
+            recordOrderToCircuitBreaker(result, 0.99 * request.size);
+            return result;
+        },
+        async marketSell(request) {
+            // Price is set to min (0.01) to ensure fill
+            const result = await executeOrder({ ...request, side: 'sell', price: 0.01, orderType: 'FOK' });
+            recordOrderToCircuitBreaker(result, 0.01 * request.size);
+            return result;
+        },
+        async makerBuy(request) {
+            const result = await executeOrder({ ...request, side: 'buy', orderType: 'GTC', postOnly: true });
+            recordOrderToCircuitBreaker(result, request.price * request.size);
+            return result;
+        },
+        async makerSell(request) {
+            const result = await executeOrder({ ...request, side: 'sell', orderType: 'GTC', postOnly: true });
+            recordOrderToCircuitBreaker(result, request.price * request.size);
+            return result;
+        },
+        async cancelOrder(platform, orderId) {
+            if (config.dryRun) {
+                logger_1.logger.info({ platform, orderId, dryRun: true }, 'Dry run cancel');
+                return true;
+            }
+            if (platform === 'polymarket' && config.polymarket) {
+                return cancelPolymarketOrder(config.polymarket, orderId);
+            }
+            if (platform === 'kalshi' && config.kalshi) {
+                return cancelKalshiOrder(config.kalshi, orderId);
+            }
+            if (platform === 'opinion' && config.opinion) {
+                return cancelOpinionOrder(config.opinion, orderId);
+            }
+            if (platform === 'predictfun' && config.predictfun) {
+                return cancelPredictFunOrder(config.predictfun, orderId);
+            }
+            return false;
+        },
+        async cancelAllOrders(platform, marketId) {
+            if (config.dryRun) {
+                logger_1.logger.info({ platform, marketId, dryRun: true }, 'Dry run cancel all');
+                return 0;
+            }
+            let count = 0;
+            if ((!platform || platform === 'polymarket') && config.polymarket) {
+                count += await cancelAllPolymarketOrders(config.polymarket, marketId);
+                // Auto-stop heartbeat if all Polymarket orders cancelled (no market filter)
+                // Heartbeat is only needed when there are open GTC/GTD orders
+                if (!marketId && isHeartbeatActive()) {
+                    stopHeartbeat();
+                    logger_1.logger.info('Heartbeat auto-stopped after cancelling all orders');
+                }
+            }
+            // Kalshi: fetch open orders, batch cancel matching ones
+            if ((!platform || platform === 'kalshi') && config.kalshi) {
+                const orders = await getKalshiOpenOrders(config.kalshi);
+                const toCancel = orders
+                    .filter(o => !marketId || o.marketId === marketId)
+                    .map(o => o.orderId);
+                if (toCancel.length > 0) {
+                    const results = await cancelKalshiOrdersBatch(config.kalshi, toCancel);
+                    count += results.filter(r => r.success).length;
+                }
+            }
+            // Opinion: use SDK's cancelAllOrders (handles batch internally)
+            if ((!platform || platform === 'opinion') && config.opinion) {
+                count += await cancelAllOpinionOrders(config.opinion, marketId);
+            }
+            // PredictFun has bulk cancel support
+            if ((!platform || platform === 'predictfun') && config.predictfun) {
+                if (marketId) {
+                    // Filter by market if specified
+                    const orders = await getPredictFunOpenOrders(config.predictfun);
+                    for (const order of orders) {
+                        if (order.marketId === marketId) {
+                            if (await cancelPredictFunOrder(config.predictfun, order.orderId)) {
+                                count++;
+                            }
+                        }
+                    }
+                }
+                else {
+                    count += await cancelAllPredictFunOrders(config.predictfun);
+                }
+            }
+            return count;
+        },
+        async getOpenOrders(platform) {
+            const orders = [];
+            if ((!platform || platform === 'polymarket') && config.polymarket) {
+                const polyOrders = await getPolymarketOpenOrders(config.polymarket);
+                orders.push(...polyOrders);
+            }
+            if ((!platform || platform === 'kalshi') && config.kalshi) {
+                const kalshiOrders = await getKalshiOpenOrders(config.kalshi);
+                orders.push(...kalshiOrders);
+            }
+            if ((!platform || platform === 'opinion') && config.opinion) {
+                const opinionOrders = await getOpinionOpenOrders(config.opinion);
+                orders.push(...opinionOrders);
+            }
+            if ((!platform || platform === 'predictfun') && config.predictfun) {
+                const predictfunOrders = await getPredictFunOpenOrders(config.predictfun);
+                orders.push(...predictfunOrders);
+            }
+            return orders;
+        },
+        async getOrder(platform, orderId) {
+            const orders = await this.getOpenOrders(platform);
+            return orders.find((o) => o.orderId === orderId) || null;
+        },
+        async estimateFill(request) {
+            try {
+                let orderbook = null;
+                if (request.platform === 'polymarket' && request.tokenId) {
+                    orderbook = await fetchPolymarketOrderbook(request.tokenId);
+                }
+                else if (request.platform === 'kalshi') {
+                    orderbook = await fetchKalshiOrderbook(request.marketId);
+                }
+                else if (request.platform === 'opinion' && request.tokenId) {
+                    orderbook = await fetchOpinionOrderbook(request.tokenId);
+                }
+                else if (request.platform === 'predictfun' && config.predictfun) {
+                    orderbook = await fetchPredictFunOrderbook(config.predictfun, request.marketId);
+                }
+                if (!orderbook) {
+                    return { avgPrice: request.price, filledSize: request.size };
+                }
+                const orders = request.side === 'buy' ? orderbook.asks : orderbook.bids;
+                const { avgFillPrice, totalFilled } = calculateFillFromOrderbook(orders, request.size, request.side);
+                return {
+                    avgPrice: totalFilled > 0 ? avgFillPrice : request.price,
+                    filledSize: totalFilled,
+                };
+            }
+            catch {
+                return { avgPrice: request.price, filledSize: request.size };
+            }
+        },
+        async protectedBuy(request, maxSlippageOverride) {
+            const slippageConfig = {
+                maxSlippage: 0.02, // 2% default
+                checkOrderbook: true,
+                autoCancel: true,
+                useLimitOrders: true,
+                limitPriceBuffer: 0.01,
+                ...config.slippageProtection,
+            };
+            const maxSlippage = maxSlippageOverride ?? request.maxSlippage ?? slippageConfig.maxSlippage;
+            // Estimate slippage before executing
+            const slippageEstimate = await this.estimateSlippage({ ...request, side: 'buy' });
+            if (slippageEstimate.slippage > maxSlippage) {
+                logger_1.logger.warn({ slippage: slippageEstimate.slippage, maxSlippage, request }, 'Slippage protection triggered - order rejected');
+                return {
+                    success: false,
+                    error: `Slippage ${(slippageEstimate.slippage * 100).toFixed(2)}% exceeds max ${(maxSlippage * 100).toFixed(2)}%`,
+                };
+            }
+            // Use limit order with buffer if enabled
+            if (slippageConfig.useLimitOrders) {
+                const limitPrice = Math.min(0.99, slippageEstimate.expectedPrice * (1 + slippageConfig.limitPriceBuffer));
+                return executeOrder({
+                    ...request,
+                    side: 'buy',
+                    price: limitPrice,
+                    orderType: 'GTC',
+                });
+            }
+            return executeOrder({ ...request, side: 'buy', orderType: request.orderType || 'GTC' });
+        },
+        async protectedSell(request, maxSlippageOverride) {
+            const slippageConfig = {
+                maxSlippage: 0.02,
+                checkOrderbook: true,
+                autoCancel: true,
+                useLimitOrders: true,
+                limitPriceBuffer: 0.01,
+                ...config.slippageProtection,
+            };
+            const maxSlippage = maxSlippageOverride ?? request.maxSlippage ?? slippageConfig.maxSlippage;
+            // Estimate slippage before executing
+            const slippageEstimate = await this.estimateSlippage({ ...request, side: 'sell' });
+            if (slippageEstimate.slippage > maxSlippage) {
+                logger_1.logger.warn({ slippage: slippageEstimate.slippage, maxSlippage, request }, 'Slippage protection triggered - order rejected');
+                return {
+                    success: false,
+                    error: `Slippage ${(slippageEstimate.slippage * 100).toFixed(2)}% exceeds max ${(maxSlippage * 100).toFixed(2)}%`,
+                };
+            }
+            // Use limit order with buffer if enabled
+            if (slippageConfig.useLimitOrders) {
+                const limitPrice = Math.max(0.01, slippageEstimate.expectedPrice * (1 - slippageConfig.limitPriceBuffer));
+                return executeOrder({
+                    ...request,
+                    side: 'sell',
+                    price: limitPrice,
+                    orderType: 'GTC',
+                });
+            }
+            return executeOrder({ ...request, side: 'sell', orderType: request.orderType || 'GTC' });
+        },
+        async estimateSlippage(request) {
+            try {
+                // Fetch orderbook based on platform
+                let orderbook = null;
+                if (request.platform === 'polymarket' && request.tokenId) {
+                    orderbook = await fetchPolymarketOrderbook(request.tokenId);
+                }
+                else if (request.platform === 'kalshi') {
+                    orderbook = await fetchKalshiOrderbook(request.marketId);
+                }
+                else if (request.platform === 'opinion' && request.tokenId) {
+                    orderbook = await fetchOpinionOrderbook(request.tokenId);
+                }
+                else if (request.platform === 'predictfun' && config.predictfun) {
+                    orderbook = await fetchPredictFunOrderbook(config.predictfun, request.marketId);
+                }
+                if (!orderbook || (orderbook.bids.length === 0 && orderbook.asks.length === 0)) {
+                    // Fallback to heuristic estimate if no orderbook
+                    const baseSlippage = 0.005;
+                    const sizeImpact = Math.min(0.05, request.size * 0.0001);
+                    const estimatedSlippage = baseSlippage + sizeImpact;
+                    return {
+                        slippage: estimatedSlippage,
+                        expectedPrice: request.side === 'buy'
+                            ? request.price * (1 + estimatedSlippage)
+                            : request.price * (1 - estimatedSlippage),
+                    };
+                }
+                // Calculate average fill price by walking through orderbook
+                const { avgFillPrice, totalFilled } = calculateFillFromOrderbook(request.side === 'buy' ? orderbook.asks : orderbook.bids, request.size, request.side);
+                if (totalFilled < request.size * 0.5) {
+                    // Less than 50% can be filled - high slippage market
+                    logger_1.logger.warn({ request, totalFilled, requested: request.size }, 'Orderbook too thin - less than 50% fillable');
+                }
+                // Calculate slippage relative to mid price
+                const midPrice = orderbook.midPrice || request.price;
+                const slippage = request.side === 'buy'
+                    ? (avgFillPrice - midPrice) / midPrice
+                    : (midPrice - avgFillPrice) / midPrice;
+                return {
+                    slippage: Math.max(0, slippage),
+                    expectedPrice: avgFillPrice,
+                };
+            }
+            catch (error) {
+                logger_1.logger.warn({ error, request }, 'Failed to estimate slippage from orderbook');
+                // Fallback to heuristic
+                const baseSlippage = 0.005;
+                const sizeImpact = Math.min(0.05, request.size * 0.0001);
+                return {
+                    slippage: baseSlippage + sizeImpact,
+                    expectedPrice: request.side === 'buy'
+                        ? request.price * (1 + baseSlippage + sizeImpact)
+                        : request.price * (1 - baseSlippage - sizeImpact),
+                };
+            }
+        },
+        async placeOrdersBatch(orders) {
+            const polyOrders = orders.filter(o => o.platform === 'polymarket');
+            const kalshiOrders = orders.filter(o => o.platform === 'kalshi');
+            const opinionOrders = orders.filter(o => o.platform === 'opinion');
+            const predictfunOrders = orders.filter(o => o.platform === 'predictfun');
+            const otherOrders = orders.filter(o => o.platform !== 'opinion' && o.platform !== 'polymarket' && o.platform !== 'kalshi' && o.platform !== 'predictfun');
+            const results = [];
+            // Execute Polymarket batch if we have Polymarket orders and config
+            if (polyOrders.length > 0 && config.polymarket) {
+                try {
+                    const batchInput = polyOrders.map(o => ({
+                        tokenId: o.tokenId,
+                        side: o.side,
+                        price: o.price,
+                        size: o.size,
+                        negRisk: o.negRisk,
+                        postOnly: o.postOnly,
+                    }));
+                    const batchResults = await placePolymarketOrdersBatch(config.polymarket, batchInput);
+                    results.push(...batchResults);
+                }
+                catch (err) {
+                    results.push(...polyOrders.map(() => ({
+                        success: false,
+                        error: err instanceof Error ? err.message : 'Batch order failed',
+                    })));
+                }
+            }
+            else if (polyOrders.length > 0) {
+                results.push(...polyOrders.map(() => ({
+                    success: false,
+                    error: 'Polymarket trading not configured',
+                })));
+            }
+            // Execute Kalshi batch if we have Kalshi orders and config
+            if (kalshiOrders.length > 0 && config.kalshi) {
+                try {
+                    const batchInput = kalshiOrders.map(o => ({
+                        ticker: o.marketId,
+                        side: o.outcome?.toLowerCase() || 'yes',
+                        action: o.side,
+                        price: o.price,
+                        count: o.size,
+                    }));
+                    const batchResults = await placeKalshiOrdersBatch(config.kalshi, batchInput);
+                    results.push(...batchResults);
+                }
+                catch (err) {
+                    results.push(...kalshiOrders.map(() => ({
+                        success: false,
+                        error: err instanceof Error ? err.message : 'Batch order failed',
+                    })));
+                }
+            }
+            else if (kalshiOrders.length > 0) {
+                results.push(...kalshiOrders.map(() => ({
+                    success: false,
+                    error: 'Kalshi trading not configured',
+                })));
+            }
+            // Execute Opinion batch if we have Opinion orders and config
+            if (opinionOrders.length > 0 && config.opinion) {
+                try {
+                    const batchInput = opinionOrders.map(o => ({
+                        marketId: parseInt(o.marketId, 10),
+                        tokenId: o.tokenId,
+                        side: o.side.toUpperCase(),
+                        price: o.price,
+                        amount: o.size,
+                    }));
+                    const batchResults = await placeOpinionOrdersBatch(config.opinion, batchInput);
+                    results.push(...batchResults.map(r => ({
+                        success: r.success,
+                        orderId: r.orderId,
+                        error: r.error,
+                    })));
+                }
+                catch (err) {
+                    // All Opinion orders failed
+                    results.push(...opinionOrders.map(() => ({
+                        success: false,
+                        error: err instanceof Error ? err.message : 'Batch order failed',
+                    })));
+                }
+            }
+            else if (opinionOrders.length > 0) {
+                // No Opinion config
+                results.push(...opinionOrders.map(() => ({
+                    success: false,
+                    error: 'Opinion trading not configured',
+                })));
+            }
+            // Execute PredictFun orders (no native batch API — sequential via SDK with EIP-712 signing)
+            if (predictfunOrders.length > 0 && config.predictfun) {
+                for (const order of predictfunOrders) {
+                    try {
+                        const result = await placePredictFunOrder(config.predictfun, order.tokenId, order.side, order.price, order.size, order.marketId);
+                        results.push(result);
+                    }
+                    catch (err) {
+                        results.push({
+                            success: false,
+                            error: err instanceof Error ? err.message : 'Order failed',
+                        });
+                    }
+                }
+            }
+            else if (predictfunOrders.length > 0) {
+                results.push(...predictfunOrders.map(() => ({
+                    success: false,
+                    error: 'PredictFun trading not configured',
+                })));
+            }
+            // Execute other orders individually (fallback)
+            for (const order of otherOrders) {
+                try {
+                    const result = order.side === 'buy'
+                        ? await this.buyLimit(order)
+                        : await this.sellLimit(order);
+                    results.push(result);
+                }
+                catch (err) {
+                    results.push({
+                        success: false,
+                        error: err instanceof Error ? err.message : 'Order failed',
+                    });
+                }
+            }
+            return results;
+        },
+        async cancelOrdersBatch(platform, orderIds) {
+            if (platform === 'polymarket' && config.polymarket) {
+                try {
+                    return await cancelPolymarketOrdersBatch(config.polymarket, orderIds);
+                }
+                catch (err) {
+                    return orderIds.map(orderId => ({ orderId, success: false }));
+                }
+            }
+            if (platform === 'kalshi' && config.kalshi) {
+                try {
+                    return await cancelKalshiOrdersBatch(config.kalshi, orderIds);
+                }
+                catch (err) {
+                    return orderIds.map(orderId => ({ orderId, success: false }));
+                }
+            }
+            if (platform === 'opinion' && config.opinion) {
+                try {
+                    return await cancelOpinionOrdersBatch(config.opinion, orderIds);
+                }
+                catch (err) {
+                    return orderIds.map(orderId => ({
+                        orderId,
+                        success: false,
+                    }));
+                }
+            }
+            if (platform === 'predictfun' && config.predictfun) {
+                // PredictFun cancel requires isNegRisk/isYieldBearing — cancel individually via SDK
+                const results = [];
+                for (const orderId of orderIds) {
+                    const success = await cancelPredictFunOrder(config.predictfun, orderId);
+                    results.push({ orderId, success });
+                }
+                return results;
+            }
+            // Fallback: cancel individually
+            const results = [];
+            for (const orderId of orderIds) {
+                try {
+                    const success = await this.cancelOrder(platform, orderId);
+                    results.push({ orderId, success });
+                }
+                catch {
+                    results.push({ orderId, success: false });
+                }
+            }
+            return results;
+        },
+        // =========================================================================
+        // REAL-TIME FILL TRACKING (Polymarket WebSocket)
+        // =========================================================================
+        async connectFillsWebSocket() {
+            return connectFillsWebSocket();
+        },
+        disconnectFillsWebSocket() {
+            disconnectFillsWebSocket();
+        },
+        isFillsWebSocketConnected() {
+            return userWs?.isConnected() ?? false;
+        },
+        onFill(callback) {
+            fillCallbacks.add(callback);
+            return () => {
+                fillCallbacks.delete(callback);
+            };
+        },
+        onOrder(callback) {
+            orderCallbacks.add(callback);
+            return () => {
+                orderCallbacks.delete(callback);
+            };
+        },
+        getTrackedFills() {
+            return Array.from(trackedFills.values());
+        },
+        getTrackedFill(orderId) {
+            return trackedFills.get(orderId);
+        },
+        clearOldFills(maxAgeMs = 3600000) {
+            const now = Date.now();
+            let cleared = 0;
+            for (const [orderId, fill] of trackedFills) {
+                if (now - fill.receivedAt > maxAgeMs) {
+                    trackedFills.delete(orderId);
+                    cleared++;
+                }
+            }
+            // Also clear old orders
+            for (const [orderId, order] of trackedOrders) {
+                if (now - order.receivedAt > maxAgeMs) {
+                    trackedOrders.delete(orderId);
+                }
+            }
+            return cleared;
+        },
+        waitForFill(orderId, timeoutMs) {
+            return waitForFill(orderId, timeoutMs);
+        },
+        // =========================================================================
+        // POLYMARKET ORDER HEARTBEAT
+        // =========================================================================
+        async startHeartbeat() {
+            return startHeartbeat();
+        },
+        async sendHeartbeat(id) {
+            return sendHeartbeat(id);
+        },
+        stopHeartbeat() {
+            stopHeartbeat();
+        },
+        isHeartbeatActive() {
+            return isHeartbeatActive();
+        },
+        // =========================================================================
+        // POLYMARKET SETTLEMENT
+        // =========================================================================
+        async getPendingSettlements() {
+            if (!config.polymarket) {
+                return [];
+            }
+            return getPolymarketPendingSettlements(config.polymarket, config.polymarket.funderAddress);
+        },
+        // =========================================================================
+        // POLYMARKET COLLATERAL APPROVAL
+        // =========================================================================
+        async approveUSDC(amount) {
+            if (!config.polymarket?.privateKey) {
+                return {
+                    success: false,
+                    error: 'Polymarket private key not configured',
+                };
+            }
+            // Approve for both CTF exchanges
+            const spender = POLY_CTF_EXCHANGE;
+            return approvePolymarketUSDC(config.polymarket.privateKey, spender, amount);
+        },
+        async getUSDCAllowance() {
+            if (!config.polymarket) {
+                return 0;
+            }
+            const owner = config.polymarket.funderAddress || config.polymarket.address;
+            return getPolymarketUSDCAllowance(owner, POLY_CTF_EXCHANGE);
+        },
+        // =========================================================================
+        // BATCH ORDERBOOK FETCHING
+        // =========================================================================
+        async getOrderbooksBatch(tokenIds) {
+            return getPolymarketOrderbooksBatch(tokenIds);
+        },
+        // =========================================================================
+        // CIRCUIT BREAKER INTEGRATION
+        // =========================================================================
+        setCircuitBreaker(breaker) {
+            circuitBreaker = breaker;
+            if (breaker) {
+                logger_1.logger.info('Circuit breaker enabled for order validation');
+            }
+            else {
+                logger_1.logger.info('Circuit breaker disabled');
+            }
+        },
+        getCircuitBreakerState() {
+            return circuitBreaker?.getState() ?? null;
+        },
+    };
+    return service;
+}
+// Exchange addresses
+exports.POLYMARKET_EXCHANGES = {
+    CTF: POLY_CTF_EXCHANGE,
+    NEG_RISK_CTF: POLY_NEG_RISK_CTF_EXCHANGE,
+};
+// Re-export sub-modules
+__exportStar(require("./smart-router"), exports);
+__exportStar(require("./mev-protection"), exports);
+__exportStar(require("./circuit-breaker"), exports);
+__exportStar(require("./position-manager"), exports);
+__exportStar(require("./futures"), exports);
+__exportStar(require("./auto-redeem"), exports);
+__exportStar(require("./twap"), exports);
+__exportStar(require("./bracket-orders"), exports);
+__exportStar(require("./trigger-orders"), exports);
+__exportStar(require("./order-persistence"), exports);
+//# sourceMappingURL=index.js.map