dexbot 1.4.11 → 1.4.12

package/dist/modules/order/grid_reconcile_internal.js

@@ -1,77 +1,20 @@
-"use strict";
 /**
  * modules/order/grid_reconcile_internal.ts - Internal helpers for grid reconciliation
  *
  * Extracted from grid_reconcile.ts for file-size management.
  * All helpers are prefixed with _ and are NOT part of the public API.
  */
-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._countActiveOnGrid = _countActiveOnGrid;
-exports._pickVirtualSlotsToActivate = _pickVirtualSlotsToActivate;
-exports._getStartupSideComparators = _getStartupSideComparators;
-exports._isGridEdgeFullyActive = _isGridEdgeFullyActive;
-exports._findLargestOrder = _findLargestOrder;
-exports._cancelLargestOrder = _cancelLargestOrder;
-exports._createOrderFromGrid = _createOrderFromGrid;
-exports._cancelChainOrder = _cancelChainOrder;
-exports._recoverStartupSyncFailure = _recoverStartupSyncFailure;
-exports._refreshStartupUpdatePlans = _refreshStartupUpdatePlans;
-exports._prepareStartupUpdatePlan = _prepareStartupUpdatePlan;
-exports._finalizeStartupUpdate = _finalizeStartupUpdate;
-exports._executeStartupUpdateBatch = _executeStartupUpdateBatch;
-exports._executeStartupSingleUpdate = _executeStartupSingleUpdate;
-exports._executeStartupSequentialUpdateFallback = _executeStartupSequentialUpdateFallback;
-exports._createStartupOrderWithHandling = _createStartupOrderWithHandling;
-exports._extractBatchOperationResults = _extractBatchOperationResults;
-exports._resolveGroupRecovery = _resolveGroupRecovery;
-exports._executeStartupCreateGroupBatch = _executeStartupCreateGroupBatch;
-exports._buildOutsideInCreateGroups = _buildOutsideInCreateGroups;
-exports._executePlannedStartupCreates = _executePlannedStartupCreates;
-exports._reconcileStartupSide = _reconcileStartupSide;
-const constants_1 = require("../constants");
-const chain_orders_1 = require("../chain_orders");
-const math_1 = require("./utils/math");
-const order_1 = require("./utils/order");
-const system_1 = require("./utils/system");
-const Format = __importStar(require("./format"));
-const errors_1 = require("../utils/errors");
+import { ORDER_TYPES, ORDER_STATES, TIMING, BTS_PRECISION } from '../constants.js';
+import { readOpenOrdersGuarded } from '../chain_orders.js';
+import { getMinAbsoluteOrderSize, getAssetFees, getAssetFeesSafe, blockchainToFloat, findPriceCollision, resolveGapBand } from './utils/math.js';
+import { isOrderPlaced, parseChainOrder, parseSlotIndex, buildCreateOrderArgs, buildOutsideInPairGroups, extractBatchOperationResults, chainOrderMatchesSlot, getSideBudget, calculateBudgetedSizes, getActiveOrdersTotal, convertToSpreadPlaceholder, isOrderGoneErrorMessage, clearDuplicateOrphanDetection } from './utils/order.js';
+import { resolveAccountRef } from './utils/system.js';
+import * as Format from './format.js';
+import { getErrorMessage } from '../utils/errors.js';
 function computePlacementPriceCollision(manager, gridOrder) {
     const createPrice = gridOrder.price;
     const createSize = gridOrder.size;
-    return createPrice != null && (0, math_1.findPriceCollision)(manager.orders.values(), gridOrder.id, createPrice, createSize, gridOrder.type, manager.assets, order_1.isOrderPlaced);
+    return createPrice != null && findPriceCollision(manager.orders.values(), gridOrder.id, createPrice, createSize, gridOrder.type, manager.assets, isOrderPlaced);
 }
 /**
  * Count active orders on the grid for a given type.
@@ -81,8 +24,8 @@ function computePlacementPriceCollision(manager, gridOrder) {
  * @private
  */
 function _countActiveOnGrid(manager, type) {
-    const active = manager.getOrdersByTypeAndState(type, constants_1.ORDER_STATES.ACTIVE).filter((o) => o && o.orderId);
-    const partial = manager.getOrdersByTypeAndState(type, constants_1.ORDER_STATES.PARTIAL).filter((o) => o && o.orderId);
+    const active = manager.getOrdersByTypeAndState(type, ORDER_STATES.ACTIVE).filter((o) => o && o.orderId);
+    const partial = manager.getOrdersByTypeAndState(type, ORDER_STATES.PARTIAL).filter((o) => o && o.orderId);
     return active.length + partial.length;
 }
 /**
@@ -123,9 +66,9 @@ function _deriveBudgetedSideSizes(manager, type) {
     }
     if (!funds)
         return derived;
-    const side = type === constants_1.ORDER_TYPES.BUY ? 'buy' : 'sell';
-    const totalTarget = (0, order_1.getActiveOrdersTotal)(manager.config);
-    const budget = (0, order_1.getSideBudget)(side, funds, manager.config, totalTarget);
+    const side = type === ORDER_TYPES.BUY ? 'buy' : 'sell';
+    const totalTarget = getActiveOrdersTotal(manager.config);
+    const budget = getSideBudget(side, funds, manager.config, totalTarget);
     if (!(budget > 0))
         return derived;
     // Include every in-rail slot that belongs to this side by geometry.  Empty
@@ -139,22 +82,22 @@ function _deriveBudgetedSideSizes(manager, type) {
     // temporarily) rather than guess a side.  Only accept concrete BUY/SELL
     // types in that case; this mirrors pre-commit behavior where the type
     // filter was the only guard.
-    const resolved = (0, math_1.resolveGapBand)(manager);
+    const resolved = resolveGapBand(manager);
     const boundaryKnown = resolved.boundaryIdx !== null && resolved.sellStartIdx !== null;
     const boundaryIdx = resolved.boundaryIdx;
     const sellStartIdx = resolved.sellStartIdx;
     const inSideRail = (o) => {
         if (!boundaryKnown)
             return true;
-        const idx = (0, order_1.parseSlotIndex)(o.id);
+        const idx = parseSlotIndex(o.id);
         if (idx === null)
             return true;
-        if (type === constants_1.ORDER_TYPES.BUY)
+        if (type === ORDER_TYPES.BUY)
             return idx <= boundaryIdx;
         return idx >= sellStartIdx;
     };
     const typeFilter = boundaryKnown
-        ? (o) => o && o.price != null && (o.type === type || o.type === constants_1.ORDER_TYPES.SPREAD)
+        ? (o) => o && o.price != null && (o.type === type || o.type === ORDER_TYPES.SPREAD)
         : (o) => o && o.price != null && o.type === type;
     const allSideSlots = Array.from(manager.orders.values())
         .filter(typeFilter)
@@ -164,7 +107,7 @@ function _deriveBudgetedSideSizes(manager, type) {
         return derived;
     let sizes;
     try {
-        sizes = (0, order_1.calculateBudgetedSizes)(allSideSlots, side, budget, weightDist[side], manager.config.incrementPercent, manager.assets);
+        sizes = calculateBudgetedSizes(allSideSlots, side, budget, weightDist[side], manager.config.incrementPercent, manager.assets);
     }
     catch (e) {
         return derived;
@@ -191,17 +134,17 @@ function _pickVirtualSlotsToActivate(manager, type, count) {
     // such slots typed BUY/SELL (never SPREAD+ACTIVE), so a VIRTUAL sell left
     // behind by a rotation/rebalance could otherwise be re-picked here and
     // placed back inside the gap. Filter by geometry, not just type.
-    const resolved = (0, math_1.resolveGapBand)(manager);
+    const resolved = resolveGapBand(manager);
     const boundaryKnown = resolved.boundaryIdx !== null && resolved.sellStartIdx !== null;
     const boundaryIdx = resolved.boundaryIdx;
     const sellStartIdx = resolved.sellStartIdx;
     const inRail = (slot) => {
         if (!boundaryKnown)
             return true;
-        const idx = (0, order_1.parseSlotIndex)(slot.id);
+        const idx = parseSlotIndex(slot.id);
         if (idx === null)
             return true;
-        if (type === constants_1.ORDER_TYPES.BUY)
+        if (type === ORDER_TYPES.BUY)
             return idx <= boundaryIdx;
         return idx >= sellStartIdx;
     };
@@ -214,15 +157,15 @@ function _pickVirtualSlotsToActivate(manager, type, count) {
     // When boundary is unknown, geometry cannot classify an empty — only
     // accept concrete BUY/SELL types (safe: don't activate what we can't place).
     const typeFilter = boundaryKnown
-        ? (slot) => slot && (slot.type === type || slot.type === constants_1.ORDER_TYPES.SPREAD)
+        ? (slot) => slot && (slot.type === type || slot.type === ORDER_TYPES.SPREAD)
         : (slot) => slot && slot.type === type;
     const slotsOfType = Array.from(manager.orders.values())
         .filter(typeFilter)
         .filter(inRail)
-        .sort((a, b) => type === constants_1.ORDER_TYPES.BUY ? b.price - a.price : a.price - b.price);
+        .sort((a, b) => type === ORDER_TYPES.BUY ? b.price - a.price : a.price - b.price);
     let effectiveMin = 0;
     try {
-        effectiveMin = (0, math_1.getMinAbsoluteOrderSize)(type, manager.assets);
+        effectiveMin = getMinAbsoluteOrderSize(type, manager.assets);
     }
     catch (e) {
         effectiveMin = 0;
@@ -234,7 +177,7 @@ function _pickVirtualSlotsToActivate(manager, type, count) {
     for (const slot of slotsOfType) {
         if (valid.length >= count)
             break;
-        if (!slot.orderId && slot.state === constants_1.ORDER_STATES.VIRTUAL) {
+        if (!slot.orderId && slot.state === ORDER_STATES.VIRTUAL) {
             // Role invariant: Only pick slots that make sense for this type based on current market pivot
             // (Strategy will enforce this strictly, but we filter here for cleaner activation)
             const storedSize = Number(slot.size) || 0;
@@ -266,10 +209,10 @@ function _pickVirtualSlotsToActivate(manager, type, count) {
     return valid;
 }
 function _getStartupSideComparators(orderType, assets) {
-    const isSell = orderType === constants_1.ORDER_TYPES.SELL;
+    const isSell = orderType === ORDER_TYPES.SELL;
     const sortUpdateComparator = isSell
-        ? (a, b) => ((0, order_1.parseChainOrder)(a, assets)?.price || 0) - ((0, order_1.parseChainOrder)(b, assets)?.price || 0)
-        : (a, b) => ((0, order_1.parseChainOrder)(b, assets)?.price || 0) - ((0, order_1.parseChainOrder)(a, assets)?.price || 0);
+        ? (a, b) => (parseChainOrder(a, assets)?.price || 0) - (parseChainOrder(b, assets)?.price || 0)
+        : (a, b) => (parseChainOrder(b, assets)?.price || 0) - (parseChainOrder(a, assets)?.price || 0);
     const sortExcessCancelComparator = isSell
         ? (a, b) => (b.parsed.price || 0) - (a.parsed.price || 0)
         : (a, b) => (a.parsed.price || 0) - (b.parsed.price || 0);
@@ -302,7 +245,7 @@ function _isGridEdgeFullyActive(manager, orderType, updateCount) {
         return false;
     // Sort: for BUY (highest to lowest price), for SELL (lowest to highest)
     // This puts market edge first, grid edge (furthest) last
-    const sorted = orderType === constants_1.ORDER_TYPES.BUY
+    const sorted = orderType === ORDER_TYPES.BUY
         ? allOrders.sort((a, b) => (b.price || 0) - (a.price || 0)) // Buy: high to low price
         : allOrders.sort((a, b) => (a.price || 0) - (b.price || 0)); // Sell: low to high price
     // Get the outermost orders (last N in sorted = furthest from market)
@@ -312,7 +255,7 @@ function _isGridEdgeFullyActive(manager, orderType, updateCount) {
     // Empty array check prevents vacuous truth: every([]) returns true
     if (edgeOrders.length === 0)
         return false;
-    const allEdgeActive = edgeOrders.every((o) => (0, order_1.isOrderPlaced)(o));
+    const allEdgeActive = edgeOrders.every((o) => isOrderPlaced(o));
     return allEdgeActive;
 }
 /**
@@ -394,7 +337,7 @@ async function _cancelLargestOrder({ chainOrders, account, privateKey, manager,
         return { index: largestIndex, orderType };
     }
     catch (err) {
-        logger?.log?.(`Warning: Could not cancel largest order ${orderId}: ${(0, errors_1.getErrorMessage)(err)}`, 'warn');
+        logger?.log?.(`Warning: Could not cancel largest order ${orderId}: ${getErrorMessage(err)}`, 'warn');
         return null;
     }
 }
@@ -433,14 +376,14 @@ async function _createOrderFromGrid({ chainOrders, account, privateKey, manager,
             `collides with placed order ${priceCollision.id} (${priceCollision.orderId}) at ${Format.formatPrice6(priceCollision.price)}`, 'warn');
         return null;
     }
-    const { amountToSell, sellAssetId, minToReceive, receiveAssetId } = (0, order_1.buildCreateOrderArgs)(gridOrder, manager.assets.assetA, manager.assets.assetB);
+    const { amountToSell, sellAssetId, minToReceive, receiveAssetId } = buildCreateOrderArgs(gridOrder, manager.assets.assetA, manager.assets.assetB);
     const result = await chainOrders.createOrder(account, privateKey, amountToSell, sellAssetId, minToReceive, receiveAssetId, null, false, extraOptions);
     if (result && result.skipped) {
         const logger = manager && manager.logger;
         logger?.log?.(`[_createOrderFromGrid] Skipped slot ${gridOrder.id}: order amounts too small to place on-chain`, 'warn');
         return null;
     }
-    const operationResults = (0, order_1.extractBatchOperationResults)(result) || [];
+    const operationResults = extractBatchOperationResults(result) || [];
     const chainOrderId = operationResults[0] && operationResults[0][1];
     if (chainOrderId) {
         // Capture chain order ID BEFORE _applySync, so even if _applySync
@@ -448,7 +391,7 @@ async function _createOrderFromGrid({ chainOrders, account, privateKey, manager,
         // will still know this order was legitimately created and avoid cancelling it.
         const capturedId = chainOrderId;
         try {
-            const btsFeeData = (0, math_1.getAssetFees)('BTS');
+            const btsFeeData = getAssetFees('BTS');
             await manager._applySync({
                 gridOrderId: gridOrder.id,
                 chainOrderId,
@@ -459,7 +402,7 @@ async function _createOrderFromGrid({ chainOrders, account, privateKey, manager,
         }
         catch (syncErr) {
             const logger = manager && manager.logger;
-            logger?.log?.(`[_createOrderFromGrid] _applySync failed after successful broadcast for ${capturedId}: ${(0, errors_1.getErrorMessage)(syncErr)}`, 'error');
+            logger?.log?.(`[_createOrderFromGrid] _applySync failed after successful broadcast for ${capturedId}: ${getErrorMessage(syncErr)}`, 'error');
             // Run recovery sync to register the orphaned order. If this also
             // fails (or the chain read is empty/truncated), the returned
             // capturedId still prevents Phase 3 cancellation.
@@ -500,13 +443,13 @@ async function _createOrderFromGrid({ chainOrders, account, privateKey, manager,
             // Note: caller does NOT hold _gridLock (Phase 2 runs outside lock),
             // so we acquire it explicitly for the grid mutation.
             try {
-                const zeroOrder = (0, order_1.convertToSpreadPlaceholder)(gridOrder);
+                const zeroOrder = convertToSpreadPlaceholder(gridOrder);
                 await manager._gridLock.acquire(async () => {
                     await manager._applyOrderUpdate(zeroOrder, 'createOrder-extraction-failure', { skipAccounting: true, fee: 0 });
                 });
             }
             catch (zeroErr) {
-                logger?.log?.(`[_createOrderFromGrid] Failed to zero slot ${gridOrder.id}: ${(0, errors_1.getErrorMessage)(zeroErr)}`, 'error');
+                logger?.log?.(`[_createOrderFromGrid] Failed to zero slot ${gridOrder.id}: ${getErrorMessage(zeroErr)}`, 'error');
             }
         }
     }
@@ -531,33 +474,57 @@ async function _createOrderFromGrid({ chainOrders, account, privateKey, manager,
 async function _cancelChainOrder({ chainOrders, account, privateKey, manager, chainOrderId, dryRun, chainOrderObj, releaseUntrackedFunds = false }) {
     if (dryRun)
         return;
-    const cancelResult = await chainOrders.cancelOrder(account, privateKey, chainOrderId);
-    if (cancelResult?.verifiedAfterFailure) {
-        const recovered = await _recoverSyncFromChain({
-            chainOrders,
-            manager,
-            account,
-            logger: manager && manager.logger,
-            source: 'cancelOrder',
-        });
-        if (!recovered) {
-            // The cancellation was authoritatively confirmed absent inside
-            // cancelOrder, but the recovery refetch was skipped (empty/
-            // truncated read — ambiguous, so the full sync must NOT run) or
-            // failed. The order is provably gone, so apply the local cancel
-            // sync to release its capital and clear the slot — same fallback
-            // as the dust-cancel path. Skipping it would leave the slot stuck
-            // ACTIVE with a chain order that no longer exists.
-            await manager._applySync({ orderId: chainOrderId }, 'cancelOrder');
+    // The snapshot this cancel is based on may be stale: another path (e.g. the
+    // sync-layer cancel-only correction) may already have cancelled the order and
+    // the wasRecentlyOwnCancelled 5s TTL lapsed before reconcile's Phase-2 ran.
+    // When releasing untracked funds, treat "order does not exist" as a successful
+    // cancel and still release the capital — otherwise the funds are stranded and
+    // the chainTotal = chainFree + chainCommitted invariant is violated. Non-release
+    // cancels (matched slots) keep the previous throw-and-log behavior.
+    let cancelResult = null;
+    let orderGone = false;
+    try {
+        cancelResult = await chainOrders.cancelOrder(account, privateKey, chainOrderId);
+    }
+    catch (cancelErr) {
+        const errMsg = getErrorMessage(cancelErr) || '';
+        if (releaseUntrackedFunds && isOrderGoneErrorMessage(errMsg)) {
+            orderGone = true;
+        }
+        else {
+            throw cancelErr;
         }
     }
-    else {
-        await manager._applySync({ orderId: chainOrderId }, 'cancelOrder');
+    if (!orderGone) {
+        if (cancelResult?.verifiedAfterFailure) {
+            const recovered = await _recoverSyncFromChain({
+                chainOrders,
+                manager,
+                account,
+                logger: manager && manager.logger,
+                source: 'cancelOrder',
+            });
+            if (!recovered) {
+                // The cancellation was authoritatively confirmed absent inside
+                // cancelOrder, but the recovery refetch was skipped (empty/
+                // truncated read — ambiguous, so the full sync must NOT run) or
+                // failed. The order is provably gone, so apply the local cancel
+                // sync to release its capital and clear the slot — same fallback
+                // as the dust-cancel path. Skipping it would leave the slot stuck
+                // ACTIVE with a chain order that no longer exists.
+                await manager._applySync({ orderId: chainOrderId }, 'cancelOrder');
+            }
+        }
+        else {
+            await manager._applySync({ orderId: chainOrderId }, 'cancelOrder');
+        }
     }
+    // Resolved: forget any persistent-duplicate escalation counter for this orphan.
+    clearDuplicateOrphanDetection(chainOrderId);
     // Unmatched chain orders are not represented as ACTIVE/PARTIAL grid slots, so
     // synchronizeWithChain('cancelOrder') cannot release their commitment.
     if (releaseUntrackedFunds && manager.accountant && chainOrderObj) {
-        const parsed = (0, order_1.parseChainOrder)(chainOrderObj, manager.assets);
+        const parsed = parseChainOrder(chainOrderObj, manager.assets);
         if (parsed && parsed.size != null && parsed.size > 0) {
             await manager._fundLock.acquire(async () => {
                 await manager.accountant.addToChainFree(parsed.type, parsed.size, 'startup-cancel-unmatched');
@@ -581,11 +548,11 @@ async function _recoverSyncFromChain({ chainOrders, manager, account, logger, so
     try {
         if (triggerMessage)
             logger?.log?.(triggerMessage, 'warn');
-        const freshChainOrders = await (0, chain_orders_1.readOpenOrdersGuarded)(chainOrders, (0, system_1.resolveAccountRef)(manager, account), {
+        const freshChainOrders = await readOpenOrdersGuarded(chainOrders, resolveAccountRef(manager, account), {
             log: (message, level) => logger?.log?.(message, level),
             label: 'RECOVERY',
             deferEmpty: true,
-            timeoutMs: constants_1.TIMING.CONNECTION_TIMEOUT_MS,
+            timeoutMs: TIMING.CONNECTION_TIMEOUT_MS,
             skipMessage: skipMessage || 'Recovery sync skipped - empty/truncated chain read is ambiguous (node may be lagging, or the get_full_accounts window omitted fresh orders); deferring to next reconcile cycle',
         });
         if (freshChainOrders === null)
@@ -597,7 +564,7 @@ async function _recoverSyncFromChain({ chainOrders, manager, account, logger, so
         return freshChainOrders;
     }
     catch (syncErr) {
-        logger?.log?.(`Recovery sync failed: ${(0, errors_1.getErrorMessage)(syncErr)}`, 'error');
+        logger?.log?.(`Recovery sync failed: ${getErrorMessage(syncErr)}`, 'error');
         return null;
     }
 }
@@ -647,12 +614,12 @@ function _prepareStartupUpdatePlan(plan, manager, logger) {
         logger?.log?.(`Startup: Skip update ${chainOrderId} -> ${gridOrder.id}; slot already matched`, 'debug');
         return null;
     }
-    const { amountToSell, minToReceive } = (0, order_1.buildCreateOrderArgs)(gridOrder, manager.assets.assetA, manager.assets.assetB);
+    const { amountToSell, minToReceive } = buildCreateOrderArgs(gridOrder, manager.assets.assetA, manager.assets.assetB);
     return {
         plan,
         chainOrderId,
         gridOrder,
-        parsedChain: (0, order_1.parseChainOrder)(plan.chainOrderObj, manager.assets),
+        parsedChain: parseChainOrder(plan.chainOrderObj, manager.assets),
         updateParams: {
             newPrice: gridOrder.price,
             amountToSell,
@@ -676,8 +643,8 @@ async function _finalizeStartupUpdate({ manager, preparedUpdate }) {
     const rawDeferredFee = plan.chainOrderObj?.deferred_fee != null
         ? Format.toFiniteNumber(plan.chainOrderObj?.deferred_fee, undefined)
         : null;
-    const deferredFeeFloat = rawDeferredFee !== null ? (0, math_1.blockchainToFloat)(rawDeferredFee, constants_1.BTS_PRECISION) : null;
-    const btsFeeData = (0, math_1.getAssetFees)('BTS');
+    const deferredFeeFloat = rawDeferredFee !== null ? blockchainToFloat(rawDeferredFee, BTS_PRECISION) : null;
+    const btsFeeData = getAssetFees('BTS');
     await manager._applySync({
         gridOrderId: plan.gridOrder.id,
         chainOrderId: plan.chainOrderId,
@@ -726,7 +693,7 @@ async function _executeStartupUpdateBatch({ updatePlans, chainOrders, account, p
             await _finalizeStartupUpdate({ manager, preparedUpdate: entry });
         }
         catch (finalizeErr) {
-            logger?.log?.(`Startup: Finalize failed for ${entry.plan.gridOrder.id}: ${(0, errors_1.getErrorMessage)(finalizeErr)}`, 'error');
+            logger?.log?.(`Startup: Finalize failed for ${entry.plan.gridOrder.id}: ${getErrorMessage(finalizeErr)}`, 'error');
             finalizeFailed = true;
         }
     }
@@ -794,7 +761,7 @@ async function _executeStartupSequentialUpdateFallback({ updatePlans, chainOrder
         }
         catch (err) {
             failed++;
-            logger?.log?.(`Startup: Sequential update failed for ${plan.chainOrderId} -> ${plan.gridOrderId || plan.gridOrder?.id}: ${(0, errors_1.getErrorMessage)(err)}`, 'error');
+            logger?.log?.(`Startup: Sequential update failed for ${plan.chainOrderId} -> ${plan.gridOrderId || plan.gridOrder?.id}: ${getErrorMessage(err)}`, 'error');
             const refreshedChainOrders = await _recoverStartupSyncFailure({
                 chainOrders,
                 manager,
@@ -829,9 +796,9 @@ async function _adoptPossiblyLandedCreate({ chainOrders, manager, account, gridO
         // reads are indistinguishable from a lagging node that missed the
         // just-broadcast transaction. Both are unverifiable; absence is only
         // authoritative on a clean, non-empty read.
-        const freshChainOrders = await (0, chain_orders_1.readOpenOrdersGuarded)(chainOrders, (0, system_1.resolveAccountRef)(manager, account), {
+        const freshChainOrders = await readOpenOrdersGuarded(chainOrders, resolveAccountRef(manager, account), {
             deferEmpty: true,
-            timeoutMs: constants_1.TIMING.CONNECTION_TIMEOUT_MS,
+            timeoutMs: TIMING.CONNECTION_TIMEOUT_MS,
         });
         if (freshChainOrders === null) {
             return 'unknown';
@@ -841,12 +808,12 @@ async function _adoptPossiblyLandedCreate({ chainOrders, manager, account, gridO
             return 'unknown';
         let matched = null;
         for (const o of freshChainOrders) {
-            const parsed = (0, order_1.parseChainOrder)(o, assets);
+            const parsed = parseChainOrder(o, assets);
             if (!parsed || parsed.type !== gridOrder.type)
                 continue;
             if (parsed.orderId && Array.from(manager.orders.values()).some((g) => g.orderId === parsed.orderId))
                 continue;
-            if (!(0, order_1.chainOrderMatchesSlot)(parsed, gridOrder, assets))
+            if (!chainOrderMatchesSlot(parsed, gridOrder, assets))
                 continue;
             matched = o;
             break;
@@ -866,7 +833,7 @@ async function _adoptPossiblyLandedCreate({ chainOrders, manager, account, gridO
         // batch path and the grid_reconcile adoption loop both apply it via
         // _applySync(fee: createFee) — mirror that here so the optimistic
         // balance reflects the real chain cost.
-        const btsFeeData = (0, math_1.getAssetFeesSafe)('BTS');
+        const btsFeeData = getAssetFeesSafe('BTS');
         await manager._applySync({
             gridOrderId: gridOrder.id,
             chainOrderId: matched.id,
@@ -877,7 +844,7 @@ async function _adoptPossiblyLandedCreate({ chainOrders, manager, account, gridO
         return matched.id || null;
     }
     catch (adoptErr) {
-        manager?.logger?.log?.(`Startup: Uncertain-create adoption check failed for ${gridOrder?.id}: ${(0, errors_1.getErrorMessage)(adoptErr)}`, 'warn');
+        manager?.logger?.log?.(`Startup: Uncertain-create adoption check failed for ${gridOrder?.id}: ${getErrorMessage(adoptErr)}`, 'warn');
         return 'unknown';
     }
 }
@@ -893,7 +860,7 @@ async function _createStartupOrderWithHandling({ chainOrders, account, privateKe
         }
         catch (err) {
             const isUncertain = err?.code === 'BROADCAST_UNCERTAIN' || err?.name === 'BroadcastUncertainError';
-            manager?.logger?.log?.(`Startup: Failed to create ${orderLabel} (attempt ${attempt}/${maxAttempts}${isUncertain ? ', uncertain broadcast' : ''}): ${(0, errors_1.getErrorMessage)(err)}`, 'error');
+            manager?.logger?.log?.(`Startup: Failed to create ${orderLabel} (attempt ${attempt}/${maxAttempts}${isUncertain ? ', uncertain broadcast' : ''}): ${getErrorMessage(err)}`, 'error');
             if (!isUncertain)
                 break;
             failedWithUncertain = true;
@@ -932,7 +899,7 @@ async function _createStartupOrderWithHandling({ chainOrders, account, privateKe
 // _extractBatchOperationResults — thin wrapper over shared utility,
 // returns empty array (not null) for callers that iterate directly.
 function _extractBatchOperationResults(result) {
-    return (0, order_1.extractBatchOperationResults)(result) || [];
+    return extractBatchOperationResults(result) || [];
 }
 function _resolveGroupRecovery(group, fallbackMessage, fallbackSource) {
     for (const plan of group || []) {
@@ -970,7 +937,7 @@ async function _executeStartupCreateGroupBatch({ group, chainOrders, account, pr
                 `at ${Format.formatPrice6(priceCollision.price)}`, 'warn');
             continue;
         }
-        const { amountToSell, sellAssetId, minToReceive, receiveAssetId } = (0, order_1.buildCreateOrderArgs)(gridOrder, manager.assets.assetA, manager.assets.assetB);
+        const { amountToSell, sellAssetId, minToReceive, receiveAssetId } = buildCreateOrderArgs(gridOrder, manager.assets.assetA, manager.assets.assetB);
         const buildResult = await chainOrders.buildCreateOrderOp(account, amountToSell, sellAssetId, minToReceive, receiveAssetId, null);
         if (!buildResult) {
             logger?.log?.(`Startup: Skip create ${plan.orderLabel} - order amounts too small to place on-chain`, 'warn');
@@ -986,7 +953,7 @@ async function _executeStartupCreateGroupBatch({ group, chainOrders, account, pr
         logger?.log?.(`Startup: Broadcasting create group ${groupIndex + 1}/${totalGroups} in single batch (${prepared.length} op${prepared.length > 1 ? 's' : ''})`, 'info');
         const batchResult = await chainOrders.executeBatch(account, privateKey, prepared.map((p) => p.op));
         const opResults = _extractBatchOperationResults(batchResult);
-        const btsFeeData = (0, math_1.getAssetFees)('BTS');
+        const btsFeeData = getAssetFees('BTS');
         // Phase A: Extract ALL chain order IDs from batch results first, capturing
         // every on-chain ID before any _applySync call. This ensures createdOrderIds
         // is complete even if a subsequent _applySync throws mid-loop.
@@ -1030,7 +997,7 @@ async function _executeStartupCreateGroupBatch({ group, chainOrders, account, pr
     }
     catch (err) {
         const isUncertain = err?.code === 'BROADCAST_UNCERTAIN' || err?.name === 'BroadcastUncertainError';
-        logger?.log?.(`Startup: Failed to create group ${groupIndex + 1}/${totalGroups}${isUncertain ? ' (uncertain broadcast)' : ''}: ${(0, errors_1.getErrorMessage)(err)}`, 'error');
+        logger?.log?.(`Startup: Failed to create group ${groupIndex + 1}/${totalGroups}${isUncertain ? ' (uncertain broadcast)' : ''}: ${getErrorMessage(err)}`, 'error');
         if (isUncertain) {
             // The batch may have landed despite the deadline. Verify on chain and
             // adopt any landed orders via chain sync instead of blindly
@@ -1048,11 +1015,11 @@ async function _executeStartupCreateGroupBatch({ group, chainOrders, account, pr
                 // guarded recovery sync, which re-reads and only syncs on
                 // an authoritative snapshot (deferring to the next
                 // reconcile cycle otherwise).
-                const freshChainOrders = await (0, chain_orders_1.readOpenOrdersGuarded)(chainOrders, (0, system_1.resolveAccountRef)(manager, account), {
+                const freshChainOrders = await readOpenOrdersGuarded(chainOrders, resolveAccountRef(manager, account), {
                     log: (message, level) => logger?.log?.(message, level),
                     label: 'STARTUP',
                     deferEmpty: true,
-                    timeoutMs: constants_1.TIMING.CONNECTION_TIMEOUT_MS,
+                    timeoutMs: TIMING.CONNECTION_TIMEOUT_MS,
                     skipMessage: (kind) => `Startup: Uncertain create group ${groupIndex + 1}/${totalGroups} verification read is ` +
                         `${kind}; cannot confirm whether the batch landed - ` +
                         `deferring to guarded recovery sync (duplicate-order protection)`,
@@ -1080,7 +1047,7 @@ async function _executeStartupCreateGroupBatch({ group, chainOrders, account, pr
                     // for every group plan whose slot was adopted, and register
                     // the adopted IDs so the final refresh never cancels them
                     // as surplus.
-                    const btsFeeData = (0, math_1.getAssetFeesSafe)('BTS');
+                    const btsFeeData = getAssetFeesSafe('BTS');
                     for (const item of prepared) {
                         const plan = item?.plan;
                         const slot = plan?.gridOrder?.id ? manager.orders.get(plan.gridOrder.id) : null;
@@ -1098,13 +1065,13 @@ async function _executeStartupCreateGroupBatch({ group, chainOrders, account, pr
                             logger?.log?.(`Startup: Uncertain create for ${plan.orderLabel} confirmed on chain (${slot.orderId}); adopted + accounted`, 'warn');
                         }
                         catch (applyErr) {
-                            logger?.log?.(`Startup: Adoption accounting failed for ${plan.orderLabel}: ${(0, errors_1.getErrorMessage)(applyErr)}`, 'warn');
+                            logger?.log?.(`Startup: Adoption accounting failed for ${plan.orderLabel}: ${getErrorMessage(applyErr)}`, 'warn');
                         }
                     }
                 }
             }
             catch (verifyErr) {
-                logger?.log?.(`Startup: Uncertain group verification failed: ${(0, errors_1.getErrorMessage)(verifyErr)}; falling back to recovery sync`, 'error');
+                logger?.log?.(`Startup: Uncertain group verification failed: ${getErrorMessage(verifyErr)}; falling back to recovery sync`, 'error');
                 await _recoverStartupSyncFailure({
                     chainOrders,
                     manager,
@@ -1129,7 +1096,7 @@ async function _executeStartupCreateGroupBatch({ group, chainOrders, account, pr
     return createdOrderIds;
 }
 function _buildOutsideInCreateGroups(createPlans) {
-    return (0, order_1.buildOutsideInPairGroups)(createPlans, {
+    return buildOutsideInPairGroups(createPlans, {
         isValid: (p) => Boolean(p?.gridOrder),
         getType: (p) => p.orderType,
         getPrice: (p) => p.gridOrder?.price,
@@ -1187,9 +1154,9 @@ async function _executePlannedStartupCreates({ createPlans, chainOrders, account
 }
 async function _reconcileStartupSide({ orderType, targetCount, chainSideOrders, unmatchedSideOrders, manager, chainOrders, account, privateKey, dryRun, plannedCreates, plannedUpdates, plannedCancels, planOnly = false, }) {
     const logger = manager?.logger;
-    const sideUpper = orderType === constants_1.ORDER_TYPES.SELL ? 'SELL' : 'BUY';
-    const balanceKey = orderType === constants_1.ORDER_TYPES.SELL ? 'sellFree' : 'buyFree';
-    const balanceSymbol = orderType === constants_1.ORDER_TYPES.SELL ? manager.assets.assetA.symbol : manager.assets.assetB.symbol;
+    const sideUpper = orderType === ORDER_TYPES.SELL ? 'SELL' : 'BUY';
+    const balanceKey = orderType === ORDER_TYPES.SELL ? 'sellFree' : 'buyFree';
+    const balanceSymbol = orderType === ORDER_TYPES.SELL ? manager.assets.assetA.symbol : manager.assets.assetB.symbol;
     const { sortUpdateComparator, sortExcessCancelComparator, sortMatchedCancelComparator, } = _getStartupSideComparators(orderType, manager.assets);
     const matchedOnGrid = _countActiveOnGrid(manager, orderType);
     const neededSlots = Math.max(0, targetCount - matchedOnGrid);
@@ -1229,7 +1196,7 @@ async function _reconcileStartupSide({ orderType, targetCount, chainSideOrders,
         const chainOrder = sortedUnmatched[i];
         const gridOrder = desiredSlots[i];
         const gridSize = Number(gridOrder.size) || 0;
-        const parsedChain = (0, order_1.parseChainOrder)(chainOrder, manager.assets);
+        const parsedChain = parseChainOrder(chainOrder, manager.assets);
         const currentSize = parsedChain ? (parsedChain.size ?? 0) : 0;
         const sizeIncrease = Math.max(0, gridSize - currentSize);
         const currentAssetBalance = projectedSideBalance;
@@ -1294,7 +1261,7 @@ async function _reconcileStartupSide({ orderType, targetCount, chainSideOrders,
     }
     if (cancelCount > 0) {
         const parsedUnmatched = processedUnmatched
-            .map((co) => ({ chain: co, parsed: (0, order_1.parseChainOrder)(co, manager.assets) }))
+            .map((co) => ({ chain: co, parsed: parseChainOrder(co, manager.assets) }))
             .filter((x) => x.parsed)
             .sort(sortExcessCancelComparator);
         if (planOnly) {
@@ -1334,11 +1301,11 @@ async function _reconcileStartupSide({ orderType, targetCount, chainSideOrders,
                     cancelCount--;
                 }
                 catch (err) {
-                    logger?.log?.(`Startup: Failed to cancel ${sideUpper} ${x.chain.id}: ${(0, errors_1.getErrorMessage)(err)}`, 'error');
+                    logger?.log?.(`Startup: Failed to cancel ${sideUpper} ${x.chain.id}: ${getErrorMessage(err)}`, 'error');
                 }
             }
             if (cancelCount > 0) {
-                const activeOrders = manager.getOrdersByTypeAndState(orderType, constants_1.ORDER_STATES.ACTIVE)
+                const activeOrders = manager.getOrdersByTypeAndState(orderType, ORDER_STATES.ACTIVE)
                     .filter((o) => o && o.orderId)
                     .sort(sortMatchedCancelComparator);
                 for (const o of activeOrders) {
@@ -1351,7 +1318,7 @@ async function _reconcileStartupSide({ orderType, targetCount, chainSideOrders,
                         cancelCount--;
                     }
                     catch (err) {
-                        logger?.log?.(`Startup: Failed to cancel matched ${sideUpper} ${o.orderId}: ${(0, errors_1.getErrorMessage)(err)}`, 'error');
+                        logger?.log?.(`Startup: Failed to cancel matched ${sideUpper} ${o.orderId}: ${getErrorMessage(err)}`, 'error');
                     }
                 }
             }
@@ -1361,4 +1328,5 @@ async function _reconcileStartupSide({ orderType, targetCount, chainSideOrders,
         chainCount,
     };
 }
+export { _countActiveOnGrid, _pickVirtualSlotsToActivate, _getStartupSideComparators, _isGridEdgeFullyActive, _findLargestOrder, _cancelLargestOrder, _createOrderFromGrid, _cancelChainOrder, _recoverStartupSyncFailure, _refreshStartupUpdatePlans, _prepareStartupUpdatePlan, _finalizeStartupUpdate, _executeStartupUpdateBatch, _executeStartupSingleUpdate, _executeStartupSequentialUpdateFallback, _createStartupOrderWithHandling, _extractBatchOperationResults, _resolveGroupRecovery, _executeStartupCreateGroupBatch, _buildOutsideInCreateGroups, _executePlannedStartupCreates, _reconcileStartupSide };
 //# sourceMappingURL=grid_reconcile_internal.js.map