dexbot 1.3.2 → 1.4.0

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

@@ -69,17 +69,94 @@
  *
  * ===============================================================================
  */
-const { ORDER_TYPES, ORDER_STATES, TIMING, FEE_PARAMETERS, GRID_LIMITS } = require('../../constants');
-const Format = require('../format');
+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.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.isOrderHealthy = isOrderHealthy;
+exports.checkSizeThreshold = checkSizeThreshold;
+exports.checkSizesBeforeMinimum = checkSizesBeforeMinimum;
+exports.calculateIdealBoundary = calculateIdealBoundary;
+exports.calculateFundDrivenBoundary = calculateFundDrivenBoundary;
+exports.assignGridRoles = assignGridRoles;
+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.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");
 const { isValidNumber, toFiniteNumber } = Format;
-const MathUtils = require('./math');
 const { blockchainToFloat, floatToBlockchainInt, quantizeFloat } = MathUtils;
-const Logger = require('../../logger');
-const orderLogger = new Logger('Order');
+const orderLogger = new logger_1.default('Order');
 const ORDER_GONE_ERROR_FRAGMENT = 'not found';
 function _filterUnmatchedChainOrders(manager, chainOrderId) {
     if (Array.isArray(manager._lastUnmatchedChainOrders)) {
-        manager._lastUnmatchedChainOrders = manager._lastUnmatchedChainOrders.filter(u => (u?.id || u?.orderId || u?.chainOrderId) !== chainOrderId);
+        manager._lastUnmatchedChainOrders = manager._lastUnmatchedChainOrders.filter((u) => (u?.id || u?.orderId || u?.chainOrderId) !== chainOrderId);
     }
 }
 // ================================================================================
@@ -110,25 +187,25 @@ function parseChainOrder(chainOrder, assets) {
         price = precisionDelta >= 0
             ? (quote.amount / base.amount) * scaleFactor
             : (quote.amount / base.amount) / scaleFactor;
-        type = ORDER_TYPES.SELL;
+        type = constants_1.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 = ORDER_TYPES.BUY;
+        type = constants_1.ORDER_TYPES.BUY;
     }
     else
         return null;
     let size;
     try {
         if (chainOrder.for_sale !== undefined && chainOrder.for_sale !== null) {
-            const prec = (type === ORDER_TYPES.SELL) ? assets.assetA.precision : assets.assetB.precision;
+            const prec = (type === constants_1.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}: ${e.message}`);
+        orderLogger.warn(`parseChainOrder failed for ${chainOrder?.id}: ${(0, errors_1.getErrorMessage)(e)}`);
         return null;
     }
     return { orderId: chainOrder.id, price, type, size };
@@ -151,7 +228,7 @@ function parseChainOrder(chainOrder, assets) {
  * @returns {Object|null} Matching grid order or null if no match found
  */
 function findMatchingGridOrderByOpenOrder(parsedChainOrder, opts) {
-    const { orders, assets, calcToleranceFn, logger } = opts || {};
+    const { orders, assets, calcToleranceFn } = opts || {};
     if (!parsedChainOrder || !orders)
         return null;
     if (parsedChainOrder.orderId) {
@@ -162,7 +239,7 @@ function findMatchingGridOrderByOpenOrder(parsedChainOrder, opts) {
     }
     const chainSize = toFiniteNumber(parsedChainOrder.size);
     const chainPrice = toFiniteNumber(parsedChainOrder.price);
-    const isSell = parsedChainOrder.type === ORDER_TYPES.SELL;
+    const isSell = parsedChainOrder.type === constants_1.ORDER_TYPES.SELL;
     const precision = isSell ? assets?.assetA?.precision : assets?.assetB?.precision;
     if (typeof precision !== 'number')
         return null;
@@ -171,12 +248,12 @@ function findMatchingGridOrderByOpenOrder(parsedChainOrder, opts) {
     let bestPriceDiff = Infinity;
     for (const gridOrder of orders.values()) {
         const typeMatch = gridOrder?.type === parsedChainOrder.type ||
-            (opts?.allowSpreadType && gridOrder?.type === ORDER_TYPES.SPREAD);
+            (opts?.allowSpreadType && gridOrder?.type === constants_1.ORDER_TYPES.SPREAD);
         if (!gridOrder || !typeMatch)
             continue;
         if (opts?.excludeGridOrderIds?.has?.(gridOrder.id))
             continue;
-        if (![ORDER_STATES.ACTIVE, ORDER_STATES.PARTIAL, ORDER_STATES.VIRTUAL].includes(gridOrder.state))
+        if (![constants_1.ORDER_STATES.ACTIVE, constants_1.ORDER_STATES.PARTIAL, constants_1.ORDER_STATES.VIRTUAL].includes(gridOrder.state))
             continue;
         if (opts?.requireAvailableSlot && gridOrder.orderId && gridOrder.orderId !== parsedChainOrder.orderId)
             continue;
@@ -217,9 +294,9 @@ function findMatchingGridOrderByOpenOrder(parsedChainOrder, opts) {
 async function applyChainSizeToGridOrder(manager, gridOrder, chainSize) {
     if (!manager || !gridOrder)
         return null;
-    if (gridOrder.state !== ORDER_STATES.ACTIVE && gridOrder.state !== ORDER_STATES.PARTIAL)
+    if (gridOrder.state !== constants_1.ORDER_STATES.ACTIVE && gridOrder.state !== constants_1.ORDER_STATES.PARTIAL)
         return null;
-    const precision = (gridOrder.type === ORDER_TYPES.SELL) ? manager.assets?.assetA?.precision : manager.assets?.assetB?.precision;
+    const precision = (gridOrder.type === constants_1.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);
@@ -283,7 +360,7 @@ function buildFillKey(fillOrParts) {
  */
 async function correctOrderPriceOnChain(manager, correctionInfo, accountName, privateKey, accountOrders) {
     const { gridOrder, chainOrderId, expectedPrice, size, type, isSurplus, cancelOnly } = correctionInfo;
-    const stillNeeded = manager.ordersNeedingPriceCorrection?.some(c => c.chainOrderId === chainOrderId);
+    const stillNeeded = manager.ordersNeedingPriceCorrection?.some((c) => c.chainOrderId === chainOrderId);
     if (!stillNeeded)
         return { success: true, skipped: true };
     // Cancel-only entries (e.g., duplicate price level orphans) — cancel without
@@ -291,7 +368,7 @@ async function correctOrderPriceOnChain(manager, correctionInfo, accountName, pr
     if (cancelOnly) {
         let shouldRemove = false;
         try {
-            const sideLabel = type === ORDER_TYPES.SELL ? 'SELL' : 'BUY';
+            const sideLabel = type === constants_1.ORDER_TYPES.SELL ? 'SELL' : 'BUY';
             manager.logger?.log?.(`[CORRECTION] Cancelling duplicate orphan ${sideLabel} order ${chainOrderId}`, 'info');
             await accountOrders.cancelOrder(accountName, privateKey, chainOrderId);
             _filterUnmatchedChainOrders(manager, chainOrderId);
@@ -299,16 +376,16 @@ async function correctOrderPriceOnChain(manager, correctionInfo, accountName, pr
             return { success: true, cancelled: true };
         }
         catch (error) {
-            const orderGone = error.message?.includes(ORDER_GONE_ERROR_FRAGMENT);
+            const orderGone = (0, errors_1.getErrorMessage)(error)?.includes(ORDER_GONE_ERROR_FRAGMENT);
             if (orderGone) {
                 shouldRemove = true;
                 _filterUnmatchedChainOrders(manager, chainOrderId);
             }
-            return { success: false, error: error.message, orderGone };
+            return { success: false, error: (0, errors_1.getErrorMessage)(error), orderGone };
         }
         finally {
             if (shouldRemove) {
-                manager.ordersNeedingPriceCorrection = manager.ordersNeedingPriceCorrection.filter(c => c.chainOrderId !== chainOrderId);
+                manager.ordersNeedingPriceCorrection = manager.ordersNeedingPriceCorrection.filter((c) => c.chainOrderId !== chainOrderId);
             }
         }
     }
@@ -316,7 +393,7 @@ async function correctOrderPriceOnChain(manager, correctionInfo, accountName, pr
     if (isSurplus) {
         let shouldRemove = false;
         try {
-            const sideLabel = type === ORDER_TYPES.SELL ? 'SELL' : 'BUY';
+            const sideLabel = type === constants_1.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) {
@@ -331,21 +408,21 @@ async function correctOrderPriceOnChain(manager, correctionInfo, accountName, pr
             return { success: true, cancelled: true };
         }
         catch (error) {
-            const orderGone = error.message?.includes(ORDER_GONE_ERROR_FRAGMENT);
+            const orderGone = (0, errors_1.getErrorMessage)(error)?.includes(ORDER_GONE_ERROR_FRAGMENT);
             if (orderGone) {
                 shouldRemove = true;
                 _filterUnmatchedChainOrders(manager, chainOrderId);
             }
-            return { success: false, error: error.message, orderGone };
+            return { success: false, error: (0, errors_1.getErrorMessage)(error), orderGone };
         }
         finally {
             if (shouldRemove) {
-                manager.ordersNeedingPriceCorrection = manager.ordersNeedingPriceCorrection.filter(c => c.chainOrderId !== chainOrderId);
+                manager.ordersNeedingPriceCorrection = manager.ordersNeedingPriceCorrection.filter((c) => c.chainOrderId !== chainOrderId);
             }
         }
     }
     let amountToSell, minToReceive;
-    if (type === ORDER_TYPES.SELL) {
+    if (type === constants_1.ORDER_TYPES.SELL) {
         amountToSell = size;
         minToReceive = size * expectedPrice;
     }
@@ -364,16 +441,16 @@ async function correctOrderPriceOnChain(manager, correctionInfo, accountName, pr
         return { success: true };
     }
     catch (error) {
-        const orderGone = error.message?.includes(ORDER_GONE_ERROR_FRAGMENT);
+        const orderGone = (0, errors_1.getErrorMessage)(error)?.includes(ORDER_GONE_ERROR_FRAGMENT);
         if (orderGone) {
             shouldRemove = true;
             _filterUnmatchedChainOrders(manager, chainOrderId);
         }
-        return { success: false, error: error.message, orderGone };
+        return { success: false, error: (0, errors_1.getErrorMessage)(error), orderGone };
     }
     finally {
         if (shouldRemove) {
-            manager.ordersNeedingPriceCorrection = manager.ordersNeedingPriceCorrection.filter(c => c.chainOrderId !== chainOrderId);
+            manager.ordersNeedingPriceCorrection = manager.ordersNeedingPriceCorrection.filter((c) => c.chainOrderId !== chainOrderId);
         }
     }
 }
@@ -395,7 +472,7 @@ async function correctAllPriceMismatches(manager, accountName, privateKey, accou
         let corrected = 0;
         let failed = 0;
         const seen = new Set();
-        const ordersToCorrect = (manager.ordersNeedingPriceCorrection || []).filter(c => {
+        const ordersToCorrect = (manager.ordersNeedingPriceCorrection || []).filter((c) => {
             if (!c.chainOrderId || seen.has(c.chainOrderId))
                 return false;
             seen.add(c.chainOrderId);
@@ -408,8 +485,7 @@ async function correctAllPriceMismatches(manager, accountName, privateKey, accou
                 corrected++;
             else
                 failed++;
-            const { sleep } = require('./system');
-            await sleep(TIMING.SYNC_DELAY_MS);
+            await (0, system_1.sleep)(constants_1.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
@@ -540,7 +616,7 @@ function virtualizeOrder(order) {
     if (!order)
         return order;
     const { btsFeeState, ...rest } = order;
-    return { ...rest, state: ORDER_STATES.VIRTUAL, orderId: null, rawOnChain: null };
+    return { ...rest, state: constants_1.ORDER_STATES.VIRTUAL, orderId: null, rawOnChain: null };
 }
 /**
  * Convert order to spread placeholder (virtual, zero-sized spread order).
@@ -550,7 +626,7 @@ function virtualizeOrder(order) {
  * @returns {Object} Spread placeholder order (VIRTUAL, SPREAD type, zero size)
  */
 function convertToSpreadPlaceholder(order) {
-    return { ...virtualizeOrder(order), type: ORDER_TYPES.SPREAD, size: 0 };
+    return { ...virtualizeOrder(order), type: constants_1.ORDER_TYPES.SPREAD, size: 0 };
 }
 // ================================================================================
 // SECTION 4-6: FILTERING, PREDICATES & SIZE VALIDATION
@@ -563,7 +639,7 @@ function convertToSpreadPlaceholder(order) {
  * @returns {Array<Object>} Filtered orders of specified type
  */
 function filterOrdersByType(orders, orderType) {
-    return Array.isArray(orders) ? orders.filter(o => o && o.type === orderType) : [];
+    return Array.isArray(orders) ? orders.filter((o) => o && o.type === orderType) : [];
 }
 /**
  * Build outside->center paired groups from mixed BUY/SELL items.
@@ -578,14 +654,14 @@ function filterOrdersByType(orders, orderType) {
  * @returns {Array<Array<*>>} Grouped items in outside->center pair order.
  */
 function buildOutsideInPairGroups(items, { isValid = Boolean, getType, getPrice }) {
-    const safeItems = Array.isArray(items) ? items.filter(item => isValid(item)) : [];
+    const safeItems = Array.isArray(items) ? items.filter((item) => isValid(item)) : [];
     if (safeItems.length === 0)
         return [];
     const sellItems = safeItems
-        .filter(item => getType(item) === ORDER_TYPES.SELL)
+        .filter((item) => getType(item) === constants_1.ORDER_TYPES.SELL)
         .sort((a, b) => Number(getPrice(b) || 0) - Number(getPrice(a) || 0));
     const buyItems = safeItems
-        .filter(item => getType(item) === ORDER_TYPES.BUY)
+        .filter((item) => getType(item) === constants_1.ORDER_TYPES.BUY)
         .sort((a, b) => Number(getPrice(a) || 0) - Number(getPrice(b) || 0));
     const groups = [];
     const maxLen = Math.max(sellItems.length, buyItems.length);
@@ -647,7 +723,7 @@ function formatUnmatchedChainOrder(order) {
  * @returns {boolean} True if order has on-chain state
  */
 function isOrderOnChain(order) {
-    return (order?.state === ORDER_STATES.ACTIVE || order?.state === ORDER_STATES.PARTIAL) && !!order?.orderId;
+    return (order?.state === constants_1.ORDER_STATES.ACTIVE || order?.state === constants_1.ORDER_STATES.PARTIAL) && !!order?.orderId;
 }
 /**
  * Check if order is virtual (not on blockchain yet).
@@ -655,7 +731,7 @@ function isOrderOnChain(order) {
  * @param {Object} order - Order to check
  * @returns {boolean} True if order in VIRTUAL state
  */
-function isOrderVirtual(order) { return order?.state === ORDER_STATES.VIRTUAL; }
+function isOrderVirtual(order) { return order?.state === constants_1.ORDER_STATES.VIRTUAL; }
 /**
  * Check if order has on-chain ID.
  *
@@ -679,7 +755,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 === ORDER_STATES.ACTIVE || order?.state === ORDER_STATES.PARTIAL;
+    const inOnChainState = order?.state === constants_1.ORDER_STATES.ACTIVE || order?.state === constants_1.ORDER_STATES.PARTIAL;
     return inOnChainState && !hasOnChainId(order);
 }
 /**
@@ -725,7 +801,7 @@ function checkSizeThreshold(sizes, threshold, precision, includeNonFinite = fals
     const precisionSlack = isValidNumber(precision)
         ? MathUtils.getPrecisionSlack(precision, 1)
         : Number.EPSILON;
-    return sizes.some(sz => {
+    return sizes.some((sz) => {
         if (!Number.isFinite(sz))
             return includeNonFinite;
         if (sz <= 0)
@@ -759,7 +835,7 @@ function checkSizesBeforeMinimum(sizes, minSize, precision) {
 function calculateIdealBoundary(allSlots, referencePrice, gapSlots) {
     if (!allSlots || allSlots.length === 0)
         return -1;
-    let splitIdx = allSlots.findIndex(s => s.price >= referencePrice);
+    let splitIdx = allSlots.findIndex((s) => s.price >= referencePrice);
     if (splitIdx === -1)
         splitIdx = allSlots.length;
     const buySpread = Math.floor(gapSlots / 2);
@@ -799,7 +875,7 @@ function calculateFundDrivenBoundary(allSlots, availA, availB, price, gapSlots)
  * @param {boolean} [options.assignOnChain=false] - Override on-chain orders if true
  * @returns {Array<Object>} Slots with updated type assignments
  */
-function assignGridRoles(allSlots, boundaryIdx, gapSlots, ORDER_TYPES, ORDER_STATES, options = {}) {
+function assignGridRoles(allSlots, boundaryIdx, gapSlots, ORDER_TYPES, _ORDER_STATES, options = {}) {
     const assignOnChain = options.assignOnChain === true;
     const getCurrentSlot = (typeof options.getCurrentSlot === 'function') ? options.getCurrentSlot : null;
     const buyEndIdx = boundaryIdx;
@@ -852,18 +928,20 @@ function shouldFlagOutOfSpread(currentSpread, nominalSpread, toleranceSteps, buy
  */
 function buildIndexes(grid) {
     const indexes = {
-        [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()
+        [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()
     };
     for (const order of grid.values()) {
-        if (indexes[order.state])
-            indexes[order.state].add(order.id);
-        if (indexes[order.type])
-            indexes[order.type].add(order.id);
+        const stateKey = order.state;
+        const typeKey = order.type;
+        if (indexes[stateKey])
+            indexes[stateKey].add(order.id);
+        if (indexes[typeKey])
+            indexes[typeKey].add(order.id);
     }
     return indexes;
 }
@@ -902,7 +980,7 @@ function validateIndexes(grid, indexes) {
 // ================================================================================
 function _getRelativeTolerance(configOverride) {
     const raw = configOverride?.gridLimits?.RELATIVE_ORDER_UPDATE_THRESHOLD_PERCENT
-        ?? GRID_LIMITS.RELATIVE_ORDER_UPDATE_THRESHOLD_PERCENT;
+        ?? constants_1.GRID_LIMITS.RELATIVE_ORDER_UPDATE_THRESHOLD_PERCENT;
     return Number(raw) / 100;
 }
 const ORDER_RELATIVE_TOLERANCE = _getRelativeTolerance();
@@ -946,9 +1024,9 @@ function observedQuantum(a, b) {
 function resolveOrderSizePrecision(orderType, precisions = {}) {
     if (!precisions || typeof precisions !== 'object')
         return null;
-    if (orderType === ORDER_TYPES.BUY)
+    if (orderType === constants_1.ORDER_TYPES.BUY)
         return parseOptionalPrecision(precisions.buyPrecision);
-    if (orderType === ORDER_TYPES.SELL)
+    if (orderType === constants_1.ORDER_TYPES.SELL)
         return parseOptionalPrecision(precisions.sellPrecision);
     return parseOptionalPrecision(precisions.defaultPrecision);
 }
@@ -995,9 +1073,10 @@ function nearlyEqualRelative(a, b, options = {}) {
  * @returns {number|null} - Size or null if not found
  */
 function getOrderSize(order) {
-    const size = toFiniteNumber(order?.size, null);
-    if (size !== null)
-        return size;
+    const raw = order?.size;
+    if (raw != null && !(typeof raw === 'number' && !Number.isFinite(raw))) {
+        return toFiniteNumber(raw);
+    }
     return toFiniteNumber(order?.amount);
 }
 /**
@@ -1020,7 +1099,7 @@ function ordersEqual(a, b, options = {}) {
         a.type === b.type &&
         a.state === b.state &&
         nearlyEqualAbsolute(a.price, b.price, priceTolerance) &&
-        nearlyEqualRelative(getOrderSize(a), getOrderSize(b), { precision: sizePrecision }) &&
+        nearlyEqualRelative(getOrderSize(a), getOrderSize(b), { precision: sizePrecision ?? undefined }) &&
         a.orderId === b.orderId &&
         a.gridIndex === b.gridIndex;
 }
@@ -1089,9 +1168,9 @@ function deriveTargetBoundary(fills, currentBoundaryIdx, allSlots, config, gapSl
             fill?.isDelayedRotationTrigger === true;
         if (!isShiftEligible)
             continue;
-        if (fill.type === ORDER_TYPES.SELL)
+        if (fill.type === constants_1.ORDER_TYPES.SELL)
             newBoundaryIdx++;
-        else if (fill.type === ORDER_TYPES.BUY)
+        else if (fill.type === constants_1.ORDER_TYPES.BUY)
             newBoundaryIdx--;
     }
     // Clamp boundary
@@ -1142,12 +1221,12 @@ function getSideBudget(side, funds, config, totalTarget) {
         return 0;
     const isBtsSide = (isBuy && config.assetB === 'BTS') || (!isBuy && config.assetA === 'BTS');
     if (isBtsSide) {
-        const btsFees = MathUtils.calculateOrderCreationFees(config.assetA, config.assetB, totalTarget, config?.feeParams?.BTS_RESERVATION_MULTIPLIER ?? FEE_PARAMETERS.BTS_RESERVATION_MULTIPLIER);
+        const btsFees = MathUtils.calculateOrderCreationFees(config.assetA, config.assetB, totalTarget, config?.feeParams?.BTS_RESERVATION_MULTIPLIER ?? constants_1.FEE_PARAMETERS.BTS_RESERVATION_MULTIPLIER);
         return Math.max(0, allocated - btsFees);
     }
     if (!funds.btsBalance)
         return allocated;
-    const btsReservationMultiplier = config?.feeParams?.BTS_RESERVATION_MULTIPLIER ?? FEE_PARAMETERS.BTS_RESERVATION_MULTIPLIER;
+    const btsReservationMultiplier = config?.feeParams?.BTS_RESERVATION_MULTIPLIER ?? constants_1.FEE_PARAMETERS.BTS_RESERVATION_MULTIPLIER;
     const formulaBudget = MathUtils.calculateOrderCreationFees(config.assetA, config.assetB, totalTarget, btsReservationMultiplier);
     return adjustBudgetForBtsFees(allocated, false, formulaBudget, config.min_BTS_value || 0, funds.btsBalance?.free || 0, isBuy ? (funds.allocatedBuy || funds.chainFreeBuy || 0) : (funds.allocatedSell || funds.chainFreeSell || 0), (funds.allocatedBuy || funds.chainFreeBuy || 0) + (funds.allocatedSell || funds.chainFreeSell || 0));
 }
@@ -1178,44 +1257,4 @@ 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);
 }
-module.exports = {
-    parseChainOrder,
-    findMatchingGridOrderByOpenOrder,
-    applyChainSizeToGridOrder,
-    buildFillKey,
-    correctOrderPriceOnChain,
-    correctAllPriceMismatches,
-    buildCreateOrderArgs,
-    getOrderTypeFromUpdatedFlags,
-    resolveConfiguredPriceBound,
-    virtualizeOrder,
-    convertToSpreadPlaceholder,
-    filterOrdersByType,
-    buildOutsideInPairGroups,
-    extractBatchOperationResults,
-    formatUnmatchedChainOrder,
-    isOrderOnChain,
-    isOrderVirtual,
-    hasOnChainId,
-    isOrderPlaced,
-    isPhantomOrder,
-    isSlotAvailable,
-    isOrderHealthy,
-    checkSizeThreshold,
-    checkSizesBeforeMinimum,
-    calculateIdealBoundary,
-    calculateFundDrivenBoundary,
-    assignGridRoles,
-    shouldFlagOutOfSpread,
-    buildIndexes,
-    validateIndexes,
-    ordersEqual,
-    buildDelta,
-    getOrderSize,
-    deriveTargetBoundary,
-    adjustBudgetForBtsFees,
-    getSideBudget,
-    calculateBudgetedSizes,
-    buildCreateOpFingerprint
-};
 //# sourceMappingURL=order.js.map