dexbot 1.1.11 → 1.1.13

package/dist/modules/dexbot_class.js

@@ -71,7 +71,7 @@ const { ProcessedFillStore, PROCESSED_FILL_PERSISTENCE_MODES } = require('./orde
 const DexbotFillRuntime = require('./dexbot_fill_runtime');
 const DexbotMaintenanceRuntime = require('./dexbot_maintenance_runtime');
 const CreditRuntime = require('./credit_runtime');
-const { ORDER_STATES, ORDER_TYPES, REBALANCE_STATES, COW_ACTIONS, TIMING, MAINTENANCE, FILL_PROCESSING, DAEMON_CODES, } = require('./constants');
+const { ORDER_STATES, ORDER_TYPES, REBALANCE_STATES, COW_ACTIONS, TIMING, PIPELINE_TIMING, MAINTENANCE, FILL_PROCESSING, DAEMON_CODES, } = require('./constants');
 const { PATHS, getRecalculateTriggerFile } = require('./paths');
 const { attemptResumePersistedGridByPriceMatch, decideStartupGridAction, reconcileGridOrders } = require('./order/grid_reconcile');
 const { AccountOrders } = require('./account_orders');
@@ -132,12 +132,15 @@ class DEXBot {
     _lastGridActivityAt;
     _currentCycleId;
     _autoCancelOrphanCycleMarker;
+    _autoCancelOrphanSubCount;
+    _orphanFillsCreditedAt;
     _consecutiveConsumeFailures;
     _consumeFailureFirstAt;
     _reconnectUnregister;
     _credentialRecoveryDeferredTimer;
     _structuralGridResyncTimer;
     _structuralGridResyncRunning;
+    _ghostOrderCancelAttempted;
     _dustHealthCheckTimer;
     _lastBroadcastHeartbeatAt;
     _currentBatchId;
@@ -220,6 +223,12 @@ class DEXBot {
         this._lastGridActivityAt = 0;
         this._currentCycleId = 0;
         this._autoCancelOrphanCycleMarker = null;
+        this._autoCancelOrphanSubCount = 0;
+        this._orphanFillsCreditedAt = null;
+        // Per-session guard: ghost order IDs successfully cancelled
+        // (avoids spamming the chain with repeated cancel attempts for the same
+        // orphan residual on every fill cycle).
+        this._ghostOrderCancelAttempted = null;
         // Dust cancellation uses immediate on-chain cancel — no maps or timers needed.
         this._dustHealthCheckTimer = null;
         // Fill consumer watchdog: consecutive failure tracking.
@@ -364,7 +373,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 });
+            await this.manager.syncFromOpenOrders(openOrders, { skipAccounting: true, fillLockAlreadyHeld: true, protectCommittedOrders: true });
             if (typeof this.manager.persistGrid === 'function') {
                 await this.manager.persistGrid();
             }
@@ -538,6 +547,57 @@ class DEXBot {
         }
         return Array.from(ids);
     }
+    /**
+     * Reload the entire grid from the persisted on-disk snapshot and reconcile
+     * with current chain state. Mirrors the startup recovery path.
+     *
+     * LOCK SAFETY: Does NOT acquire _fillProcessingLock. Caller must either
+     * hold it already or accept concurrent fill-processing risk — matches
+     * the startup pattern at line ~1340.
+     *
+     * @returns {Promise<{success: boolean, reason?: string}>}
+     */
+    async _recoverFromPersistedGrid() {
+        if (!this.accountOrders || !this.manager) {
+            return { success: false, reason: 'accountOrders or manager unavailable' };
+        }
+        const accountRef = this.accountId || this.account?.id || this.account;
+        if (!accountRef) {
+            return { success: false, reason: 'no account reference' };
+        }
+        this.manager.logger.log('[RECOVERY] Attempting full grid reload from persisted snapshot...', 'warn');
+        try {
+            // 1. Force reload from disk
+            const persistedGrid = this.accountOrders.loadGrid(true);
+            if (!persistedGrid || persistedGrid.length === 0) {
+                return { success: false, reason: 'no persisted grid on disk' };
+            }
+            const boundaryIdx = this.accountOrders.loadBoundaryIdx(true);
+            // 2. Load into manager (same path as startup at line 1340)
+            await Grid.loadGrid(this.manager, persistedGrid, boundaryIdx);
+            // 3. Read current chain state
+            const chainOpenOrders = await chainOrders.readOpenOrders(accountRef);
+            // 4. Reconcile
+            if (chainOpenOrders.length > 0 && this.manager?.syncFromOpenOrders) {
+                await this.manager.syncFromOpenOrders(chainOpenOrders, {
+                    skipAccounting: true,
+                    fillLockAlreadyHeld: true,
+                    protectCommittedOrders: true
+                });
+            }
+            // 5. Persist the reconciled state
+            if (typeof this.manager.persistGrid === 'function') {
+                await this.manager.persistGrid();
+            }
+            this.manager.logger.log(`[RECOVERY] Grid reloaded from persisted snapshot: ${this.manager.orders.size} orders, ` +
+                `${chainOpenOrders.length} on-chain orders synced`, 'info');
+            return { success: true };
+        }
+        catch (err) {
+            this.manager.logger.log(`[RECOVERY] Full grid reload from persisted snapshot failed: ${err.message}`, 'error');
+            return { success: false, reason: err.message };
+        }
+    }
     /**
      * Attempt to repair size-drift for specific order IDs by reading their
      * current on-chain state and correcting the local grid directly.
@@ -1147,6 +1207,12 @@ class DEXBot {
                         await Grid.loadGrid(this.manager, persistedGrid, persistedBoundaryIdx);
                         let startupChainOpenOrders = chainOpenOrders;
                         const syncResult = await this.manager.syncFromOpenOrders(startupChainOpenOrders, { skipAccounting: true, fillLockAlreadyHeld: 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.
+                        if (syncResult.ordersNeedingCorrection?.length > 0) {
+                            await correctAllPriceMismatches(this.manager, this.account, this.privateKey, chainOrders);
+                        }
                         if (syncResult.filledOrders && syncResult.filledOrders.length > 0) {
                             this._log(`Startup sync: ${syncResult.filledOrders.length} grid order(s) found filled. Processing proceeds.`, 'info');
                             const batchResult = await this._processFillsWithBatching(syncResult.filledOrders, new Set(), 'startup sync fill rebalance', { skipAccountTotalsUpdate: true });
@@ -1438,6 +1504,14 @@ class DEXBot {
                 return;
             }
             await this.manager._fillProcessingLock.acquire(async () => {
+                // Reset orphan-fill credit timestamp at the start of each
+                // fill cycle. It is re-set when orphan fills are credited,
+                // and consumed (set to null) on the next fund-invariant check
+                // in accounting.ts, which widens tolerance by 5x while set.
+                // Also cleared by _performStateRecovery after a fresh chain
+                // fetch. The timestamp value itself is not compared against a
+                // window — it acts as a consume-on-read boolean.
+                this._orphanFillsCreditedAt = null;
                 while (this._incomingFillQueue.length > 0) {
                     const batchStartTime = Date.now();
                     // Track max queue depth
@@ -1501,6 +1575,10 @@ class DEXBot {
                                 if (accountingResult.status === 'missing_key') {
                                     requiresOpenOrdersSync = true;
                                 }
+                                // Record orphan fill credit timestamp for fund invariant
+                                // tolerance widening. Accounting checks recency via
+                                // _checkOrphanFillRecency() instead of a cross-module flag.
+                                this._orphanFillsCreditedAt = Date.now();
                                 // Don't add to validFills - we can't do rebalancing without a grid slot
                                 // But the funds are now credited, preventing fund invariant violation
                                 continue;
@@ -1547,6 +1625,7 @@ class DEXBot {
                     // 3. Sync and Collect Filled Orders
                     let allFilledOrders = [];
                     let ordersNeedingCorrection = [];
+                    const pendingGhostOrders = new Set();
                     const fillMode = chainOrders.getFillProcessingMode();
                     const processValidFills = async (fillsToSync) => {
                         let resolvedOrders = [];
@@ -1568,6 +1647,8 @@ class DEXBot {
                                     resolvedOrders.push(...resultHistory.filledOrders);
                                 if (resultHistory.requiresOpenOrdersSync)
                                     requiresOpenOrdersSync = true;
+                                if (resultHistory.ghostOrderId)
+                                    pendingGhostOrders.add(resultHistory.ghostOrderId);
                             }
                         }
                         if (fillMode !== 'history' || requiresOpenOrdersSync) {
@@ -1587,7 +1668,49 @@ class DEXBot {
                     };
                     this.manager.pauseFundRecalc();
                     try {
-                        allFilledOrders = await processValidFills(validFills);
+                        // FIX 1: Block-level fill batching — group valid fills by block
+                        // and process each block group as a unit. This prevents slot
+                        // collisions when fills from the same block (original + replacement
+                        // orders both filled) arrive in different sync batches. Processing
+                        // all fills from a block together lets the sync engine see every
+                        // fill for overlapping slots simultaneously.
+                        const fillsByBlock = new Map();
+                        const fillsWithoutBlock = [];
+                        for (const fill of validFills) {
+                            if (fill.block_num != null) {
+                                const list = fillsByBlock.get(fill.block_num);
+                                if (list)
+                                    list.push(fill);
+                                else
+                                    fillsByBlock.set(fill.block_num, [fill]);
+                            }
+                            else {
+                                fillsWithoutBlock.push(fill);
+                            }
+                        }
+                        // Process block groups in ascending block order so the sync
+                        // engine sees a deterministic, chronological fill sequence.
+                        const sortedBlocks = [...fillsByBlock.keys()].sort((a, b) => a - b);
+                        const accumulatedOrders = [];
+                        let anyRequiresSync = false;
+                        for (const blockNum of sortedBlocks) {
+                            // Reset requiresOpenOrdersSync per block group so one
+                            // block's history-id gap doesn't force the next block
+                            // into an unnecessary open-orders snapshot re-fetch.
+                            requiresOpenOrdersSync = false;
+                            this.manager.logger.log(`[FILL-BLOCK] Processing ${fillsByBlock.get(blockNum).length} fill(s) from block ${blockNum}`, 'debug');
+                            const blockResult = await processValidFills(fillsByBlock.get(blockNum));
+                            accumulatedOrders.push(...blockResult);
+                            if (requiresOpenOrdersSync)
+                                anyRequiresSync = true;
+                        }
+                        requiresOpenOrdersSync = anyRequiresSync;
+                        if (fillsWithoutBlock.length > 0) {
+                            this.manager.logger.log(`[FILL-BLOCK] Processing ${fillsWithoutBlock.length} fill(s) without block info`, 'debug');
+                            const noBlockResult = await processValidFills(fillsWithoutBlock);
+                            accumulatedOrders.push(...noBlockResult);
+                        }
+                        allFilledOrders = accumulatedOrders;
                         // 4. Handle Price Corrections
                         if (ordersNeedingCorrection.length > 0) {
                             const correctionResult = await correctAllPriceMismatches(this.manager, this.account, this.privateKey, chainOrders);
@@ -1596,6 +1719,30 @@ class DEXBot {
                         }
                     }
                     finally {
+                        // 4b. Cancel orphaned chain orders detected by other-side rounding.
+                        //     These orders have a tiny residual that the bot treated as fully
+                        //     filled, but the blockchain did not close the order. We send a
+                        //     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.
+                        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);
+                                }
+                                catch (err) {
+                                    this.manager.logger.log(`[SYNC] Failed to cancel orphaned order ${ghostOrderId}: ${err?.message || err}`, 'warn');
+                                }
+                            }
+                        }
                         await this.manager.resumeFundRecalc();
                     }
                     // 5. Fixed-Cap Fill Rebalance
@@ -2054,7 +2201,8 @@ class DEXBot {
             const openOrders = await chainOrders.readOpenOrders(accountRef);
             const recoveryResult = await this.manager.syncFromOpenOrders(openOrders, {
                 skipAccounting: false,
-                fillLockAlreadyHeld: true
+                fillLockAlreadyHeld: true,
+                protectCommittedOrders: true
             });
             this._preserveMissingCreateBlockersAfterRecovery(preRecoveryMissingCreateBlockers, recoveryResult);
             // Persist any master grid mutations from the recovery sync. The
@@ -2442,7 +2590,7 @@ class DEXBot {
             return { executed: false, hadRotation: false, uncertain: true };
         }
         const adopted = [];
-        const discarded = [];
+        let discarded = [];
         // 2. For each pending broadcast, look for a chain match.
         for (const entry of pending) {
             const match = this._findChainOrderForSlot(chainSnapshot, entry.slotId, {
@@ -2456,44 +2604,82 @@ class DEXBot {
                 this.manager._pendingBroadcasts.delete(entry.fingerprint);
             }
             else {
-                discarded.push({ slotId: entry.slotId });
-            }
-        }
-        // 3. Apply the result to the working grid.
-        // - For adopted entries: re-run a structural sync so the manager picks up
-        //   the chain order into the planned slot. The pre-broadcast guard
-        //   already cleared the working grid, so we use a fresh sync.
-        // - For discarded entries: leave the planned slot empty; the next
-        //   planning cycle will refill it.
-        // - Short-circuit the re-sync when every CREATE in the batch was
-        //   fingerprinted AND adopted (the happy path of a slow but successful
-        //   chain). The chain state is already known for those slots, so a full
-        //   sync would just produce a burst of false-positive "no adoptable
-        //   slot" warnings for any non-CREATE orders that were already in
-        //   place before this batch.
-        let hadRotation = false;
-        const allCreatesAdopted = pending.length > 0
-            && pending.every(p => adopted.some(a => a.slotId === p.slotId));
-        const shouldRunHeavySync = !(allCreatesAdopted && discarded.length === 0);
-        if (shouldRunHeavySync) {
+                // Preserve full entry context so the recheck below can use
+                // both the fingerprint match path (against _pendingBroadcasts)
+                // and the near-match path (via finalInts/orderType), not just
+                // slotId alone.
+                discarded.push(entry);
+            }
+        }
+        // ---- RACE MITIGATION: block-delay recheck before discarding creates ----
+        // 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_INTERVAL_MS = TIMING.MILLISECONDS_PER_SECOND * 3; // 3s
+        let recheckRound = 0;
+        while (discarded.length > 0 && recheckRound < UNCERTAIN_RECHECK_MAX_ATTEMPTS) {
+            recheckRound++;
+            await new Promise(r => setTimeout(r, UNCERTAIN_RECHECK_INTERVAL_MS));
+            let freshSnapshot;
             try {
-                if (chainSnapshot && chainSnapshot.length > 0 && this.manager?.syncFromOpenOrders) {
-                    await this.manager.syncFromOpenOrders(chainSnapshot, {
-                        skipAccounting: true,
-                        fillLockAlreadyHeld: true
-                    });
-                    hadRotation = true;
+                freshSnapshot = await chainOrders.readOpenOrders(accountRef);
+            }
+            catch {
+                break;
+            }
+            const stillDiscarded = [];
+            for (const entry of discarded) {
+                const match = this._findChainOrderForSlot(freshSnapshot, entry.slotId, {
+                    sell: entry.finalInts?.sell,
+                    receive: entry.finalInts?.receive,
+                    orderType: entry.orderType || entry.order?.type,
+                    fingerprint: entry.fingerprint
+                });
+                if (match) {
+                    adopted.push({ slotId: entry.slotId, chainOrderId: match.id });
+                    this.manager.logger.log(`[COW][UNCERTAIN] CREATE re-adopted after ${recheckRound} block(s): ` +
+                        `${entry.slotId}->${match.id}`, 'info');
+                }
+                else {
+                    stillDiscarded.push(entry);
                 }
             }
+            discarded = stillDiscarded;
+        }
+        // 3. Re-read chain with latest state. The initial snapshot may be
+        // stale for non-CREATE ops (updates/cancels) not tracked in
+        // _pendingBroadcasts — the seed cause of the slot-115 cascade.
+        let latestSnapshot;
+        try {
+            latestSnapshot = await chainOrders.readOpenOrders(accountRef);
+        }
+        catch {
+            latestSnapshot = chainSnapshot;
+        }
+        // Always sync to link adopted chain orders into grid slots.
+        // Otherwise an adopted slot stays VIRTUAL and the next COW cycle
+        // places a duplicate order at the same price.
+        let hadRotation = false;
+        if (latestSnapshot && latestSnapshot.length > 0 && this.manager?.syncFromOpenOrders) {
+            try {
+                await this.manager.syncFromOpenOrders(latestSnapshot, {
+                    skipAccounting: true,
+                    fillLockAlreadyHeld: true,
+                    protectCommittedOrders: true
+                });
+                hadRotation = true;
+            }
             catch (syncErr) {
                 this.manager.logger.log(`[COW][UNCERTAIN] syncFromOpenOrders failed during recovery: ${syncErr?.message || syncErr}`, 'error');
+                // Fallback: reload from persisted snapshot + re-sync.
+                this.manager.logger.log('[COW][UNCERTAIN] syncFromOpenOrders failed; falling back to full grid reload from persisted snapshot', 'warn');
+                const fallbackResult = await this._recoverFromPersistedGrid();
+                if (fallbackResult.success) {
+                    hadRotation = true;
+                }
             }
         }
-        else {
-            hadRotation = true;
-            this.manager.logger.log(`[COW][UNCERTAIN] All ${adopted.length} fingerprinted CREATE(s) adopted; ` +
-                `skipping heavy re-sync to avoid false-positive unmatched warnings.`, 'debug');
-        }
         // 4. Log structured summary.
         const elapsedMs = Date.now() - startedAt;
         const heartbeatAgeMs = this._lastBroadcastHeartbeatAt
@@ -2501,14 +2687,14 @@ class DEXBot {
             : null;
         this.manager.logger.log(`[COW][UNCERTAIN] batchId=${err?.batchId || 'n/a'} ops=${opContexts.length} ` +
             `staleSinceMs=${err?.timeoutMs || 'n/a'} heartbeatAgeMs=${heartbeatAgeMs ?? 'n/a'} ` +
-            `adopted=${adopted.length} discarded=${discarded.length} elapsedMs=${elapsedMs}`, adopted.length > 0 ? 'info' : 'warn');
+            `adopted=${adopted.length} discarded=${discarded.length} recheckRounds=${recheckRound} elapsedMs=${elapsedMs}`, adopted.length > 0 ? 'info' : 'warn');
         if (adopted.length > 0) {
             this.manager.logger.log(`[COW][UNCERTAIN] Adopted chain orders: ${adopted
                 .map(a => `${a.slotId}->${a.chainOrderId}`)
                 .join(', ')}`, 'info');
         }
         if (discarded.length > 0) {
-            this.manager.logger.log(`[COW][UNCERTAIN] Discarded planned CREATEs (no chain match): ${discarded
+            this.manager.logger.log(`[COW][UNCERTAIN] Discarded planned CREATEs (no chain match after ${recheckRound} recheck(s)): ${discarded
                 .map(d => d.slotId)
                 .join(', ')}`, 'warn');
         }
@@ -2557,8 +2743,18 @@ class DEXBot {
      */
     async _autoCancelOneUnmatchedOrphan() {
         const cycleId = this._currentCycleId || 0;
+        // FIX 4: Higher cap during recovery mode so orphan backlog clears faster.
+        const recoveryActive = this.manager?._recoveryState?.structuralResyncRequested === true;
+        const cycleCap = recoveryActive ? 5 : 1;
         if (this._autoCancelOrphanCycleMarker === cycleId) {
-            return { cancelled: false, reason: 'cap-reached-this-cycle' };
+            if (this._autoCancelOrphanSubCount >= cycleCap) {
+                return { cancelled: false, reason: 'cap-reached-this-cycle', subCount: this._autoCancelOrphanSubCount };
+            }
+        }
+        else {
+            // Reset sub-count on first call this cycle
+            this._autoCancelOrphanCycleMarker = cycleId;
+            this._autoCancelOrphanSubCount = 0;
         }
         const pending = (this.manager && this.manager._pendingBroadcasts instanceof Map)
             ? this.manager._pendingBroadcasts.size
@@ -2587,13 +2783,15 @@ class DEXBot {
             return { cancelled: false, reason: 'cancelOrder-unavailable' };
         }
         try {
-            this._autoCancelOrphanCycleMarker = cycleId;
-            this.manager.logger.log(`[COW] Auto-cancelling 1/${unmatched.length} unmatched chain order ` +
-                `(${this._formatUnmatchedChainOrderForLog(target)}) — per-cycle cap=1.`, 'warn');
             await chainOrders.cancelOrder(this.account, this.privateKey, orderId);
             if (typeof chainOrders.recordOwnCancel === 'function') {
                 chainOrders.recordOwnCancel(orderId);
             }
+            // Increment sub-count only after a confirmed successful cancel.
+            // Failed cancels do not consume the per-cycle cap budget.
+            this._autoCancelOrphanSubCount++;
+            this.manager.logger.log(`[COW] Auto-cancelled ${this._autoCancelOrphanSubCount}/${unmatched.length} unmatched chain order ` +
+                `(${this._formatUnmatchedChainOrderForLog(target)}) — per-cycle cap=${cycleCap}.`, 'warn');
             return { cancelled: true, orderId };
         }
         catch (err) {
@@ -2647,6 +2845,21 @@ class DEXBot {
                 if (isRetriable) {
                     this.manager.logger.log(`[COW] Broadcast uncertain (attempt ${attempt}/${MAX_RETRIES + 1}), retrying...`, 'warn');
                     await this._ensureCredentialDaemonWritable('COW batch retry');
+                    // Reconcile before retry — stale ops would fail "not found".
+                    try {
+                        const accountRef = this.accountId || this.account?.id || this.account;
+                        const freshChain = await chainOrders.readOpenOrders(accountRef);
+                        if (freshChain.length > 0 && this.manager?.syncFromOpenOrders) {
+                            await this.manager.syncFromOpenOrders(freshChain, {
+                                skipAccounting: true,
+                                fillLockAlreadyHeld: true,
+                                protectCommittedOrders: true
+                            });
+                        }
+                    }
+                    catch (syncErr) {
+                        this.manager.logger.log(`[COW] Pre-retry sync failed (non-fatal): ${syncErr?.message || syncErr}`, 'warn');
+                    }
                     continue;
                 }
                 throw err;
@@ -3409,58 +3622,111 @@ class DEXBot {
             ? Array.from(this.manager._pendingBroadcasts.values())
             : [];
         if (hasCreateActions && (unmatchedChainOrders.length > 0 || pendingBroadcasts.length > 0)) {
-            const blockers = [];
-            if (unmatchedChainOrders.length > 0)
-                blockers.push(`${unmatchedChainOrders.length} unmatched chain order(s)`);
-            if (pendingBroadcasts.length > 0)
-                blockers.push(`${pendingBroadcasts.length} pending broadcast(s)`);
-            const reasonText = blockers.join(' and ');
-            if (pendingBroadcasts.length > 0) {
-                this.manager.logger.log(`[COW] Rejecting CREATE batch: ${reasonText} from a prior uncertain ` +
-                    `broadcast. Running recovery before placing replacement orders.`, 'error');
-            }
-            else {
-                const sample = unmatchedChainOrders
-                    .slice(0, 3)
-                    .map(order => this._formatUnmatchedChainOrderForLog(order))
-                    .join(' | ');
-                this.manager.logger.log(`[COW] Rejecting CREATE batch: ${reasonText} ` +
-                    `are not represented in the grid${sample ? ` (${sample})` : ''}. ` +
-                    `Run structural reconciliation before placing replacement orders.`, 'error');
+            // ---- FIX 3: Absorb unmatched orders instead of rejecting ----
+            // When unmatched chain orders exist, try to auto-cancel them
+            // inline to unblock the CREATE batch. Only fall through to
+            // full rejection + structural resync if cancellation fails.
+            let cancelledUnmatched = 0;
+            if (unmatchedChainOrders.length > 0 && pendingBroadcasts.length === 0) {
+                // Bounded-parallel cancellation: process unmatched orders in
+                // concurrent batches (3 at a time) to avoid serialising 19+
+                // individual cancel txs (~0.5s each = 10s batch hold).
+                const CANCEL_CONCURRENCY = 3;
+                const cancelable = unmatchedChainOrders.filter(u => {
+                    const oid = u?.id || u?.orderId || u?.chainOrderId;
+                    return Boolean(oid) && !u?.fingerprint;
+                });
+                for (let i = 0; i < cancelable.length; i += CANCEL_CONCURRENCY) {
+                    const batch = cancelable.slice(i, i + CANCEL_CONCURRENCY);
+                    const results = await Promise.allSettled(batch.map(async (unmatched) => {
+                        const orderId = unmatched.id || unmatched.orderId || unmatched.chainOrderId;
+                        this.manager.logger.log(`[COW] Auto-cancelling unmatched chain order ${orderId} ` +
+                            `(${this._formatUnmatchedChainOrderForLog(unmatched)}) to unblock CREATE batch.`, 'warn');
+                        await chainOrders.cancelOrder(this.account, this.privateKey, orderId);
+                        if (typeof chainOrders.recordOwnCancel === 'function') {
+                            chainOrders.recordOwnCancel(orderId);
+                        }
+                    }));
+                    for (const r of results) {
+                        if (r.status === 'fulfilled')
+                            cancelledUnmatched++;
+                        else
+                            this.manager.logger.log(`[COW] Failed to cancel unmatched chain order: ${r.reason?.message || r.reason}`, 'warn');
+                    }
+                }
+                if (cancelledUnmatched >= cancelable.length) {
+                    this.manager.logger.log(`[COW] Cancelled all ${cancelledUnmatched} unmatched chain order(s); proceeding with CREATE batch.`, 'warn');
+                    // Optimistic clear: the cancel txs are sent but not yet
+                    // confirmed. If a cancel silently fails on chain, the
+                    // next sync cycle will re-detect the unmatched order and
+                    // re-enter this guard — that's safe because the cancel
+                    // is idempotent and the re-detection is non-blocking.
+                    this.manager._lastUnmatchedChainOrders = [];
+                }
+                else {
+                    this.manager.logger.log(`[COW] Cancelled ${cancelledUnmatched}/${cancelable.length} unmatched chain order(s); ` +
+                        `remaining must be handled by structural reconciliation.`, 'warn');
+                }
             }
-            if (typeof this.manager.requestStructuralGridResync === 'function') {
-                if (this.manager._recoveryState)
-                    this.manager._recoveryState.structuralResyncRequested = true;
-                await this.manager.requestStructuralGridResync(pendingBroadcasts.length > 0
-                    ? 'pending broadcasts before COW create'
-                    : 'unmatched chain orders before COW create', pendingBroadcasts.length > 0
-                    ? { pendingBroadcasts: pendingBroadcasts.map(p => p.slotId) }
-                    : { unmatchedChainOrders });
-            }
-            // If we have pending broadcasts, drive the recovery now so the
-            // next planning cycle has a clean state.
-            if (pendingBroadcasts.length > 0) {
-                try {
-                    await this._reconcileAfterUncertainBroadcast(new BroadcastUncertainError('rejected CREATE batch had pending broadcasts', {
-                        operations: pendingBroadcasts.map(p => p.order),
-                        accountName: this.account,
-                        batchId: this._currentBatchId || null,
-                        payload: null,
-                        timeoutMs: null
-                    }), [], { fillLockAlreadyHeld: true });
+            // Re-check after auto-cancel attempt
+            const remainingUnmatched = Array.isArray(this.manager?._lastUnmatchedChainOrders)
+                ? this.manager._lastUnmatchedChainOrders
+                : [];
+            if (remainingUnmatched.length > 0 || pendingBroadcasts.length > 0) {
+                const blockers = [];
+                if (remainingUnmatched.length > 0)
+                    blockers.push(`${remainingUnmatched.length} unmatched chain order(s)`);
+                if (pendingBroadcasts.length > 0)
+                    blockers.push(`${pendingBroadcasts.length} pending broadcast(s)`);
+                const reasonText = blockers.join(' and ');
+                if (pendingBroadcasts.length > 0) {
+                    this.manager.logger.log(`[COW] Rejecting CREATE batch: ${reasonText} from a prior uncertain ` +
+                        `broadcast. Running recovery before placing replacement orders.`, 'error');
+                }
+                else {
+                    const sample = remainingUnmatched
+                        .slice(0, 3)
+                        .map(order => this._formatUnmatchedChainOrderForLog(order))
+                        .join(' | ');
+                    this.manager.logger.log(`[COW] Rejecting CREATE batch: ${reasonText} ` +
+                        `are not represented in the grid${sample ? ` (${sample})` : ''}. ` +
+                        `Run structural reconciliation before placing replacement orders.`, 'error');
                 }
-                catch (recoverErr) {
-                    this.manager.logger.log(`[COW] Recovery from pending broadcasts failed: ${recoverErr?.message || recoverErr}`, 'error');
+                if (typeof this.manager.requestStructuralGridResync === 'function') {
+                    if (this.manager._recoveryState)
+                        this.manager._recoveryState.structuralResyncRequested = true;
+                    await this.manager.requestStructuralGridResync(pendingBroadcasts.length > 0
+                        ? 'pending broadcasts before COW create'
+                        : 'unmatched chain orders before COW create', pendingBroadcasts.length > 0
+                        ? { pendingBroadcasts: pendingBroadcasts.map(p => p.slotId) }
+                        : { unmatchedChainOrders: remainingUnmatched });
                 }
+                // If we have pending broadcasts, drive the recovery now so the
+                // next planning cycle has a clean state.
+                if (pendingBroadcasts.length > 0) {
+                    try {
+                        await this._reconcileAfterUncertainBroadcast(new BroadcastUncertainError('rejected CREATE batch had pending broadcasts', {
+                            operations: pendingBroadcasts.map(p => p.order),
+                            accountName: this.account,
+                            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');
+                    }
+                }
+                return {
+                    executed: false,
+                    aborted: true,
+                    reason: pendingBroadcasts.length > 0 ? 'PENDING_BROADCASTS' : 'UNMATCHED_CHAIN_ORDERS',
+                    unmatchedChainOrders: pendingBroadcasts.length > 0 ? [] : remainingUnmatched,
+                    pendingBroadcasts: pendingBroadcasts.map(p => p.slotId),
+                    hadRotation: false
+                };
             }
-            return {
-                executed: false,
-                aborted: true,
-                reason: pendingBroadcasts.length > 0 ? 'PENDING_BROADCASTS' : 'UNMATCHED_CHAIN_ORDERS',
-                unmatchedChainOrders: pendingBroadcasts.length > 0 ? [] : unmatchedChainOrders,
-                pendingBroadcasts: pendingBroadcasts.map(p => p.slotId),
-                hadRotation: false
-            };
+            // All unmatched were cancelled — fall through to continue batch
         }
         const { assetA, assetB } = this.manager.assets;
         const operations = [];
@@ -3501,7 +3767,13 @@ class DEXBot {
                         opContexts.push({ kind: 'cancel', order });
                     }
                     catch (err) {
-                        this.manager.logger.log(`Failed to prepare cancel op for ${action.id}: ${err.message}`, 'error');
+                        const orderNotFound = /\bnot found\b/i.test(err.message) || /\bdoes not exist\b/i.test(err.message);
+                        if (orderNotFound) {
+                            this.manager.logger.log(`[COW] Cancel skipped for ${action.id} (${action.orderId}): order already removed from chain`, 'debug');
+                        }
+                        else {
+                            this.manager.logger.log(`Failed to prepare cancel op for ${action.id}: ${err.message}`, 'error');
+                        }
                     }
                 }
                 else if (action.type === COW_ACTIONS.CREATE) {
@@ -3613,8 +3885,60 @@ class DEXBot {
                             type: orderType
                         };
                         opContexts.push({ kind: 'size-update', updateInfo: { partialOrder, newSize }, finalInts: op.finalInts });
+                        // Catch for both rotation-update and size-update branches.
                     }
                     catch (err) {
+                        const orderNotFound = /\bnot found\b/i.test(err.message) || /\bdoes not exist\b/i.test(err.message);
+                        if (orderNotFound) {
+                            try {
+                                const fbOrder = action.order || this.manager.orders.get(action.id);
+                                const fbType = fbOrder?.type;
+                                const fbSize = action.newSize || fbOrder?.size || 0;
+                                // Live price from TARGET slot (same pattern as CREATE path).
+                                const targetSlotId = action.newGridId || action.id;
+                                const plannedPrice = action.newPrice || action.order?.price || 0;
+                                const liveSlotForPrice = this.manager.orders.get(targetSlotId);
+                                const livePrice = liveSlotForPrice ? Number(liveSlotForPrice.price) : NaN;
+                                const priceDrift = Number.isFinite(plannedPrice) && Number.isFinite(livePrice)
+                                    ? Math.abs(livePrice - plannedPrice)
+                                    : 0;
+                                const fbPrice = (priceDrift > 0) ? livePrice : plannedPrice;
+                                if (priceDrift > 0) {
+                                    this.manager.logger.log(`[COW] CREATE fallback price drift for ${action.id} -> ${targetSlotId}: ` +
+                                        `planned=${plannedPrice} live=${livePrice} (diff=${priceDrift})`, 'debug');
+                                }
+                                // Same size gate as regular CREATE path.
+                                const sizeCheck = this._validateOrderSizeForExecution(fbSize, fbType, fbOrder, fbSize);
+                                if (!sizeCheck.isValid) {
+                                    this.manager.logger.log(`[COW] CREATE fallback for ${action.id} rejected by size validation: ${sizeCheck.reason}`, 'warn');
+                                }
+                                else if (fbType && fbSize > 0 && fbPrice > 0) {
+                                    const fbArgs = buildCreateOrderArgs({ type: fbType, size: fbSize, price: fbPrice }, assetA, assetB);
+                                    const fbResult = await chainOrders.buildCreateOrderOp(this.account, fbArgs.amountToSell, fbArgs.sellAssetId, fbArgs.minToReceive, fbArgs.receiveAssetId, null);
+                                    if (fbResult) {
+                                        operations.push(fbResult.op);
+                                        opContexts.push({
+                                            kind: 'create',
+                                            id: targetSlotId,
+                                            order: { id: targetSlotId, type: fbType, price: fbPrice, size: fbSize },
+                                            args: { amountToSell: fbArgs.amountToSell, minToReceive: fbArgs.minToReceive },
+                                            finalInts: fbResult.finalInts
+                                        });
+                                        this._recordPendingBroadcast({
+                                            opIndex: operations.length - 1,
+                                            ctxIndex: opContexts.length - 1,
+                                            order: { id: targetSlotId, type: fbType, price: fbPrice, size: fbSize },
+                                            finalInts: fbResult.finalInts
+                                        });
+                                        this.manager.logger.log(`[COW] Recovered "not found" for ${action.id}: converted UPDATE to CREATE for slot ${targetSlotId}`, 'warn');
+                                        continue;
+                                    }
+                                }
+                            }
+                            catch (fbErr) {
+                                this.manager.logger.log(`[COW] CREATE fallback also failed for ${action.id}: ${fbErr.message}`, 'warn');
+                            }
+                        }
                         this.manager.logger.log(`Failed to prepare update op for ${action.id}: ${err.message}`, 'error');
                     }
                 }
@@ -4246,6 +4570,16 @@ class DEXBot {
                     return;
                 this._structuralGridResyncRunning = true;
                 try {
+                    // Try the lighter persisted-grid reload before full reset.
+                    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;
+                        }
+                        return;
+                    }
                     const suffix = unmatchedCount > 0 ? ` (${unmatchedCount} unmatched chain order(s))` : '';
                     this._warn(`[RECOVERY] Running structural full grid resync for ${reason}${suffix}`);
                     const resetResult = await this.requestGridReset('rms_structural_grid_resync', {