dexbot 1.4.11 → 1.4.13

package/dist/modules/dexbot_cow_runtime.js

@@ -1,4 +1,3 @@
-"use strict";
 /**
  * modules/dexbot_cow_runtime.ts - COW (Copy-on-Write) Batch Execution Runtime
  *
@@ -8,24 +7,41 @@
  * Each function takes the DEXBot instance as its first parameter, following
  * the same pattern as dexbot_fill_runtime.ts.
  */
-const chainOrders = require('./chain_orders');
-const { readOpenOrdersWithMetaSafe, readOpenOrdersGuarded } = require('./chain_orders');
-const { BroadcastUncertainError } = require('./dexbot_credential_client');
-const { buildCreateOrderArgs, buildCreateOpFingerprint, extractBatchOperationResults, formatUnmatchedChainOrder, convertToSpreadPlaceholder, buildOutsideInPairGroups, isOrderPlaced, } = require('./order/utils/order');
-const { validateCreateTargetSlots, evaluateCommit, hasExecutableActions } = require('./order/utils/validate');
-const { validateOrderSize, findPriceCollision } = require('./order/utils/math');
+import * as chainOrdersModule from './chain_orders.js';
+const chainOrders = chainOrdersModule;
+const { readOpenOrdersWithMetaSafe, readOpenOrdersGuarded } = chainOrdersModule;
+import { BroadcastUncertainError as BroadcastUncertainErrorBinding } from './dexbot_credential_client.js';
+const BroadcastUncertainError = BroadcastUncertainErrorBinding;
+import * as orderUtils from './order/utils/order.js';
+const { buildCreateOrderArgs, buildCreateOpFingerprint, extractBatchOperationResults, formatUnmatchedChainOrder, convertToSpreadPlaceholder, buildOutsideInPairGroups, isOrderPlaced, } = orderUtils;
+import * as validate from './order/utils/validate.js';
+const { validateCreateTargetSlots, evaluateCommit, hasExecutableActions } = validate;
+import * as math from './order/utils/math.js';
+const { validateOrderSize, findPriceCollision } = math;
 // Lazy accessor so test mocks on the math module export take effect at call time.
 function getAssetFeesSafe(...args) { return require('./order/utils/math').getAssetFeesSafe(...args); }
-const { COW_ACTIONS, ORDER_STATES, ORDER_TYPES, REBALANCE_STATES, } = require('./constants');
-const Format = require('./order/format');
-const { WorkingGrid } = require('./order/working_grid');
-const { getErrorMessage } = require('./utils/errors');
+import * as constantsModule from './constants.js';
+const { COW_ACTIONS, ORDER_STATES, ORDER_TYPES, REBALANCE_STATES, } = constantsModule;
+import { acquireIfNotHeld } from './order/async_lock.js';
+import * as FormatModule from './order/format.js';
+const Format = FormatModule;
+import * as workingGridModule from './order/working_grid.js';
+const { WorkingGrid } = workingGridModule;
+import { getErrorMessage } from './utils/errors.js';
+import { createRequire } from 'node:module';
+const require = createRequire(import.meta.url);
 // Maximum number of times the pre-broadcast staleness guard may re-plan the
 // batch from a fresh master before proceeding anyway. Bounded so a master
 // grid that keeps mutating (fill bursts, sync loops) can never livelock the
 // pipeline: after one re-plan the batch is shipped regardless, and the
 // commit-time guard + post-refused-commit chain adoption close divergence.
 const STALE_PLAN_REPLAN_LIMIT = 1;
+// Maximum wall-clock time (ms) a COW batch waits for an in-flight broadcast to
+// settle before proceeding anyway. The in-flight batch clears the flag in its
+// outer finally, so this only triggers if the flag is left stuck by a crash in
+// a non-finally path — proceed after the cap and let the commit guard + chain
+// adoption close divergence instead of blocking the pipeline forever.
+const SINGLE_FLIGHT_MAX_WAIT_MS = 120000;
 /**
  * Group orders into outside-in pairs for atomic create execution.
  * @param {Array} orders
@@ -95,7 +111,7 @@ function findMissingCreateResultContexts(operationResults, opContexts) {
 }
 /**
  * Run an immediate chain sync after a successful CREATE broadcast returned incomplete ids.
- * @param {import('./dexbot_class').DEXBot} bot
+ * @param {import('./dexbot_class.js').DEXBot} bot
  * @param {string} [reason]
  * @returns {Promise<void>}
  */
@@ -148,7 +164,7 @@ async function recoverAfterMissingCreateResults(bot, reason = 'missing create op
 }
 /**
  * Restore unresolved missing-create blockers after recovery if sync did not adopt them.
- * @param {import('./dexbot_class').DEXBot} bot
+ * @param {import('./dexbot_class.js').DEXBot} bot
  * @param {Array} blockers
  * @param {Object} recoveryResult
  */
@@ -180,7 +196,7 @@ function preserveMissingCreateBlockersAfterRecovery(bot, blockers, recoveryResul
 }
 /**
  * Merge missing CREATE result contexts into manager._lastUnmatchedChainOrders.
- * @param {import('./dexbot_class').DEXBot} bot
+ * @param {import('./dexbot_class.js').DEXBot} bot
  * @param {Array<{index:number, ctx:Object}>} missingCreateResults
  */
 function markMissingCreateResultsAsStructuralBlocker(bot, missingCreateResults) {
@@ -231,7 +247,7 @@ function formatUnmatchedChainOrderForLog(order) {
 }
 /**
  * Record a pending CREATE broadcast on the manager.
- * @param {import('./dexbot_class').DEXBot} bot
+ * @param {import('./dexbot_class.js').DEXBot} bot
  * @param {Object} entry
  */
 function recordPendingBroadcast(bot, entry) {
@@ -285,7 +301,7 @@ function clearPendingBroadcasts(pendingBroadcasts) {
  * (duplicate orders). The batch-entry guard only fires for batches WITH
  * CREATE actions, so a create-less batch can reach the re-plan path while
  * earlier entries are still live.
- * @param {import('./dexbot_class').DEXBot} bot
+ * @param {import('./dexbot_class.js').DEXBot} bot
  * @param {Array} actions - The abandoned batch's actions (COW_ACTIONS)
  */
 function clearPendingBroadcastsForSlots(bot, actions) {
@@ -310,7 +326,7 @@ function clearPendingBroadcastsForSlots(bot, actions) {
  * no-trigger processFilledOrders outputs, updateOrdersOnChainPlan cowResults,
  * reconcileGridOrders null results) leave the stack untouched — an unmatched
  * pop could steal a nested grid's entry.
- * @param {import('./dexbot_class').DEXBot} bot
+ * @param {import('./dexbot_class.js').DEXBot} bot
  * @param {Object} cowResult - Rebalance/COW result carrying _workingGridPushed
  */
 function popPushedWorkingGrid(bot, cowResult) {
@@ -323,7 +339,7 @@ function popPushedWorkingGrid(bot, cowResult) {
  * omits the freshest orders (exactly the batch's creates), so absence is
  * never authoritative: the pending-broadcast protection is kept and a
  * structural resync is requested so the next cycle adopts any landed orders.
- * @param {import('./dexbot_class').DEXBot} bot
+ * @param {import('./dexbot_class.js').DEXBot} bot
  * @param {string} detail - The failure detail (before the common suffix)
  * @param {string} suffix - Parenthetical explanation appended to the message
  * @param {string} resyncReason - Reason string passed to the structural resync
@@ -340,7 +356,7 @@ async function deferUncertainBroadcastRead(bot, detail, suffix, resyncReason, re
 /**
  * Build a fingerprint for an on-chain order so it can be matched against
  * the pending-broadcast cache.
- * @param {import('./dexbot_class').DEXBot} bot
+ * @param {import('./dexbot_class.js').DEXBot} bot
  * @param {Object} chainOrder
  * @param {string} slotId
  * @returns {string|null}
@@ -363,7 +379,7 @@ function buildChainOrderFingerprint(bot, chainOrder, slotId) {
 /**
  * Normalize raw BitShares limit_order_object data into the integer tuple
  * used by pending-broadcast recovery.
- * @param {import('./dexbot_class').DEXBot} bot
+ * @param {import('./dexbot_class.js').DEXBot} bot
  * @param {Object} chainOrder
  * @returns {{side: string, assetA: string, assetB: string, sellInt: number, receiveInt: number}|null}
  */
@@ -406,7 +422,7 @@ function normalizeChainOrderForPendingMatch(bot, chainOrder) {
 }
 /**
  * Find a chain order that matches a planned slot using price+size proximity.
- * @param {import('./dexbot_class').DEXBot} bot
+ * @param {import('./dexbot_class.js').DEXBot} bot
  * @param {Array} chainOrders - Open chain orders for the account
  * @param {string} slotId - Planned grid slot id
  * @param {Object} planned - { sell, receive, orderType } integers from the planned op
@@ -467,23 +483,18 @@ function findChainOrderForSlot(bot, chainOrders, slotId, planned) {
 /**
  * Reconcile a broadcast whose chain state is unknown.
  * Thin wrapper that optionally acquires _fillProcessingLock before delegating.
- * @param {import('./dexbot_class').DEXBot} bot
+ * @param {import('./dexbot_class.js').DEXBot} bot
  * @param {BroadcastUncertainError} err
  * @param {Array<Object>} opContexts
  * @param {Object} [options]
  * @returns {Promise<Object>}
  */
 async function reconcileAfterUncertainBroadcast(bot, err, opContexts, options = {}) {
-    if (bot.manager?._fillProcessingLock &&
-        typeof bot.manager._fillProcessingLock.acquire === 'function' &&
-        !bot.manager._fillProcessingLock.isReentrant()) {
-        return bot.manager._fillProcessingLock.acquire(() => reconcileAfterUncertainBroadcast(bot, err, opContexts, options));
-    }
-    return reconcileAfterUncertainBroadcastImpl(bot, err, opContexts, options);
+    return acquireIfNotHeld(bot.manager?._fillProcessingLock, () => reconcileAfterUncertainBroadcastImpl(bot, err, opContexts, options));
 }
 /**
  * Reconcile a broadcast whose chain state is unknown (implementation).
- * @param {import('./dexbot_class').DEXBot} bot
+ * @param {import('./dexbot_class.js').DEXBot} bot
  * @param {BroadcastUncertainError} err
  * @param {Array<Object>} opContexts
  * @param {Object} options
@@ -660,7 +671,17 @@ async function reconcileAfterUncertainBroadcastImpl(bot, err, opContexts, _optio
     for (const entry of discarded) {
         discardedCount++;
         const plannedOpCtx = opContexts[entry.ctxIndex];
-        if (plannedOpCtx && plannedOpCtx.kind === 'create') {
+        // A pending-broadcast entry is always a CREATE (recordPendingBroadcast
+        // only records creates), so the slot restore below must not depend on
+        // opContexts being present: the PENDING_BROADCASTS reject path invokes
+        // this reconcile with an empty opContexts array, and skipping the
+        // restore would leave the slot a clean hole that the next cycle could
+        // re-CREATE (duplicate) once the original broadcast lands. The inner
+        // entry.order checks still choose between creation-uncertain restore
+        // and plain target-size restore.
+        const isDiscardedCreate = (plannedOpCtx && plannedOpCtx.kind === 'create')
+            || (entry.order?.id && entry.order?.type);
+        if (isDiscardedCreate) {
             try {
                 // Restore target grid sizes for discarded CREATEs so the slots are
                 // immediately available for the next cycle without waiting for a
@@ -787,7 +808,7 @@ async function reconcileAfterUncertainBroadcastImpl(bot, err, opContexts, _optio
 }
 /**
  * Auto-cancel one unmatched orphan (price-drift orphan) per cycle.
- * @param {import('./dexbot_class').DEXBot} bot
+ * @param {import('./dexbot_class.js').DEXBot} bot
  * @returns {Promise<{cancelled: boolean, reason?: string, orderId?: string}>}
  */
 async function autoCancelOneUnmatchedOrphan(bot) {
@@ -847,7 +868,7 @@ async function autoCancelOneUnmatchedOrphan(bot) {
 }
 /**
  * Check whether to execute creates in outside-in pair mode.
- * @param {import('./dexbot_class').DEXBot} bot
+ * @param {import('./dexbot_class.js').DEXBot} bot
  * @param {Array} opContexts
  * @returns {boolean}
  */
@@ -874,7 +895,7 @@ function shouldExecuteCreatePairMode(_bot, opContexts) {
  *  - 'absent'  → provably never transmitted → retry safe
  *  - 'landed'  → provably applied on chain → must defer
  *  - 'unknown' → chain state unverifiable → must defer
- * @param {import('./dexbot_class').DEXBot} bot
+ * @param {import('./dexbot_class.js').DEXBot} bot
  * @param {Array} freshChain - Non-empty, non-truncated chain snapshot
  * @param {Object} ctx - Operation context (kind: create/cancel/size-update/rotation)
  * @returns {'absent' | 'landed' | 'unknown'}
@@ -964,7 +985,7 @@ function verifyUpdateUnapplied(freshChain, ctx) {
  * reconciliation machinery (pollChainForConfirmation +
  * reconcileAfterUncertainBroadcast), which verifies inclusion and adopts
  * landed orders before the next cycle.
- * @param {import('./dexbot_class').DEXBot} bot
+ * @param {import('./dexbot_class.js').DEXBot} bot
  * @param {Array} operations
  * @param {Array} opContexts
  * @returns {Promise<{result: Object, opContexts: Array}>}
@@ -1069,7 +1090,7 @@ function chainOrderUnchangedFromCache(chainOrder, cachedRaw) {
 }
 /**
  * Execute blockchain operations with appropriate strategy (single batch or pair mode).
- * @param {import('./dexbot_class').DEXBot} bot
+ * @param {import('./dexbot_class.js').DEXBot} bot
  * @param {Array} operations
  * @param {Array} opContexts
  * @returns {Promise<{result: Object, opContexts: Array}>}
@@ -1132,7 +1153,7 @@ async function executeOperationsWithStrategy(bot, operations, opContexts) {
 }
 /**
  * Validate that operations can be executed with available funds before broadcasting.
- * @param {import('./dexbot_class').DEXBot} bot
+ * @param {import('./dexbot_class.js').DEXBot} bot
  * @param {Array} operations
  * @param {Object} assetA
  * @param {Object} assetB
@@ -1223,7 +1244,7 @@ function validateOperationFunds(bot, operations, assetA, assetB) {
 }
 /**
  * Resolve the ideal size from an order-like object with fallback.
- * @param {import('./dexbot_class').DEXBot} bot
+ * @param {import('./dexbot_class.js').DEXBot} bot
  * @param {Object|null} orderLike
  * @param {number|null} [fallbackSize=null]
  * @returns {number|null}
@@ -1246,19 +1267,19 @@ function resolveIdealSizeForValidation(_bot, orderLike, fallbackSize = null) {
 }
 /**
  * Validate that an order size is safe to execute.
- * @param {import('./dexbot_class').DEXBot} bot
+ * @param {import('./dexbot_class.js').DEXBot} bot
  * @param {number} size
  * @param {string} type
  * @param {Object|null} [orderLike=null]
  * @param {number|null} [fallbackSize=null]
- * @returns {import('./types').OrderValidationResult}
+ * @returns {import('./types.js').OrderValidationResult}
  */
 function validateOrderSizeForExecution(bot, size, type, orderLike = null, fallbackSize = null) {
     return validateOrderSize(size, type, bot.manager.assets, bot.config.gridLimits?.MIN_ORDER_SIZE_FACTOR, resolveIdealSizeForValidation(bot, orderLike, fallbackSize), bot.config.gridLimits?.PARTIAL_DUST_THRESHOLD_PERCENTAGE);
 }
 /**
  * Build COW actions array from a simple plan object.
- * @param {import('./dexbot_class').DEXBot} bot
+ * @param {import('./dexbot_class.js').DEXBot} bot
  * @param {Object|Array} plan
  * @returns {Array}
  */
@@ -1335,9 +1356,9 @@ function buildActionsFromPlan(_bot, plan) {
 }
 /**
  * Build a COW result object (workingGrid + actions) from a simple plan.
- * @param {import('./dexbot_class').DEXBot} bot
+ * @param {import('./dexbot_class.js').DEXBot} bot
  * @param {Object|Array} plan
- * @returns {{workingGrid: import('./types').WorkingGrid, workingIndexes: Object, workingBoundary: number, actions: Array}}
+ * @returns {{workingGrid: import('./types.js').WorkingGrid, workingIndexes: Object, workingBoundary: number, actions: Array}}
  */
 function buildCowResultFromPlan(bot, plan) {
     const workingGrid = new WorkingGrid(bot.manager.orders, {
@@ -1418,8 +1439,8 @@ function buildCowResultFromPlan(bot, plan) {
 }
 /**
  * Restore skipped update slots in the working grid to master state.
- * @param {import('./dexbot_class').DEXBot} bot
- * @param {import('./types').WorkingGrid} workingGrid
+ * @param {import('./dexbot_class.js').DEXBot} bot
+ * @param {import('./types.js').WorkingGrid} workingGrid
  * @param {Set<string>} skippedSlotIds
  * @param {number} [skippedCount=0]
  */
@@ -1603,7 +1624,7 @@ function restoreSkippedUpdateSlotsInWorkingGrid(bot, workingGrid, skippedSlotIds
  * release exactly the entry they were pushed with, instead of underflowing
  * or stealing a nested grid's entry.
  *
- * @param {import('./dexbot_class').DEXBot} bot
+ * @param {import('./dexbot_class.js').DEXBot} bot
  * @param {Object} cowResult - The stale plan result
  * @param {number} replanDepth - Recursion depth (0 = first attempt)
  * @param {Object} preBroadcastGuard - The failed evaluateCommit result
@@ -1696,9 +1717,35 @@ async function replanStaleBatch(bot, cowResult, replanDepth, preBroadcastGuard)
     await requestStructuralResync(bot, 're-plan unavailable (proceeding with original plan)', { reason: preBroadcastGuard.reason });
     return { handled: false };
 }
+/**
+ * Wait for any in-flight COW broadcast to settle before this batch proceeds.
+ * The in-flight batch sets _cowBroadcastInFlight right before broadcasting and
+ * clears it in its outer finally, so this wait is bounded by the broadcast +
+ * recovery duration. Returns after the flag clears, the cap is exceeded, or
+ * shutdown begins. Callers MUST set bot._cowBroadcastInFlight = true
+ * synchronously (before the next await) once this resolves so the
+ * check-and-set stays atomic and two planning batches cannot both win the
+ * broadcast slot.
+ * @param {import('./dexbot_class.js').DEXBot} bot
+ * @param {string} label - Stage label for the deferral log (e.g. 'entry', 'pre-broadcast')
+ */
+async function waitForCowBroadcastSingleFlight(bot, label) {
+    if (!bot._cowBroadcastInFlight)
+        return;
+    bot.manager.logger.log(`[COW] ${label}: a COW broadcast is already in flight; deferring this batch until it settles (prevents overlapping-broadcast commit collision).`, 'warn');
+    const waitDeadline = Date.now() + SINGLE_FLIGHT_MAX_WAIT_MS;
+    while (bot._cowBroadcastInFlight) {
+        if (bot._shuttingDown || Date.now() > waitDeadline)
+            break;
+        await sleep(250);
+    }
+    if (bot._cowBroadcastInFlight) {
+        bot.manager.logger.log(`[COW] ${label}: waited for in-flight broadcast but it did not settle within the cap; proceeding (commit guard + chain adoption will close divergence).`, 'warn');
+    }
+}
 /**
  * COW broadcast: Execute blockchain operations and commit working grid on success.
- * @param {import('./dexbot_class').DEXBot} bot
+ * @param {import('./dexbot_class.js').DEXBot} bot
  * @param {Object} cowResult
  * @param {Object} [options={}] - Internal execution options (replanDepth)
  * @returns {Promise<Object>}
@@ -1720,6 +1767,14 @@ async function updateOrdersOnChainBatchCOW(bot, cowResult, options = {}) {
         popPushedWorkingGrid(bot, cowResult);
         return { executed: true, hadRotation: false };
     }
+    // Single-flight COW broadcast guard (entry check): never broadcast two
+    // batches concurrently. Overlapping broadcasts plan from the same base
+    // grid version; when the first commits it bumps _gridVersion, so the
+    // second's commit is refused (base-version mismatch) -> adopt-from-chain
+    // -> snapshot reload that can drop the adopted order and produce an
+    // orphan fill. This entry wait is an optimization; the authoritative
+    // atomic check-and-set happens right before the broadcast below.
+    await waitForCowBroadcastSingleFlight(bot, 'entry');
     const chainOrderCandidates = Array.isArray(bot.manager?._lastUnmatchedChainOrders)
         ? bot.manager._lastUnmatchedChainOrders
         : [];
@@ -1925,6 +1980,14 @@ async function updateOrdersOnChainBatchCOW(bot, cowResult, options = {}) {
         }
     }
     bot.manager.lockOrders(idsToLock);
+    // Ownership of the single-flight broadcast slot for THIS frame. Only the
+    // frame that claimed the slot (set bot._cowBroadcastInFlight = true below)
+    // may clear it in the finally. A frame that waits at the entry check or
+    // early-returns after planning (fund validation, create-slot abort, op-prep
+    // throw) never owns the slot and MUST NOT clear it — an unconditional clear
+    // would wipe a concurrent batch's in-flight flag and let a third batch
+    // broadcast on top of it (the exact overlap this guard prevents).
+    let heldBroadcastSlot = false;
     try {
         bot._batchInFlight++;
         bot._markGridActivity('batch start');
@@ -2174,6 +2237,15 @@ async function updateOrdersOnChainBatchCOW(bot, cowResult, options = {}) {
             }
             // Fall through: proceed with the current plan (bounded policy).
         }
+        // Single-flight broadcast slot (authoritative, atomic check-and-set):
+        // by this point this batch finished planning; any other batch that
+        // started planning concurrently and beat us here holds the slot. Wait
+        // for it to settle, then claim the slot synchronously (no await
+        // between the check inside waitForCowBroadcastSingleFlight and the
+        // assignment below), so two batches can never broadcast together.
+        await waitForCowBroadcastSingleFlight(bot, 'pre-broadcast');
+        bot._cowBroadcastInFlight = true;
+        heldBroadcastSlot = true;
         await bot._ensureCredentialDaemonWritable('COW batch broadcast');
         bot.manager.logger.log(`[COW] Broadcasting batch with ${operations.length} operations...`, 'info');
         bot._lastBroadcastHeartbeatAt = Date.now();
@@ -2392,6 +2464,8 @@ async function updateOrdersOnChainBatchCOW(bot, cowResult, options = {}) {
     }
     finally {
         bot._batchInFlight--;
+        if (heldBroadcastSlot)
+            bot._cowBroadcastInFlight = false;
         bot._markGridActivity('batch end');
         bot.manager.unlockOrders(idsToLock);
         if (!bot._shuttingDown && bot._incomingFillQueue.length > 0) {
@@ -2403,7 +2477,7 @@ async function updateOrdersOnChainBatchCOW(bot, cowResult, options = {}) {
  * Request a structural grid resync with the recovery-state flag raised, so a
  * later plan cannot duplicate orders placed by a batch whose chain adoption is
  * pending. No-op when the manager has no structural-resync handler.
- * @param {import('./dexbot_class').DEXBot} bot
+ * @param {import('./dexbot_class.js').DEXBot} bot
  * @param {string} reason - Human-readable resync reason
  * @param {Object} [details={}] - Details passed to the resync handler
  */
@@ -2424,7 +2498,7 @@ async function requestStructuralResync(bot, reason, details = {}) {
  * not be read (empty/lagging read, truncated read, or sync failure) — the
  * caller then keeps the pending-broadcast protection and defers adoption to
  * a structural resync.
- * @param {import('./dexbot_class').DEXBot} bot
+ * @param {import('./dexbot_class.js').DEXBot} bot
  * @param {Object} chainOrders - Chain orders module
  * @param {string} logPrefix - Log prefix for sync failure messages
  * @returns {Promise<boolean>}
@@ -2458,7 +2532,7 @@ async function adoptPlacedBatchFromChain(bot, chainOrders, logPrefix) {
  * Persist the master grid after a chain adoption and clear the pending
  * broadcast protection. Persist failures are logged, not thrown — the
  * in-memory master is authoritative and the next sync/persist converges disk.
- * @param {import('./dexbot_class').DEXBot} bot
+ * @param {import('./dexbot_class.js').DEXBot} bot
  * @param {string} logPrefix - Log prefix for persist failure messages
  */
 async function persistGridAndClearPendingBroadcasts(bot, logPrefix) {
@@ -2484,7 +2558,7 @@ async function persistGridAndClearPendingBroadcasts(bot, logPrefix) {
  * capital release for cancelled orders (diff-based, applying it again would
  * double-release), and rotations without a committed destination cannot be
  * accounted locally.
- * @param {import('./dexbot_class').DEXBot} bot
+ * @param {import('./dexbot_class.js').DEXBot} bot
  * @param {Array<Object>} contexts - Executed op contexts (create/rotation/cancel)
  */
 async function applyAdoptionFeeAccounting(bot, contexts) {
@@ -2548,7 +2622,7 @@ async function applyAdoptionFeeAccounting(bot, contexts) {
 /**
  * Process results from batch transaction execution.
  * Updates order state, synchronizes with chain, and deducts BTS fees.
- * @param {import('./dexbot_class').DEXBot} bot
+ * @param {import('./dexbot_class.js').DEXBot} bot
  * @param {Object} result
  * @param {Array} opContexts
  * @returns {Object} Result with { executed: boolean, hadRotation: boolean }
@@ -2725,7 +2799,8 @@ async function processBatchResults(bot, result, opContexts) {
         updateOperationCount
     };
 }
-module.exports = {
+export { buildOutsideInPairGroupsForOrders, buildOutsideInPairGroupsForCreateEntries, extractOperationResults, findMissingCreateResultContexts, recoverAfterMissingCreateResults, preserveMissingCreateBlockersAfterRecovery, markMissingCreateResultsAsStructuralBlocker, formatUnmatchedChainOrderForLog, recordPendingBroadcast, clearPendingBroadcasts, clearPendingBroadcastsForSlots, popPushedWorkingGrid, buildChainOrderFingerprint, normalizeChainOrderForPendingMatch, findChainOrderForSlot, reconcileAfterUncertainBroadcast, reconcileAfterUncertainBroadcastImpl, autoCancelOneUnmatchedOrphan, shouldExecuteCreatePairMode, executeWithRetryOnUncertain, executeOperationsWithStrategy, validateOperationFunds, resolveIdealSizeForValidation, validateOrderSizeForExecution, buildActionsFromPlan, buildCowResultFromPlan, restoreSkippedUpdateSlotsInWorkingGrid, applyRotationTransitionsToWorkingGrid, pollChainForConfirmation, updateOrdersOnChainBatchCOW, processBatchResults };
+export default {
     buildOutsideInPairGroupsForOrders,
     buildOutsideInPairGroupsForCreateEntries,
     extractOperationResults,