clodds 1.5.1 → 1.5.2

package/dist/execution/index.js

@@ -974,9 +974,11 @@ async function placeKalshiOrder(auth, ticker, side, action, price, count, orderT
                     };
                 }
                 // Calculate slippage from mid price
-                const slippage = action === 'buy'
-                    ? (avgFillPrice - orderbook.midPrice) / orderbook.midPrice
-                    : (orderbook.midPrice - avgFillPrice) / orderbook.midPrice;
+                const slippage = orderbook.midPrice > 0
+                    ? (action === 'buy'
+                        ? (avgFillPrice - orderbook.midPrice) / orderbook.midPrice
+                        : (orderbook.midPrice - avgFillPrice) / orderbook.midPrice)
+                    : 0;
                 if (slippage > maxSlippage) {
                     return {
                         success: false,
@@ -1844,6 +1846,10 @@ function createExecutionService(config) {
     }
     // ==========================================================================
     function validateOrder(request) {
+        // Guard against NaN/Infinity values that would bypass all checks
+        if (!Number.isFinite(request.price) || !Number.isFinite(request.size)) {
+            return `Invalid order: price=${request.price}, size=${request.size} (must be finite numbers)`;
+        }
         // Circuit breaker check - block orders when tripped
         if (circuitBreaker && !circuitBreaker.canTrade()) {
             const state = circuitBreaker.getState();
@@ -1901,8 +1907,9 @@ function createExecutionService(config) {
                 }
             }
             catch (err) {
-                // Shield not loaded or RPC failure — log but don't block
-                logger_1.logger.debug({ err }, 'Security shield check skipped');
+                // Shield failure — log at warn level so it's visible; allow trade to proceed
+                // but flag it so operators know security was not verified
+                logger_1.logger.warn({ err }, 'Security shield check failed — trade proceeding without security verification');
             }
         }
         // Dry run mode
@@ -2242,133 +2249,132 @@ function createExecutionService(config) {
             }
         },
         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 = [];
+            // Track original indices so results are returned in the same order as input
+            const indexedOrders = orders.map((o, i) => ({ order: o, index: i }));
+            const resultsByIndex = new Array(orders.length);
+            const polyIndexed = indexedOrders.filter(o => o.order.platform === 'polymarket');
+            const kalshiIndexed = indexedOrders.filter(o => o.order.platform === 'kalshi');
+            const opinionIndexed = indexedOrders.filter(o => o.order.platform === 'opinion');
+            const predictfunIndexed = indexedOrders.filter(o => o.order.platform === 'predictfun');
+            const otherIndexed = indexedOrders.filter(o => o.order.platform !== 'opinion' && o.order.platform !== 'polymarket' && o.order.platform !== 'kalshi' && o.order.platform !== 'predictfun');
             // Execute Polymarket batch if we have Polymarket orders and config
-            if (polyOrders.length > 0 && config.polymarket) {
+            if (polyIndexed.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 batchInput = polyIndexed.map(o => ({
+                        tokenId: o.order.tokenId,
+                        side: o.order.side,
+                        price: o.order.price,
+                        size: o.order.size,
+                        negRisk: o.order.negRisk,
+                        postOnly: o.order.postOnly,
                     }));
                     const batchResults = await placePolymarketOrdersBatch(config.polymarket, batchInput);
-                    results.push(...batchResults);
+                    for (let i = 0; i < polyIndexed.length; i++) {
+                        resultsByIndex[polyIndexed[i].index] = batchResults[i] ?? { success: false, error: 'Missing batch result' };
+                    }
                 }
                 catch (err) {
-                    results.push(...polyOrders.map(() => ({
-                        success: false,
-                        error: err instanceof Error ? err.message : 'Batch order failed',
-                    })));
+                    for (const o of polyIndexed) {
+                        resultsByIndex[o.index] = { 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',
-                })));
+            else if (polyIndexed.length > 0) {
+                for (const o of polyIndexed) {
+                    resultsByIndex[o.index] = { success: false, error: 'Polymarket trading not configured' };
+                }
             }
             // Execute Kalshi batch if we have Kalshi orders and config
-            if (kalshiOrders.length > 0 && config.kalshi) {
+            if (kalshiIndexed.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 batchInput = kalshiIndexed.map(o => ({
+                        ticker: o.order.marketId,
+                        side: o.order.outcome?.toLowerCase() || 'yes',
+                        action: o.order.side,
+                        price: o.order.price,
+                        count: o.order.size,
                     }));
                     const batchResults = await placeKalshiOrdersBatch(config.kalshi, batchInput);
-                    results.push(...batchResults);
+                    for (let i = 0; i < kalshiIndexed.length; i++) {
+                        resultsByIndex[kalshiIndexed[i].index] = batchResults[i] ?? { success: false, error: 'Missing batch result' };
+                    }
                 }
                 catch (err) {
-                    results.push(...kalshiOrders.map(() => ({
-                        success: false,
-                        error: err instanceof Error ? err.message : 'Batch order failed',
-                    })));
+                    for (const o of kalshiIndexed) {
+                        resultsByIndex[o.index] = { 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',
-                })));
+            else if (kalshiIndexed.length > 0) {
+                for (const o of kalshiIndexed) {
+                    resultsByIndex[o.index] = { success: false, error: 'Kalshi trading not configured' };
+                }
             }
             // Execute Opinion batch if we have Opinion orders and config
-            if (opinionOrders.length > 0 && config.opinion) {
+            if (opinionIndexed.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 batchInput = opinionIndexed.map(o => ({
+                        marketId: parseInt(o.order.marketId, 10),
+                        tokenId: o.order.tokenId,
+                        side: o.order.side.toUpperCase(),
+                        price: o.order.price,
+                        amount: o.order.size,
                     }));
                     const batchResults = await placeOpinionOrdersBatch(config.opinion, batchInput);
-                    results.push(...batchResults.map(r => ({
-                        success: r.success,
-                        orderId: r.orderId,
-                        error: r.error,
-                    })));
+                    for (let i = 0; i < opinionIndexed.length; i++) {
+                        const r = batchResults[i];
+                        resultsByIndex[opinionIndexed[i].index] = r
+                            ? { success: r.success, orderId: r.orderId, error: r.error }
+                            : { success: false, error: 'Missing batch result' };
+                    }
                 }
                 catch (err) {
-                    // All Opinion orders failed
-                    results.push(...opinionOrders.map(() => ({
-                        success: false,
-                        error: err instanceof Error ? err.message : 'Batch order failed',
-                    })));
+                    for (const o of opinionIndexed) {
+                        resultsByIndex[o.index] = { 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',
-                })));
+            else if (opinionIndexed.length > 0) {
+                for (const o of opinionIndexed) {
+                    resultsByIndex[o.index] = { 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) {
+            if (predictfunIndexed.length > 0 && config.predictfun) {
+                for (const o of predictfunIndexed) {
                     try {
-                        const result = await placePredictFunOrder(config.predictfun, order.tokenId, order.side, order.price, order.size, order.marketId);
-                        results.push(result);
+                        const result = await placePredictFunOrder(config.predictfun, o.order.tokenId, o.order.side, o.order.price, o.order.size, o.order.marketId);
+                        resultsByIndex[o.index] = result;
                     }
                     catch (err) {
-                        results.push({
+                        resultsByIndex[o.index] = {
                             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',
-                })));
+            else if (predictfunIndexed.length > 0) {
+                for (const o of predictfunIndexed) {
+                    resultsByIndex[o.index] = { success: false, error: 'PredictFun trading not configured' };
+                }
             }
             // Execute other orders individually (fallback)
-            for (const order of otherOrders) {
+            for (const o of otherIndexed) {
                 try {
-                    const result = order.side === 'buy'
-                        ? await this.buyLimit(order)
-                        : await this.sellLimit(order);
-                    results.push(result);
+                    const result = o.order.side === 'buy'
+                        ? await this.buyLimit(o.order)
+                        : await this.sellLimit(o.order);
+                    resultsByIndex[o.index] = result;
                 }
                 catch (err) {
-                    results.push({
+                    resultsByIndex[o.index] = {
                         success: false,
                         error: err instanceof Error ? err.message : 'Order failed',
-                    });
+                    };
                 }
             }
+            const results = resultsByIndex;
             return results;
         },
         async cancelOrdersBatch(platform, orderIds) {