clodds 1.6.10 → 1.6.11

package/dist/execution/index.js

@@ -148,6 +148,29 @@ 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)
+/**
+ * Evict expired entries from module-level caches to prevent unbounded growth.
+ * Called periodically by the execution service.
+ */
+function evictExpiredCaches() {
+    const now = Date.now();
+    for (const [key, val] of tickSizeCache) {
+        if (now - val.cachedAt > 86400000)
+            tickSizeCache.delete(key); // 24h
+    }
+    for (const [key, val] of negRiskCache) {
+        if (now - val.cachedAt > 86400000)
+            negRiskCache.delete(key); // 24h
+    }
+    for (const [key, val] of feeRateCache) {
+        if (now - val.cachedAt > 3600000)
+            feeRateCache.delete(key); // 1h
+    }
+    for (const [key, val] of orderbookCache) {
+        if (now - val.cachedAt > 30000)
+            orderbookCache.delete(key); // 30s
+    }
+}
 // 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
@@ -361,12 +384,17 @@ async function getPolymarketBalance(auth, address) {
             headers: { 'Content-Type': 'application/json' },
             body: JSON.stringify({ jsonrpc: '2.0', method: 'eth_call', params: [{ to: USDC_POLYGON, data }, 'latest'], id: 1 }),
         });
+        if (!rpcResponse.ok) {
+            logger_1.logger.warn({ status: rpcResponse.status }, 'Polygon RPC error fetching balance');
+            throw new Error(`RPC error: ${rpcResponse.status}`);
+        }
         const rpcData = await rpcResponse.json();
-        const balance = parseInt(rpcData.result || '0x0', 16) / 1e6;
+        const rawBalance = BigInt(rpcData.result || '0x0');
+        const balance = Number(rawBalance) / 1e6;
         return { balance, allowance: balance };
     }
     catch (error) {
-        logger_1.logger.error({ error, walletAddress }, 'Failed to fetch Polymarket balance');
+        logger_1.logger.error({ error, walletAddress: walletAddress ? `${walletAddress.slice(0, 6)}...${walletAddress.slice(-4)}` : 'unknown' }, 'Failed to fetch Polymarket balance');
         return { balance: 0, allowance: 0 };
     }
 }
@@ -416,7 +444,7 @@ async function getPolymarketTrades(auth, limit = 100) {
             .map(t => ({
             id: t.transactionHash || '',
             tokenId: t.asset || '',
-            side: (t.side?.toUpperCase() || 'BUY'),
+            side: (t.side?.toUpperCase() ?? 'BUY'),
             price: t.price || 0,
             size: t.size || t.usdcSize || 0,
             timestamp: new Date((t.timestamp || 0) * 1000),
@@ -657,8 +685,14 @@ async function placePolymarketOrder(auth, tokenId, side, price, size, orderType
             headers: { ...headers, 'Content-Type': 'application/json' },
             body: JSON.stringify(order),
         });
+        if (!response.ok) {
+            const errorBody = await response.text().catch(() => '');
+            const redactedError = errorBody.slice(0, 200).replace(/0x[a-fA-F0-9]{20,}/g, '0x***').replace(/"(api[Kk]ey|secret|password|token)"\s*:\s*"[^"]+"/g, '"$1":"***"');
+            logger_1.logger.error({ status: response.status, errorBody: redactedError, tokenId, side, price, size }, 'Polymarket order failed');
+            return { success: false, error: `HTTP ${response.status}: ${redactedError}` };
+        }
         const data = (await response.json());
-        if (!response.ok || data.errorMsg) {
+        if (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}` };
@@ -1009,13 +1043,18 @@ async function placeKalshiOrder(auth, ticker, side, action, price, count, orderT
             logger_1.logger.warn({ err, ticker }, 'Failed to check slippage, proceeding with market order');
         }
     }
+    // FAK (Fill-and-Kill) is not natively supported on Kalshi; treat as FOK (closest equivalent)
+    if (orderType === 'FAK') {
+        logger_1.logger.warn('[execution] FAK order type not supported on Kalshi, using FOK instead');
+        orderType = 'FOK';
+    }
     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,
+        yes_price: side === 'yes' ? Math.round((effectivePrice + Number.EPSILON) * 100) : undefined,
+        no_price: side === 'no' ? Math.round((effectivePrice + Number.EPSILON) * 100) : undefined,
         count,
     };
     try {
@@ -1294,8 +1333,14 @@ async function placeOpinionOrder(auth, tokenId, side, price, size, orderType = '
     }
     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');
+    const marketId = parseInt(tokenId.split('-')[0], 10);
+    if (Number.isNaN(marketId)) {
+        throw new Error(`Invalid tokenId format: ${tokenId}`);
+    }
+    const result = await opinion.placeOrder(config, marketId, tokenId, side === 'buy' ? 'BUY' : 'SELL', price, size, (orderType === 'FOK' || orderType === 'FAK') ? 'MARKET' : 'LIMIT');
+    if (orderType === 'FAK') {
+        logger_1.logger.warn('[execution] FAK order type not supported on Opinion, using FOK/MARKET instead');
+    }
     return {
         success: result.success,
         orderId: result.orderId,
@@ -1586,6 +1631,10 @@ async function getPolymarketUSDCAllowance(ownerAddress, spenderAddress) {
                 id: 1,
             }),
         });
+        if (!response.ok) {
+            logger_1.logger.warn({ status: response.status }, 'Polygon RPC error fetching USDC allowance');
+            throw new Error(`RPC error: ${response.status}`);
+        }
         const result = await response.json();
         if (!result.result || result.result === '0x') {
             return 0;
@@ -1735,6 +1784,9 @@ function createExecutionService(config) {
         if (userWs?.isConnected()) {
             return;
         }
+        // Clean up any previous WebSocket before creating a new one to prevent
+        // listener accumulation on reconnect (each call adds on('fill'), etc.)
+        disconnectFillsWebSocket();
         const userId = config.polymarket.funderAddress || config.polymarket.apiKey;
         userWs = (0, user_ws_1.createUserWebSocket)(userId, {
             privateKey: config.polymarket.privateKey || '',
@@ -1763,6 +1815,7 @@ function createExecutionService(config) {
     // ==========================================================================
     let heartbeatId = null;
     let heartbeatInterval = null;
+    let heartbeatInProgress = false;
     const HEARTBEAT_INTERVAL_MS = 8000; // 8s to be safe (10s timeout)
     async function postHeartbeat(existingId) {
         if (!config.polymarket) {
@@ -1792,16 +1845,23 @@ function createExecutionService(config) {
         return data.heartbeat_id || existingId || '';
     }
     async function startHeartbeat() {
+        // Stop any existing interval before starting a new one to prevent
+        // duplicate intervals if startHeartbeat() is called twice.
         if (heartbeatInterval) {
-            // Already running, just return current ID
-            if (heartbeatId)
-                return heartbeatId;
+            clearInterval(heartbeatInterval);
+            heartbeatInterval = null;
         }
+        heartbeatInProgress = false;
         // Initial heartbeat
         heartbeatId = await postHeartbeat();
         logger_1.logger.info({ heartbeatId }, 'Polymarket heartbeat started');
-        // Start recurring heartbeat
+        // Start recurring heartbeat with overlap guard: if postHeartbeat takes
+        // longer than HEARTBEAT_INTERVAL_MS, skip the next tick instead of
+        // running two concurrent heartbeat requests.
         heartbeatInterval = setInterval(async () => {
+            if (heartbeatInProgress)
+                return;
+            heartbeatInProgress = true;
             try {
                 heartbeatId = await postHeartbeat(heartbeatId || undefined);
                 logger_1.logger.debug({ heartbeatId }, 'Heartbeat sent');
@@ -1809,6 +1869,9 @@ function createExecutionService(config) {
             catch (err) {
                 logger_1.logger.error({ err }, 'Heartbeat failed - orders may be cancelled');
             }
+            finally {
+                heartbeatInProgress = false;
+            }
         }, HEARTBEAT_INTERVAL_MS);
         return heartbeatId;
     }
@@ -1887,17 +1950,16 @@ function createExecutionService(config) {
     function recordOrderToCircuitBreaker(result, sizeUsd) {
         if (!circuitBreaker)
             return;
-        // Record as trade (P&L = 0 for now, actual P&L tracked on fills/closes)
+        // Record as trade (P&L = 0 at order time — actual P&L tracked on fills/closes).
+        // recordTrade already increments errorCount when success=false (line 251),
+        // so do NOT also call recordError() — that would double-count errors in both
+        // totalTrades and errorCount, inflating the error rate.
         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
@@ -1962,7 +2024,10 @@ function createExecutionService(config) {
             if (!config.kalshi) {
                 return { success: false, error: 'Kalshi not configured' };
             }
-            const outcome = request.outcome?.toLowerCase() || 'yes';
+            const outcome = (request.outcome?.toLowerCase() ?? 'yes');
+            if (outcome !== 'yes' && outcome !== 'no') {
+                return { success: false, error: `Invalid Kalshi outcome: ${request.outcome}. Must be 'yes' or 'no'.`, status: 'rejected' };
+            }
             return placeKalshiOrder(config.kalshi, request.marketId, outcome, request.side, request.price, request.size, request.orderType, request.maxSlippage);
         }
         if (request.platform === 'opinion') {
@@ -2044,47 +2109,71 @@ function createExecutionService(config) {
                 return 0;
             }
             let count = 0;
+            const errors = [];
             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');
+                try {
+                    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');
+                    }
+                }
+                catch (err) {
+                    errors.push(`Polymarket: ${err.message}`);
                 }
             }
             // 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;
+                try {
+                    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;
+                    }
+                }
+                catch (err) {
+                    errors.push(`Kalshi: ${err.message}`);
                 }
             }
             // Opinion: use SDK's cancelAllOrders (handles batch internally)
             if ((!platform || platform === 'opinion') && config.opinion) {
-                count += await cancelAllOpinionOrders(config.opinion, marketId);
+                try {
+                    count += await cancelAllOpinionOrders(config.opinion, marketId);
+                }
+                catch (err) {
+                    errors.push(`Opinion: ${err.message}`);
+                }
             }
             // 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++;
+                try {
+                    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);
+                    }
                 }
-                else {
-                    count += await cancelAllPredictFunOrders(config.predictfun);
+                catch (err) {
+                    errors.push(`PredictFun: ${err.message}`);
                 }
             }
+            if (errors.length > 0) {
+                logger_1.logger.warn({ errors }, 'Some platforms failed during cancelAllOrders');
+            }
             return count;
         },
         async getOpenOrders(platform) {
@@ -2473,18 +2562,27 @@ function createExecutionService(config) {
         clearOldFills(maxAgeMs = 3600000) {
             const now = Date.now();
             let cleared = 0;
+            // Collect keys to delete first to avoid mutation during iteration
+            const toDelete = [];
             for (const [orderId, fill] of trackedFills) {
                 if (now - fill.receivedAt > maxAgeMs) {
-                    trackedFills.delete(orderId);
-                    cleared++;
+                    toDelete.push(orderId);
                 }
             }
+            for (const orderId of toDelete) {
+                trackedFills.delete(orderId);
+                cleared++;
+            }
             // Also clear old orders
+            const ordersToDelete = [];
             for (const [orderId, order] of trackedOrders) {
                 if (now - order.receivedAt > maxAgeMs) {
-                    trackedOrders.delete(orderId);
+                    ordersToDelete.push(orderId);
                 }
             }
+            for (const orderId of ordersToDelete) {
+                trackedOrders.delete(orderId);
+            }
             return cleared;
         },
         waitForFill(orderId, timeoutMs) {
@@ -2563,6 +2661,10 @@ function createExecutionService(config) {
                 clearInterval(fillCleanupInterval);
                 fillCleanupInterval = null;
             }
+            if (cacheEvictionInterval) {
+                clearInterval(cacheEvictionInterval);
+                cacheEvictionInterval = null;
+            }
         },
     };
     // Periodic cleanup of old tracked fills/orders (every 10 minutes)
@@ -2574,6 +2676,10 @@ function createExecutionService(config) {
     }, 10 * 60 * 1000);
     fillCleanupTimer.unref();
     let fillCleanupInterval = fillCleanupTimer;
+    // Periodic eviction of expired module-level caches (every 60 seconds)
+    const cacheEvictionTimer = setInterval(evictExpiredCaches, 60000);
+    cacheEvictionTimer.unref();
+    let cacheEvictionInterval = cacheEvictionTimer;
     return service;
 }
 // Exchange addresses