dexbot 1.3.3 → 1.4.1

package/dist/modules/order/utils/validate.js

@@ -31,17 +31,71 @@
  *
  * ===============================================================================
  */
+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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VALID_ORDER_TYPES = exports.VALID_ORDER_STATES = void 0;
+exports.validateOrder = validateOrder;
+exports.validateGridForPersistence = validateGridForPersistence;
+exports.calculateRequiredFunds = calculateRequiredFunds;
+exports.validateWorkingGridFunds = validateWorkingGridFunds;
+exports.checkFundDrift = checkFundDrift;
+exports.reconcileGrid = reconcileGrid;
+exports.optimizeRebalanceActions = optimizeRebalanceActions;
+exports.summarizeActions = summarizeActions;
+exports.hasExecutableActions = hasExecutableActions;
+exports.validateCreateTargetSlots = validateCreateTargetSlots;
+exports.hasActionForOrder = hasActionForOrder;
+exports.removeActionsForOrder = removeActionsForOrder;
+exports.projectTargetToWorkingGrid = projectTargetToWorkingGrid;
+exports.buildStateUpdates = buildStateUpdates;
+exports.buildAbortedResult = buildAbortedResult;
+exports.buildSuccessResult = buildSuccessResult;
+exports.evaluateCommit = evaluateCommit;
 // ===============================================================================
 // SECTION 1: EXTERNAL DEPENDENCIES
 // ===============================================================================
-const { ORDER_STATES, ORDER_TYPES, COW_ACTIONS, GRID_LIMITS } = require('../../constants');
-const { floatToBlockchainInt, blockchainToFloat, getPrecisionSlack, getDoubleDustThreshold } = require('./math');
-const { isOrderOnChain, isPhantomOrder, convertToSpreadPlaceholder } = require('./order');
-const Format = require('../format');
+const Format = __importStar(require("../format"));
+const constants_1 = require("../../constants");
+const math_1 = require("./math");
+const order_1 = require("./order");
 const { isValidNumber, toFiniteNumber } = Format;
 // Pre-computed valid sets
-const VALID_ORDER_STATES = new Set(Object.values(ORDER_STATES));
-const VALID_ORDER_TYPES = new Set(Object.values(ORDER_TYPES));
+const VALID_ORDER_STATES = new Set(Object.values(constants_1.ORDER_STATES));
+exports.VALID_ORDER_STATES = VALID_ORDER_STATES;
+const VALID_ORDER_TYPES = new Set(Object.values(constants_1.ORDER_TYPES));
+exports.VALID_ORDER_TYPES = VALID_ORDER_TYPES;
 // ===============================================================================
 // SECTION 2: VALIDATION
 // ===============================================================================
@@ -60,10 +114,10 @@ function validateOrder(order, oldOrder = null, context = 'validate') {
         errors.push({ code: 'MISSING_ID', message: 'Refusing to update order: missing ID' });
         return { isValid: false, errors, warnings, normalizedOrder: null };
     }
-    if (!normalizedOrder.type && normalizedOrder.state === ORDER_STATES.VIRTUAL) {
+    if (!normalizedOrder.type && normalizedOrder.state === constants_1.ORDER_STATES.VIRTUAL) {
         const placeholderSize = toFiniteNumber(normalizedOrder.size);
         if (placeholderSize === 0) {
-            normalizedOrder.type = ORDER_TYPES.SPREAD;
+            normalizedOrder.type = constants_1.ORDER_TYPES.SPREAD;
         }
     }
     if (!VALID_ORDER_STATES.has(normalizedOrder.state)) {
@@ -78,47 +132,47 @@ function validateOrder(order, oldOrder = null, context = 'validate') {
             message: `Refusing to update order ${order.id}: invalid type '${normalizedOrder.type}' (context: ${context})`
         });
     }
-    if (normalizedOrder.type === ORDER_TYPES.SPREAD && toFiniteNumber(normalizedOrder.size) !== 0) {
+    if (normalizedOrder.type === constants_1.ORDER_TYPES.SPREAD && toFiniteNumber(normalizedOrder.size) !== 0) {
         warnings.push({
             code: 'SPREAD_SIZE_NORMALIZED',
             message: `[INVARIANT] Normalizing SPREAD order ${order.id} size ${normalizedOrder.size} -> 0 (context: ${context})`
         });
         normalizedOrder.size = 0;
     }
-    const isOnChainState = (normalizedOrder.state === ORDER_STATES.ACTIVE ||
-        normalizedOrder.state === ORDER_STATES.PARTIAL);
-    if (normalizedOrder.type === ORDER_TYPES.SPREAD && isOnChainState) {
+    const isOnChainState = (normalizedOrder.state === constants_1.ORDER_STATES.ACTIVE ||
+        normalizedOrder.state === constants_1.ORDER_STATES.PARTIAL);
+    if (normalizedOrder.type === constants_1.ORDER_TYPES.SPREAD && isOnChainState) {
         errors.push({
             code: 'ILLEGAL_SPREAD_STATE',
             message: `ILLEGAL STATE: Refusing to move SPREAD order ${order.id} to ${normalizedOrder.state}. SPREAD orders must remain VIRTUAL.`,
             isFatal: true
         });
     }
-    if (isPhantomOrder(normalizedOrder)) {
+    if ((0, order_1.isPhantomOrder)(normalizedOrder)) {
         errors.push({
             code: 'PHANTOM_ORDER',
             message: `ILLEGAL STATE: Refusing to set order ${order.id} to ${normalizedOrder.state} without orderId. Context: ${context}. This would create a phantom order that doubles fund tracking.`,
             autoCorrect: {
-                state: ORDER_STATES.VIRTUAL,
+                state: constants_1.ORDER_STATES.VIRTUAL,
                 orderId: null,
                 rawOnChain: null,
                 size: 0
             }
         });
     }
-    if (normalizedOrder.type === ORDER_TYPES.BUY || normalizedOrder.type === ORDER_TYPES.SELL) {
+    if (normalizedOrder.type === constants_1.ORDER_TYPES.BUY || normalizedOrder.type === constants_1.ORDER_TYPES.SELL) {
         normalizedOrder.committedSide = normalizedOrder.type;
     }
     else if (!normalizedOrder.committedSide && oldOrder) {
         if (oldOrder.committedSide) {
             normalizedOrder.committedSide = oldOrder.committedSide;
         }
-        else if (oldOrder.type === ORDER_TYPES.BUY || oldOrder.type === ORDER_TYPES.SELL) {
+        else if (oldOrder.type === constants_1.ORDER_TYPES.BUY || oldOrder.type === constants_1.ORDER_TYPES.SELL) {
             normalizedOrder.committedSide = oldOrder.type;
         }
     }
     return {
-        isValid: errors.length === 0 || !errors.some(e => e.isFatal),
+        isValid: errors.length === 0 || !errors.some((e) => e.isFatal),
         errors,
         warnings,
         normalizedOrder
@@ -132,7 +186,7 @@ function validateOrder(order, oldOrder = null, context = 'validate') {
  */
 function validateGridForPersistence(orders, accountTotals) {
     for (const order of orders.values()) {
-        if (isPhantomOrder(order)) {
+        if ((0, order_1.isPhantomOrder)(order)) {
             return {
                 isValid: false,
                 reason: `Phantom order detected: order ${order.id} is ${order.state} but has no orderId`
@@ -161,21 +215,21 @@ function calculateRequiredFunds(grid, precisions = {}) {
     for (const order of grid.values()) {
         const size = toFiniteNumber(order.size ?? order.amount);
         const state = order.state;
-        const isActive = state === ORDER_STATES.ACTIVE || state === ORDER_STATES.PARTIAL;
-        if (isActive && isOrderOnChain(order)) {
-            if (order.type === ORDER_TYPES.BUY) {
-                buyRequiredInt += floatToBlockchainInt(size, buyPrecision);
+        const isActive = state === constants_1.ORDER_STATES.ACTIVE || state === constants_1.ORDER_STATES.PARTIAL;
+        if (isActive && (0, order_1.isOrderOnChain)(order)) {
+            if (order.type === constants_1.ORDER_TYPES.BUY) {
+                buyRequiredInt += (0, math_1.floatToBlockchainInt)(size, buyPrecision);
             }
-            else if (order.type === ORDER_TYPES.SELL) {
-                sellRequiredInt += floatToBlockchainInt(size, sellPrecision);
+            else if (order.type === constants_1.ORDER_TYPES.SELL) {
+                sellRequiredInt += (0, math_1.floatToBlockchainInt)(size, sellPrecision);
             }
         }
     }
     return {
         buyInt: buyRequiredInt,
         sellInt: sellRequiredInt,
-        buy: blockchainToFloat(buyRequiredInt, buyPrecision),
-        sell: blockchainToFloat(sellRequiredInt, sellPrecision)
+        buy: (0, math_1.blockchainToFloat)(buyRequiredInt, buyPrecision),
+        sell: (0, math_1.blockchainToFloat)(sellRequiredInt, sellPrecision)
     };
 }
 /**
@@ -201,26 +255,26 @@ function validateWorkingGridFunds(workingGrid, projectedFunds, precisions = {},
             ? Number(projectedFunds.chainTotalSell)
             : toFiniteNumber(projectedFunds?.freeSell ?? projectedFunds?.chainFreeSell);
     const shortfalls = [];
-    const availableBuyInt = floatToBlockchainInt(availableBuy, buyPrecision);
-    const availableSellInt = floatToBlockchainInt(availableSell, sellPrecision);
+    const availableBuyInt = (0, math_1.floatToBlockchainInt)(availableBuy, buyPrecision);
+    const availableSellInt = (0, math_1.floatToBlockchainInt)(availableSell, sellPrecision);
     if (required.buyInt > availableBuyInt) {
-        const requiredBuyFloat = blockchainToFloat(required.buyInt, buyPrecision);
-        const availableBuyFloat = blockchainToFloat(availableBuyInt, buyPrecision);
+        const requiredBuyFloat = (0, math_1.blockchainToFloat)(required.buyInt, buyPrecision);
+        const availableBuyFloat = (0, math_1.blockchainToFloat)(availableBuyInt, buyPrecision);
         shortfalls.push({
             asset: assets?.assetB?.symbol || 'buyAsset',
             required: requiredBuyFloat,
             available: availableBuyFloat,
-            deficit: blockchainToFloat(required.buyInt - availableBuyInt, buyPrecision)
+            deficit: (0, math_1.blockchainToFloat)(required.buyInt - availableBuyInt, buyPrecision)
         });
     }
     if (required.sellInt > availableSellInt) {
-        const requiredSellFloat = blockchainToFloat(required.sellInt, sellPrecision);
-        const availableSellFloat = blockchainToFloat(availableSellInt, sellPrecision);
+        const requiredSellFloat = (0, math_1.blockchainToFloat)(required.sellInt, sellPrecision);
+        const availableSellFloat = (0, math_1.blockchainToFloat)(availableSellInt, sellPrecision);
         shortfalls.push({
             asset: assets?.assetA?.symbol || 'sellAsset',
             required: requiredSellFloat,
             available: availableSellFloat,
-            deficit: blockchainToFloat(required.sellInt - availableSellInt, sellPrecision)
+            deficit: (0, math_1.blockchainToFloat)(required.sellInt - availableSellInt, sellPrecision)
         });
     }
     return {
@@ -242,11 +296,11 @@ function checkFundDrift(orders, accountTotals, assets = null, gridLimits = null)
     let gridBuy = 0, gridSell = 0;
     for (const order of Array.from(orders.values())) {
         const size = toFiniteNumber(order.size);
-        if (size <= 0 || !isOrderOnChain(order))
+        if (size <= 0 || !(0, order_1.isOrderOnChain)(order))
             continue;
-        if (order.type === ORDER_TYPES.BUY)
+        if (order.type === constants_1.ORDER_TYPES.BUY)
             gridBuy += size;
-        else if (order.type === ORDER_TYPES.SELL)
+        else if (order.type === constants_1.ORDER_TYPES.SELL)
             gridSell += size;
     }
     const chainFreeBuy = accountTotals?.buyFree || 0;
@@ -262,9 +316,9 @@ function checkFundDrift(orders, accountTotals, assets = null, gridLimits = null)
     if (!isValidNumber(buyPrecision) || !isValidNumber(sellPrecision)) {
         return { isValid: true, reason: 'Skipped: precision not available', driftBuy, driftSell };
     }
-    const precisionSlackBuy = getPrecisionSlack(buyPrecision);
-    const precisionSlackSell = getPrecisionSlack(sellPrecision);
-    const fundInvariantTolerance = gridLimits?.FUND_INVARIANT_PERCENT_TOLERANCE ?? GRID_LIMITS.FUND_INVARIANT_PERCENT_TOLERANCE;
+    const precisionSlackBuy = (0, math_1.getPrecisionSlack)(buyPrecision);
+    const precisionSlackSell = (0, math_1.getPrecisionSlack)(sellPrecision);
+    const fundInvariantTolerance = gridLimits?.FUND_INVARIANT_PERCENT_TOLERANCE ?? constants_1.GRID_LIMITS.FUND_INVARIANT_PERCENT_TOLERANCE;
     const percentTolerance = fundInvariantTolerance / 100;
     const allowedDriftBuy = Math.max(precisionSlackBuy, actualBuy * percentTolerance);
     const allowedDriftSell = Math.max(precisionSlackSell, actualSell * percentTolerance);
@@ -307,7 +361,7 @@ function reconcileGrid(masterGrid, targetGrid, targetBoundary, options = {}) {
         const idealSize = toFiniteNumber(order.idealSize || order.size);
         if (idealSize <= 0)
             return true;
-        const minHealthy = getDoubleDustThreshold(idealSize, dustThresholdPercent);
+        const minHealthy = (0, math_1.getDoubleDustThreshold)(idealSize, dustThresholdPercent);
         if (order.size < minHealthy) {
             if (logger) {
                 logger(`[RECONCILE] Skipping dust target order: ${order.id} ` +
@@ -331,40 +385,40 @@ function reconcileGrid(masterGrid, targetGrid, targetBoundary, options = {}) {
     }
     for (const [id, targetOrder] of targetGrid) {
         const masterOrder = masterGrid.get(id);
-        if (!masterOrder || masterOrder.state === ORDER_STATES.VIRTUAL) {
+        if (!masterOrder || masterOrder.state === constants_1.ORDER_STATES.VIRTUAL) {
             // Slot is empty or virtual - check if we need to fill it
-            if (targetOrder.size > 0 && targetOrder.state === ORDER_STATES.ACTIVE) {
+            if (targetOrder.size > 0 && targetOrder.state === constants_1.ORDER_STATES.ACTIVE) {
                 // This is a hole that needs filling
-                if (targetOrder.type === ORDER_TYPES.BUY) {
+                if (targetOrder.type === constants_1.ORDER_TYPES.BUY) {
                     holesBuy.push({ id, order: targetOrder });
                 }
-                else if (targetOrder.type === ORDER_TYPES.SELL) {
+                else if (targetOrder.type === constants_1.ORDER_TYPES.SELL) {
                     holesSell.push({ id, order: targetOrder });
                 }
             }
             continue;
         }
         if (masterOrder.type !== targetOrder.type) {
-            actions.push({ type: COW_ACTIONS.CANCEL, id, orderId: masterOrder.orderId, reason: 'type-mismatch' });
-            if (targetOrder.size > 0 && targetOrder.state === ORDER_STATES.ACTIVE && isCreateHealthy(targetOrder)) {
-                actions.push({ type: COW_ACTIONS.CREATE, id, order: targetOrder });
+            actions.push({ type: constants_1.COW_ACTIONS.CANCEL, id, orderId: masterOrder.orderId, reason: 'type-mismatch' });
+            if (targetOrder.size > 0 && targetOrder.state === constants_1.ORDER_STATES.ACTIVE && isCreateHealthy(targetOrder)) {
+                actions.push({ type: constants_1.COW_ACTIONS.CREATE, id, order: targetOrder });
             }
             continue;
         }
         // If master is on-chain but target should be VIRTUAL (outside window),
         // this is a surplus candidate for rotation.
-        if (isOrderOnChain(masterOrder) && targetOrder.state === ORDER_STATES.VIRTUAL) {
-            if (masterOrder.type === ORDER_TYPES.BUY) {
+        if ((0, order_1.isOrderOnChain)(masterOrder) && targetOrder.state === constants_1.ORDER_STATES.VIRTUAL) {
+            if (masterOrder.type === constants_1.ORDER_TYPES.BUY) {
                 surplusesBuy.push({ id, master: masterOrder, target: targetOrder });
             }
-            else if (masterOrder.type === ORDER_TYPES.SELL) {
+            else if (masterOrder.type === constants_1.ORDER_TYPES.SELL) {
                 surplusesSell.push({ id, master: masterOrder, target: targetOrder });
             }
             continue;
         }
         if (masterOrder.size !== targetOrder.size) {
             if (targetOrder.size === 0) {
-                actions.push({ type: COW_ACTIONS.CANCEL, id, orderId: masterOrder.orderId, reason: 'target-size-zero' });
+                actions.push({ type: constants_1.COW_ACTIONS.CANCEL, id, orderId: masterOrder.orderId, reason: 'target-size-zero' });
             }
             // Intentionally no in-place size UPDATE here.
             // Fill-driven COW rebalance keeps updates rotation-only (newGridId path).
@@ -375,12 +429,12 @@ function reconcileGrid(masterGrid, targetGrid, targetBoundary, options = {}) {
     const cancelSurpluses = (surpluses) => {
         for (const surplus of surpluses) {
             if (surplus.master.orderId) {
-                actions.push({ type: COW_ACTIONS.CANCEL, id: surplus.id, orderId: surplus.master.orderId, reason: 'surplus-no-rotation-target' });
+                actions.push({ type: constants_1.COW_ACTIONS.CANCEL, id: surplus.id, orderId: surplus.master.orderId, reason: 'surplus-no-rotation-target' });
             }
         }
     };
     const pairRotations = (surpluses, holes) => {
-        const healthyHoles = holes.filter(hole => isCreateHealthy(hole.order));
+        const healthyHoles = holes.filter((hole) => isCreateHealthy(hole.order));
         if (healthyHoles.length === 0) {
             // No viable rotation targets — cancel all unmatched surpluses
             cancelSurpluses(surpluses);
@@ -388,11 +442,11 @@ function reconcileGrid(masterGrid, targetGrid, targetBoundary, options = {}) {
         }
         if (surpluses.length === 0) {
             for (const hole of healthyHoles) {
-                actions.push({ type: COW_ACTIONS.CREATE, id: hole.id, order: hole.order });
+                actions.push({ type: constants_1.COW_ACTIONS.CREATE, id: hole.id, order: hole.order });
             }
             return;
         }
-        const isBuy = surpluses[0]?.master?.type === ORDER_TYPES.BUY;
+        const isBuy = surpluses[0]?.master?.type === constants_1.ORDER_TYPES.BUY;
         healthyHoles.sort((a, b) => isBuy ? b.order.price - a.order.price : a.order.price - b.order.price);
         surpluses.sort((a, b) => isBuy ? a.master.price - b.master.price : b.master.price - a.master.price);
         const rotationCount = Math.min(surpluses.length, healthyHoles.length);
@@ -400,7 +454,7 @@ function reconcileGrid(masterGrid, targetGrid, targetBoundary, options = {}) {
             const surplus = surpluses[i];
             const hole = healthyHoles[i];
             actions.push({
-                type: COW_ACTIONS.UPDATE,
+                type: constants_1.COW_ACTIONS.UPDATE,
                 id: surplus.id,
                 orderId: surplus.master.orderId,
                 newGridId: hole.id,
@@ -411,7 +465,7 @@ function reconcileGrid(masterGrid, targetGrid, targetBoundary, options = {}) {
             });
         }
         for (let i = rotationCount; i < healthyHoles.length; i++) {
-            actions.push({ type: COW_ACTIONS.CREATE, id: healthyHoles[i].id, order: healthyHoles[i].order });
+            actions.push({ type: constants_1.COW_ACTIONS.CREATE, id: healthyHoles[i].id, order: healthyHoles[i].order });
         }
         // Cancel any surpluses that couldn't be paired with a hole
         cancelSurpluses(surpluses.slice(rotationCount));
@@ -419,8 +473,8 @@ function reconcileGrid(masterGrid, targetGrid, targetBoundary, options = {}) {
     pairRotations(surplusesBuy, holesBuy);
     pairRotations(surplusesSell, holesSell);
     for (const [id, masterOrder] of masterGrid) {
-        if (!targetGrid.has(id) && isOrderOnChain(masterOrder)) {
-            actions.push({ type: COW_ACTIONS.CANCEL, id, orderId: masterOrder.orderId, reason: 'orphan-slot' });
+        if (!targetGrid.has(id) && (0, order_1.isOrderOnChain)(masterOrder)) {
+            actions.push({ type: constants_1.COW_ACTIONS.CANCEL, id, orderId: masterOrder.orderId, reason: 'orphan-slot' });
         }
     }
     return {
@@ -446,10 +500,10 @@ function optimizeRebalanceActions(actions, masterGrid) {
     const cancels = [];
     const passthrough = [];
     for (const action of actions) {
-        if (action?.type === COW_ACTIONS.CREATE) {
+        if (action?.type === constants_1.COW_ACTIONS.CREATE) {
             creates.push(action);
         }
-        else if (action?.type === COW_ACTIONS.CANCEL) {
+        else if (action?.type === constants_1.COW_ACTIONS.CANCEL) {
             cancels.push(action);
         }
         else {
@@ -489,7 +543,7 @@ function optimizeRebalanceActions(actions, masterGrid) {
         }
         const createAction = remainingCreates.splice(bestIdx, 1)[0];
         optimized.push({
-            type: COW_ACTIONS.UPDATE,
+            type: constants_1.COW_ACTIONS.UPDATE,
             id: cancelAction.id,
             orderId: cancelAction.orderId,
             newGridId: createAction.id,
@@ -512,9 +566,9 @@ function optimizeRebalanceActions(actions, masterGrid) {
 function summarizeActions(actions) {
     return {
         total: actions.length,
-        creates: actions.filter(a => a.type === COW_ACTIONS.CREATE).length,
-        cancels: actions.filter(a => a.type === COW_ACTIONS.CANCEL).length,
-        updates: actions.filter(a => a.type === COW_ACTIONS.UPDATE).length
+        creates: actions.filter((a) => a.type === constants_1.COW_ACTIONS.CREATE).length,
+        cancels: actions.filter((a) => a.type === constants_1.COW_ACTIONS.CANCEL).length,
+        updates: actions.filter((a) => a.type === constants_1.COW_ACTIONS.UPDATE).length
     };
 }
 /**
@@ -528,23 +582,33 @@ function hasExecutableActions(rebalanceResult) {
     return Array.isArray(actions) && actions.length > 0;
 }
 /**
- * Validate that CREATE actions target slots that are not already occupied on-chain.
- * Cancelled or rotation-released slots are considered free.
+ * Validate that CREATE actions target slots that are not already occupied on-chain
+ * and that no CREATE price collides with an existing placed order or unmatched
+ * on-chain order.  Checks four layers:
+ *   1. Slot occupancy — target grid slot already has a placed order
+ *   2. Master grid price collision — a placed order in the grid has the same price
+ *   3. Chain orphan collision — an unmatched on-chain order has the same price
+ *   4. Same-batch duplicate — two CREATEs in the same batch have identical prices
+ *
+ * Cancel and rotation-released slots are considered free.
  *
  * @param {Array<import('./types').CowAction>} actions - List of COW actions
  * @param {Map} orders - Current order grid
- * @returns {{isValid: boolean, violations: Array<Object>}} Validation result with any violations
+ * @param {Object|null} [assets=null] - Asset metadata for tolerance calculation
+ * @param {Array<Object>} [chainOrderCandidates=[]] - Unmatched on-chain orders
+ *   with {chainOrderId, price, size, type} to check beyond the grid
+ * @returns {{isValid: boolean, violations: Array<Object>}} Validation result
  */
-function validateCreateTargetSlots(actions, orders) {
+function validateCreateTargetSlots(actions, orders, assets = null, chainOrderCandidates = []) {
     const safeActions = Array.isArray(actions) ? actions : [];
     const orderMap = orders instanceof Map ? orders : new Map();
     const releasedSlotIds = new Set();
     for (const action of safeActions) {
-        if (action?.type === COW_ACTIONS.CANCEL && action.id) {
+        if (action?.type === constants_1.COW_ACTIONS.CANCEL && action.id) {
             releasedSlotIds.add(action.id);
             continue;
         }
-        if (action?.type === COW_ACTIONS.UPDATE &&
+        if (action?.type === constants_1.COW_ACTIONS.UPDATE &&
             action.id &&
             action.newGridId &&
             action.newGridId !== action.id) {
@@ -552,23 +616,99 @@ function validateCreateTargetSlots(actions, orders) {
         }
     }
     const violations = [];
+    const createEntries = [];
     for (const action of safeActions) {
-        if (action?.type !== COW_ACTIONS.CREATE)
+        if (action?.type !== constants_1.COW_ACTIONS.CREATE)
             continue;
         const targetId = action.id || action.order?.id;
         if (!targetId || releasedSlotIds.has(targetId))
             continue;
         const current = orderMap.get(targetId);
-        if (!current)
-            continue;
-        if (isOrderOnChain(current)) {
+        // isOrderOnChain already checks orderId is truthy
+        if (current && (0, order_1.isOrderOnChain)(current)) {
             violations.push({
                 targetId,
                 currentOrderId: current.orderId,
                 currentType: current.type,
-                currentState: current.state
+                currentState: current.state,
+                reason: 'slot_occupied'
             });
         }
+        if (action.order?.price != null && action.order?.type != null) {
+            const liveSlot = orderMap.get(targetId);
+            const livePrice = liveSlot && Number.isFinite(Number(liveSlot.price))
+                ? Number(liveSlot.price)
+                : null;
+            const effectivePrice = livePrice !== null ? livePrice : Number(action.order.price);
+            createEntries.push({
+                targetId,
+                action,
+                price: effectivePrice,
+                size: Number(action.order.size || 0),
+                type: action.order.type,
+            });
+        }
+    }
+    if (assets && createEntries.length > 0) {
+        for (const entry of createEntries) {
+            const collision = (0, math_1.findPriceCollision)(orderMap.values(), entry.targetId, entry.price, entry.size, entry.type, assets, (o) => (0, order_1.isOrderPlaced)(o) && o.id !== entry.targetId);
+            if (collision) {
+                violations.push({
+                    targetId: entry.targetId,
+                    currentOrderId: collision.orderId,
+                    currentType: entry.type,
+                    currentState: collision.state,
+                    reason: 'price_collision',
+                });
+            }
+        }
+        // Filter out malformed chain entries (missing chainOrderId); all production
+        // set sites guard this, but a defensive skip prevents crashes on
+        // unexpected data shapes during development or deserialization.
+        const validChainCandidates = chainOrderCandidates.length > 0
+            ? chainOrderCandidates.filter((u) => u.chainOrderId && typeof u.price === 'number')
+            : [];
+        if (validChainCandidates.length > 0) {
+            const mapped = validChainCandidates.map((u) => ({
+                id: u.chainOrderId,
+                price: u.price,
+                size: u.size || 0,
+                orderId: u.chainOrderId,
+            }));
+            for (const entry of createEntries) {
+                const chainCollision = (0, math_1.findPriceCollision)(mapped, entry.targetId, entry.price, entry.size, entry.type, assets, (item) => item.price != null);
+                if (chainCollision) {
+                    violations.push({
+                        targetId: entry.targetId,
+                        currentOrderId: chainCollision.orderId,
+                        currentType: entry.type,
+                        currentState: 'CHAIN_ORPHAN',
+                        reason: 'chain_orphan_collision',
+                    });
+                }
+            }
+        }
+        // Exact-equality sanity net: same-batch CREATEs from the same calculation
+        // produce identical float prices.  1e-8 is far below any precision-based
+        // tolerance (calculatePriceTolerance returns ~1e-5 at minimum), so this
+        // strictly catches bit-identical duplicates — not near-matches.  Near-matches
+        // are caught by the tolerance-based findPriceCollision check below in the
+        // COW loop's batchCollision guard.
+        for (let i = 0; i < createEntries.length; i++) {
+            for (let j = i + 1; j < createEntries.length; j++) {
+                const a = createEntries[i];
+                const b = createEntries[j];
+                if (Math.abs(a.price - b.price) <= 1e-8) {
+                    violations.push({
+                        targetId: b.targetId,
+                        currentOrderId: null,
+                        currentType: b.type,
+                        currentState: 'CREATE',
+                        reason: 'same_batch_price_collision',
+                    });
+                }
+            }
+        }
     }
     return {
         isValid: violations.length === 0,
@@ -602,7 +742,7 @@ function actionMatchesOrder(action, orderRef) {
 function hasActionForOrder(actions, actionType, orderRef) {
     if (!Array.isArray(actions))
         return false;
-    return actions.some(action => {
+    return actions.some((action) => {
         if (actionType && action?.type !== actionType)
             return false;
         return actionMatchesOrder(action, orderRef);
@@ -643,7 +783,7 @@ function _buildUpdateSelectors(actions) {
     if (!Array.isArray(actions))
         return selectors;
     for (const action of actions) {
-        if (action?.type !== COW_ACTIONS.UPDATE)
+        if (action?.type !== constants_1.COW_ACTIONS.UPDATE)
             continue;
         if (action.id)
             selectors.slotIds.add(String(action.id));
@@ -708,13 +848,13 @@ function projectTargetToWorkingGrid(workingGrid, targetGrid, options = {}) {
             workingGrid.set(id, {
                 ...targetOrder,
                 size: Math.max(0, targetSize),
-                state: ORDER_STATES.VIRTUAL,
+                state: constants_1.ORDER_STATES.VIRTUAL,
                 orderId: null
             });
             continue;
         }
         if (targetSize > 0) {
-            const keepOrderId = isOrderOnChain(current) && current.type === targetOrder.type;
+            const keepOrderId = (0, order_1.isOrderOnChain)(current) && current.type === targetOrder.type;
             const hasExplicitUpdate = _hasExplicitUpdateForOrder(updateSelectors, current, id);
             // Orders without on-chain ID remain VIRTUAL until synchronizeWithChain
             // confirms blockchain placement and triggers accounting deduction.
@@ -727,7 +867,7 @@ function projectTargetToWorkingGrid(workingGrid, targetGrid, options = {}) {
             const preservedSize = shouldPreserveSize
                 ? Math.max(0, toFiniteNumber(current.size))
                 : targetSize;
-            const resultState = keepOrderId ? current.state : ORDER_STATES.VIRTUAL;
+            const resultState = keepOrderId ? current.state : constants_1.ORDER_STATES.VIRTUAL;
             const resultOrderId = keepOrderId ? current.orderId : null;
             if (!_isProjectionUnchanged(current, targetOrder, preservedSize, resultState, resultOrderId)) {
                 workingGrid.set(id, {
@@ -740,12 +880,12 @@ function projectTargetToWorkingGrid(workingGrid, targetGrid, options = {}) {
             }
         }
         else {
-            if (!_isProjectionUnchanged(current, targetOrder, 0, ORDER_STATES.VIRTUAL, null)) {
+            if (!_isProjectionUnchanged(current, targetOrder, 0, constants_1.ORDER_STATES.VIRTUAL, null)) {
                 workingGrid.set(id, {
                     ...current,
                     ...targetOrder,
                     size: 0,
-                    state: ORDER_STATES.VIRTUAL,
+                    state: constants_1.ORDER_STATES.VIRTUAL,
                     orderId: null
                 });
             }
@@ -754,8 +894,8 @@ function projectTargetToWorkingGrid(workingGrid, targetGrid, options = {}) {
     for (const [id, current] of workingGrid.entries()) {
         if (targetIds.has(id))
             continue;
-        if (isOrderOnChain(current)) {
-            workingGrid.set(id, convertToSpreadPlaceholder(current));
+        if ((0, order_1.isOrderOnChain)(current)) {
+            workingGrid.set(id, (0, order_1.convertToSpreadPlaceholder)(current));
         }
     }
 }
@@ -768,20 +908,20 @@ function projectTargetToWorkingGrid(workingGrid, targetGrid, options = {}) {
 function buildStateUpdates(actions, masterGrid) {
     const stateUpdates = [];
     for (const action of actions) {
-        if (action.type === COW_ACTIONS.CREATE) {
+        if (action.type === constants_1.COW_ACTIONS.CREATE) {
             stateUpdates.push({
                 ...action.order,
-                state: ORDER_STATES.VIRTUAL,
+                state: constants_1.ORDER_STATES.VIRTUAL,
                 orderId: null
             });
         }
-        else if (action.type === COW_ACTIONS.CANCEL) {
+        else if (action.type === constants_1.COW_ACTIONS.CANCEL) {
             const masterOrder = masterGrid.get(action.id);
             if (masterOrder) {
-                stateUpdates.push(convertToSpreadPlaceholder(masterOrder));
+                stateUpdates.push((0, order_1.convertToSpreadPlaceholder)(masterOrder));
             }
         }
-        else if (action.type === COW_ACTIONS.UPDATE) {
+        else if (action.type === constants_1.COW_ACTIONS.UPDATE) {
             const masterOrder = masterGrid.get(action.id);
             if (masterOrder) {
                 const newSize = toFiniteNumber(action.newSize ?? action.order?.size);
@@ -818,7 +958,7 @@ function buildSuccessResult({ actions, stateUpdates, workingGrid, workingBoundar
     return {
         actions,
         stateUpdates,
-        hadRotation: actions.some(a => a.type === COW_ACTIONS.CREATE || a.type === COW_ACTIONS.UPDATE),
+        hadRotation: actions.some((a) => a.type === constants_1.COW_ACTIONS.CREATE || a.type === constants_1.COW_ACTIONS.UPDATE),
         workingGrid,
         workingIndexes: workingGrid.getIndexes(),
         workingBoundary,
@@ -834,7 +974,7 @@ function buildSuccessResult({ actions, stateUpdates, workingGrid, workingBoundar
  */
 function evaluateCommit(workingGrid, options = {}) {
     const hasLock = typeof options === 'boolean' ? options : !!options?.hasLock;
-    const currentVersion = toFiniteNumber(options?.currentVersion, null);
+    const currentVersion = toFiniteNumber(options?.currentVersion, undefined);
     const masterGrid = typeof options === 'object' ? options.masterGrid : null;
     if (!workingGrid) {
         return {
@@ -889,27 +1029,4 @@ function evaluateCommit(workingGrid, options = {}) {
     }
     return { canCommit: true };
 }
-module.exports = {
-    // Validation
-    validateOrder,
-    validateGridForPersistence,
-    calculateRequiredFunds,
-    validateWorkingGridFunds,
-    checkFundDrift,
-    VALID_ORDER_STATES,
-    VALID_ORDER_TYPES,
-    // Grid reconciliation (COW pipeline)
-    reconcileGrid,
-    optimizeRebalanceActions,
-    summarizeActions,
-    hasExecutableActions,
-    validateCreateTargetSlots,
-    hasActionForOrder,
-    removeActionsForOrder,
-    projectTargetToWorkingGrid,
-    buildStateUpdates,
-    buildAbortedResult,
-    buildSuccessResult,
-    evaluateCommit
-};
 //# sourceMappingURL=validate.js.map