dexbot 1.2.1 → 1.2.2

package/dist/modules/dexbot_class.js

@@ -134,7 +134,6 @@ class DEXBot {
     _currentCycleId;
     _autoCancelOrphanCycleMarker;
     _autoCancelOrphanSubCount;
-    _orphanFillsCreditedAt;
     _consecutiveConsumeFailures;
     _consumeFailureFirstAt;
     _reconnectUnregister;
@@ -226,7 +225,6 @@ class DEXBot {
         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).
@@ -1070,24 +1068,30 @@ class DEXBot {
                             if (trackedFillKey && !this._isNewFillKey(trackedFillKey, processedFillKeys, '[POST-RESET]', fillOp.order_id)) {
                                 continue;
                             }
-                            const accountingResult = await this._applyReplaySafeTrackedFillAccounting(fill, fillOp, {
-                                context: 'POST-RESET',
-                                logger: { log: this._log.bind(this) },
-                                replayMessage: (op) => `[POST-RESET] Replay detected for ${op.order_id}; skipping duplicate rebalance`
-                            });
-                            if (accountingResult.status === 'missing_key') {
-                                requiresOpenOrdersSync = true;
-                                continue;
-                            }
-                            if (accountingResult.status !== 'applied') {
-                                continue;
+                            this.manager.lockOrders([gridOrder.id]);
+                            try {
+                                const accountingResult = await this._applyReplaySafeTrackedFillAccounting(fill, fillOp, {
+                                    context: 'POST-RESET',
+                                    logger: { log: this._log.bind(this) },
+                                    replayMessage: (op) => `[POST-RESET] Replay detected for ${op.order_id}; skipping duplicate rebalance`
+                                });
+                                if (accountingResult.status === 'missing_key') {
+                                    requiresOpenOrdersSync = true;
+                                    continue;
+                                }
+                                if (accountingResult.status !== 'applied') {
+                                    continue;
+                                }
+                                // Process this fill through the full rebalance pipeline
+                                // This will shift the boundary and place a new order on the filled slot
+                                const result = await this._processFillsWithBatching([gridOrder], new Set(), `[POST-RESET] fill ${gridOrder.id}`);
+                                if (result.aborted) {
+                                    this._warn('[POST-RESET] Aborted batch due to illegal state; skipping grid persistence this cycle');
+                                    continue;
+                                }
                             }
-                            // Process this fill through the full rebalance pipeline
-                            // This will shift the boundary and place a new order on the filled slot
-                            const result = await this._processFillsWithBatching([gridOrder], new Set(), `[POST-RESET] fill ${gridOrder.id}`);
-                            if (result.aborted) {
-                                this._warn('[POST-RESET] Aborted batch due to illegal state; skipping grid persistence this cycle');
-                                continue;
+                            finally {
+                                this.manager.unlockOrders([gridOrder.id]);
                             }
                         }
                         if (requiresOpenOrdersSync) {
@@ -1566,10 +1570,12 @@ class DEXBot {
                 // 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.
+                // Written to this.manager (not this) because accounting.ts
+                // reads from the OrderManager reference (mgr).
                 // 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;
+                this.manager._orphanFillsCreditedAt = null;
                 while (this._incomingFillQueue.length > 0) {
                     const batchStartTime = Date.now();
                     // Track max queue depth
@@ -1634,9 +1640,9 @@ class DEXBot {
                                     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();
+                                // tolerance widening. Written to this.manager because
+                                // accounting.ts reads from the OrderManager (mgr).
+                                this.manager._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;
@@ -1644,7 +1650,7 @@ class DEXBot {
                             // Process both maker and taker fills for our grid orders
                             // Grid validation ensures we only process fills belonging to our account
                             // Taker fills are included because the bot may execute market orders or act as taker
-                            const roleStr = fillOp.is_maker ? 'maker' : 'taker';
+                            const roleStr = fillOp.is_maker !== false ? 'maker' : 'taker';
                             this.manager.logger.log(`Processing ${roleStr} fill for order ${fillOp.order_id}`, 'debug');
                             const fillKey = buildFillKey(fill);
                             if (!fillKey) {
@@ -1751,6 +1757,12 @@ class DEXBot {
                         const sortedBlocks = [...fillsByBlock.keys()].sort((a, b) => a - b);
                         const accumulatedOrders = [];
                         let anyRequiresSync = false;
+                        // Capture whether any fill was skipped during validation
+                        // (e.g. missing history ID) and set the sync flag. The
+                        // per-block reset below would lose this state since those
+                        // fills were filtered out of validFills and never enter
+                        // any block group.
+                        const initialRequiresSync = requiresOpenOrdersSync;
                         for (const blockNum of sortedBlocks) {
                             // Reset requiresOpenOrdersSync per block group so one
                             // block's history-id gap doesn't force the next block
@@ -1762,12 +1774,24 @@ class DEXBot {
                             if (requiresOpenOrdersSync)
                                 anyRequiresSync = true;
                         }
-                        requiresOpenOrdersSync = anyRequiresSync;
+                        // Preserve both per-block sync flags and the initial flag
+                        // from filtered-out fills (missing history ID).
+                        requiresOpenOrdersSync = anyRequiresSync || initialRequiresSync;
                         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);
                         }
+                        // If a fill was filtered out during validation (e.g. missing
+                        // history ID) and no block group triggered the open-orders
+                        // sync, run it now so the grid state is reconciled.
+                        if (requiresOpenOrdersSync && !anyRequiresSync) {
+                            this.manager.logger.log('[FILL-BLOCK] Running open-orders sync for fills with missing history identifiers', 'warn');
+                            const fallbackOrders = await processValidFills([]);
+                            accumulatedOrders.push(...fallbackOrders);
+                            // Flag consumed — variable goes out of scope on
+                            // next while iteration.
+                        }
                         allFilledOrders = accumulatedOrders;
                         // 4. Handle Price Corrections
                         if (ordersNeedingCorrection.length > 0) {
@@ -2002,20 +2026,26 @@ class DEXBot {
             if (trackedFillKey && !this._isNewFillKey(trackedFillKey, processedFillKeys, '[BOOTSTRAP]', fillOp.order_id)) {
                 continue;
             }
-            const accountingResult = await this._applyReplaySafeTrackedFillAccounting(fill, fillOp, {
-                context: 'BOOTSTRAP',
-                replayMessage: (op) => `[BOOTSTRAP] Replay detected for ${op.order_id}; skipping duplicate bootstrap rebalance`
-            });
-            if (accountingResult.status === 'missing_key') {
-                requiresOpenOrdersSync = true;
-                continue;
+            this.manager.lockOrders([gridOrder.id]);
+            try {
+                const accountingResult = await this._applyReplaySafeTrackedFillAccounting(fill, fillOp, {
+                    context: 'BOOTSTRAP',
+                    replayMessage: (op) => `[BOOTSTRAP] Replay detected for ${op.order_id}; skipping duplicate bootstrap rebalance`
+                });
+                if (accountingResult.status === 'missing_key') {
+                    requiresOpenOrdersSync = true;
+                    continue;
+                }
+                if (accountingResult.status !== 'applied') {
+                    continue;
+                }
+                validFills.push({ ...fill, gridOrder });
+                const fillType = gridOrder.type === ORDER_TYPES.BUY ? 'BUY' : 'SELL';
+                this._log(`[BOOTSTRAP] Fill detected: ${fillType} order (${fillOp.is_maker !== false ? 'maker' : 'taker'})`);
             }
-            if (accountingResult.status !== 'applied') {
-                continue;
+            finally {
+                this.manager.unlockOrders([gridOrder.id]);
             }
-            validFills.push({ ...fill, gridOrder });
-            const fillType = gridOrder.type === ORDER_TYPES.BUY ? 'BUY' : 'SELL';
-            this._log(`[BOOTSTRAP] Fill detected: ${fillType} order (${fillOp.is_maker ? 'maker' : 'taker'})`);
         }
         if (requiresOpenOrdersSync) {
             this._log('[BOOTSTRAP] Falling back to open-orders sync for fill(s) missing replay-safe history identifiers', 'warn');