dexbot 1.1.14 → 1.2.0

package/dist/modules/dexbot_class.d.ts

@@ -319,7 +319,7 @@ declare class DEXBot {
      * @returns {string|null} Fallback key or null
      */
     _buildOrphanFillFallbackKey(fill: any): any;
-    _isNewFillKey(fillKey: any, processedFillKeys: any, label?: string): boolean;
+    _isNewFillKey(fillKey: any, processedFillKeys: any, label?: string, orderId?: string): boolean;
     /**
      * Apply replay-safe fill accounting using a provided fill key.
      * @param {Object} fill - Fill event object
@@ -648,10 +648,7 @@ declare class DEXBot {
      * @param {Array<Object>} opContexts - Original opContexts from the failed batch
      * @returns {Promise<Object>} Result object compatible with batch return shape
      */
-    _reconcileAfterUncertainBroadcast(err: any, opContexts: any, options?: {
-        fillLockAlreadyHeld?: boolean;
-        [key: string]: any;
-    }): Promise<any>;
+    _reconcileAfterUncertainBroadcast(err: any, opContexts: any, options?: Record<string, any>): Promise<any>;
     _reconcileAfterUncertainBroadcastImpl(err: any, opContexts: any, options: any): Promise<{
         executed: boolean;
         hadRotation: boolean;
@@ -939,13 +936,13 @@ declare class DEXBot {
      * @private
      */
     _runStartupSequence(): Promise<void>;
+    _runCreditOnlyStartup(): Promise<void>;
     /**
      * 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
      */
@@ -1008,7 +1005,6 @@ declare class DEXBot {
     _stopCreditWatchdogInterval(): void;
     requestGridReset(reason?: string, options?: {
         refreshCenterPrice?: boolean;
-        fillLockAlreadyHeld?: boolean;
         [key: string]: any;
     }): Promise<any>;
     _wireStructuralGridResyncRequest(): void;
@@ -1053,14 +1049,13 @@ declare 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
      */
-    _cancelDustOrders({ buy: buyDust, sell: sellDust, fillLockAlreadyHeld }?: {
+    _cancelDustOrders({ buy: buyDust, sell: sellDust }?: {
         buy?: any[];
         sell?: any[];
-        fillLockAlreadyHeld?: boolean;
     }): Promise<any>;
     /**
      * Set up the periodic dust health check interval.
@@ -1086,7 +1081,6 @@ declare 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

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

@@ -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) {
@@ -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.
@@ -1284,13 +1282,12 @@ class DEXBot {
                     // 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 +1299,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 +1343,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;
@@ -1601,7 +1598,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 +1628,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 +1691,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 +1824,6 @@ class DEXBot {
                                 const dustCancelResult = await this._cancelDustOrders({
                                     buy: healthResult.buyDustOrders,
                                     sell: healthResult.sellDustOrders,
-                                    fillLockAlreadyHeld: true,
                                 });
                                 if (dustCancelResult?.batchResult?.aborted) {
                                     abortedFillCycle = true;
@@ -1841,7 +1837,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 +1962,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 +1975,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 +1996,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 +2234,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 +2577,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);
     }
@@ -2702,8 +2693,6 @@ class DEXBot {
             try {
                 await this.manager.syncFromOpenOrders(latestSnapshot, {
                     skipAccounting: true,
-                    fillLockAlreadyHeld: true,
-                    protectCommittedOrders: true
                 });
                 hadRotation = true;
             }
@@ -2758,9 +2747,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. Every planned
+        // CREATE in the batch represents a fill whose opposite-side boundary step
+        // was lost — regardless of whether the individual CREATE was later adopted
+        // on chain (adopted) or not (discarded). Manually adjust manager.boundaryIdx
+        // so the next COW cycle (triggered by the next fill or periodic maintenance)
+        // generates replacement opposite-side orders using the correct boundary.
+        //
+        // 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.
+        if (hadRotation && this.manager && pending.length > 0) {
+            let boundaryShift = 0;
+            for (const entry of pending) {
+                const orderType = entry.orderType || entry.order?.type;
+                if (orderType === ORDER_TYPES.SELL) {
+                    boundaryShift--; // SELL CREATE → fill was BUY → boundary LEFT
+                }
+                else if (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 / ${discarded.length} discarded CREATE(s)): ` +
+                            `${oldIdx} → ${newIdx}. Next COW cycle will generate replacement opposite-side orders.`, 'warn');
+                        if (typeof this.manager._markGridDirty === 'function') {
+                            this.manager._markGridDirty(`boundary adjustment after ${pending.length} planned CREATE(s)`);
+                        }
+                    }
+                }
+            }
+        }
         // 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 +2930,6 @@ class DEXBot {
                         if (freshChain.length > 0 && this.manager?.syncFromOpenOrders) {
                             await this.manager.syncFromOpenOrders(freshChain, {
                                 skipAccounting: true,
-                                fillLockAlreadyHeld: true,
-                                protectCommittedOrders: true
                             });
                         }
                     }
@@ -3316,7 +3346,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 +3803,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 +4163,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 +4469,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 +4482,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 +4642,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 +4764,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 +4794,6 @@ class DEXBot {
                         await this._cancelDustOrders({
                             buy: health.buyDustOrders,
                             sell: health.sellDustOrders,
-                            fillLockAlreadyHeld: true,
                         });
                     });
                 }
@@ -4776,7 +4819,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