dexbot 1.5.3 → 1.6.0

package/dist/modules/dexbot_cow_runtime.js

@@ -1048,7 +1048,7 @@ async function autoCancelOneUnmatchedOrphan(bot) {
     }
     const target = unmatched.find((u) => u && u.reason === 'price-drift-orphan');
     if (!target) {
-        return { cancelled: false, reason: 'no-price-drift-orphan', message: 'no price-drift orphan to cancel; other unmatched orders are adoptable' };
+        return { cancelled: false, reason: 'no-price-drift-orphan', message: 'no price-drift orphan to cancel; remaining unmatched orders need no cancellation (adoptable or deferred holds)' };
     }
     const orderId = target.id || target.orderId || target.chainOrderId;
     if (!orderId) {
@@ -2200,6 +2200,57 @@ function resolveRefillBoundaryHold(workingBoundary, committedBoundary, skippedUp
         heldRefillSlotIds
     };
 }
+/**
+ * Track consecutive boundary-hold batches on the manager (ops visibility).
+ *
+ * A single hold is normal maker discipline: the guard vetoed stale-priced
+ * refills, so the committed boundary stays instead of advancing past
+ * stranded rail holes. A growing run means the grid is trailing the market
+ * (plans keep pricing refills against a racing guard pivot, typically while
+ * fill batches run on backlogged state) and only fresh fills unstick it —
+ * worth escalating so it cannot hide inside per-batch warns.
+ *
+ * Also records a hold signature (`_lastHeldPlanSignature`) for the
+ * identical-held-plan suppression in `performSafeRebalance`, and the caller
+ * escalates a long run to a guard-aware structural re-center. A fill-less
+ * re-plan from unchanged master re-derives the identical plan and re-hits
+ * the identical guard blocks, so it is suppressed rather than re-broadcast;
+ * the heal path is a fresh fill-driven plan or the re-center.
+ * @param {any} manager - Order manager (mutable tracking fields)
+ * @param {boolean} held - Whether this batch held the boundary
+ * @param {any} keptBoundary - Committed boundary that was kept
+ * @param {any} plannedBoundary - Boundary the plan wanted
+ * @param {string[]} heldSlotIds - Refill slots skipped this batch
+ * @returns {number} Consecutive-hold count after this batch (0 when clear)
+ */
+function trackBoundaryHold(manager, held, keptBoundary, plannedBoundary, heldSlotIds) {
+    if (!manager)
+        return 0;
+    const prev = Number(manager._consecutiveBoundaryHolds) || 0;
+    const consecutive = held ? prev + 1 : 0;
+    manager._consecutiveBoundaryHolds = consecutive;
+    if (held) {
+        manager._lastBoundaryHoldInfo = {
+            at: Date.now(),
+            kept: keptBoundary,
+            planned: plannedBoundary,
+            slots: Array.isArray(heldSlotIds) ? [...heldSlotIds] : [],
+        };
+        // Signature for the identical-held-plan suppression in
+        // performSafeRebalance: a fill-less replan with the same boundary,
+        // pivot and fill timestamp can only reproduce this hold.
+        manager._lastHeldPlanSignature = {
+            boundaryIdx: keptBoundary,
+            pivot: manager._lastFilledPrice ?? null,
+            fillsAt: manager._lastFilledAt ?? 0,
+            wire: Array.isArray(heldSlotIds) ? [...heldSlotIds] : [],
+        };
+    }
+    else {
+        manager._lastHeldPlanSignature = null;
+    }
+    return consecutive;
+}
 /**
  * Restore skipped update slots in the working grid to master state.
  * @param {import('./dexbot_class.js').DEXBot} bot
@@ -2533,8 +2584,13 @@ async function runPreBroadcastGuards(bot, cowResult) {
     const unmatchedChainOrders = Array.isArray(bot.manager?._lastUnmatchedChainOrders)
         ? bot.manager._lastUnmatchedChainOrders
         : [];
+    // Out-of-grid holds are permanent by design (live orders held outside
+    // the frozen rail): they can never be adopted and collide with nothing,
+    // so they must not block CREATES — otherwise one dip-protection hold
+    // freezes the whole grid. Only adoptable/cancellable orphans block.
+    const blockingUnmatched = unmatchedChainOrders.filter((u) => !orderUtils.isNonBlockingUnmatchedOrder(u));
     const pendingBroadcasts = getPendingBroadcasts(bot);
-    if (hasCreateActions && (unmatchedChainOrders.length > 0 || pendingBroadcasts.length > 0)) {
+    if (hasCreateActions && (blockingUnmatched.length > 0 || pendingBroadcasts.length > 0)) {
         if (pendingBroadcasts.length > 0) {
             bot.manager.logger.log(`[COW] Rejecting CREATE batch: ${pendingBroadcasts.length} pending broadcast(s) from a prior uncertain ` +
                 `broadcast. Running recovery before placing replacement orders.`, 'error');
@@ -2562,11 +2618,11 @@ async function runPreBroadcastGuards(bot, cowResult) {
                 }
             };
         }
-        const unmatchedSample = unmatchedChainOrders
+        const unmatchedSample = blockingUnmatched
             .slice(0, 3)
             .map((o) => formatUnmatchedChainOrderForLog(o))
             .join(' | ');
-        bot.manager.logger.log(`[COW] ${unmatchedChainOrders.length} unmatched chain order(s) blocking CREATES ` +
+        bot.manager.logger.log(`[COW] ${blockingUnmatched.length} unmatched chain order(s) blocking CREATES ` +
             (unmatchedSample ? `(${unmatchedSample})` : '') +
             ` — adopting via sync instead of cancelling`, 'info');
         try {
@@ -2662,6 +2718,19 @@ async function updateOrdersOnChainBatchCOW(bot, cowResult, options = {}) {
     // frozen for every downstream commit path (success + uncertain-catch).
     // workingBoundary itself stays untouched (audit trail).
     let effectiveBoundary = workingBoundary;
+    // True when the refill hold pinned the committed boundary over the plan's
+    // target. Hoisted out of the broadcast try block: the uncertain-broadcast
+    // catch commits too, and a held boundary must keep the owed fill crawls
+    // there as well (see _commitWorkingGrid pending-crawl bookkeeping).
+    let boundaryHeld = false;
+    // Consecutive-hold re-center tuning (see the escalation block below).
+    const boundaryHoldTiming = constantsModule?.TIMING || {};
+    const holdResyncThreshold = Number(boundaryHoldTiming.BOUNDARY_HOLD_RESYNC_THRESHOLD) > 0
+        ? Number(boundaryHoldTiming.BOUNDARY_HOLD_RESYNC_THRESHOLD)
+        : 4;
+    const holdResyncCooldownMs = Number(boundaryHoldTiming.BOUNDARY_HOLD_RESYNC_COOLDOWN_MS) > 0
+        ? Number(boundaryHoldTiming.BOUNDARY_HOLD_RESYNC_COOLDOWN_MS)
+        : 5 * 60 * 1000;
     if (bot.config.dryRun) {
         const cancelCount = actions.filter((a) => a.type === COW_ACTIONS.CANCEL).length;
         const createCount = actions.filter((a) => a.type === COW_ACTIONS.CREATE).length;
@@ -2775,6 +2844,16 @@ async function updateOrdersOnChainBatchCOW(bot, cowResult, options = {}) {
         bot._markGridActivity('batch start');
         bot.manager._setRebalanceState(REBALANCE_STATES.BROADCASTING);
         bot.manager.startBroadcasting();
+        // P3 — freeze the guard pivot once per batch: per-action refreshes
+        // mutated the pivot mid-batch (02:03 pivots drifted 0.001523→0.001529
+        // across 20 checks), so early actions were judged against a different
+        // pivot than later ones. The batch summary still reports whether this
+        // freeze moved the pivot under the plan.
+        try {
+            if (refreshLastFillPivotFromQueue(bot))
+                lastFillGuardPivotRefreshed = true;
+        }
+        catch { /* best-effort */ }
         for (const action of actions) {
             if (action.type === COW_ACTIONS.CANCEL) {
                 try {
@@ -2861,13 +2940,13 @@ async function updateOrdersOnChainBatchCOW(bot, cowResult, options = {}) {
                         const isCorrectionCreate = actionOrigin === 'spread-correction'
                             || (actionOrigin == null && batchOrigin === 'spread-correction');
                         if (!isCorrectionCreate) {
-                            const { check, refreshed } = runLastFillGuardCheck(bot, createPrice, order.size, order.type, lastFillGuardStats);
+                            const { check, refreshed } = runLastFillGuardCheck(bot, createPrice, order.size, order.type, lastFillGuardStats, true);
                             if (refreshed)
                                 lastFillGuardPivotRefreshed = true;
                             if (check.blocked) {
                                 lastFillGuardStats.skipped++;
                                 const dir = order.type === ORDER_TYPES.BUY ? 'above' : 'below';
-                                bot.manager.logger.log(`[LAST-FILL-GUARD] Skipping ${order.type} CREATE for ${order.id} at ${Format.formatPrice6(createPrice)}: ${dir} last filled ${Format.formatPrice6(check.pivot)} (halfInc ${check.halfInc}% thr ${Format.formatPrice6(check.threshold)}); re-planned after market moves`, 'warn');
+                                bot.manager.logger.log(`[LAST-FILL-GUARD] Skipping ${order.type} CREATE for ${order.id} at ${Format.formatPrice6(createPrice)}: ${dir} last filled ${Format.formatPrice6(check.pivot)} (halfInc ${check.halfInc}% thr ${Format.formatPrice6(check.threshold)}); re-planned after market moves`, 'debug');
                                 if (order.id)
                                     skippedCreateSlotIds.add(order.id);
                                 continue;
@@ -2938,6 +3017,15 @@ async function updateOrdersOnChainBatchCOW(bot, cowResult, options = {}) {
                         }
                         const rotationSizeValidation = validateOrderSizeForExecution(bot, newSize, orderType, action.order, newSize);
                         if (!rotationSizeValidation.isValid) {
+                            // Record like every sibling skip site: the skip set
+                            // feeds both the working-grid restore and the
+                            // boundary hold (a skipped refill must not let the
+                            // committed boundary advance past its empty slot).
+                            skippedUpdateCount++;
+                            if (action.id)
+                                skippedUpdateSlotIds.add(action.id);
+                            if (action.newGridId)
+                                skippedUpdateSlotIds.add(action.newGridId);
                             bot.manager.logger.log(`Skipping rotation update ${action.id} -> ${action.newGridId}: ${rotationSizeValidation.reason}`, 'warn');
                             continue;
                         }
@@ -3087,7 +3175,7 @@ async function updateOrdersOnChainBatchCOW(bot, cowResult, options = {}) {
                                 lastFillGuardStats.bypassed++;
                             }
                             else {
-                                const { check, refreshed } = runLastFillGuardCheck(bot, newPrice, newSize, orderType, lastFillGuardStats);
+                                const { check, refreshed } = runLastFillGuardCheck(bot, newPrice, newSize, orderType, lastFillGuardStats, true);
                                 if (refreshed)
                                     lastFillGuardPivotRefreshed = true;
                                 if (check.blocked) {
@@ -3098,7 +3186,7 @@ async function updateOrdersOnChainBatchCOW(bot, cowResult, options = {}) {
                                     if (action.newGridId)
                                         skippedUpdateSlotIds.add(action.newGridId);
                                     const dir = orderType === ORDER_TYPES.BUY ? 'above' : 'below';
-                                    bot.manager.logger.log(`[LAST-FILL-GUARD] Skipping ${orderType} UPDATE for ${action.id} -> ${action.newGridId} at ${Format.formatPrice6(newPrice)}: ${dir} last filled ${Format.formatPrice6(check.pivot)} (halfInc ${check.halfInc}% thr ${Format.formatPrice6(check.threshold)})`, 'warn');
+                                    bot.manager.logger.log(`[LAST-FILL-GUARD] Skipping ${orderType} UPDATE for ${action.id} -> ${action.newGridId} at ${Format.formatPrice6(newPrice)}: ${dir} last filled ${Format.formatPrice6(check.pivot)} (halfInc ${check.halfInc}% thr ${Format.formatPrice6(check.threshold)})`, 'debug');
                                     continue;
                                 }
                                 lastFillGuardStats.passed++;
@@ -3214,10 +3302,10 @@ async function updateOrdersOnChainBatchCOW(bot, cowResult, options = {}) {
                                 }
                                 // LAST-FILL GUARD (fallback variant): this CREATE
                                 // replaces a rotation UPDATE at a repriced level,
-                                // so it obeys the same guard with a refreshed
-                                // pivot — no origin bypass, same as rotations.
+                                // so it obeys the same guard against the frozen
+                                // batch pivot — no origin bypass, same as rotations.
                                 try {
-                                    const { check: fbCheck, refreshed: fbRefreshed } = runLastFillGuardCheck(bot, fbPrice, fbSize, fbType, lastFillGuardStats);
+                                    const { check: fbCheck, refreshed: fbRefreshed } = runLastFillGuardCheck(bot, fbPrice, fbSize, fbType, lastFillGuardStats, true);
                                     if (fbRefreshed)
                                         lastFillGuardPivotRefreshed = true;
                                     if (fbCheck.blocked) {
@@ -3226,7 +3314,7 @@ async function updateOrdersOnChainBatchCOW(bot, cowResult, options = {}) {
                                         bot.manager.logger.log(`[LAST-FILL-GUARD] Skipping CREATE fallback for ${targetSlotId} at ` +
                                             `${Format.formatPrice6(fbPrice)}: ${fbDir} last filled ` +
                                             `${Format.formatPrice6(fbCheck.pivot)} (halfInc ${fbCheck.halfInc}% thr ` +
-                                            `${Format.formatPrice6(fbCheck.threshold)}); re-planned after market moves`, 'warn');
+                                            `${Format.formatPrice6(fbCheck.threshold)}); re-planned after market moves`, 'debug');
                                         continue;
                                     }
                                     lastFillGuardStats.passed++;
@@ -3268,10 +3356,10 @@ async function updateOrdersOnChainBatchCOW(bot, cowResult, options = {}) {
         // are what incident reconstruction needs. Origin folds in here as
         // mode=bypassed(<origin>); there is no second source of truth.
         // Cold (guard off) is warn, not info — a disabled guard must say so.
-        // pivotRefreshed surfaces whether a mid-broadcast queued fill moved the
-        // pivot under this batch's checks (the refresh itself stays debug).
-        // Note the printed pivot is end-of-batch state: when pivotRefreshed is
-        // true, early actions were checked against the older pivot.
+        // pivotRefreshed surfaces whether the batch-start freeze picked up a
+        // queued fill (the refresh itself stays debug). The pivot is frozen
+        // for the whole batch, so every action was checked against the same
+        // pivot printed here.
         try {
             const totalGuarded = lastFillGuardStats.checked + lastFillGuardStats.bypassed;
             if (totalGuarded > 0) {
@@ -3312,10 +3400,42 @@ async function updateOrdersOnChainBatchCOW(bot, cowResult, options = {}) {
         // the committed boundary; intersect-only, grid still commits.
         const refillHold = resolveRefillBoundaryHold(workingBoundary, bot.manager.boundaryIdx, skippedUpdateSlotIds, clampedUpdateSlotIds, cowResult?.refillSlotIds, skippedCreateSlotIds);
         effectiveBoundary = refillHold.effectiveBoundary;
+        boundaryHeld = refillHold.heldRefillSlotIds.length > 0;
         if (refillHold.heldRefillSlotIds.length > 0) {
             bot.manager.logger.log(`[COW] Boundary hold: ${refillHold.heldRefillSlotIds.length} refill slot(s) skipped ` +
                 `(${refillHold.heldRefillSlotIds.join(', ')}) — keeping ${bot.manager.boundaryIdx} over planned ${workingBoundary}`, 'warn');
         }
+        // Consecutive-hold tracking (INV-COW-007 visibility): escalate a
+        // growing run — the grid is trailing the market and only fresh
+        // fills unstick it. Cleared automatically on the first clean batch.
+        const consecutiveHolds = trackBoundaryHold(bot.manager, refillHold.heldRefillSlotIds.length > 0, bot.manager.boundaryIdx, workingBoundary, refillHold.heldRefillSlotIds);
+        if (consecutiveHolds >= 3) {
+            bot.manager.logger.log(`[COW] Boundary held ${consecutiveHolds} consecutive batches ` +
+                `(keeping ${bot.manager.boundaryIdx} over planned ${workingBoundary}). ` +
+                `Grid is trailing the market — refills re-price once the guard pivot settles; ` +
+                `heals on the next fill-driven plan. Investigate only if the run keeps growing without new fills.`, 'warn');
+        }
+        // Guard-aware re-center escalation (INV-COW-007 heal path): a run of
+        // holds carrying fresh fills means the grid is trailing the market and
+        // will not heal from fill-less replans (they re-derive the identical
+        // veto). Request a structural resync that re-derives centers on the
+        // live pivot; the cooldown prevents resync storms. requestStructuralGridResync
+        // re-defers while this batch is still in flight, so it runs in a clean context.
+        if (boundaryHeld && consecutiveHolds >= holdResyncThreshold) {
+            const freshFills = Array.isArray(cowResult?.fills) && cowResult.fills.length > 0;
+            const lastResyncAt = Number(bot.manager._lastBoundaryHoldResyncAt) || 0;
+            if (freshFills && (Date.now() - lastResyncAt) >= holdResyncCooldownMs) {
+                bot.manager._lastBoundaryHoldResyncAt = Date.now();
+                bot.manager.logger.log(`[COW] Boundary held ${consecutiveHolds} consecutive batches with fresh fills; ` +
+                    `requesting guard-aware structural re-center (cooldown ${Math.round(holdResyncCooldownMs / 1000)}s)`, 'warn');
+                try {
+                    void bot.manager.requestStructuralGridResync?.('boundary-hold-trailing-market', { reason: 'boundary-hold-trailing-market' });
+                }
+                catch (err) {
+                    bot.manager.logger.log(`[COW] Structural re-center request failed (non-fatal): ${getErrorMessage(err)}`, 'warn');
+                }
+            }
+        }
         if (operations.length === 0) {
             // Pop the working grid: in the re-plan recursion the fresh plan's
             // grid was pushed by performSafeRebalance, and nothing downstream
@@ -3454,7 +3574,7 @@ async function updateOrdersOnChainBatchCOW(bot, cowResult, options = {}) {
                 // options.result, so a later throw in this frame (e.g.
                 // processBatchResults after a successful commit) cannot pop a
                 // second time for the same grid in the batch catch below.
-                const commitOk = await bot.manager._commitWorkingGrid(workingGrid, workingIndexes, effectiveBoundary, { skipRecalc: true, result: cowResult });
+                const commitOk = await bot.manager._commitWorkingGrid(workingGrid, workingIndexes, effectiveBoundary, { skipRecalc: true, result: cowResult, boundaryHeld });
                 if (!commitOk) {
                     // Master changed during broadcast (e.g. a fill landed and was
                     // processed concurrently) so the commit was refused. The batch
@@ -3544,7 +3664,7 @@ async function updateOrdersOnChainBatchCOW(bot, cowResult, options = {}) {
                     // _commitWorkingGrid pops on every settle path and clears
                     // the push marker via options.result, so a later throw here
                     // must not pop again in the batch catch below.
-                    const pollCommitOk = await bot.manager._commitWorkingGrid(workingGrid, workingIndexes, effectiveBoundary, { skipRecalc: true, result: cowResult });
+                    const pollCommitOk = await bot.manager._commitWorkingGrid(workingGrid, workingIndexes, effectiveBoundary, { skipRecalc: true, result: cowResult, boundaryHeld });
                     if (!pollCommitOk) {
                         // Master moved while polling — same recovery as the
                         // refused-commit path: adopt from chain, keep pending
@@ -3878,24 +3998,32 @@ async function recoverRefusedCommit(bot, chainOrders, logPrefix, adoptOpts, cont
     return successReturn ?? { executed: false, hadRotation: false, commitRefused: true, ...extraReturn };
 }
 /**
- * Run the last-fill guard probe: refresh the pivot from still-queued fills,
- * read the durable pivot, and evaluate isLastFillGuardBlocked. Consolidates
- * the identical probe pattern in the CREATE, UPDATE-rotation, and
- * CREATE-fallback guards (origin bypasses and skip logging stay at the
- * call sites, which differ per action kind).
+ * Run the last-fill guard probe: optionally refresh the pivot from
+ * still-queued fills, read the durable pivot, and evaluate
+ * isLastFillGuardBlocked. Consolidates the identical probe pattern in the
+ * CREATE, UPDATE-rotation, and CREATE-fallback guards (origin bypasses and
+ * skip logging stay at the call sites, which differ per action kind).
+ * Batch callers pass skipRefresh=true: the batch-start freeze owns refreshes
+ * so every action in a batch is judged against the same pivot.
  * @param {Object} bot
  * @param {number} price - Target order price
  * @param {number} size - Order size
  * @param {string} type - ORDER_TYPES.BUY/SELL
  * @param {Object} stats - lastFillGuardStats tracker (checked++ here)
+ * @param {boolean} [skipRefresh=false] - Skip the queued-fill pivot refresh
  * @returns {{check: Object, refreshed: boolean}}
  */
-function runLastFillGuardCheck(bot, price, size, type, stats) {
+function runLastFillGuardCheck(bot, price, size, type, stats, skipRefresh = false) {
     let refreshed = false;
-    try {
-        refreshed = !!refreshLastFillPivotFromQueue(bot);
+    // The batch-start freeze (see broadcast loop head) owns pivot refreshes;
+    // per-action refreshes are disabled so every action in a batch is judged
+    // against the same pivot. Kept opt-in for non-batch callers.
+    if (!skipRefresh) {
+        try {
+            refreshed = !!refreshLastFillPivotFromQueue(bot);
+        }
+        catch { /* best-effort */ }
     }
-    catch { /* best-effort */ }
     const lastPrice = bot.manager?._lastFilledPrice;
     const lastType = bot.manager?._lastFilledType;
     const inc = resolveLastFillGuardIncrement(bot);
@@ -4145,7 +4273,7 @@ async function processBatchResults(bot, result, opContexts) {
         updateOperationCount
     };
 }
-export { isLastFillGuardBlocked, refreshLastFillPivotFromQueue, buildOutsideInPairGroupsForOrders, buildOutsideInPairGroupsForCreateEntries, extractOperationResults, findMissingCreateResultContexts, markMissingCreateResultsAsStructuralBlocker, formatUnmatchedChainOrderForLog, recordPendingBroadcast, clearPendingBroadcasts, clearPendingBroadcastsForSlots, popPushedWorkingGrid, buildChainOrderFingerprint, normalizeChainOrderForPendingMatch, findChainOrderForSlot, reconcileAfterUncertainBroadcast, reconcileAfterUncertainBroadcastImpl, autoCancelOneUnmatchedOrphan, shouldExecuteCreatePairMode, executeWithRetryOnUncertain, executeChunkedWithRetryOnUncertain, formatPartialBroadcastSummary, executeOperationsWithStrategy, validateOperationFunds, resolveIdealSizeForValidation, validateOrderSizeForExecution, buildActionsFromPlan, buildCowResultFromPlan, restoreSkippedUpdateSlotsInWorkingGrid, applyRotationTransitionsToWorkingGrid, pollChainForConfirmation, updateOrdersOnChainBatchCOW, processBatchResults, adoptPlacedBatchFromChain, resolveRefillBoundaryHold, toRefillSlotIdSet };
+export { isLastFillGuardBlocked, refreshLastFillPivotFromQueue, buildOutsideInPairGroupsForOrders, buildOutsideInPairGroupsForCreateEntries, extractOperationResults, findMissingCreateResultContexts, markMissingCreateResultsAsStructuralBlocker, formatUnmatchedChainOrderForLog, recordPendingBroadcast, clearPendingBroadcasts, clearPendingBroadcastsForSlots, popPushedWorkingGrid, buildChainOrderFingerprint, normalizeChainOrderForPendingMatch, findChainOrderForSlot, reconcileAfterUncertainBroadcast, reconcileAfterUncertainBroadcastImpl, autoCancelOneUnmatchedOrphan, shouldExecuteCreatePairMode, executeWithRetryOnUncertain, executeChunkedWithRetryOnUncertain, formatPartialBroadcastSummary, executeOperationsWithStrategy, validateOperationFunds, resolveIdealSizeForValidation, validateOrderSizeForExecution, buildActionsFromPlan, buildCowResultFromPlan, restoreSkippedUpdateSlotsInWorkingGrid, applyRotationTransitionsToWorkingGrid, pollChainForConfirmation, updateOrdersOnChainBatchCOW, processBatchResults, adoptPlacedBatchFromChain, resolveRefillBoundaryHold, toRefillSlotIdSet, trackBoundaryHold };
 // Exported for regression tests (issue #23 sibling): the uncertain-broadcast
 // discard path must never drop a placement silently when master lost the slot.
 export { restoreDiscardedCreates };
@@ -4179,6 +4307,7 @@ export default {
     restoreSkippedUpdateSlotsInWorkingGrid,
     resolveRefillBoundaryHold,
     toRefillSlotIdSet,
+    trackBoundaryHold,
     applyRotationTransitionsToWorkingGrid,
     pollChainForConfirmation,
     updateOrdersOnChainBatchCOW,