dexbot 1.4.10 → 1.4.12

package/dist/modules/order/utils/order.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"order.d.ts","sourceRoot":"","sources":["../../../../modules/order/utils/order.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"order.d.ts","sourceRoot":"","sources":["../../../../modules/order/utils/order.ts"],"names":[],"mappings":"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"}

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

@@ -1,4 +1,3 @@
-"use strict";
 /**
  * modules/order/utils/order.ts - Order Domain Utilities
  *
@@ -69,97 +68,127 @@
  *
  * ===============================================================================
  */
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseChainOrder = parseChainOrder;
-exports.findMatchingGridOrderByOpenOrder = findMatchingGridOrderByOpenOrder;
-exports.applyChainSizeToGridOrder = applyChainSizeToGridOrder;
-exports.buildFillKey = buildFillKey;
-exports.correctOrderPriceOnChain = correctOrderPriceOnChain;
-exports.correctAllPriceMismatches = correctAllPriceMismatches;
-exports.buildCreateOrderArgs = buildCreateOrderArgs;
-exports.getOrderTypeFromUpdatedFlags = getOrderTypeFromUpdatedFlags;
-exports.resolveConfiguredPriceBound = resolveConfiguredPriceBound;
-exports.virtualizeOrder = virtualizeOrder;
-exports.convertToSpreadPlaceholder = convertToSpreadPlaceholder;
-exports.resolveSpreadOrderSide = resolveSpreadOrderSide;
-exports.chainOrderMatchesSlot = chainOrderMatchesSlot;
-exports.parseSlotIndex = parseSlotIndex;
-exports.filterOrdersByType = filterOrdersByType;
-exports.buildOutsideInPairGroups = buildOutsideInPairGroups;
-exports.extractBatchOperationResults = extractBatchOperationResults;
-exports.formatUnmatchedChainOrder = formatUnmatchedChainOrder;
-exports.isOrderOnChain = isOrderOnChain;
-exports.isOrderVirtual = isOrderVirtual;
-exports.hasOnChainId = hasOnChainId;
-exports.isOrderPlaced = isOrderPlaced;
-exports.isPhantomOrder = isPhantomOrder;
-exports.isSlotAvailable = isSlotAvailable;
-exports.isEmptyGridSlot = isEmptyGridSlot;
-exports.isOrderHealthy = isOrderHealthy;
-exports.checkSizeThreshold = checkSizeThreshold;
-exports.checkSizesBeforeMinimum = checkSizesBeforeMinimum;
-exports.calculateIdealBoundary = calculateIdealBoundary;
-exports.calculateFundDrivenBoundary = calculateFundDrivenBoundary;
-exports.assignGridRoles = assignGridRoles;
-exports.resolveOnChainRetypeType = resolveOnChainRetypeType;
-exports.shouldFlagOutOfSpread = shouldFlagOutOfSpread;
-exports.buildIndexes = buildIndexes;
-exports.validateIndexes = validateIndexes;
-exports.ordersEqual = ordersEqual;
-exports.buildDelta = buildDelta;
-exports.getOrderSize = getOrderSize;
-exports.deriveTargetBoundary = deriveTargetBoundary;
-exports.adjustBudgetForBtsFees = adjustBudgetForBtsFees;
-exports.getActiveOrdersTotal = getActiveOrdersTotal;
-exports.getSideBudget = getSideBudget;
-exports.calculateBudgetedSizes = calculateBudgetedSizes;
-exports.buildCreateOpFingerprint = buildCreateOpFingerprint;
-const constants_1 = require("../../constants");
-const Format = __importStar(require("../format"));
-const MathUtils = __importStar(require("./math"));
-const logger_1 = __importDefault(require("../../logger"));
-const system_1 = require("./system");
-const errors_1 = require("../../utils/errors");
+import { ORDER_TYPES, ORDER_STATES, TIMING, FEE_PARAMETERS, GRID_LIMITS, NATIVE_CLIENT } from '../../constants.js';
+import * as Format from '../format.js';
+import * as MathUtils from './math.js';
+import Logger from '../../logger.js';
+import { sleep } from './system.js';
+import { getErrorMessage } from '../../utils/errors.js';
 const { isValidNumber, toFiniteNumber } = Format;
 const { blockchainToFloat, floatToBlockchainInt, quantizeFloat, calculatePriceTolerance } = MathUtils;
-const orderLogger = new logger_1.default('Order');
+const orderLogger = new Logger('Order');
 const ORDER_GONE_ERROR_FRAGMENT = 'not found';
+/**
+ * Detect a "chain order does not exist" error from a broadcast/read failure.
+ * Single canonical implementation used by the correction, reconcile-cancel,
+ * dust-cancel, and residual-cancel paths.
+ *
+ * The explicit "order ... does not exist" phrasings always match. The legacy
+ * generic 'not found' fragment and the object-missing phrasings match as-is
+ * when no orderId is given (legacy order.ts behavior for the correction path);
+ * when an orderId IS given (dust/residual cancel paths) they additionally
+ * require the orderId to appear in the message, so an unrelated missing-object
+ * error is never mistaken for a gone order.
+ * @param {string} message - Error message to inspect.
+ * @param {string} [orderId] - Order ID required to be present in the message
+ *   for generic object-missing phrasings (precision mode).
+ * @returns {boolean} True if the message indicates the order is gone.
+ */
+function isOrderGoneErrorMessage(message, orderId) {
+    if (typeof message !== 'string' || message.length === 0)
+        return false;
+    if (/\border\b.*\bdoes not exist\b/i.test(message))
+        return true;
+    if (/\bdoes not exist\b.*\border\b/i.test(message))
+        return true;
+    if (orderId && !message.toLowerCase().includes(String(orderId).toLowerCase()))
+        return false;
+    if (message.includes(ORDER_GONE_ERROR_FRAGMENT))
+        return true;
+    if (/\bdoes not exist\b/i.test(message))
+        return true;
+    if (/\bcould not find object\b/i.test(message))
+        return true;
+    if (/\bunable to find object\b/i.test(message))
+        return true;
+    if (/\bobject\b.*\bnot found\b/i.test(message))
+        return true;
+    return false;
+}
+// ---------------------------------------------------------------------------
+// Persistent duplicate-orphan detection escalation. A duplicate-price-level
+// orphan is expected self-healing (fully filled order leaves a sub-dust
+// residual that collides with the rotated replacement). First sightings log at
+// info; if the SAME orderId keeps being re-detected — its cancel keeps failing
+// or it keeps getting re-created — the detection sites escalate to warn so the
+// silent loop is surfaced instead of degrading quietly. Reuses the existing
+// warn-rate-limit and recent-orderId-map tuning from constants.ts rather than
+// defining new knobs: repeats are rate-limited by TIMING.STALE_TOTALS_WARN_
+// RATE_LIMIT_MS and the counter map is capped by ORDER_EVENTS.
+// RECENT_OWN_CANCEL_MAX_ENTRIES (same lazy-GC pattern as chain_orders.ts).
+// ---------------------------------------------------------------------------
+const _duplicateOrphanDetections = new Map();
+/**
+ * Record a duplicate-orphan detection for an orderId.
+ * First sighting stays quiet (count 1). A repeated sighting of the same
+ * orderId escalates, but no more often than TIMING.STALE_TOTALS_WARN_RATE_LIMIT_MS.
+ * @param {string} orderId - Duplicate orphan chain order ID.
+ * @returns {{ count: number; shouldEscalate: boolean }} Detection stats.
+ */
+function recordDuplicateOrphanDetection(orderId) {
+    if (!orderId)
+        return { count: 0, shouldEscalate: false };
+    const warnRateLimitMs = Number.isFinite(TIMING?.STALE_TOTALS_WARN_RATE_LIMIT_MS)
+        ? TIMING.STALE_TOTALS_WARN_RATE_LIMIT_MS
+        : 60000;
+    const maxEntries = Number.isFinite(NATIVE_CLIENT?.ORDER_EVENTS?.RECENT_OWN_CANCEL_MAX_ENTRIES)
+        ? NATIVE_CLIENT.ORDER_EVENTS.RECENT_OWN_CANCEL_MAX_ENTRIES
+        : 256;
+    const now = Date.now();
+    const existing = _duplicateOrphanDetections.get(String(orderId));
+    const count = existing ? existing.count + 1 : 1;
+    let shouldEscalate = false;
+    let lastWarnAt = existing ? existing.lastWarnAt : null;
+    if (count >= 2 && (lastWarnAt == null || now - lastWarnAt >= warnRateLimitMs)) {
+        shouldEscalate = true;
+        lastWarnAt = now;
+    }
+    _duplicateOrphanDetections.set(String(orderId), { count, lastWarnAt });
+    // Lazy GC: drop the oldest entries when the map exceeds the shared budget.
+    if (_duplicateOrphanDetections.size > maxEntries) {
+        let toDelete = _duplicateOrphanDetections.size - maxEntries;
+        for (const [id] of _duplicateOrphanDetections) {
+            if (toDelete <= 0)
+                break;
+            _duplicateOrphanDetections.delete(id);
+            toDelete--;
+        }
+    }
+    return { count, shouldEscalate };
+}
+/**
+ * Clear the detection counter for an orderId (e.g. after a confirmed cancel),
+ * so a resolved orphan never lingers and false-escalates later.
+ * @param {string} orderId - Chain order ID to forget.
+ */
+function clearDuplicateOrphanDetection(orderId) {
+    if (orderId)
+        _duplicateOrphanDetections.delete(String(orderId));
+}
+/**
+ * Record a duplicate-orphan detection and return the log level + re-detection
+ * suffix for the caller's diagnostic line. First sightings log at info; a
+ * repeat escalates to warn (rate-limited).
+ * @param {string} orderId - Duplicate orphan chain order ID.
+ * @returns {{ level: 'info'|'warn'; suffix: string }} Log level and suffix text.
+ */
+function duplicateOrphanLogInfo(orderId) {
+    const { count, shouldEscalate } = recordDuplicateOrphanDetection(orderId);
+    return {
+        level: shouldEscalate ? 'warn' : 'info',
+        suffix: count > 1 ? ` [re-detected ${count}×; cancel may be failing or the order keeps getting re-created]` : '',
+    };
+}
 function _filterUnmatchedChainOrders(manager, chainOrderId) {
     if (Array.isArray(manager._lastUnmatchedChainOrders)) {
         manager._lastUnmatchedChainOrders = manager._lastUnmatchedChainOrders.filter((u) => (u?.id || u?.orderId || u?.chainOrderId) !== chainOrderId);
@@ -193,25 +222,25 @@ function parseChainOrder(chainOrder, assets) {
         price = precisionDelta >= 0
             ? (quote.amount / base.amount) * scaleFactor
             : (quote.amount / base.amount) / scaleFactor;
-        type = constants_1.ORDER_TYPES.SELL;
+        type = ORDER_TYPES.SELL;
     }
     else if (base.asset_id === assets.assetB.id && quote.asset_id === assets.assetA.id) {
         price = precisionDelta >= 0
             ? (base.amount / quote.amount) * scaleFactor
             : (base.amount / quote.amount) / scaleFactor;
-        type = constants_1.ORDER_TYPES.BUY;
+        type = ORDER_TYPES.BUY;
     }
     else
         return null;
     let size;
     try {
         if (chainOrder.for_sale !== undefined && chainOrder.for_sale !== null) {
-            const prec = (type === constants_1.ORDER_TYPES.SELL) ? assets.assetA.precision : assets.assetB.precision;
+            const prec = (type === ORDER_TYPES.SELL) ? assets.assetA.precision : assets.assetB.precision;
             size = blockchainToFloat(toFiniteNumber(chainOrder.for_sale), prec);
         }
     }
     catch (e) {
-        orderLogger.warn(`parseChainOrder failed for ${chainOrder?.id}: ${(0, errors_1.getErrorMessage)(e)}`);
+        orderLogger.warn(`parseChainOrder failed for ${chainOrder?.id}: ${getErrorMessage(e)}`);
         return null;
     }
     return { orderId: chainOrder.id, price, type, size };
@@ -245,7 +274,7 @@ function findMatchingGridOrderByOpenOrder(parsedChainOrder, opts) {
     }
     const chainSize = toFiniteNumber(parsedChainOrder.size);
     const chainPrice = toFiniteNumber(parsedChainOrder.price);
-    const isSell = parsedChainOrder.type === constants_1.ORDER_TYPES.SELL;
+    const isSell = parsedChainOrder.type === ORDER_TYPES.SELL;
     const precision = isSell ? assets?.assetA?.precision : assets?.assetB?.precision;
     if (typeof precision !== 'number')
         return null;
@@ -254,12 +283,12 @@ function findMatchingGridOrderByOpenOrder(parsedChainOrder, opts) {
     let bestPriceDiff = Infinity;
     for (const gridOrder of orders.values()) {
         const typeMatch = gridOrder?.type === parsedChainOrder.type ||
-            (opts?.allowSpreadType && gridOrder?.type === constants_1.ORDER_TYPES.SPREAD);
+            (opts?.allowSpreadType && gridOrder?.type === ORDER_TYPES.SPREAD);
         if (!gridOrder || !typeMatch)
             continue;
         if (opts?.excludeGridOrderIds?.has?.(gridOrder.id))
             continue;
-        if (![constants_1.ORDER_STATES.ACTIVE, constants_1.ORDER_STATES.PARTIAL, constants_1.ORDER_STATES.VIRTUAL].includes(gridOrder.state))
+        if (![ORDER_STATES.ACTIVE, ORDER_STATES.PARTIAL, ORDER_STATES.VIRTUAL].includes(gridOrder.state))
             continue;
         if (opts?.requireAvailableSlot && gridOrder.orderId && gridOrder.orderId !== parsedChainOrder.orderId)
             continue;
@@ -287,7 +316,6 @@ function findMatchingGridOrderByOpenOrder(parsedChainOrder, opts) {
 /**
  * Update grid order size based on blockchain state.
  * Detects partial fills and updates accounting if size changed.
- * Skips dust refills (prevents unnecessary sync when size decreases).
  *
  * Returns the updated order object or null if no update needed.
  *
@@ -300,9 +328,9 @@ function findMatchingGridOrderByOpenOrder(parsedChainOrder, opts) {
 async function applyChainSizeToGridOrder(manager, gridOrder, chainSize) {
     if (!manager || !gridOrder)
         return null;
-    if (gridOrder.state !== constants_1.ORDER_STATES.ACTIVE && gridOrder.state !== constants_1.ORDER_STATES.PARTIAL)
+    if (gridOrder.state !== ORDER_STATES.ACTIVE && gridOrder.state !== ORDER_STATES.PARTIAL)
         return null;
-    const precision = (gridOrder.type === constants_1.ORDER_TYPES.SELL) ? manager.assets?.assetA?.precision : manager.assets?.assetB?.precision;
+    const precision = (gridOrder.type === ORDER_TYPES.SELL) ? manager.assets?.assetA?.precision : manager.assets?.assetB?.precision;
     if (isValidNumber(precision) && isValidNumber(chainSize)) {
         const SUSPICIOUS_SATOSHI_LIMIT = 1e15;
         const suspiciousThreshold = SUSPICIOUS_SATOSHI_LIMIT / Math.pow(10, precision);
@@ -314,15 +342,6 @@ async function applyChainSizeToGridOrder(manager, gridOrder, chainSize) {
     }
     const oldSize = toFiniteNumber(gridOrder.size);
     const newSize = isValidNumber(chainSize) ? toFiniteNumber(chainSize) : oldSize;
-    if (gridOrder.isDustRefill && newSize < oldSize) {
-        const oldInt = floatToBlockchainInt(oldSize, precision);
-        const newInt = floatToBlockchainInt(newSize, precision);
-        const deltaInt = Math.max(0, oldInt - newInt);
-        // Ignore only negligible one-unit quantization noise on dust refill orders.
-        // Real decreases must still be synchronized to avoid stuck PARTIAL states.
-        if (deltaInt <= 1)
-            return null;
-    }
     if (floatToBlockchainInt(oldSize, precision) === floatToBlockchainInt(newSize, precision)) {
         return null;
     }
@@ -374,20 +393,22 @@ async function correctOrderPriceOnChain(manager, correctionInfo, accountName, pr
     if (cancelOnly) {
         let shouldRemove = false;
         try {
-            const sideLabel = type === constants_1.ORDER_TYPES.SELL ? 'SELL' : 'BUY';
+            const sideLabel = type === ORDER_TYPES.SELL ? 'SELL' : 'BUY';
             manager.logger?.log?.(`[CORRECTION] Cancelling duplicate orphan ${sideLabel} order ${chainOrderId}`, 'info');
             await accountOrders.cancelOrder(accountName, privateKey, chainOrderId);
+            clearDuplicateOrphanDetection(chainOrderId);
             _filterUnmatchedChainOrders(manager, chainOrderId);
             shouldRemove = true;
             return { success: true, cancelled: true };
         }
         catch (error) {
-            const orderGone = (0, errors_1.getErrorMessage)(error)?.includes(ORDER_GONE_ERROR_FRAGMENT);
+            const orderGone = isOrderGoneErrorMessage(getErrorMessage(error));
             if (orderGone) {
+                clearDuplicateOrphanDetection(chainOrderId);
                 shouldRemove = true;
                 _filterUnmatchedChainOrders(manager, chainOrderId);
             }
-            return { success: false, error: (0, errors_1.getErrorMessage)(error), orderGone };
+            return { success: false, error: getErrorMessage(error), orderGone };
         }
         finally {
             if (shouldRemove) {
@@ -399,7 +420,7 @@ async function correctOrderPriceOnChain(manager, correctionInfo, accountName, pr
     if (isSurplus) {
         let shouldRemove = false;
         try {
-            const sideLabel = type === constants_1.ORDER_TYPES.SELL ? 'SELL' : 'BUY';
+            const sideLabel = type === ORDER_TYPES.SELL ? 'SELL' : 'BUY';
             manager.logger?.log?.(`[CORRECTION] Cancelling surplus/mismatched ${sideLabel} order ${chainOrderId} for slot ${gridOrder?.id || 'unknown'}`, 'info');
             await accountOrders.cancelOrder(accountName, privateKey, chainOrderId);
             if (gridOrder && manager._applyOrderUpdate) {
@@ -414,12 +435,12 @@ async function correctOrderPriceOnChain(manager, correctionInfo, accountName, pr
             return { success: true, cancelled: true };
         }
         catch (error) {
-            const orderGone = (0, errors_1.getErrorMessage)(error)?.includes(ORDER_GONE_ERROR_FRAGMENT);
+            const orderGone = getErrorMessage(error)?.includes(ORDER_GONE_ERROR_FRAGMENT);
             if (orderGone) {
                 shouldRemove = true;
                 _filterUnmatchedChainOrders(manager, chainOrderId);
             }
-            return { success: false, error: (0, errors_1.getErrorMessage)(error), orderGone };
+            return { success: false, error: getErrorMessage(error), orderGone };
         }
         finally {
             if (shouldRemove) {
@@ -428,7 +449,7 @@ async function correctOrderPriceOnChain(manager, correctionInfo, accountName, pr
         }
     }
     let amountToSell, minToReceive;
-    if (type === constants_1.ORDER_TYPES.SELL) {
+    if (type === ORDER_TYPES.SELL) {
         amountToSell = size;
         minToReceive = size * expectedPrice;
     }
@@ -447,7 +468,7 @@ async function correctOrderPriceOnChain(manager, correctionInfo, accountName, pr
         return { success: true };
     }
     catch (error) {
-        const orderGone = (0, errors_1.getErrorMessage)(error)?.includes(ORDER_GONE_ERROR_FRAGMENT);
+        const orderGone = getErrorMessage(error)?.includes(ORDER_GONE_ERROR_FRAGMENT);
         if (orderGone) {
             shouldRemove = true;
             _filterUnmatchedChainOrders(manager, chainOrderId);
@@ -462,7 +483,7 @@ async function correctOrderPriceOnChain(manager, correctionInfo, accountName, pr
             shouldRemove = true;
             manager.logger?.log?.(`[CORRECTION] Uncertain price update for ${chainOrderId}; deferring verification to next sync re-detection`, 'warn');
         }
-        return { success: false, error: (0, errors_1.getErrorMessage)(error), orderGone };
+        return { success: false, error: getErrorMessage(error), orderGone };
     }
     finally {
         if (shouldRemove) {
@@ -501,7 +522,7 @@ async function correctAllPriceMismatches(manager, accountName, privateKey, accou
                 corrected++;
             else
                 failed++;
-            await (0, system_1.sleep)(constants_1.TIMING.SYNC_DELAY_MS);
+            await sleep(TIMING.SYNC_DELAY_MS);
         }
         // Persist master grid mutations from surplus-type-mismatch cancellations.
         // Without this, corrections that cancel an order and convert its grid slot
@@ -632,7 +653,7 @@ function virtualizeOrder(order) {
     if (!order)
         return order;
     const { btsFeeState, ...rest } = order;
-    return { ...rest, state: constants_1.ORDER_STATES.VIRTUAL, orderId: null, rawOnChain: null };
+    return { ...rest, state: ORDER_STATES.VIRTUAL, orderId: null, rawOnChain: null };
 }
 /**
  * Convert order to spread placeholder (virtual, zero-sized spread order).
@@ -642,7 +663,7 @@ function virtualizeOrder(order) {
  * @returns {Object} Spread placeholder order (VIRTUAL, SPREAD type, zero size)
  */
 function convertToSpreadPlaceholder(order) {
-    return { ...virtualizeOrder(order), type: constants_1.ORDER_TYPES.SPREAD, size: 0 };
+    return { ...virtualizeOrder(order), type: ORDER_TYPES.SPREAD, size: 0 };
 }
 /**
  * Resolve the real BUY/SELL side of a SPREAD-typed grid slot from its price
@@ -656,7 +677,7 @@ function convertToSpreadPlaceholder(order) {
  * @returns {string} ORDER_TYPES.BUY or ORDER_TYPES.SELL
  */
 function resolveSpreadOrderSide(price, startPrice) {
-    return Number(price) < Number(startPrice) ? constants_1.ORDER_TYPES.BUY : constants_1.ORDER_TYPES.SELL;
+    return Number(price) < Number(startPrice) ? ORDER_TYPES.BUY : ORDER_TYPES.SELL;
 }
 /**
  * Parse a grid slot id ("slot-123") to its rail index. Slot ids are assigned
@@ -690,12 +711,12 @@ function parseSlotIndex(id) {
 function chainOrderMatchesSlot(parsed, slot, assets) {
     if (!parsed || !slot || !assets)
         return false;
-    if (parsed.type !== slot.type && slot.type !== constants_1.ORDER_TYPES.SPREAD)
+    if (parsed.type !== slot.type && slot.type !== ORDER_TYPES.SPREAD)
         return false;
     const priceTolerance = calculatePriceTolerance(slot.price, slot.size, parsed.type, assets) || 0;
     if (Math.abs(parsed.price - slot.price) > priceTolerance)
         return false;
-    const precision = parsed.type === constants_1.ORDER_TYPES.SELL ? assets.assetA.precision : assets.assetB.precision;
+    const precision = parsed.type === ORDER_TYPES.SELL ? assets.assetA.precision : assets.assetB.precision;
     const sizeTolerance = Math.max(2, Math.floor(floatToBlockchainInt(slot.size, precision) * 0.01));
     if (Math.abs(floatToBlockchainInt(parsed.size, precision) - floatToBlockchainInt(slot.size, precision)) > sizeTolerance)
         return false;
@@ -731,10 +752,10 @@ function buildOutsideInPairGroups(items, { isValid = Boolean, getType, getPrice
     if (safeItems.length === 0)
         return [];
     const sellItems = safeItems
-        .filter((item) => getType(item) === constants_1.ORDER_TYPES.SELL)
+        .filter((item) => getType(item) === ORDER_TYPES.SELL)
         .sort((a, b) => Number(getPrice(b) || 0) - Number(getPrice(a) || 0));
     const buyItems = safeItems
-        .filter((item) => getType(item) === constants_1.ORDER_TYPES.BUY)
+        .filter((item) => getType(item) === ORDER_TYPES.BUY)
         .sort((a, b) => Number(getPrice(a) || 0) - Number(getPrice(b) || 0));
     const groups = [];
     const maxLen = Math.max(sellItems.length, buyItems.length);
@@ -796,7 +817,7 @@ function formatUnmatchedChainOrder(order) {
  * @returns {boolean} True if order has on-chain state
  */
 function isOrderOnChain(order) {
-    return (order?.state === constants_1.ORDER_STATES.ACTIVE || order?.state === constants_1.ORDER_STATES.PARTIAL) && !!order?.orderId;
+    return (order?.state === ORDER_STATES.ACTIVE || order?.state === ORDER_STATES.PARTIAL) && !!order?.orderId;
 }
 /**
  * Resolve the type to keep when a slot holding a live on-chain order would
@@ -828,7 +849,7 @@ function resolveOnChainRetypeType(slot, idx, buyEndIdx, ORDER_TYPES) {
  * @param {Object} order - Order to check
  * @returns {boolean} True if order in VIRTUAL state
  */
-function isOrderVirtual(order) { return order?.state === constants_1.ORDER_STATES.VIRTUAL; }
+function isOrderVirtual(order) { return order?.state === ORDER_STATES.VIRTUAL; }
 /**
  * Whether a slot is an empty reusable placeholder: VIRTUAL, no chain order,
  * and zero size.  Empty slots are normalized to SPREAD (side-neutral) so their
@@ -855,7 +876,7 @@ function isEmptyGridSlot(slot, liveSlot = null, opts = {}) {
     if (!slot)
         return false;
     const target = liveSlot || slot;
-    if (target.state !== constants_1.ORDER_STATES.VIRTUAL)
+    if (target.state !== ORDER_STATES.VIRTUAL)
         return false;
     if (target.orderId)
         return false;
@@ -888,7 +909,7 @@ function isOrderPlaced(order) { return isOrderOnChain(order) && hasOnChainId(ord
  * @returns {boolean} True if order appears on-chain but has no ID
  */
 function isPhantomOrder(order) {
-    const inOnChainState = order?.state === constants_1.ORDER_STATES.ACTIVE || order?.state === constants_1.ORDER_STATES.PARTIAL;
+    const inOnChainState = order?.state === ORDER_STATES.ACTIVE || order?.state === ORDER_STATES.PARTIAL;
     return inOnChainState && !hasOnChainId(order);
 }
 /**
@@ -916,7 +937,7 @@ function isOrderHealthy(size, type, assets, idealSize) {
         return false;
     if (!Number.isFinite(numericIdeal) || numericIdeal <= 0)
         return false;
-    return MathUtils.validateOrderSize(numericSize, type, assets, constants_1.GRID_LIMITS.MIN_ORDER_SIZE_FACTOR, numericIdeal, constants_1.GRID_LIMITS.PARTIAL_DUST_THRESHOLD_PERCENTAGE).isValid;
+    return MathUtils.validateOrderSize(numericSize, type, assets, GRID_LIMITS.MIN_ORDER_SIZE_FACTOR, numericIdeal, GRID_LIMITS.PARTIAL_DUST_THRESHOLD_PERCENTAGE).isValid;
 }
 /**
  * Check if any size in array falls below threshold.
@@ -1087,12 +1108,12 @@ function shouldFlagOutOfSpread(currentSpread, nominalSpread, toleranceSteps, buy
  */
 function buildIndexes(grid) {
     const indexes = {
-        [constants_1.ORDER_STATES.VIRTUAL]: new Set(),
-        [constants_1.ORDER_STATES.ACTIVE]: new Set(),
-        [constants_1.ORDER_STATES.PARTIAL]: new Set(),
-        [constants_1.ORDER_TYPES.BUY]: new Set(),
-        [constants_1.ORDER_TYPES.SELL]: new Set(),
-        [constants_1.ORDER_TYPES.SPREAD]: new Set()
+        [ORDER_STATES.VIRTUAL]: new Set(),
+        [ORDER_STATES.ACTIVE]: new Set(),
+        [ORDER_STATES.PARTIAL]: new Set(),
+        [ORDER_TYPES.BUY]: new Set(),
+        [ORDER_TYPES.SELL]: new Set(),
+        [ORDER_TYPES.SPREAD]: new Set()
     };
     for (const order of grid.values()) {
         const stateKey = order.state;
@@ -1139,7 +1160,7 @@ function validateIndexes(grid, indexes) {
 // ================================================================================
 function _getRelativeTolerance(configOverride) {
     const raw = configOverride?.gridLimits?.RELATIVE_ORDER_UPDATE_THRESHOLD_PERCENT
-        ?? constants_1.GRID_LIMITS.RELATIVE_ORDER_UPDATE_THRESHOLD_PERCENT;
+        ?? GRID_LIMITS.RELATIVE_ORDER_UPDATE_THRESHOLD_PERCENT;
     return Number(raw) / 100;
 }
 const ORDER_RELATIVE_TOLERANCE = _getRelativeTolerance();
@@ -1183,9 +1204,9 @@ function observedQuantum(a, b) {
 function resolveOrderSizePrecision(orderType, precisions = {}) {
     if (!precisions || typeof precisions !== 'object')
         return null;
-    if (orderType === constants_1.ORDER_TYPES.BUY)
+    if (orderType === ORDER_TYPES.BUY)
         return parseOptionalPrecision(precisions.buyPrecision);
-    if (orderType === constants_1.ORDER_TYPES.SELL)
+    if (orderType === ORDER_TYPES.SELL)
         return parseOptionalPrecision(precisions.sellPrecision);
     return parseOptionalPrecision(precisions.defaultPrecision);
 }
@@ -1328,9 +1349,9 @@ function deriveTargetBoundary(fills, currentBoundaryIdx, allSlots, config, gapSl
             fill?.isDelayedRotationTrigger === true;
         if (!isShiftEligible)
             continue;
-        if (fill.type === constants_1.ORDER_TYPES.SELL)
+        if (fill.type === ORDER_TYPES.SELL)
             netShift++;
-        else if (fill.type === constants_1.ORDER_TYPES.BUY)
+        else if (fill.type === ORDER_TYPES.BUY)
             netShift--;
     }
     // Cap cumulative shift to prevent overreaction from burst fills.
@@ -1396,11 +1417,11 @@ function getSideBudget(side, funds, config, totalTarget) {
     if (allocated <= 0)
         return 0;
     const btsOrderType = MathUtils.getBtsSide(config?.assetA, config?.assetB);
-    const isBtsSide = isBuy ? (btsOrderType === constants_1.ORDER_TYPES.BUY) : (btsOrderType === constants_1.ORDER_TYPES.SELL);
+    const isBtsSide = isBuy ? (btsOrderType === ORDER_TYPES.BUY) : (btsOrderType === ORDER_TYPES.SELL);
     // Non-BTS side without btsBalance data: no fee adjustment to make.
     if (!isBtsSide && !funds.btsBalance)
         return allocated;
-    const btsReservationMultiplier = config?.feeParams?.BTS_RESERVATION_MULTIPLIER ?? constants_1.FEE_PARAMETERS.BTS_RESERVATION_MULTIPLIER;
+    const btsReservationMultiplier = config?.feeParams?.BTS_RESERVATION_MULTIPLIER ?? FEE_PARAMETERS.BTS_RESERVATION_MULTIPLIER;
     const formulaBudget = MathUtils.calculateOrderCreationFees(config.assetA, config.assetB, totalTarget, btsReservationMultiplier);
     if (isBtsSide) {
         return adjustBudgetForBtsFees(allocated, true, formulaBudget, 0, 0, 0, 0);
@@ -1434,4 +1455,5 @@ function calculateBudgetedSizes(slots, side, budget, weightDist, incrementPercen
     return MathUtils.allocateFundsByWeights(budget, slots.length, weightDist, incrementFactor, isBuy, // Reverse for BUY (Market-Close is last in array)
     0, precision);
 }
+export { parseChainOrder, findMatchingGridOrderByOpenOrder, applyChainSizeToGridOrder, buildFillKey, correctOrderPriceOnChain, correctAllPriceMismatches, buildCreateOrderArgs, getOrderTypeFromUpdatedFlags, resolveConfiguredPriceBound, virtualizeOrder, convertToSpreadPlaceholder, resolveSpreadOrderSide, chainOrderMatchesSlot, parseSlotIndex, filterOrdersByType, buildOutsideInPairGroups, extractBatchOperationResults, formatUnmatchedChainOrder, isOrderOnChain, isOrderVirtual, hasOnChainId, isOrderPlaced, isPhantomOrder, isSlotAvailable, isEmptyGridSlot, isOrderHealthy, checkSizeThreshold, checkSizesBeforeMinimum, calculateIdealBoundary, calculateFundDrivenBoundary, assignGridRoles, resolveOnChainRetypeType, shouldFlagOutOfSpread, buildIndexes, validateIndexes, ordersEqual, buildDelta, getOrderSize, deriveTargetBoundary, adjustBudgetForBtsFees, getActiveOrdersTotal, getSideBudget, calculateBudgetedSizes, buildCreateOpFingerprint, isOrderGoneErrorMessage, recordDuplicateOrphanDetection, clearDuplicateOrphanDetection, duplicateOrphanLogInfo };
 //# sourceMappingURL=order.js.map