dexbot 1.2.0 → 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).
@@ -349,7 +347,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
         };
     }
     /**
@@ -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) {
@@ -1279,6 +1283,30 @@ 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()
@@ -1504,11 +1532,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;
@@ -1542,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
@@ -1610,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;
@@ -1620,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) {
@@ -1727,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
@@ -1738,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) {
@@ -1978,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');
@@ -2628,7 +2682,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 {
@@ -2665,7 +2723,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');
                 }
@@ -2748,27 +2810,27 @@ class DEXBot {
             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.
+        // 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.
-        if (hadRotation && this.manager && pending.length > 0) {
+        // 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 pending) {
-                const orderType = entry.orderType || entry.order?.type;
-                if (orderType === ORDER_TYPES.SELL) {
+            for (const entry of adopted) {
+                if (entry.orderType === ORDER_TYPES.SELL) {
                     boundaryShift--; // SELL CREATE → fill was BUY → boundary LEFT
                 }
-                else if (orderType === ORDER_TYPES.BUY) {
+                else if (entry.orderType === ORDER_TYPES.BUY) {
                     boundaryShift++; // BUY CREATE → fill was SELL → boundary RIGHT
                 }
             }
@@ -2780,10 +2842,10 @@ class DEXBot {
                     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)): ` +
+                            `(${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(`boundary adjustment after ${pending.length} planned CREATE(s)`);
+                            this.manager._markGridDirty();
                         }
                     }
                 }
@@ -3324,7 +3386,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(() => {