dexbot 1.2.5 → 1.2.7

package/dist/modules/dexbot_class.js

@@ -111,7 +111,6 @@ class DEXBot {
     _staleCleanupRetentionMs;
     _metrics;
     _shuttingDown;
-    _shutdownStarted;
     _shutdownPromise;
     _blockchainFetchInterval;
     _blockchainFetchInFlight;
@@ -166,6 +165,8 @@ class DEXBot {
         this.config.feeParams = rs.feeParams;
         this.config.incrementBounds = rs.incrementBounds;
         this.config.timing = rs.timing;
+        this.config.fillProcessing = rs.fillProcessing;
+        this.config.pipelineTiming = rs.pipelineTiming;
         this.config.logging = rs.logging;
         this._fillDedupeWindowMs = this.config.timing.FILL_DEDUPE_WINDOW_MS;
         this._fillRecordRetentionMs = this.config.timing.FILL_RECORD_RETENTION_MS;
@@ -200,7 +201,6 @@ class DEXBot {
         };
         // Shutdown state
         this._shuttingDown = false;
-        this._shutdownStarted = false;
         this._shutdownPromise = null;
         // Runtime handles for graceful lifecycle management
         this._blockchainFetchInterval = null;
@@ -322,6 +322,7 @@ class DEXBot {
      * @private
      */
     async _persistAndRecoverIfNeeded() {
+        this.manager._recentFillKeysSnapshot = this._getRecentFillKeysSnapshot();
         const validation = await this.manager.persistGrid();
         if (!validation.isValid) {
             this._warn(`Startup validation failed: ${validation.reason}. Triggering immediate recovery...`);
@@ -329,6 +330,7 @@ class DEXBot {
             const recoveryValidation = await this.manager.accountant._performStateRecovery(this.manager);
             if (recoveryValidation.isValid) {
                 this._log(`✓ Startup recovery successful. Persistent state restored.`);
+                this.manager._recentFillKeysSnapshot = this._getRecentFillKeysSnapshot();
                 await this.manager.persistGrid();
             }
             else {
@@ -336,6 +338,37 @@ class DEXBot {
             }
         }
     }
+    /**
+     * Snapshot the recently queued fill keys as a plain object for crash-durable persistence.
+     * Merges with any existing snapshot to avoid losing keys that were evicted from the
+     * in-memory map between persist cycles but remain within the dedup window.
+     * Only includes entries within the dedup window to avoid writing stale keys.
+     * @returns {Record<string, number>}
+     */
+    _getRecentFillKeysSnapshot() {
+        const snapshot = {};
+        const now = Date.now();
+        // 1. Collect live keys from the in-memory map
+        for (const [key, timestamp] of this._recentlyQueuedFills) {
+            if (now - Number(timestamp) < this._fillDedupeWindowMs) {
+                snapshot[key] = Number(timestamp);
+            }
+        }
+        // 2. Merge with the previous snapshot — carry forward any keys that
+        //    were present in a prior persist cycle, are still within the
+        //    dedup window, but have been evicted from _recentlyQueuedFills
+        //    (e.g. by TTL-based pruning between two persistGrid calls).
+        //    This prevents a crash + restart from losing keys that were
+        //    processed but not yet persisted.
+        if (this.manager?._recentFillKeysSnapshot) {
+            for (const [key, timestamp] of Object.entries(this.manager._recentFillKeysSnapshot)) {
+                if (!(key in snapshot) && now - Number(timestamp) < this._fillDedupeWindowMs) {
+                    snapshot[key] = Number(timestamp);
+                }
+            }
+        }
+        return snapshot;
+    }
     /**
      * Get current pipeline signal state for congestion checks.
      * @returns {{incomingFillQueueLength: number, shadowLocks: number, batchInFlight: boolean, recoveryInFlight: boolean, broadcasting: boolean}}
@@ -676,8 +709,6 @@ class DEXBot {
      * @returns {Promise<boolean>} True if all affected orders were repaired
      */
     async _targetedOrderRepair(orderIds) {
-        const { BitShares } = require('./bitshares_client');
-        const { virtualizeOrder } = require('./order/utils/order');
         try {
             const objects = await BitShares.db.get_objects(orderIds);
             if (!Array.isArray(objects) || objects.length !== orderIds.length)
@@ -801,11 +832,13 @@ class DEXBot {
             const persistedBtsFeesOwed = this.accountOrders.loadBtsFeesOwed();
             const persistedBoundaryIdx = this.accountOrders.loadBoundaryIdx();
             const persistedBtsBalance = this.accountOrders.loadBtsBalance();
+            const persistedRecentFillKeys = this.accountOrders.loadRecentFillKeys();
             return {
                 persistedGrid: repairedGrid,
                 persistedBtsFeesOwed,
                 persistedBoundaryIdx,
                 persistedBtsBalance,
+                persistedRecentFillKeys,
             };
         }
         finally {
@@ -930,10 +963,10 @@ class DEXBot {
      * @param {string} [options.context]
      * @param {Object} [options.logger]
      * @param {string} [options.replayMessage]
-     * @param {string} [options.persistenceMode='immediate']
+     * @param {string} [options.persistenceMode='batched']
      * @returns {Promise<import('./types').ReplaySafeFillResult>}
      */
-    async _applyReplaySafeOrphanFillAccounting(fill, fillOp, { context, logger = this.manager?.logger, replayMessage, persistenceMode = PROCESSED_FILL_PERSISTENCE_MODES.IMMEDIATE } = {}) {
+    async _applyReplaySafeOrphanFillAccounting(fill, fillOp, { context, logger = this.manager?.logger, replayMessage, persistenceMode = PROCESSED_FILL_PERSISTENCE_MODES.BATCHED } = {}) {
         return DexbotFillRuntime.applyReplaySafeOrphanFillAccounting(this, fill, fillOp, {
             context,
             logger,
@@ -956,7 +989,7 @@ class DEXBot {
      * @private
      */
     async _finishStartupSequence(startupState) {
-        let { persistedGrid, persistedBtsFeesOwed, persistedBoundaryIdx, persistedBtsBalance, } = startupState;
+        let { persistedGrid, persistedBtsFeesOwed, persistedBoundaryIdx, persistedBtsBalance, persistedRecentFillKeys, } = startupState;
         try {
             // CRITICAL: Activate fill listener EARLY - before ANY operations that place orders
             // This ensures fills during trigger reset and grid initialization are captured
@@ -993,11 +1026,13 @@ class DEXBot {
                                 if (this._shuttingDown)
                                     return;
                                 if (syncResult?.filledOrders?.length > 0) {
+                                    this._refreshDynamicWeightDistribution('post-reconnect sync fill');
                                     this._log(`Post-reconnect sync: ${syncResult.filledOrders.length} grid order(s) found filled.`, 'info');
                                     await this._processFillsWithBatching(syncResult.filledOrders, new Set(), 'post-reconnect sync fill');
                                     if (this._shuttingDown)
                                         return;
                                 }
+                                this.manager._recentFillKeysSnapshot = this._getRecentFillKeysSnapshot();
                                 await this.manager.persistGrid();
                                 // Cancel any dust created by reconnect fills immediately.
                                 if (!this._shuttingDown) {
@@ -1139,6 +1174,7 @@ class DEXBot {
                             }
                         }
                         await this._flushProcessedFillPersistence('post-reset-batch');
+                        this.manager._recentFillKeysSnapshot = this._getRecentFillKeysSnapshot();
                         await this.manager.persistGrid();
                     }
                     // STEP 2: Refresh chain truth before spread correction. Trigger
@@ -1205,6 +1241,15 @@ class DEXBot {
                     };
                 }
             }
+            // Restore recently queued fill keys for crash-durable dedup window.
+            // All persisted keys are restored; the in-memory TTL (_fillDedupeWindowMs)
+            // will naturally evict any that are already expired on the next fill cycle.
+            if (persistedRecentFillKeys && typeof persistedRecentFillKeys === 'object') {
+                for (const [fillKey, timestamp] of Object.entries(persistedRecentFillKeys)) {
+                    this._recentlyQueuedFills.set(fillKey, Number(timestamp));
+                }
+                this._log(`Restored ${Object.keys(persistedRecentFillKeys).length} recently queued fill key(s) from persisted snapshot`, 'debug');
+            }
             if (!this.config.dryRun && !this.accountId) {
                 throw new Error('Cannot start bot without a resolved account ID');
             }
@@ -1410,6 +1455,7 @@ class DEXBot {
             const syncResult = await this.manager.synchronizeWithChain(openOrders, 'readOpenOrders');
             let aborted = false;
             if (syncResult?.filledOrders?.length > 0) {
+                this._refreshDynamicWeightDistribution(`${tag} sync-fill`);
                 this._log(`[SYNC-CHAIN] ${syncResult.filledOrders.length} filled order(s) found during ${tag}`, 'info');
                 const batchResult = await this._processFillsWithBatching(syncResult.filledOrders, new Set(), `${tag} sync-fill`);
                 if (!batchResult?.aborted) {
@@ -1429,7 +1475,7 @@ class DEXBot {
         }
     }
     _maxConsecutiveFillConsumerFailures() {
-        return FILL_PROCESSING.MAX_CONSECUTIVE_CONSUMER_FAILURES;
+        return this.config.fillProcessing?.MAX_CONSECUTIVE_CONSUMER_FAILURES ?? FILL_PROCESSING.MAX_CONSECUTIVE_CONSUMER_FAILURES;
     }
     /**
      * Compute the backoff delay for fill-consumer retries after the failure
@@ -1441,15 +1487,16 @@ class DEXBot {
      * @private
      */
     _computeFillConsumerBackoffMs(failures) {
-        const initial = FILL_PROCESSING.CONSUMER_BACKOFF_INITIAL_MS;
-        const max = FILL_PROCESSING.CONSUMER_BACKOFF_MAX_MS;
-        const stepAfterMax = Math.max(0, failures - FILL_PROCESSING.MAX_CONSECUTIVE_CONSUMER_FAILURES);
+        const fp = this.config.fillProcessing || FILL_PROCESSING;
+        const initial = fp.CONSUMER_BACKOFF_INITIAL_MS;
+        const max = fp.CONSUMER_BACKOFF_MAX_MS;
+        const stepAfterMax = Math.max(0, failures - this._maxConsecutiveFillConsumerFailures());
         // 0 -> initial, 1 -> 2*initial, 2 -> 4*initial, ... capped at max.
         return Math.min(max, initial * Math.pow(2, stepAfterMax));
     }
     _scheduleFillConsumerRestart(chainOrders) {
         const failures = this._consecutiveConsumeFailures;
-        if (failures >= FILL_PROCESSING.MAX_CONSECUTIVE_CONSUMER_FAILURES) {
+        if (failures >= this._maxConsecutiveFillConsumerFailures()) {
             // Past the failure budget: switch from tight setImmediate loop to
             // exponential backoff. The consumer continues to retry — a transient
             // outage (e.g., credential daemon recovery) will resume normal
@@ -1731,24 +1778,51 @@ class DEXBot {
                         let resolvedOrders = [];
                         if (fillMode === 'history') {
                             this.manager.logger.log(`Syncing ${fillsToSync.length} fill(s) (history mode)`, 'info');
-                            for (const fill of fillsToSync) {
-                                const resultHistory = await this.manager.syncFromFillHistory(fill, {
-                                    persistenceMode: PROCESSED_FILL_PERSISTENCE_MODES.IMMEDIATE
-                                });
-                                const fillKey = buildFillKey({
-                                    orderId: fill?.op?.[1]?.order_id,
-                                    blockNum: fill?.block_num,
-                                    historyId: fill?.id
+                            // Batch mode for 2+ fills: acquires _gridLock once, batches drift refetch
+                            if (fillsToSync.length >= 2) {
+                                const batchResult = await this.manager.syncFromFillHistoryBatch(fillsToSync, {
+                                    persistenceMode: PROCESSED_FILL_PERSISTENCE_MODES.BATCHED
                                 });
-                                if (fillKey)
-                                    pendingFillKeysForCurrentCycle.add(fillKey);
-                                // Dust is handled by post-fill detection below.
-                                if (resultHistory.filledOrders)
-                                    resolvedOrders.push(...resultHistory.filledOrders);
-                                if (resultHistory.requiresOpenOrdersSync)
+                                for (const fill of fillsToSync) {
+                                    const fillKey = buildFillKey({
+                                        orderId: fill?.op?.[1]?.order_id,
+                                        blockNum: fill?.block_num,
+                                        historyId: fill?.id
+                                    });
+                                    if (fillKey)
+                                        pendingFillKeysForCurrentCycle.add(fillKey);
+                                }
+                                if (batchResult.filledOrders)
+                                    resolvedOrders.push(...batchResult.filledOrders);
+                                if (batchResult.requiresOpenOrdersSync)
                                     requiresOpenOrdersSync = true;
-                                if (resultHistory.ghostOrderId)
-                                    pendingGhostOrders.add(resultHistory.ghostOrderId);
+                                if (batchResult.ghostOrderIds?.length > 0) {
+                                    for (const id of batchResult.ghostOrderIds) {
+                                        pendingGhostOrders.add(id);
+                                    }
+                                }
+                            }
+                            else {
+                                // Single fill: use individual per-fill path
+                                for (const fill of fillsToSync) {
+                                    const resultHistory = await this.manager.syncFromFillHistory(fill, {
+                                        persistenceMode: PROCESSED_FILL_PERSISTENCE_MODES.BATCHED
+                                    });
+                                    const fillKey = buildFillKey({
+                                        orderId: fill?.op?.[1]?.order_id,
+                                        blockNum: fill?.block_num,
+                                        historyId: fill?.id
+                                    });
+                                    if (fillKey)
+                                        pendingFillKeysForCurrentCycle.add(fillKey);
+                                    // Dust is handled by post-fill detection below.
+                                    if (resultHistory.filledOrders)
+                                        resolvedOrders.push(...resultHistory.filledOrders);
+                                    if (resultHistory.requiresOpenOrdersSync)
+                                        requiresOpenOrdersSync = true;
+                                    if (resultHistory.ghostOrderId)
+                                        pendingGhostOrders.add(resultHistory.ghostOrderId);
+                                }
                             }
                         }
                         if (fillMode !== 'history' || requiresOpenOrdersSync) {
@@ -1845,26 +1919,77 @@ class DEXBot {
                         //     cancel tx to clean up the zombie order on chain.
                         //     Runs in the finally so it still fires even if processValidFills
                         //     throws after collecting ghost IDs into pendingGhostOrders.
-                        //     Each cancelOrder is individually try/caught so no per-order
-                        //     error can prevent resumeFundRecalc from running.
+                        //
+                        //     OPTIMIZATION: Batch all new ghost cancels into one executeBatch
+                        //     call with multiple cancelOrder ops, reducing per-order tx fees
+                        //     and broadcast overhead. Falls back to individual cancels on
+                        //     batch failure.
                         if (pendingGhostOrders.size > 0) {
                             if (!this._ghostOrderCancelAttempted)
                                 this._ghostOrderCancelAttempted = new Set();
-                            for (const ghostOrderId of pendingGhostOrders) {
-                                if (this._ghostOrderCancelAttempted.has(ghostOrderId))
-                                    continue;
-                                try {
-                                    this.manager.logger.log(`[SYNC] Cancelling orphaned chain order ${ghostOrderId} (other-side full-fill residual)`, 'info');
-                                    await chainOrders.cancelOrder(this.account, this.privateKey, ghostOrderId);
-                                    this._ghostOrderCancelAttempted.add(ghostOrderId);
+                            const newGhostIds = [...pendingGhostOrders].filter(id => !this._ghostOrderCancelAttempted.has(id));
+                            if (newGhostIds.length > 0) {
+                                const MAX_OPS_PER_TX = 200;
+                                let batchFailed = false;
+                                // Build cancel ops with per-ID error tolerance.
+                                // Index correlates 1:1 with newGhostIds (allSettled preserves order).
+                                const buildResults = await Promise.allSettled(newGhostIds.map(id => chainOrders.buildCancelOrderOp(this.account, id)));
+                                const cancelOps = [];
+                                for (let i = 0; i < buildResults.length; i++) {
+                                    const result = buildResults[i];
+                                    const id = newGhostIds[i];
+                                    if (result.status === 'fulfilled') {
+                                        cancelOps.push(result.value);
+                                    }
+                                    else {
+                                        this.manager.logger.log(`[SYNC] Failed to build cancel op for ghost order ${id}: ${result.reason?.message || result.reason}`, 'warn');
+                                    }
+                                }
+                                // Chunk into batches respecting MAX_OPS_PER_TX
+                                for (let i = 0; i < cancelOps.length; i += MAX_OPS_PER_TX) {
+                                    const chunk = cancelOps.slice(i, i + MAX_OPS_PER_TX);
+                                    const batchIds = newGhostIds.slice(i, i + MAX_OPS_PER_TX);
+                                    try {
+                                        this.manager.logger.log(`[SYNC] Batch-cancelling ${chunk.length} orphaned chain order(s) ` +
+                                            `(batch ${Math.floor(i / MAX_OPS_PER_TX) + 1}/${Math.ceil(cancelOps.length / MAX_OPS_PER_TX)})`, 'info');
+                                        await chainOrders.executeBatch(this.account, this.privateKey, chunk);
+                                        // Mark successfully cancelled IDs immediately
+                                        for (const id of batchIds) {
+                                            this._ghostOrderCancelAttempted.add(id);
+                                        }
+                                    }
+                                    catch (batchErr) {
+                                        batchFailed = true;
+                                        this.manager.logger.log(`[SYNC] Batch ghost cancel failed for chunk ${Math.floor(i / MAX_OPS_PER_TX) + 1} ` +
+                                            `(${chunk.length} orders): ${batchErr?.message || batchErr}`, 'warn');
+                                    }
                                 }
-                                catch (err) {
-                                    this.manager.logger.log(`[SYNC] Failed to cancel orphaned order ${ghostOrderId}: ${err?.message || err}`, 'warn');
+                                // Log overall success if all chunks and all builds succeeded
+                                if (!batchFailed && cancelOps.length === newGhostIds.length) {
+                                    this.manager.logger.log(`[SYNC] Successfully batch-cancelled ${newGhostIds.length} orphaned chain order(s)`, 'info');
+                                }
+                                // Fallback: individual cancels for IDs that were not marked successful
+                                for (const ghostOrderId of newGhostIds) {
+                                    if (this._ghostOrderCancelAttempted.has(ghostOrderId))
+                                        continue;
+                                    try {
+                                        this.manager.logger.log(`[SYNC] Cancelling orphaned chain order ${ghostOrderId} (other-side full-fill residual)`, 'info');
+                                        await chainOrders.cancelOrder(this.account, this.privateKey, ghostOrderId);
+                                        this._ghostOrderCancelAttempted.add(ghostOrderId);
+                                    }
+                                    catch (err) {
+                                        this.manager.logger.log(`[SYNC] Failed to cancel orphaned order ${ghostOrderId}: ${err?.message || err}`, 'warn');
+                                    }
                                 }
                             }
                         }
                         await this.manager.resumeFundRecalc();
                     }
+                    // Refresh dynamic weight distribution before processing fills
+                    // so the rebalance uses the latest market adapter weights, not
+                    // stale values from the last periodic refresh cycle.
+                    // Lightweight: reads local JSON snapshot file.
+                    this._refreshDynamicWeightDistribution('fill queue');
                     // 5. Fixed-Cap Fill Rebalance
                     // - 1..MAX_FILL_BATCH_SIZE fills: unified full-set planning
                     // - larger bursts: fixed-size chunking at MAX_FILL_BATCH_SIZE
@@ -1929,6 +2054,7 @@ class DEXBot {
                     else if (pendingFillKeysForCurrentCycle.size > 0) {
                         await this._flushProcessedFillPersistenceForKeys(pendingFillKeysForCurrentCycle, 'fill-batch-no-rotations');
                     }
+                    this.manager._recentFillKeysSnapshot = this._getRecentFillKeysSnapshot();
                     await retryPersistenceIfNeeded(this.manager);
                     // Periodically clean up old fill records after processing N fills.
                     // Counter is protected by _fillProcessingLock during fill consumption.
@@ -2255,7 +2381,7 @@ class DEXBot {
      * @returns {number} Positive maximum number of fill-driven rotations per broadcast cycle
      */
     _getMaxFillBatchSize() {
-        return Math.max(1, FILL_PROCESSING.MAX_FILL_BATCH_SIZE);
+        return Math.max(1, this.config.fillProcessing?.MAX_FILL_BATCH_SIZE ?? FILL_PROCESSING.MAX_FILL_BATCH_SIZE);
     }
     /**
      * Extract operation results from a batch transaction result.
@@ -2739,7 +2865,7 @@ class DEXBot {
         // BROADCAST_DEADLINE fires while the transaction may still be valid
         // and land in the next block. Wait for up to 3 blocks (~1 BitShares
         // block interval each) and re-check before permanently discarding.
-        const UNCERTAIN_RECHECK_MAX_ATTEMPTS = PIPELINE_TIMING.RETRY_MAX_ATTEMPTS; // 3
+        const UNCERTAIN_RECHECK_MAX_ATTEMPTS = this.config.pipelineTiming?.RETRY_MAX_ATTEMPTS ?? PIPELINE_TIMING.RETRY_MAX_ATTEMPTS; // 3
         const UNCERTAIN_RECHECK_INTERVAL_MS = TIMING.MILLISECONDS_PER_SECOND * 3; // 3s
         let recheckRound = 0;
         while (discarded.length > 0 && recheckRound < UNCERTAIN_RECHECK_MAX_ATTEMPTS) {
@@ -3485,8 +3611,7 @@ class DEXBot {
                     this._runCredentialRecoveryAfterDaemonRestored().catch(err => {
                         this.manager?.logger?.log?.(`[CREDENTIAL] Deferred recovery failed: ${err.message}`, 'error');
                         if (this.manager) {
-                            this.manager._recoveryState = this.manager._recoveryState || {};
-                            this.manager._recoveryState.lastFailureAt = Date.now();
+                            this.manager._recoveryState = { ...this.manager._recoveryState, lastFailureAt: Date.now() };
                         }
                     });
                 }, 1000);
@@ -3873,7 +3998,7 @@ class DEXBot {
                     `broadcast. Running recovery before placing replacement orders.`, 'error');
                 if (typeof this.manager.requestStructuralGridResync === 'function') {
                     if (this.manager._recoveryState)
-                        this.manager._recoveryState.structuralResyncRequested = true;
+                        this.manager._recoveryState = { ...this.manager._recoveryState, structuralResyncRequested: true };
                     await this.manager.requestStructuralGridResync('pending broadcasts before COW create', { pendingBroadcasts: pendingBroadcasts.map(p => p.slotId) });
                 }
                 try {
@@ -3963,7 +4088,7 @@ class DEXBot {
             // Request structural resync to rebuild the grid on the next cycle.
             if (typeof this.manager.requestStructuralGridResync === 'function') {
                 if (this.manager._recoveryState)
-                    this.manager._recoveryState.structuralResyncRequested = true;
+                    this.manager._recoveryState = { ...this.manager._recoveryState, structuralResyncRequested: true };
                 await this.manager.requestStructuralGridResync('unmatched chain orders before COW create', { unmatchedChainOrders: unmatchedChainOrders });
             }
             this.manager.logger.log(`[COW] Rejecting CREATE batch after sync: working grid invalidated by master mutation`, 'info');
@@ -4266,8 +4391,7 @@ class DEXBot {
                                 `(${retryResult.reason || 'no reason'}). Master grid in memory ` +
                                 `is ahead of disk snapshot; structural resync requested.`, 'error');
                             if (typeof this.manager.requestStructuralGridResync === 'function') {
-                                this.manager._recoveryState = this.manager._recoveryState || {};
-                                this.manager._recoveryState.structuralResyncRequested = true;
+                                this.manager._recoveryState = { ...this.manager._recoveryState, structuralResyncRequested: true };
                                 await this.manager.requestStructuralGridResync('persistence guard triggered after COW batch', { persistReason: retryResult.reason || 'unknown' });
                             }
                         }
@@ -4837,9 +4961,7 @@ class DEXBot {
                     const persistedResult = await this._recoverFromPersistedGrid();
                     if (persistedResult.success) {
                         if (this.manager?._recoveryState) {
-                            this.manager._recoveryState.attemptCount = 0;
-                            this.manager._recoveryState.lastAttemptAt = 0;
-                            this.manager._recoveryState.lastFailureAt = 0;
+                            this.manager._recoveryState = { ...this.manager._recoveryState, attemptCount: 0, lastAttemptAt: 0, lastFailureAt: 0 };
                         }
                         return;
                     }
@@ -4849,9 +4971,7 @@ class DEXBot {
                         refreshCenterPrice: true,
                     });
                     if (resetResult && this.manager?._recoveryState) {
-                        this.manager._recoveryState.attemptCount = 0;
-                        this.manager._recoveryState.lastAttemptAt = 0;
-                        this.manager._recoveryState.lastFailureAt = 0;
+                        this.manager._recoveryState = { ...this.manager._recoveryState, attemptCount: 0, lastAttemptAt: 0, lastFailureAt: 0 };
                     }
                 }
                 catch (err) {
@@ -4860,7 +4980,7 @@ class DEXBot {
                 finally {
                     this._structuralGridResyncRunning = false;
                     if (this.manager?._recoveryState) {
-                        this.manager._recoveryState.structuralResyncRequested = false;
+                        this.manager._recoveryState = { ...this.manager._recoveryState, structuralResyncRequested: false };
                     }
                 }
             }, 0);
@@ -4998,11 +5118,11 @@ class DEXBot {
      * @returns {Promise<void>}
      */
     async shutdown() {
-        if (this._shutdownStarted) {
+        if (this._shuttingDown) {
             this._log('Shutdown already in progress; ignoring re-entrant call');
             return this._shutdownPromise || Promise.resolve();
         }
-        this._shutdownStarted = true;
+        this._shuttingDown = true;
         const shutdownImpl = typeof this._shutdownImpl === 'function'
             ? this._shutdownImpl
             : DEXBot.prototype._shutdownImpl;
@@ -5011,7 +5131,6 @@ class DEXBot {
     }
     async _shutdownImpl() {
         this._log('Initiating graceful shutdown...');
-        this._shuttingDown = true;
         this._processedFillStore.setShuttingDown(true);
         // Stop accepting new work
         this._stopBlockchainFetchInterval();