dexbot 1.1.14 → 1.2.1

package/dist/modules/dexbot_class.js

@@ -248,25 +248,28 @@ class DEXBot {
      */
     _validateStartupConfig(config) {
         const errors = [];
-        // Validate startPrice is numeric or valid string mode
-        const startPrice = config.startPrice;
-        const validPriceModes = ['pool', 'book'];
-        const isPriceNumeric = typeof startPrice === 'number' && Number.isFinite(startPrice) && startPrice > 0;
-        const isPriceMode = typeof startPrice === 'string' && validPriceModes.includes(startPrice.toLowerCase());
-        if (!isPriceNumeric && !isPriceMode) {
-            errors.push(`startPrice must be a positive number or valid mode (${validPriceModes.join('/')}), got: ${startPrice}`);
-        }
-        // Validate assetA and assetB are present
-        if (!config.assetA || typeof config.assetA !== 'string') {
-            errors.push(`assetA must be a non-empty string, got: ${config.assetA}`);
-        }
-        if (!config.assetB || typeof config.assetB !== 'string') {
-            errors.push(`assetB must be a non-empty string, got: ${config.assetB}`);
-        }
-        // Validate incrementPercent
-        const increment = config.incrementPercent;
-        if (!Number.isFinite(increment) || increment <= 0 || increment > 100) {
-            errors.push(`incrementPercent must be between 0 and 100, got: ${increment}`);
+        // Skip trading field validation in credit-only mode
+        if (!config.creditOnly) {
+            // Validate startPrice is numeric or valid string mode
+            const startPrice = config.startPrice;
+            const validPriceModes = ['pool', 'book'];
+            const isPriceNumeric = typeof startPrice === 'number' && Number.isFinite(startPrice) && startPrice > 0;
+            const isPriceMode = typeof startPrice === 'string' && validPriceModes.includes(startPrice.toLowerCase());
+            if (!isPriceNumeric && !isPriceMode) {
+                errors.push(`startPrice must be a positive number or valid mode (${validPriceModes.join('/')}), got: ${startPrice}`);
+            }
+            // Validate assetA and assetB are present
+            if (!config.assetA || typeof config.assetA !== 'string') {
+                errors.push(`assetA must be a non-empty string, got: ${config.assetA}`);
+            }
+            if (!config.assetB || typeof config.assetB !== 'string') {
+                errors.push(`assetB must be a non-empty string, got: ${config.assetB}`);
+            }
+            // Validate incrementPercent
+            const increment = config.incrementPercent;
+            if (!Number.isFinite(increment) || increment <= 0 || increment > 100) {
+                errors.push(`incrementPercent must be between 0 and 100, got: ${increment}`);
+            }
         }
         // Throw all validation errors at once
         if (errors.length > 0) {
@@ -346,7 +349,7 @@ class DEXBot {
             shadowLocks: this.manager?.shadowOrderIds?.size || 0,
             batchInFlight: this._batchInFlight,
             recoveryInFlight: this._recoverySyncInFlight,
-            broadcasting: this.manager?._state?.isBroadcastingActive() || false
+            broadcasting: this.manager?.isBroadcastingActive?.() || false
         };
     }
     /**
@@ -375,7 +378,7 @@ class DEXBot {
             this.manager.logger.log(`Triggering state recovery sync (${reason})...`, 'info');
             await this.manager.fetchAccountTotals(this.accountId);
             const openOrders = await chainOrders.readOpenOrders(this.accountId);
-            await this.manager.syncFromOpenOrders(openOrders, { skipAccounting: true, fillLockAlreadyHeld: true, protectCommittedOrders: true });
+            await this.manager.syncFromOpenOrders(openOrders, { skipAccounting: true });
             if (typeof this.manager.persistGrid === 'function') {
                 await this.manager.persistGrid();
             }
@@ -587,8 +590,6 @@ class DEXBot {
             if (chainOpenOrders.length > 0 && this.manager?.syncFromOpenOrders) {
                 await this.manager.syncFromOpenOrders(chainOpenOrders, {
                     skipAccounting: true,
-                    fillLockAlreadyHeld: true,
-                    protectCommittedOrders: true
                 });
             }
             // 5. Persist the reconciled state
@@ -819,13 +820,14 @@ class DEXBot {
     _buildOrphanFillFallbackKey(fill) {
         return DexbotFillRuntime.buildOrphanFillFallbackKey(this, fill);
     }
-    _isNewFillKey(fillKey, processedFillKeys, label = '') {
+    _isNewFillKey(fillKey, processedFillKeys, label = '', orderId = '') {
         const now = Date.now();
         if (this._recentlyQueuedFills.has(fillKey)) {
             const lastProcessed = this._recentlyQueuedFills.get(fillKey);
             if (now - lastProcessed < this._fillDedupeWindowMs) {
                 if (label) {
-                    this.manager?.logger?.log?.(`${label} Skipping duplicate fill (processed ${now - lastProcessed}ms ago)`, 'debug');
+                    const idSuffix = orderId ? ` for ${orderId}` : '';
+                    this.manager?.logger?.log?.(`${label} Skipping duplicate fill${idSuffix} (processed ${now - lastProcessed}ms ago)`, 'debug');
                 }
                 return false;
             }
@@ -953,7 +955,7 @@ class DEXBot {
                                 const chainOpenOrders = await chainOrders.readOpenOrders(this.accountId);
                                 if (this._shuttingDown)
                                     return;
-                                const syncResult = await this.manager.synchronizeWithChain(chainOpenOrders, 'readOpenOrders', { fillLockAlreadyHeld: true });
+                                const syncResult = await this.manager.synchronizeWithChain(chainOpenOrders, 'readOpenOrders');
                                 if (this._shuttingDown)
                                     return;
                                 if (syncResult?.filledOrders?.length > 0) {
@@ -970,7 +972,6 @@ class DEXBot {
                                         await this._cancelDustOrders({
                                             buy: reconnectHealth.buyDustOrders,
                                             sell: reconnectHealth.sellDustOrders,
-                                            fillLockAlreadyHeld: true,
                                         });
                                     }
                                     catch (_dustErr) {
@@ -1050,7 +1051,7 @@ class DEXBot {
                                 if (!orphanFillKey) {
                                     orphanFillKey = this._buildOrphanFillFallbackKey(fill);
                                 }
-                                if (orphanFillKey && !this._isNewFillKey(orphanFillKey, processedFillKeys, '[POST-RESET]')) {
+                                if (orphanFillKey && !this._isNewFillKey(orphanFillKey, processedFillKeys, '[POST-RESET]', fillOp.order_id)) {
                                     continue;
                                 }
                                 this._log(`[POST-RESET] Processing funds for unknown order ${fillOp.order_id} (not in grid but crediting proceeds)`, 'warn');
@@ -1066,7 +1067,7 @@ class DEXBot {
                             }
                             this._log(`[POST-RESET] Processing fill for ${gridOrder.type} order ${gridOrder.id} at price ${gridOrder.price}`);
                             const trackedFillKey = buildFillKey(fill);
-                            if (trackedFillKey && !this._isNewFillKey(trackedFillKey, processedFillKeys, '[POST-RESET]')) {
+                            if (trackedFillKey && !this._isNewFillKey(trackedFillKey, processedFillKeys, '[POST-RESET]', fillOp.order_id)) {
                                 continue;
                             }
                             const accountingResult = await this._applyReplaySafeTrackedFillAccounting(fill, fillOp, {
@@ -1092,7 +1093,7 @@ class DEXBot {
                         if (requiresOpenOrdersSync) {
                             this._log('[POST-RESET] Falling back to open-orders sync for fill(s) missing replay-safe history identifiers', 'warn');
                             const postResetChainOpenOrders = await chainOrders.readOpenOrders(this.accountId);
-                            const syncResult = await this.manager.syncFromOpenOrders(postResetChainOpenOrders, { fillLockAlreadyHeld: true });
+                            const syncResult = await this.manager.syncFromOpenOrders(postResetChainOpenOrders);
                             if (syncResult.filledOrders?.length > 0) {
                                 await this._processFillsWithBatching(syncResult.filledOrders, new Set(), '[POST-RESET] open-orders fallback');
                             }
@@ -1123,7 +1124,6 @@ class DEXBot {
                             await this._cancelDustOrders({
                                 buy: postResetHealth.buyDustOrders,
                                 sell: postResetHealth.sellDustOrders,
-                                fillLockAlreadyHeld: true,
                             });
                         }
                         catch (_dustErr) {
@@ -1219,7 +1219,7 @@ class DEXBot {
                         if (Array.isArray(chainOpenOrders) && chainOpenOrders.length > 0) {
                             this._log('Generating new grid and syncing with existing on-chain orders...');
                             await Grid.initializeGrid(this.manager);
-                            await this.manager.syncFromOpenOrders(chainOpenOrders, { skipAccounting: true, fillLockAlreadyHeld: true });
+                            await this.manager.syncFromOpenOrders(chainOpenOrders, { skipAccounting: true });
                             const rebalanceResult = await reconcileGridOrders({
                                 manager: this.manager,
                                 config: this.config,
@@ -1227,7 +1227,6 @@ class DEXBot {
                                 privateKey: this.privateKey,
                                 chainOrders,
                                 chainOpenOrders,
-                                fillLockAlreadyHeld: true,
                             });
                             await this._executeBatchIfNeeded(rebalanceResult, 'startup reconcile (regenerated grid)');
                         }
@@ -1241,7 +1240,7 @@ class DEXBot {
                         this._log('Found active session. Loading and syncing existing grid.');
                         await Grid.loadGrid(this.manager, persistedGrid, persistedBoundaryIdx);
                         let startupChainOpenOrders = chainOpenOrders;
-                        const syncResult = await this.manager.syncFromOpenOrders(startupChainOpenOrders, { skipAccounting: true, fillLockAlreadyHeld: true });
+                        const syncResult = await this.manager.syncFromOpenOrders(startupChainOpenOrders, { skipAccounting: true });
                         // Process price corrections queued during startup sync.
                         // These are not picked up by _consumeFillQueue until a fill
                         // arrives, which may never come for an idle market.
@@ -1255,7 +1254,7 @@ class DEXBot {
                                 // Refresh open orders so startup reconcile works with post-batch chain reality
                                 // and avoids reconciling against a stale pre-batch snapshot.
                                 startupChainOpenOrders = await chainOrders.readOpenOrders(this.accountId);
-                                await this.manager.synchronizeWithChain(startupChainOpenOrders, 'readOpenOrders', { fillLockAlreadyHeld: true });
+                                await this.manager.synchronizeWithChain(startupChainOpenOrders, 'readOpenOrders');
                             }
                         }
                         const rebalanceResult = await reconcileGridOrders({
@@ -1265,7 +1264,6 @@ class DEXBot {
                             privateKey: this.privateKey,
                             chainOrders,
                             chainOpenOrders: startupChainOpenOrders,
-                            fillLockAlreadyHeld: true,
                         });
                         await this._executeBatchIfNeeded(rebalanceResult, 'startup reconcile (loaded grid)');
                         // Dust state is no longer persisted — cancelled immediately on detection.
@@ -1281,16 +1279,39 @@ class DEXBot {
                         await this._processFillsWithBootstrapMode(chainOrders);
                     }
                     this.manager.finishBootstrap();
+                    // Refresh account totals after bootstrap to eliminate the timing
+                    // gap between the initial balance fetch and grid operations (sync,
+                    // reconcile, fills). Without this, the first maintenance cycle sees
+                    // a fund drift (expected at bootstrap) and triggers an unnecessary
+                    // invariant violation + full recovery cycle.
+                    // Bound by a timeout to avoid blocking _fillProcessingLock on a
+                    // flaky node. If the fetch times out, continue with cached values;
+                    // the next periodic maintenance cycle will retry.
+                    const FETCH_TIMEOUT_MS = 30000;
+                    let _fetchTimeoutHandle;
+                    try {
+                        await Promise.race([
+                            this.manager.fetchAccountTotals(),
+                            new Promise((_, reject) => {
+                                _fetchTimeoutHandle = setTimeout(() => reject(new Error('timeout')), FETCH_TIMEOUT_MS);
+                            })
+                        ]);
+                    }
+                    catch (fetchErr) {
+                        this._log(`[STARTUP] [${this.config?.botKey || 'unknown'}] fetchAccountTotals ${fetchErr.message === 'timeout' ? 'timed out' : 'failed'} (${fetchErr.message}). Continuing with cached account totals.`, 'warn');
+                    }
+                    finally {
+                        clearTimeout(_fetchTimeoutHandle);
+                    }
                     // Perform initial grid maintenance (thresholds, divergence, spread, health)
                     // Consolidated into shared logic to ensure consistent behavior at boot and runtime.
                     // CRITICAL: Pass lockAlreadyHeld since we're inside _fillProcessingLock.acquire()
-                    await this._runGridMaintenance('startup', { fillLockAlreadyHeld: true });
+                    await this._runGridMaintenance('startup');
                     // Cancel any dust from a previous bot lifetime immediately.
                     const startupHealth = await this.manager.checkGridHealth(this.updateOrdersOnChainPlan.bind(this));
                     await this._cancelDustOrders({
                         buy: startupHealth.buyDustOrders,
                         sell: startupHealth.sellDustOrders,
-                        fillLockAlreadyHeld: true,
                     });
                     this._log('Bootstrap phase complete - fill processing resumed', 'info');
                 }
@@ -1302,7 +1323,7 @@ class DEXBot {
             await this._setupTriggerFileDetection();
             await this._setupCreditRuntime();
             await this._refreshAndSyncCreditRuntime();
-            await this._runCreditRuntimeMaintenance('startup', { fillLockAlreadyHeld: true });
+            await this._runCreditRuntimeMaintenance('startup');
             this._setupBlockchainFetchInterval();
             this._setupCreditWatchdogInterval();
             this._setupCredentialDaemonWatchdogInterval();
@@ -1346,14 +1367,14 @@ class DEXBot {
         }
         try {
             let openOrders = await chainOrders.readOpenOrders(this.accountId);
-            const syncResult = await this.manager.synchronizeWithChain(openOrders, 'readOpenOrders', { fillLockAlreadyHeld: true });
+            const syncResult = await this.manager.synchronizeWithChain(openOrders, 'readOpenOrders');
             let aborted = false;
             if (syncResult?.filledOrders?.length > 0) {
                 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) {
                     openOrders = await chainOrders.readOpenOrders(this.accountId);
-                    await this.manager.synchronizeWithChain(openOrders, 'readOpenOrders', { fillLockAlreadyHeld: true });
+                    await this.manager.synchronizeWithChain(openOrders, 'readOpenOrders');
                 }
                 else {
                     aborted = true;
@@ -1507,11 +1528,11 @@ class DEXBot {
         try {
             // BOOTSTRAP OPTIMIZATION: During bootstrap, prioritize fill processing over grid-wide checks
             // Process fills immediately with side-only rebalancing (no expensive full grid recalculations)
-            if (this.manager._state.isBootstrapping()) {
+            if (this.manager.isBootstrapping()) {
                 // During bootstrap: skip lock contention checks, process fills directly
                 let bootstrapSkipped = false;
                 await this.manager._fillProcessingLock.acquire(async () => {
-                    if (!this.manager._state.isBootstrapping()) {
+                    if (!this.manager.isBootstrapping()) {
                         // Bootstrap finished while waiting for the lock — no
                         // work to do, but the iteration is still healthy.
                         bootstrapSkipped = true;
@@ -1601,7 +1622,7 @@ class DEXBot {
                                 if (!orphanFillKey) {
                                     orphanFillKey = this._buildOrphanFillFallbackKey(fill);
                                 }
-                                if (orphanFillKey && !this._isNewFillKey(orphanFillKey, processedFillKeys, '[ORPHAN-FILL]')) {
+                                if (orphanFillKey && !this._isNewFillKey(orphanFillKey, processedFillKeys, '[ORPHAN-FILL]', fillOp.order_id)) {
                                     continue;
                                 }
                                 this.manager.logger.log(`[ORPHAN-FILL] Processing funds for unknown order ${fillOp.order_id} (not in grid but crediting proceeds)`, 'warn');
@@ -1631,7 +1652,7 @@ class DEXBot {
                                 requiresOpenOrdersSync = true;
                                 continue;
                             }
-                            if (!this._isNewFillKey(fillKey, processedFillKeys, '[FILL]')) {
+                            if (!this._isNewFillKey(fillKey, processedFillKeys, '[FILL]', fillOp.order_id)) {
                                 continue;
                             }
                             validFills.push(fill);
@@ -1694,7 +1715,7 @@ class DEXBot {
                             }
                             this.manager.logger.log(`Syncing ${fillsToSync.length} fill(s) (open orders mode)`, 'info');
                             const chainOpenOrders = await chainOrders.readOpenOrders(this.account);
-                            const resultOpenOrders = await this.manager.syncFromOpenOrders(chainOpenOrders, { fillLockAlreadyHeld: true });
+                            const resultOpenOrders = await this.manager.syncFromOpenOrders(chainOpenOrders);
                             // Dust is handled by post-fill detection below.
                             if (resultOpenOrders.filledOrders)
                                 resolvedOrders.push(...resultOpenOrders.filledOrders);
@@ -1827,7 +1848,6 @@ class DEXBot {
                                 const dustCancelResult = await this._cancelDustOrders({
                                     buy: healthResult.buyDustOrders,
                                     sell: healthResult.sellDustOrders,
-                                    fillLockAlreadyHeld: true,
                                 });
                                 if (dustCancelResult?.batchResult?.aborted) {
                                     abortedFillCycle = true;
@@ -1841,7 +1861,7 @@ class DEXBot {
                         // After: Grid maintenance waits for isPipelineEmpty() before structural changes
                         // Run only when the cycle contains at least one full fill.
                         if (shouldRunPostFillChecks && !abortedFillCycle) {
-                            await this._runGridMaintenance('post-fill', { fillLockAlreadyHeld: true });
+                            await this._runGridMaintenance('post-fill');
                         }
                     }
                     else if (pendingFillKeysForCurrentCycle.size > 0) {
@@ -1966,7 +1986,7 @@ class DEXBot {
                 if (!orphanFillKey) {
                     orphanFillKey = this._buildOrphanFillFallbackKey(fill);
                 }
-                if (orphanFillKey && !this._isNewFillKey(orphanFillKey, processedFillKeys, '[BOOTSTRAP]')) {
+                if (orphanFillKey && !this._isNewFillKey(orphanFillKey, processedFillKeys, '[BOOTSTRAP]', fillOp.order_id)) {
                     continue;
                 }
                 this.manager.logger.log(`[BOOTSTRAP] Processing funds for unknown order ${fillOp.order_id} (not in grid but crediting proceeds)`, 'warn');
@@ -1979,7 +1999,7 @@ class DEXBot {
                 continue;
             }
             const trackedFillKey = buildFillKey(fill);
-            if (trackedFillKey && !this._isNewFillKey(trackedFillKey, processedFillKeys, '[BOOTSTRAP]')) {
+            if (trackedFillKey && !this._isNewFillKey(trackedFillKey, processedFillKeys, '[BOOTSTRAP]', fillOp.order_id)) {
                 continue;
             }
             const accountingResult = await this._applyReplaySafeTrackedFillAccounting(fill, fillOp, {
@@ -2000,7 +2020,7 @@ class DEXBot {
         if (requiresOpenOrdersSync) {
             this._log('[BOOTSTRAP] Falling back to open-orders sync for fill(s) missing replay-safe history identifiers', 'warn');
             const bootstrapChainOpenOrders = await chainOrders.readOpenOrders(this.accountId);
-            const syncResult = await this.manager.syncFromOpenOrders(bootstrapChainOpenOrders, { fillLockAlreadyHeld: true });
+            const syncResult = await this.manager.syncFromOpenOrders(bootstrapChainOpenOrders);
             if (syncResult.filledOrders?.length > 0) {
                 const queuedOrderIds = new Set(validFills.map(fill => fill?.gridOrder?.orderId).filter(Boolean));
                 for (const filledOrder of syncResult.filledOrders) {
@@ -2238,8 +2258,6 @@ class DEXBot {
             const openOrders = await chainOrders.readOpenOrders(accountRef);
             const recoveryResult = await this.manager.syncFromOpenOrders(openOrders, {
                 skipAccounting: false,
-                fillLockAlreadyHeld: true,
-                protectCommittedOrders: true
             });
             this._preserveMissingCreateBlockersAfterRecovery(preRecoveryMissingCreateBlockers, recoveryResult);
             // Persist any master grid mutations from the recovery sync. The
@@ -2583,13 +2601,10 @@ class DEXBot {
      * @returns {Promise<Object>} Result object compatible with batch return shape
      */
     async _reconcileAfterUncertainBroadcast(err, opContexts, options = {}) {
-        if (options.fillLockAlreadyHeld !== true &&
-            this.manager?._fillProcessingLock &&
-            typeof this.manager._fillProcessingLock.acquire === 'function') {
-            return this.manager._fillProcessingLock.acquire(async () => (this._reconcileAfterUncertainBroadcast(err, opContexts, {
-                ...options,
-                fillLockAlreadyHeld: true
-            })));
+        if (this.manager?._fillProcessingLock &&
+            typeof this.manager._fillProcessingLock.acquire === 'function' &&
+            !this.manager._fillProcessingLock.isReentrant()) {
+            return this.manager._fillProcessingLock.acquire(() => this._reconcileAfterUncertainBroadcast(err, opContexts, options));
         }
         return this._reconcileAfterUncertainBroadcastImpl(err, opContexts, options);
     }
@@ -2637,7 +2652,11 @@ class DEXBot {
                 fingerprint: entry.fingerprint
             });
             if (match) {
-                adopted.push({ slotId: entry.slotId, chainOrderId: match.id });
+                adopted.push({
+                    slotId: entry.slotId,
+                    chainOrderId: match.id,
+                    orderType: entry.orderType || entry.order?.type,
+                });
                 this.manager._pendingBroadcasts.delete(entry.fingerprint);
             }
             else {
@@ -2674,7 +2693,11 @@ class DEXBot {
                     fingerprint: entry.fingerprint
                 });
                 if (match) {
-                    adopted.push({ slotId: entry.slotId, chainOrderId: match.id });
+                    adopted.push({
+                        slotId: entry.slotId,
+                        chainOrderId: match.id,
+                        orderType: entry.orderType || entry.order?.type,
+                    });
                     this.manager.logger.log(`[COW][UNCERTAIN] CREATE re-adopted after ${recheckRound} block(s): ` +
                         `${entry.slotId}->${match.id}`, 'info');
                 }
@@ -2702,8 +2725,6 @@ class DEXBot {
             try {
                 await this.manager.syncFromOpenOrders(latestSnapshot, {
                     skipAccounting: true,
-                    fillLockAlreadyHeld: true,
-                    protectCommittedOrders: true
                 });
                 hadRotation = true;
             }
@@ -2758,9 +2779,52 @@ class DEXBot {
         catch (orphanErr) {
             this.manager.logger.log(`[COW][UNCERTAIN] Auto-cancel pass failed: ${orphanErr?.message || orphanErr}`, 'warn');
         }
+        // Boundary shift recovery: the COW batch that should have committed the
+        // boundary shift from this fill cycle failed before commit. Only COUNT
+        // ADOPTED CREATEs — orders that actually landed on-chain. Discarded
+        // CREATEs represent orders that never existed, so the grid must NOT
+        // shift the boundary for them. The next fill cycle's
+        // calculateTargetGrid → deriveTargetBoundary will recompute the correct
+        // boundary from scratch for any discarded slots.
+        //
+        // NOTE: Direct mutation of manager.boundaryIdx outside a COW commit
+        // violates the invariant stated in grid.ts:1217-1220 (boundary must only
+        // be updated atomically inside _commitWorkingGrid). This is intentional
+        // here because the COW commit already failed — the invariant was already
+        // broken by the broadcast uncertainty, and the adjustment only restores
+        // the state to what the successful commit would have produced for
+        // orders that are confirmed on-chain.
+        if (hadRotation && this.manager && adopted.length > 0) {
+            let boundaryShift = 0;
+            for (const entry of adopted) {
+                if (entry.orderType === ORDER_TYPES.SELL) {
+                    boundaryShift--; // SELL CREATE → fill was BUY → boundary LEFT
+                }
+                else if (entry.orderType === ORDER_TYPES.BUY) {
+                    boundaryShift++; // BUY CREATE → fill was SELL → boundary RIGHT
+                }
+            }
+            if (boundaryShift !== 0) {
+                const oldIdx = this.manager.boundaryIdx;
+                if (typeof oldIdx === 'number') {
+                    const maxIdx = Math.max(0, (this.manager.orders?.size || 1) - 1);
+                    const newIdx = Math.max(0, Math.min(maxIdx, oldIdx + boundaryShift));
+                    if (newIdx !== oldIdx) {
+                        this.manager.boundaryIdx = newIdx;
+                        this.manager.logger.log(`[COW][UNCERTAIN] Boundary adjusted by ${boundaryShift} ` +
+                            `(${adopted.length} adopted CREATE(s), ${discarded.length} discarded): ` +
+                            `${oldIdx} → ${newIdx}. Next COW cycle will generate replacement opposite-side orders.`, 'warn');
+                        if (typeof this.manager._markGridDirty === 'function') {
+                            this.manager._markGridDirty();
+                        }
+                    }
+                }
+            }
+        }
         // Persist master grid mutations from the reconciliation sync and any
         // orphan auto-cancellation that ran above. These apply outside the COW
-        // broadcast path and would otherwise be in-memory only.
+        // broadcast path and would otherwise be in-memory only. The boundary
+        // adjustment above is also persisted here.
         if (typeof this.manager?.persistGrid === 'function') {
             await this.manager.persistGrid();
         }
@@ -2898,8 +2962,6 @@ class DEXBot {
                         if (freshChain.length > 0 && this.manager?.syncFromOpenOrders) {
                             await this.manager.syncFromOpenOrders(freshChain, {
                                 skipAccounting: true,
-                                fillLockAlreadyHeld: true,
-                                protectCommittedOrders: true
                             });
                         }
                     }
@@ -3294,7 +3356,7 @@ class DEXBot {
         if (this._credentialRecoveryInFlight || !this._credentialRecoveryNeeded || this._shuttingDown) {
             return;
         }
-        if (this.manager?._state?.isBootstrapping?.() || this.manager?._state?.isBroadcastingActive?.()) {
+        if (this.manager?.isBootstrapping?.() || this.manager?.isBroadcastingActive?.()) {
             if (!this._credentialRecoveryDeferredTimer) {
                 this.manager?.logger?.log?.('[CREDENTIAL] Deferring credential recovery until startup/broadcast activity is idle.', 'info');
                 this._credentialRecoveryDeferredTimer = setTimeout(() => {
@@ -3316,7 +3378,7 @@ class DEXBot {
             this._resumeGridPersistenceAfterCredentialRecovery('credential recovery started');
             const runRecovery = async () => {
                 await this._triggerStateRecoverySync('credential daemon restored');
-                await this._runGridMaintenance('credential-recovery', { fillLockAlreadyHeld: true });
+                await this._runGridMaintenance('credential-recovery');
             };
             if (this.manager?._fillProcessingLock) {
                 await this.manager._fillProcessingLock.acquire(runRecovery);
@@ -3773,7 +3835,7 @@ class DEXBot {
                             batchId: this._currentBatchId || null,
                             payload: null,
                             timeoutMs: null
-                        }), [], { fillLockAlreadyHeld: true });
+                        }), []);
                     }
                     catch (recoverErr) {
                         this.manager.logger.log(`[COW] Recovery from pending broadcasts failed: ${recoverErr?.message || recoverErr}`, 'error');
@@ -4133,7 +4195,7 @@ class DEXBot {
             // throwing would re-enter the catch loop on the next attempt and
             // potentially double-publish.
             if (err instanceof BroadcastUncertainError) {
-                return await this._reconcileAfterUncertainBroadcast(err, opContexts, { fillLockAlreadyHeld: true });
+                return await this._reconcileAfterUncertainBroadcast(err, opContexts);
             }
             // Handle hard abort
             const hardAbortResult = await this._handleBatchHardAbort(err, 'COW batch processing', operations.length);
@@ -4439,6 +4501,10 @@ class DEXBot {
      */
     async _runStartupSequence() {
         try {
+            if (this.config.creditOnly) {
+                await this._runCreditOnlyStartup();
+                return;
+            }
             const startupState = await this._initializeStartupState();
             await this._finishStartupSequence(startupState);
         }
@@ -4448,13 +4514,20 @@ class DEXBot {
             throw err;
         }
     }
+    async _runCreditOnlyStartup() {
+        await this._setupCreditRuntime();
+        await this._refreshAndSyncCreditRuntime();
+        await this._runCreditRuntimeMaintenance('startup');
+        this._setupCreditWatchdogInterval();
+        this._setupCredentialDaemonWatchdogInterval();
+        this._log('DEXBot started (credit-only mode)');
+    }
     /**
      * Perform periodic grid checks: fund thresholds, spread condition, grid health.
      * Called by the periodic blockchain fetch interval to check if grid needs updates.
      *
      * IMPORTANT: This method MUST only be called from within _fillProcessingLock.acquire()
-     * (specifically from _setupBlockchainFetchInterval). It passes fillLockAlreadyHeld
-     * to avoid deadlock with _consumeFillQueue which uses the same lock ordering.
+     * (specifically from _setupBlockchainFetchInterval).
      *
      * @private
      */
@@ -4601,14 +4674,17 @@ class DEXBot {
             return { skipped: true, reason: 'grid resync unavailable' };
         }
         const message = reason ? `[CR-RESET] ${reason}` : '[CR-RESET] grid reset requested';
-        // Manual/programmatic resets should advance the persisted center baseline
-        // before rebuilding the grid, unless a caller explicitly disables it.
         this._log(`${message}; rebuilding grid from fresh on-chain state`, 'info');
         const resetOptions = {
             ...options,
             refreshCenterPrice: options.refreshCenterPrice !== false,
         };
-        if (options.fillLockAlreadyHeld || !this.manager._fillProcessingLock) {
+        // Skip acquire if no lock exists (no fill processing to serialize against)
+        // or if the caller already holds the lock (re-entrant). In the latter case
+        // the lock's isReentrant() check prevents queueing and runs inline.
+        // Otherwise, wait on the queue — this is the intended path for callers
+        // outside the fill-processing context that need exclusive access.
+        if (!this.manager._fillProcessingLock || this.manager._fillProcessingLock.isReentrant()) {
             return this._performGridResync(resetOptions);
         }
         return this.manager._fillProcessingLock.acquire(async () => this._performGridResync(resetOptions));
@@ -4720,12 +4796,12 @@ class DEXBot {
      * Cancel dust partial orders immediately — no maps, no timers, no delay.
      * Each dust order is cancelled on chain and its slot rotated through the
      * synthetic-fill pipeline.
-     * @param {{ buy: Array, sell: Array, fillLockAlreadyHeld?: boolean }} options
+     * @param {{ buy: Array, sell: Array }} options
      * @returns {Promise<{cancelledCount: number, batchResult: {aborted: boolean}|null}>}
      * @private
      */
-    async _cancelDustOrders({ buy: buyDust = [], sell: sellDust = [], fillLockAlreadyHeld = false } = {}) {
-        return DexbotMaintenanceRuntime.cancelDustOrders(this, { buy: buyDust, sell: sellDust, fillLockAlreadyHeld });
+    async _cancelDustOrders({ buy: buyDust = [], sell: sellDust = [] } = {}) {
+        return DexbotMaintenanceRuntime.cancelDustOrders(this, { buy: buyDust, sell: sellDust });
     }
     /**
      * Set up the periodic dust health check interval.
@@ -4750,7 +4826,6 @@ class DEXBot {
                         await this._cancelDustOrders({
                             buy: health.buyDustOrders,
                             sell: health.sellDustOrders,
-                            fillLockAlreadyHeld: true,
                         });
                     });
                 }
@@ -4776,7 +4851,6 @@ class DEXBot {
      *
      * LOCK ORDERING:
      * - Canonical order: _fillProcessingLock → _divergenceLock
-     * - This function handles lock acquisition based on fillLockAlreadyHeld parameter
      * - When called from post-fill context, fill lock is already held
      * - When called from periodic context, both locks must be acquired
      * - Matches the order used in _consumeFillQueue to prevent deadlocks