dexbot 1.4.11 → 1.4.13

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

@@ -1,4 +1,3 @@
-"use strict";
 /**
  * modules/order/utils/validate.ts
  *
@@ -31,71 +30,17 @@
  *
  * ===============================================================================
  */
-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 Format = __importStar(require("../format"));
-const constants_1 = require("../../constants");
-const math_1 = require("./math");
-const order_1 = require("./order");
+import * as Format from '../format.js';
+import { ORDER_STATES, ORDER_TYPES, COW_ACTIONS, GRID_LIMITS } from '../../constants.js';
+import { floatToBlockchainInt, blockchainToFloat, getPrecisionSlack, getDoubleDustThreshold, findPriceCollision, calculatePriceTolerance } from './math.js';
+import { isOrderOnChain, isPhantomOrder, convertToSpreadPlaceholder, isOrderPlaced } from './order.js';
 const { isValidNumber, toFiniteNumber } = Format;
 // Pre-computed valid sets
-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;
+const VALID_ORDER_STATES = new Set(Object.values(ORDER_STATES));
+const VALID_ORDER_TYPES = new Set(Object.values(ORDER_TYPES));
 // ===============================================================================
 // SECTION 2: VALIDATION
 // ===============================================================================
@@ -114,10 +59,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 === constants_1.ORDER_STATES.VIRTUAL) {
+    if (!normalizedOrder.type && normalizedOrder.state === ORDER_STATES.VIRTUAL) {
         const placeholderSize = toFiniteNumber(normalizedOrder.size);
         if (placeholderSize === 0) {
-            normalizedOrder.type = constants_1.ORDER_TYPES.SPREAD;
+            normalizedOrder.type = ORDER_TYPES.SPREAD;
         }
     }
     if (!VALID_ORDER_STATES.has(normalizedOrder.state)) {
@@ -132,42 +77,42 @@ function validateOrder(order, oldOrder = null, context = 'validate') {
             message: `Refusing to update order ${order.id}: invalid type '${normalizedOrder.type}' (context: ${context})`
         });
     }
-    if (normalizedOrder.type === constants_1.ORDER_TYPES.SPREAD && toFiniteNumber(normalizedOrder.size) !== 0) {
+    if (normalizedOrder.type === 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 === constants_1.ORDER_STATES.ACTIVE ||
-        normalizedOrder.state === constants_1.ORDER_STATES.PARTIAL);
-    if (normalizedOrder.type === constants_1.ORDER_TYPES.SPREAD && isOnChainState) {
+    const isOnChainState = (normalizedOrder.state === ORDER_STATES.ACTIVE ||
+        normalizedOrder.state === ORDER_STATES.PARTIAL);
+    if (normalizedOrder.type === 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 ((0, order_1.isPhantomOrder)(normalizedOrder)) {
+    if (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: constants_1.ORDER_STATES.VIRTUAL,
+                state: ORDER_STATES.VIRTUAL,
                 orderId: null,
                 rawOnChain: null,
                 size: 0
             }
         });
     }
-    if (normalizedOrder.type === constants_1.ORDER_TYPES.BUY || normalizedOrder.type === constants_1.ORDER_TYPES.SELL) {
+    if (normalizedOrder.type === ORDER_TYPES.BUY || normalizedOrder.type === ORDER_TYPES.SELL) {
         normalizedOrder.committedSide = normalizedOrder.type;
     }
     else if (!normalizedOrder.committedSide && oldOrder) {
         if (oldOrder.committedSide) {
             normalizedOrder.committedSide = oldOrder.committedSide;
         }
-        else if (oldOrder.type === constants_1.ORDER_TYPES.BUY || oldOrder.type === constants_1.ORDER_TYPES.SELL) {
+        else if (oldOrder.type === ORDER_TYPES.BUY || oldOrder.type === ORDER_TYPES.SELL) {
             normalizedOrder.committedSide = oldOrder.type;
         }
     }
@@ -186,7 +131,7 @@ function validateOrder(order, oldOrder = null, context = 'validate') {
  */
 function validateGridForPersistence(orders, accountTotals) {
     for (const order of orders.values()) {
-        if ((0, order_1.isPhantomOrder)(order)) {
+        if (isPhantomOrder(order)) {
             return {
                 isValid: false,
                 reason: `Phantom order detected: order ${order.id} is ${order.state} but has no orderId`
@@ -215,21 +160,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 === 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);
+        const isActive = state === ORDER_STATES.ACTIVE || state === ORDER_STATES.PARTIAL;
+        if (isActive && isOrderOnChain(order)) {
+            if (order.type === ORDER_TYPES.BUY) {
+                buyRequiredInt += floatToBlockchainInt(size, buyPrecision);
             }
-            else if (order.type === constants_1.ORDER_TYPES.SELL) {
-                sellRequiredInt += (0, math_1.floatToBlockchainInt)(size, sellPrecision);
+            else if (order.type === ORDER_TYPES.SELL) {
+                sellRequiredInt += floatToBlockchainInt(size, sellPrecision);
             }
         }
     }
     return {
         buyInt: buyRequiredInt,
         sellInt: sellRequiredInt,
-        buy: (0, math_1.blockchainToFloat)(buyRequiredInt, buyPrecision),
-        sell: (0, math_1.blockchainToFloat)(sellRequiredInt, sellPrecision)
+        buy: blockchainToFloat(buyRequiredInt, buyPrecision),
+        sell: blockchainToFloat(sellRequiredInt, sellPrecision)
     };
 }
 /**
@@ -255,26 +200,26 @@ function validateWorkingGridFunds(workingGrid, projectedFunds, precisions = {},
             ? Number(projectedFunds.chainTotalSell)
             : toFiniteNumber(projectedFunds?.freeSell ?? projectedFunds?.chainFreeSell);
     const shortfalls = [];
-    const availableBuyInt = (0, math_1.floatToBlockchainInt)(availableBuy, buyPrecision);
-    const availableSellInt = (0, math_1.floatToBlockchainInt)(availableSell, sellPrecision);
+    const availableBuyInt = floatToBlockchainInt(availableBuy, buyPrecision);
+    const availableSellInt = floatToBlockchainInt(availableSell, sellPrecision);
     if (required.buyInt > availableBuyInt) {
-        const requiredBuyFloat = (0, math_1.blockchainToFloat)(required.buyInt, buyPrecision);
-        const availableBuyFloat = (0, math_1.blockchainToFloat)(availableBuyInt, buyPrecision);
+        const requiredBuyFloat = blockchainToFloat(required.buyInt, buyPrecision);
+        const availableBuyFloat = blockchainToFloat(availableBuyInt, buyPrecision);
         shortfalls.push({
             asset: assets?.assetB?.symbol || 'buyAsset',
             required: requiredBuyFloat,
             available: availableBuyFloat,
-            deficit: (0, math_1.blockchainToFloat)(required.buyInt - availableBuyInt, buyPrecision)
+            deficit: blockchainToFloat(required.buyInt - availableBuyInt, buyPrecision)
         });
     }
     if (required.sellInt > availableSellInt) {
-        const requiredSellFloat = (0, math_1.blockchainToFloat)(required.sellInt, sellPrecision);
-        const availableSellFloat = (0, math_1.blockchainToFloat)(availableSellInt, sellPrecision);
+        const requiredSellFloat = blockchainToFloat(required.sellInt, sellPrecision);
+        const availableSellFloat = blockchainToFloat(availableSellInt, sellPrecision);
         shortfalls.push({
             asset: assets?.assetA?.symbol || 'sellAsset',
             required: requiredSellFloat,
             available: availableSellFloat,
-            deficit: (0, math_1.blockchainToFloat)(required.sellInt - availableSellInt, sellPrecision)
+            deficit: blockchainToFloat(required.sellInt - availableSellInt, sellPrecision)
         });
     }
     return {
@@ -296,11 +241,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 || !(0, order_1.isOrderOnChain)(order))
+        if (size <= 0 || !isOrderOnChain(order))
             continue;
-        if (order.type === constants_1.ORDER_TYPES.BUY)
+        if (order.type === ORDER_TYPES.BUY)
             gridBuy += size;
-        else if (order.type === constants_1.ORDER_TYPES.SELL)
+        else if (order.type === ORDER_TYPES.SELL)
             gridSell += size;
     }
     const chainFreeBuy = accountTotals?.buyFree || 0;
@@ -316,9 +261,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 = (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 precisionSlackBuy = getPrecisionSlack(buyPrecision);
+    const precisionSlackSell = getPrecisionSlack(sellPrecision);
+    const fundInvariantTolerance = gridLimits?.FUND_INVARIANT_PERCENT_TOLERANCE ?? GRID_LIMITS.FUND_INVARIANT_PERCENT_TOLERANCE;
     const percentTolerance = fundInvariantTolerance / 100;
     const allowedDriftBuy = Math.max(precisionSlackBuy, actualBuy * percentTolerance);
     const allowedDriftSell = Math.max(precisionSlackSell, actualSell * percentTolerance);
@@ -349,7 +294,7 @@ function checkFundDrift(orders, accountTotals, assets = null, gridLimits = null)
  * @returns {Object} Reconciliation result with actions
  */
 function reconcileGrid(masterGrid, targetGrid, targetBoundary, options = {}) {
-    const { logger = null, dustThresholdPercent = constants_1.GRID_LIMITS.PARTIAL_DUST_THRESHOLD_PERCENTAGE } = options;
+    const { logger = null, dustThresholdPercent = GRID_LIMITS.PARTIAL_DUST_THRESHOLD_PERCENTAGE } = options;
     const actions = [];
     const surplusesBuy = [];
     const surplusesSell = [];
@@ -361,7 +306,7 @@ function reconcileGrid(masterGrid, targetGrid, targetBoundary, options = {}) {
         const idealSize = toFiniteNumber(order.idealSize || order.size);
         if (idealSize <= 0)
             return true;
-        const minHealthy = (0, math_1.getDoubleDustThreshold)(idealSize, dustThresholdPercent);
+        const minHealthy = getDoubleDustThreshold(idealSize, dustThresholdPercent);
         if (order.size < minHealthy) {
             if (logger) {
                 logger(`[RECONCILE] Skipping dust target order: ${order.id} ` +
@@ -385,40 +330,40 @@ function reconcileGrid(masterGrid, targetGrid, targetBoundary, options = {}) {
     }
     for (const [id, targetOrder] of targetGrid) {
         const masterOrder = masterGrid.get(id);
-        if (!masterOrder || masterOrder.state === constants_1.ORDER_STATES.VIRTUAL) {
+        if (!masterOrder || masterOrder.state === ORDER_STATES.VIRTUAL) {
             // Slot is empty or virtual - check if we need to fill it
-            if (targetOrder.size > 0 && targetOrder.state === constants_1.ORDER_STATES.ACTIVE) {
+            if (targetOrder.size > 0 && targetOrder.state === ORDER_STATES.ACTIVE) {
                 // This is a hole that needs filling
-                if (targetOrder.type === constants_1.ORDER_TYPES.BUY) {
+                if (targetOrder.type === ORDER_TYPES.BUY) {
                     holesBuy.push({ id, order: targetOrder });
                 }
-                else if (targetOrder.type === constants_1.ORDER_TYPES.SELL) {
+                else if (targetOrder.type === ORDER_TYPES.SELL) {
                     holesSell.push({ id, order: targetOrder });
                 }
             }
             continue;
         }
         if (masterOrder.type !== targetOrder.type) {
-            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 });
+            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 });
             }
             continue;
         }
         // If master is on-chain but target should be VIRTUAL (outside window),
         // this is a surplus candidate for rotation.
-        if ((0, order_1.isOrderOnChain)(masterOrder) && targetOrder.state === constants_1.ORDER_STATES.VIRTUAL) {
-            if (masterOrder.type === constants_1.ORDER_TYPES.BUY) {
+        if (isOrderOnChain(masterOrder) && targetOrder.state === ORDER_STATES.VIRTUAL) {
+            if (masterOrder.type === ORDER_TYPES.BUY) {
                 surplusesBuy.push({ id, master: masterOrder, target: targetOrder });
             }
-            else if (masterOrder.type === constants_1.ORDER_TYPES.SELL) {
+            else if (masterOrder.type === ORDER_TYPES.SELL) {
                 surplusesSell.push({ id, master: masterOrder, target: targetOrder });
             }
             continue;
         }
         if (masterOrder.size !== targetOrder.size) {
             if (targetOrder.size === 0) {
-                actions.push({ type: constants_1.COW_ACTIONS.CANCEL, id, orderId: masterOrder.orderId, reason: 'target-size-zero' });
+                actions.push({ type: 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).
@@ -429,7 +374,7 @@ function reconcileGrid(masterGrid, targetGrid, targetBoundary, options = {}) {
     const cancelSurpluses = (surpluses) => {
         for (const surplus of surpluses) {
             if (surplus.master.orderId) {
-                actions.push({ type: constants_1.COW_ACTIONS.CANCEL, id: surplus.id, orderId: surplus.master.orderId, reason: 'surplus-no-rotation-target' });
+                actions.push({ type: COW_ACTIONS.CANCEL, id: surplus.id, orderId: surplus.master.orderId, reason: 'surplus-no-rotation-target' });
             }
         }
     };
@@ -442,11 +387,11 @@ function reconcileGrid(masterGrid, targetGrid, targetBoundary, options = {}) {
         }
         if (surpluses.length === 0) {
             for (const hole of healthyHoles) {
-                actions.push({ type: constants_1.COW_ACTIONS.CREATE, id: hole.id, order: hole.order });
+                actions.push({ type: COW_ACTIONS.CREATE, id: hole.id, order: hole.order });
             }
             return;
         }
-        const isBuy = surpluses[0]?.master?.type === constants_1.ORDER_TYPES.BUY;
+        const isBuy = surpluses[0]?.master?.type === 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);
@@ -454,7 +399,7 @@ function reconcileGrid(masterGrid, targetGrid, targetBoundary, options = {}) {
             const surplus = surpluses[i];
             const hole = healthyHoles[i];
             actions.push({
-                type: constants_1.COW_ACTIONS.UPDATE,
+                type: COW_ACTIONS.UPDATE,
                 id: surplus.id,
                 orderId: surplus.master.orderId,
                 newGridId: hole.id,
@@ -465,7 +410,7 @@ function reconcileGrid(masterGrid, targetGrid, targetBoundary, options = {}) {
             });
         }
         for (let i = rotationCount; i < healthyHoles.length; i++) {
-            actions.push({ type: constants_1.COW_ACTIONS.CREATE, id: healthyHoles[i].id, order: healthyHoles[i].order });
+            actions.push({ type: 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));
@@ -473,8 +418,8 @@ function reconcileGrid(masterGrid, targetGrid, targetBoundary, options = {}) {
     pairRotations(surplusesBuy, holesBuy);
     pairRotations(surplusesSell, holesSell);
     for (const [id, masterOrder] of masterGrid) {
-        if (!targetGrid.has(id) && (0, order_1.isOrderOnChain)(masterOrder)) {
-            actions.push({ type: constants_1.COW_ACTIONS.CANCEL, id, orderId: masterOrder.orderId, reason: 'orphan-slot' });
+        if (!targetGrid.has(id) && isOrderOnChain(masterOrder)) {
+            actions.push({ type: COW_ACTIONS.CANCEL, id, orderId: masterOrder.orderId, reason: 'orphan-slot' });
         }
     }
     return {
@@ -500,10 +445,10 @@ function optimizeRebalanceActions(actions, masterGrid) {
     const cancels = [];
     const passthrough = [];
     for (const action of actions) {
-        if (action?.type === constants_1.COW_ACTIONS.CREATE) {
+        if (action?.type === COW_ACTIONS.CREATE) {
             creates.push(action);
         }
-        else if (action?.type === constants_1.COW_ACTIONS.CANCEL) {
+        else if (action?.type === COW_ACTIONS.CANCEL) {
             cancels.push(action);
         }
         else {
@@ -543,7 +488,7 @@ function optimizeRebalanceActions(actions, masterGrid) {
         }
         const createAction = remainingCreates.splice(bestIdx, 1)[0];
         optimized.push({
-            type: constants_1.COW_ACTIONS.UPDATE,
+            type: COW_ACTIONS.UPDATE,
             id: cancelAction.id,
             orderId: cancelAction.orderId,
             newGridId: createAction.id,
@@ -566,9 +511,9 @@ function optimizeRebalanceActions(actions, masterGrid) {
 function summarizeActions(actions) {
     return {
         total: actions.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
+        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
     };
 }
 /**
@@ -610,11 +555,11 @@ function validateCreateTargetSlots(actions, orders, assets = null, chainOrderCan
     const orderMap = orders instanceof Map ? orders : new Map();
     const releasedSlotIds = new Set();
     for (const action of safeActions) {
-        if (action?.type === constants_1.COW_ACTIONS.CANCEL && action.id) {
+        if (action?.type === COW_ACTIONS.CANCEL && action.id) {
             releasedSlotIds.add(action.id);
             continue;
         }
-        if (action?.type === constants_1.COW_ACTIONS.UPDATE &&
+        if (action?.type === COW_ACTIONS.UPDATE &&
             action.id &&
             action.newGridId &&
             action.newGridId !== action.id) {
@@ -624,14 +569,14 @@ function validateCreateTargetSlots(actions, orders, assets = null, chainOrderCan
     const violations = [];
     const createEntries = [];
     for (const action of safeActions) {
-        if (action?.type !== constants_1.COW_ACTIONS.CREATE)
+        if (action?.type !== COW_ACTIONS.CREATE)
             continue;
         const targetId = action.id || action.order?.id;
         if (!targetId || releasedSlotIds.has(targetId))
             continue;
         const current = orderMap.get(targetId);
         // isOrderOnChain already checks orderId is truthy
-        if (current && (0, order_1.isOrderOnChain)(current)) {
+        if (current && isOrderOnChain(current)) {
             violations.push({
                 targetId,
                 currentOrderId: current.orderId,
@@ -657,7 +602,7 @@ function validateCreateTargetSlots(actions, orders, assets = null, chainOrderCan
     }
     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);
+            const collision = findPriceCollision(orderMap.values(), entry.targetId, entry.price, entry.size, entry.type, assets, (o) => isOrderPlaced(o) && o.id !== entry.targetId);
             if (collision) {
                 violations.push({
                     targetId: entry.targetId,
@@ -682,7 +627,7 @@ function validateCreateTargetSlots(actions, orders, assets = null, chainOrderCan
                 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);
+                const chainCollision = findPriceCollision(mapped, entry.targetId, entry.price, entry.size, entry.type, assets, (item) => item.price != null);
                 if (chainCollision) {
                     violations.push({
                         targetId: entry.targetId,
@@ -709,8 +654,8 @@ function validateCreateTargetSlots(actions, orders, assets = null, chainOrderCan
             for (let j = i + 1; j < createEntries.length; j++) {
                 const a = createEntries[i];
                 const b = createEntries[j];
-                const tolA = (0, math_1.calculatePriceTolerance)(Math.min(a.price, b.price), Math.max(a.size, b.size), a.type, assets);
-                const tolB = (0, math_1.calculatePriceTolerance)(Math.min(a.price, b.price), Math.max(a.size, b.size), b.type, assets);
+                const tolA = calculatePriceTolerance(Math.min(a.price, b.price), Math.max(a.size, b.size), a.type, assets);
+                const tolB = calculatePriceTolerance(Math.min(a.price, b.price), Math.max(a.size, b.size), b.type, assets);
                 const tolerance = (tolA != null && tolB != null)
                     ? Math.min(tolA, tolB)
                     : (tolA != null ? tolA : tolB);
@@ -807,7 +752,7 @@ function _buildUpdateSelectors(actions) {
     if (!Array.isArray(actions))
         return selectors;
     for (const action of actions) {
-        if (action?.type !== constants_1.COW_ACTIONS.UPDATE)
+        if (action?.type !== COW_ACTIONS.UPDATE)
             continue;
         if (action.id)
             selectors.slotIds.add(String(action.id));
@@ -872,13 +817,13 @@ function projectTargetToWorkingGrid(workingGrid, targetGrid, options = {}) {
             workingGrid.set(id, {
                 ...targetOrder,
                 size: Math.max(0, targetSize),
-                state: constants_1.ORDER_STATES.VIRTUAL,
+                state: ORDER_STATES.VIRTUAL,
                 orderId: null
             });
             continue;
         }
         if (targetSize > 0) {
-            const keepOrderId = (0, order_1.isOrderOnChain)(current) && current.type === targetOrder.type;
+            const keepOrderId = 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.
@@ -891,7 +836,7 @@ function projectTargetToWorkingGrid(workingGrid, targetGrid, options = {}) {
             const preservedSize = shouldPreserveSize
                 ? Math.max(0, toFiniteNumber(current.size))
                 : targetSize;
-            const resultState = keepOrderId ? current.state : constants_1.ORDER_STATES.VIRTUAL;
+            const resultState = keepOrderId ? current.state : ORDER_STATES.VIRTUAL;
             const resultOrderId = keepOrderId ? current.orderId : null;
             if (!_isProjectionUnchanged(current, targetOrder, preservedSize, resultState, resultOrderId)) {
                 workingGrid.set(id, {
@@ -904,12 +849,12 @@ function projectTargetToWorkingGrid(workingGrid, targetGrid, options = {}) {
             }
         }
         else {
-            if (!_isProjectionUnchanged(current, targetOrder, 0, constants_1.ORDER_STATES.VIRTUAL, null)) {
+            if (!_isProjectionUnchanged(current, targetOrder, 0, ORDER_STATES.VIRTUAL, null)) {
                 workingGrid.set(id, {
                     ...current,
                     ...targetOrder,
                     size: 0,
-                    state: constants_1.ORDER_STATES.VIRTUAL,
+                    state: ORDER_STATES.VIRTUAL,
                     orderId: null
                 });
             }
@@ -918,8 +863,8 @@ function projectTargetToWorkingGrid(workingGrid, targetGrid, options = {}) {
     for (const [id, current] of workingGrid.entries()) {
         if (targetIds.has(id))
             continue;
-        if ((0, order_1.isOrderOnChain)(current)) {
-            workingGrid.set(id, (0, order_1.convertToSpreadPlaceholder)(current));
+        if (isOrderOnChain(current)) {
+            workingGrid.set(id, convertToSpreadPlaceholder(current));
         }
     }
 }
@@ -932,20 +877,20 @@ function projectTargetToWorkingGrid(workingGrid, targetGrid, options = {}) {
 function buildStateUpdates(actions, masterGrid) {
     const stateUpdates = [];
     for (const action of actions) {
-        if (action.type === constants_1.COW_ACTIONS.CREATE) {
+        if (action.type === COW_ACTIONS.CREATE) {
             stateUpdates.push({
                 ...action.order,
-                state: constants_1.ORDER_STATES.VIRTUAL,
+                state: ORDER_STATES.VIRTUAL,
                 orderId: null
             });
         }
-        else if (action.type === constants_1.COW_ACTIONS.CANCEL) {
+        else if (action.type === COW_ACTIONS.CANCEL) {
             const masterOrder = masterGrid.get(action.id);
             if (masterOrder) {
-                stateUpdates.push((0, order_1.convertToSpreadPlaceholder)(masterOrder));
+                stateUpdates.push(convertToSpreadPlaceholder(masterOrder));
             }
         }
-        else if (action.type === constants_1.COW_ACTIONS.UPDATE) {
+        else if (action.type === COW_ACTIONS.UPDATE) {
             const masterOrder = masterGrid.get(action.id);
             if (masterOrder) {
                 const newSize = toFiniteNumber(action.newSize ?? action.order?.size);
@@ -982,7 +927,7 @@ function buildSuccessResult({ actions, stateUpdates, workingGrid, workingBoundar
     return {
         actions,
         stateUpdates,
-        hadRotation: actions.some((a) => a.type === constants_1.COW_ACTIONS.CREATE || a.type === constants_1.COW_ACTIONS.UPDATE),
+        hadRotation: actions.some((a) => a.type === COW_ACTIONS.CREATE || a.type === COW_ACTIONS.UPDATE),
         workingGrid,
         workingIndexes: workingGrid.getIndexes(),
         workingBoundary,
@@ -1053,4 +998,8 @@ function evaluateCommit(workingGrid, options = {}) {
     }
     return { canCommit: true };
 }
+// ===============================================================================
+// EXPORTS
+// ===============================================================================
+export { validateOrder, validateGridForPersistence, calculateRequiredFunds, validateWorkingGridFunds, checkFundDrift, VALID_ORDER_STATES, VALID_ORDER_TYPES, reconcileGrid, optimizeRebalanceActions, summarizeActions, hasExecutableActions, validateCreateTargetSlots, hasActionForOrder, removeActionsForOrder, projectTargetToWorkingGrid, buildStateUpdates, buildAbortedResult, buildSuccessResult, evaluateCommit };
 //# sourceMappingURL=validate.js.map