dexbot 1.2.4 → 1.2.6

package/dist/modules/dexbot_class.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"dexbot_class.d.ts","sourceRoot":"","sources":["../../modules/dexbot_class.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"dexbot_class.d.ts","sourceRoot":"","sources":["../../modules/dexbot_class.ts"],"names":[],"mappings":"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"}

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) {
@@ -1817,6 +1891,8 @@ class DEXBot {
                             this.manager.logger.log(`[FILL-BLOCK] Processing ${fillsWithoutBlock.length} fill(s) without block info`, 'debug');
                             const noBlockResult = await processValidFills(fillsWithoutBlock);
                             accumulatedOrders.push(...noBlockResult);
+                            if (requiresOpenOrdersSync)
+                                anyRequiresSync = true;
                         }
                         // If a fill was filtered out during validation (e.g. missing
                         // history ID) and no block group triggered the open-orders
@@ -1843,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
@@ -1927,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.
@@ -2155,14 +2283,14 @@ class DEXBot {
                     this._warn(`Credential daemon probe failed: ${err.message}. Falling back to interactive authentication.`);
                 }
                 if (!privateKey) {
-                    const unlockSecret = await getKeyStore().authenticate();
-                    privateKey = await getKeyStore().resolvePrivateKey(this.config.preferredAccount, unlockSecret, BitShares);
+                    const unlockSecret = await chainKeys.authenticate();
+                    privateKey = await chainKeys.resolvePrivateKey(this.config.preferredAccount, unlockSecret, BitShares);
                 }
                 this.privateKey = privateKey;
                 await this._setupAccountContext(this.config.preferredAccount);
             }
             catch (err) {
-                if (getKeyStore().isMasterPasswordFailure(err)) {
+                if (chainKeys.isMasterPasswordFailure(err)) {
                     throw err;
                 }
                 this._warn(`Auto-selection of preferredAccount failed: ${err.message}`);
@@ -2253,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.
@@ -2737,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) {
@@ -3483,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);
@@ -3871,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 {
@@ -3961,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');
@@ -4264,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' });
                             }
                         }
@@ -4777,6 +4903,9 @@ class DEXBot {
                 this._warn(`Credit watchdog error: ${err.message}`);
             }
         }, intervalMs);
+        if (typeof this._creditWatchdogInterval?.unref === 'function') {
+            this._creditWatchdogInterval.unref();
+        }
         this._log(`Credit deal watchdog started (${intervalMin}min interval)`);
     }
     /**
@@ -4832,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;
                     }
@@ -4844,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) {
@@ -4855,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);
@@ -4954,6 +5079,9 @@ class DEXBot {
                 // Silently retry next interval
             }
         }, DUST_HEALTH_CHECK_INTERVAL_MS);
+        if (typeof this._dustHealthCheckTimer?.unref === 'function') {
+            this._dustHealthCheckTimer.unref();
+        }
     }
     /**
      * Perform grid maintenance: fund thresholds, spread condition, grid health, divergence.
@@ -4990,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;
@@ -5003,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();