dexbot 1.4.7 → 1.4.8

package/dist/modules/order/sync_engine.js

@@ -719,7 +719,12 @@ class SyncEngine {
                     else {
                         const spreadOrder = (0, order_1.convertToSpreadPlaceholder)(gridOrder);
                         await mgr._applyOrderUpdate(spreadOrder, 'sync-pass1-filled', { skipAccounting: skipAccounting, fee: 0 });
-                        filledOrders.push(spreadOrder);
+                        // Push the filled order with its REAL side (chain order
+                        // type), not the SPREAD placeholder: downstream fill
+                        // processing (deriveTargetBoundary) derives boundary
+                        // movement from fill.type, and a SPREAD type would
+                        // silently drop the shift for this completed order.
+                        filledOrders.push({ ...gridOrder, type: chainOrder.type });
                         updatedOrders.push(spreadOrder);
                     }
                 }
@@ -760,7 +765,7 @@ class SyncEngine {
                 // this open-orders sync.
                 if (mgr._committedOrderIds?.has(gridOrder.orderId)) {
                     const commitAge = Date.now() - (mgr._committedOrderIdsBuiltAt || 0);
-                    const isGhost = gridOrder.isGhost === true || (gridOrder.size <= 0 && gridOrder.state === constants_1.ORDER_STATES.PARTIAL);
+                    const isGhost = gridOrder.size <= 0 && gridOrder.state === constants_1.ORDER_STATES.PARTIAL;
                     if (!isGhost && commitAge < constants_1.TIMING.SYNC_LOCK_TIMEOUT_MS) {
                         continue;
                     }
@@ -771,7 +776,18 @@ class SyncEngine {
                 await mgr._applyOrderUpdate(spreadOrder, 'sync-cleanup-phantom', { skipAccounting: skipAccounting, fee: 0 });
                 // Only genuine disappearances (had orderId) count as fills.
                 if (hadOrderId) {
-                    filledOrders.push({ ...currentGridOrder });
+                    // A SPREAD slot can carry an on-chain order (spread-correction
+                    // activation). Resolve the real side before pushing: the fill
+                    // drives deriveTargetBoundary, which only shifts on BUY/SELL —
+                    // a SPREAD-typed fill would silently drop the boundary crawl
+                    // for this completed order. Same price-vs-startPrice convention
+                    // as the funds check (manager.ts) since no chain order remains
+                    // to resolve the side from.
+                    let resolvedType = currentGridOrder.type;
+                    if (resolvedType === constants_1.ORDER_TYPES.SPREAD) {
+                        resolvedType = (0, order_1.resolveSpreadOrderSide)(currentGridOrder.price, mgr.config.startPrice);
+                    }
+                    filledOrders.push({ ...currentGridOrder, type: resolvedType });
                 }
             }
         }
@@ -1012,7 +1028,22 @@ class SyncEngine {
         return null;
     }
     _computeFillContext(mgr, matchedGridOrder, paysAssetId, paysAmountRaw) {
-        const orderType = matchedGridOrder.type;
+        // A SPREAD slot can carry an on-chain order (e.g. spread-correction
+        // activation). Resolve the real side from the fill's pays asset so the
+        // transition result is BUY/SELL — never SPREAD with an on-chain state,
+        // which validateOrder rejects as fatal ILLEGAL_SPREAD_STATE. When the
+        // pays asset matches neither side (malformed fill event), fall back to
+        // the price-vs-startPrice convention so the type can never leak SPREAD
+        // into a fill result (which would drop the boundary shift downstream).
+        let orderType = matchedGridOrder.type;
+        if (orderType === constants_1.ORDER_TYPES.SPREAD) {
+            if (paysAssetId === mgr.assets.assetB.id)
+                orderType = constants_1.ORDER_TYPES.BUY;
+            else if (paysAssetId === mgr.assets.assetA.id)
+                orderType = constants_1.ORDER_TYPES.SELL;
+            else
+                orderType = (0, order_1.resolveSpreadOrderSide)(matchedGridOrder.price, mgr.config.startPrice);
+        }
         const currentSize = toFiniteNumber(matchedGridOrder.size);
         const precision = (orderType === constants_1.ORDER_TYPES.SELL) ? mgr.assets.assetA.precision : mgr.assets.assetB.precision;
         let filledAmount = 0;
@@ -1047,39 +1078,45 @@ class SyncEngine {
         }
         const gridAlsoEmpty = currentSizeIntFromGrid <= 0;
         let isEffectivelyFull = resolvedChainConfirmsEmpty || gridAlsoEmpty;
-        let ghostOrderId;
         if (!isEffectivelyFull) {
             const otherPrecision = (orderType === constants_1.ORDER_TYPES.SELL) ? mgr.assets.assetB.precision : mgr.assets.assetA.precision;
-            const price = matchedGridOrder.price;
-            const otherSize = (orderType === constants_1.ORDER_TYPES.SELL) ? newSize * price : newSize / price;
+            const otherSidePrice = matchedGridOrder.price;
+            const otherSize = (orderType === constants_1.ORDER_TYPES.SELL) ? newSize * otherSidePrice : newSize / otherSidePrice;
             if ((0, math_1.floatToBlockchainInt)(otherSize, otherPrecision) <= 0) {
-                mgr.logger.log(`[SYNC] Order ${matchedGridOrder.orderId} (slot ${matchedGridOrder.id}) other-side (${otherSize}) rounds to 0. Treating as full fill to trigger rotation.`, 'info');
+                // A fill event is authoritative: the order WAS on-chain and this
+                // fill consumed the tradeable remainder. A fill is a fill — we do
+                // not need to preserve the orderId as a "ghost" PARTIAL to block
+                // a duplicate CREATE. Any residual dust that remains on-chain
+                // after rounding is cancelled by the normal reconciliation /
+                // duplicate-price cancel path, not by stalling the grid. Treating
+                // every sub-dust other-side fill as a real full fill lets rotation
+                // immediately plan the opposite-side replacement, preserving the
+                // grid invariant (each filled side produces a new order on the
+                // other side). This replaces the legacy ghost mechanism whose
+                // preserved orderIds caused instantly-filled replacement orders
+                // to deadlock the COW create pipeline.
+                mgr.logger.log(`[SYNC] Order ${matchedGridOrder.orderId} (slot ${matchedGridOrder.id}) other-side (${otherSize}) rounds to 0. ` +
+                    `Fill is authoritative: treating as full fill for rotation; residual dust left for reconciliation cancel.`, 'info');
                 isEffectivelyFull = true;
-                ghostOrderId = matchedGridOrder.orderId;
             }
         }
         let fullUpdate;
-        let ghostUpdate;
         let partialUpdate;
         let filledOrderResult;
         if (isEffectivelyFull) {
-            if (ghostOrderId) {
-                ghostUpdate = {
-                    ...matchedGridOrder,
-                    size: 0,
-                    state: constants_1.ORDER_STATES.PARTIAL,
-                    orderId: ghostOrderId,
-                    isGhost: true,
-                };
-            }
-            else {
-                fullUpdate = (0, order_1.convertToSpreadPlaceholder)(matchedGridOrder);
-            }
-            filledOrderResult = { ...matchedGridOrder, blockNum, historyId, isMaker };
+            fullUpdate = (0, order_1.convertToSpreadPlaceholder)(matchedGridOrder);
+            filledOrderResult = {
+                ...matchedGridOrder,
+                type: orderType,
+                blockNum,
+                historyId,
+                isMaker
+            };
         }
         else {
             filledOrderResult = {
                 ...matchedGridOrder,
+                type: orderType,
                 size: filledAmount,
                 isPartial: true,
                 blockNum,
@@ -1087,7 +1124,7 @@ class SyncEngine {
                 isMaker
             };
             const { btsFeeState, ...matchedWithoutDeferredFee } = matchedGridOrder;
-            let updatedOrder = { ...matchedWithoutDeferredFee, state: constants_1.ORDER_STATES.PARTIAL };
+            let updatedOrder = { ...matchedWithoutDeferredFee, type: orderType, state: constants_1.ORDER_STATES.PARTIAL };
             if (updatedOrder.rawOnChain && updatedOrder.rawOnChain.for_sale !== undefined) {
                 const baselineForSale = (chainRefetched && Number.isFinite(effectiveRawForSale))
                     ? effectiveRawForSale
@@ -1107,11 +1144,8 @@ class SyncEngine {
         }
         return {
             isFull: isEffectivelyFull,
-            isGhost: !!ghostOrderId,
-            ghostOrderId,
             filledOrder: filledOrderResult,
             fullUpdate,
-            ghostUpdate,
             partialUpdate,
             newSize
         };
@@ -1145,108 +1179,124 @@ class SyncEngine {
             mgr.logger.log(`[SYNC] Missing replay-safe fill key for order ${orderId} block ${blockNum}; deferring to open-orders sync`, 'warn');
             return { filledOrders: [], updatedOrders: [], partialFill: false, requiresOpenOrdersSync: true };
         }
-        const orderIdsToLock = new Set([orderId]);
-        mgr.lockOrders([...orderIdsToLock]);
+        // Raise the fill-batch in-flight guard BEFORE the accountTotals refresh
+        // (mirrors syncFromFillHistoryBatch): the refresh returns post-fill
+        // balances while the grid still holds the filled order as committed, so
+        // a fund-invariant check in this window would fire a spurious CRITICAL.
+        // The guard is lowered before the final consolidated recalc so the
+        // settled (re-anchored) state is still verified.
+        mgr._fillBatchInFlight = (mgr._fillBatchInFlight ?? 0) + 1;
         try {
-            mgr.pauseFundRecalc();
+            const totalsGate = await mgr.refreshAccountTotalsIfStale();
+            if (!totalsGate.ok) {
+                mgr.logger.log(`[SYNC] Deferring fill ${historyId}: accountTotals refresh failed (stale snapshot). Will be re-processed on the next cycle.`, 'warn');
+                return { filledOrders: [], updatedOrders: [], partialFill: false, requiresOpenOrdersSync: false, deferred: true };
+            }
+            const orderIdsToLock = new Set([orderId]);
+            mgr.lockOrders([...orderIdsToLock]);
             try {
-                const appliedAccounting = await mgr.accountant.processFillAccounting(fillOp, fillKey, { persistenceMode });
-                if (!appliedAccounting) {
-                    mgr.logger.log(`[SYNC] Replay detected for fill ${fillKey}; skipping duplicate order mutation`, 'debug');
-                    return { filledOrders: [], updatedOrders: [], partialFill: false };
-                }
-                const assetAPrecision = mgr.assets?.assetA?.precision;
-                const assetBPrecision = mgr.assets?.assetB?.precision;
-                if (assetAPrecision === undefined || assetBPrecision === undefined) {
-                    mgr.logger?.log?.('Error: manager.assets precision missing in syncFromFillHistory', 'error');
-                    return { filledOrders: [], updatedOrders: [], partialFill: false };
-                }
-                const matchedGridOrder = this._findMatchingGridOrder(mgr, orderId);
-                if (!matchedGridOrder) {
-                    mgr.logger.log(`[SYNC] Fill for order ${orderId} ignored: order not found in active grid.`, 'debug');
-                    return { filledOrders: [], updatedOrders: [], partialFill: false };
-                }
-                const ctx = this._computeFillContext(mgr, matchedGridOrder, paysAssetId, paysAmountRaw);
-                mgr.logger.log(`[SYNC] Order ${orderId} (${ctx.orderType}) currentSize=${ctx.currentSize}, filledAmount=${ctx.filledAmount}`, 'debug');
-                let effectiveRawForSale = ctx.rawForSaleInt;
-                let chainConfirmsEmpty = false;
-                let chainRefetched = false;
-                if (ctx.driftSignal) {
-                    try {
-                        const fresh = await chainOrders.readSingleOrder(orderId, 3000);
-                        if (fresh) {
-                            const freshForSale = toFiniteNumber(fresh.for_sale, undefined);
-                            if (Number.isFinite(freshForSale)) {
-                                effectiveRawForSale = freshForSale;
-                                chainRefetched = true;
-                                mgr.logger.log(`[SYNC] Drift detected for ${orderId} (cached=${ctx.rawForSaleInt} < grid=${ctx.currentSizeIntFromGrid}); ` +
-                                    `refetched for_sale=${freshForSale}`, 'warn');
+                mgr.pauseFundRecalc();
+                try {
+                    const appliedAccounting = await mgr.accountant.processFillAccounting(fillOp, fillKey, { persistenceMode });
+                    if (!appliedAccounting) {
+                        mgr.logger.log(`[SYNC] Replay detected for fill ${fillKey}; skipping duplicate order mutation`, 'debug');
+                        return { filledOrders: [], updatedOrders: [], partialFill: false };
+                    }
+                    const assetAPrecision = mgr.assets?.assetA?.precision;
+                    const assetBPrecision = mgr.assets?.assetB?.precision;
+                    if (assetAPrecision === undefined || assetBPrecision === undefined) {
+                        mgr.logger?.log?.('Error: manager.assets precision missing in syncFromFillHistory', 'error');
+                        return { filledOrders: [], updatedOrders: [], partialFill: false };
+                    }
+                    const matchedGridOrder = this._findMatchingGridOrder(mgr, orderId);
+                    if (!matchedGridOrder) {
+                        mgr.logger.log(`[SYNC] Fill for order ${orderId} ignored: order not found in active grid.`, 'debug');
+                        return { filledOrders: [], updatedOrders: [], partialFill: false };
+                    }
+                    const ctx = this._computeFillContext(mgr, matchedGridOrder, paysAssetId, paysAmountRaw);
+                    mgr.logger.log(`[SYNC] Order ${orderId} (${ctx.orderType}) currentSize=${ctx.currentSize}, filledAmount=${ctx.filledAmount}`, 'debug');
+                    let effectiveRawForSale = ctx.rawForSaleInt;
+                    let chainConfirmsEmpty = false;
+                    let chainRefetched = false;
+                    if (ctx.driftSignal) {
+                        try {
+                            const fresh = await chainOrders.readSingleOrder(orderId, 3000);
+                            if (fresh) {
+                                const freshForSale = toFiniteNumber(fresh.for_sale, undefined);
+                                if (Number.isFinite(freshForSale)) {
+                                    effectiveRawForSale = freshForSale;
+                                    chainRefetched = true;
+                                    mgr.logger.log(`[SYNC] Drift detected for ${orderId} (cached=${ctx.rawForSaleInt} < grid=${ctx.currentSizeIntFromGrid}); ` +
+                                        `refetched for_sale=${freshForSale}`, 'warn');
+                                }
+                            }
+                            else {
+                                chainConfirmsEmpty = true;
+                                mgr.logger.log(`[SYNC] Drift refetch for ${orderId} returned null; chain confirms empty`, 'info');
                             }
                         }
-                        else {
-                            chainConfirmsEmpty = true;
-                            mgr.logger.log(`[SYNC] Drift refetch for ${orderId} returned null; chain confirms empty`, 'info');
+                        catch (refetchErr) {
+                            mgr.logger.log(`[SYNC] Drift refetch for ${orderId} failed; falling back to cache: ${refetchErr?.message || refetchErr}`, 'warn');
                         }
                     }
-                    catch (refetchErr) {
-                        mgr.logger.log(`[SYNC] Drift refetch for ${orderId} failed; falling back to cache: ${refetchErr?.message || refetchErr}`, 'warn');
-                    }
-                }
-                const result = await this._computeFillTransitionResult(mgr, {
-                    matchedGridOrder,
-                    orderType: ctx.orderType,
-                    precision: ctx.precision,
-                    filledAmount: ctx.filledAmount,
-                    filledAmountInt: (0, math_1.floatToBlockchainInt)(ctx.filledAmount, ctx.precision),
-                    currentSizeIntFromGrid: ctx.currentSizeIntFromGrid,
-                    rawForSaleInt: ctx.rawForSaleInt,
-                    chainRefetched,
-                    chainConfirmsEmpty,
-                    effectiveRawForSale,
-                    blockNum,
-                    historyId,
-                    isMaker
-                });
-                const filledOrders = [];
-                const updatedOrders = [];
-                if (result.isFull) {
-                    if (result.isGhost) {
-                        mgr.logger.log(`[SYNC] Ghost full fill for order ${orderId} (slot ${matchedGridOrder.id}): preserving orderId ${result.ghostOrderId} as PARTIAL to block duplicate CREATE.`, 'info');
-                        const ghostOk = await mgr._updateOrder(result.ghostUpdate, 'handle-fill-ghost', { skipAccounting: false, fee: 0 });
-                        if (ghostOk === false) {
-                            mgr.logger.log(`[SYNC] Failed to apply ghost fill state for order ${orderId}; marking totals stale for next sync cycle`, 'warn');
+                    const result = await this._computeFillTransitionResult(mgr, {
+                        matchedGridOrder,
+                        orderType: ctx.orderType,
+                        precision: ctx.precision,
+                        filledAmount: ctx.filledAmount,
+                        filledAmountInt: (0, math_1.floatToBlockchainInt)(ctx.filledAmount, ctx.precision),
+                        currentSizeIntFromGrid: ctx.currentSizeIntFromGrid,
+                        rawForSaleInt: ctx.rawForSaleInt,
+                        chainRefetched,
+                        chainConfirmsEmpty,
+                        effectiveRawForSale,
+                        blockNum,
+                        historyId,
+                        isMaker
+                    });
+                    const filledOrders = [];
+                    const updatedOrders = [];
+                    if (result.isFull) {
+                        mgr.logger.log(`[SYNC] Full fill for order ${orderId} (slot ${matchedGridOrder.id}).`, 'info');
+                        const fullOk = await mgr._updateOrder(result.fullUpdate, 'handle-fill-full', { skipAccounting: false, fee: 0 });
+                        if (fullOk === false) {
+                            mgr.logger.log(`[SYNC] Failed to convert filled order ${orderId} to spread placeholder; marking totals stale for next sync cycle`, 'warn');
                             mgr.accountTotalsStale = true;
                         }
                         filledOrders.push(result.filledOrder);
-                        return { filledOrders, updatedOrders, partialFill: false };
                     }
-                    mgr.logger.log(`[SYNC] Full fill for order ${orderId} (slot ${matchedGridOrder.id}).`, 'info');
-                    const fullOk = await mgr._updateOrder(result.fullUpdate, 'handle-fill-full', { skipAccounting: false, fee: 0 });
-                    if (fullOk === false) {
-                        mgr.logger.log(`[SYNC] Failed to convert filled order ${orderId} to spread placeholder; marking totals stale for next sync cycle`, 'warn');
-                        mgr.accountTotalsStale = true;
+                    else {
+                        mgr.logger.log(`[SYNC] Partial fill for order ${orderId} (slot ${matchedGridOrder.id}): newSize=${result.newSize}`, 'info');
+                        const partialOk = await mgr._updateOrder(result.partialUpdate, 'handle-fill-partial', { skipAccounting: false, fee: 0 });
+                        if (partialOk === false) {
+                            mgr.logger.log(`[SYNC] Failed to update partially filled order ${orderId}; marking totals stale for next sync cycle`, 'warn');
+                            mgr.accountTotalsStale = true;
+                        }
+                        updatedOrders.push(result.partialUpdate);
+                        filledOrders.push(result.filledOrder);
                     }
-                    filledOrders.push(result.filledOrder);
-                    return { filledOrders, updatedOrders, partialFill: false };
+                    // Re-anchor accountTotals to authoritative post-fill chain truth
+                    // after the fill's optimistic accounting + grid update (see
+                    // syncFromFillHistoryBatch for rationale).
+                    await mgr.reanchorAccountTotals('fill-sync');
+                    return { filledOrders, updatedOrders, partialFill: result.isFull ? false : true };
                 }
-                else {
-                    mgr.logger.log(`[SYNC] Partial fill for order ${orderId} (slot ${matchedGridOrder.id}): newSize=${result.newSize}`, 'info');
-                    const partialOk = await mgr._updateOrder(result.partialUpdate, 'handle-fill-partial', { skipAccounting: false, fee: 0 });
-                    if (partialOk === false) {
-                        mgr.logger.log(`[SYNC] Failed to update partially filled order ${orderId}; marking totals stale for next sync cycle`, 'warn');
-                        mgr.accountTotalsStale = true;
-                    }
-                    updatedOrders.push(result.partialUpdate);
-                    filledOrders.push(result.filledOrder);
-                    return { filledOrders, updatedOrders, partialFill: true };
+                finally {
+                    // Lower the guard before the final consolidated recalc so the
+                    // settled (re-anchored) state is still verified.
+                    mgr._fillBatchInFlight = Math.max(0, (mgr._fillBatchInFlight ?? 0) - 1);
+                    await mgr.resumeFundRecalc();
                 }
             }
             finally {
-                await mgr.resumeFundRecalc();
+                mgr.unlockOrders([...orderIdsToLock]);
             }
         }
         finally {
-            mgr.unlockOrders([...orderIdsToLock]);
+            // Safety net: ensure the guard never leaks across cycles on early
+            // returns (deferral) or exceptions in the refresh/lock region.
+            if ((mgr._fillBatchInFlight ?? 0) > 0)
+                mgr._fillBatchInFlight--;
         }
     }
     /**
@@ -1299,172 +1349,197 @@ class SyncEngine {
         }
         // Phase 2: Lock all unique order IDs once
         const allOrderIds = [...new Set(fillEntries.map(e => e.orderId))];
-        mgr.lockOrders(allOrderIds);
+        // Raise the fill-batch in-flight guard BEFORE the accountTotals refresh.
+        // The refresh fetches post-fill balances, but the grid still holds the
+        // filled orders as committed until the batch's grid mutation (Phase 7),
+        // so any fund-invariant check in this window would fire a spurious
+        // CRITICAL with diff == the fills' size. The guard is lowered right
+        // before the final consolidated recalc so the settled state is still
+        // verified.
+        mgr._fillBatchInFlight = (mgr._fillBatchInFlight ?? 0) + 1;
         try {
-            mgr.pauseFundRecalc();
+            const totalsGate = await mgr.refreshAccountTotalsIfStale();
+            if (!totalsGate.ok) {
+                mgr.logger.log('[SYNC] Deferring fill batch: accountTotals refresh failed (stale snapshot). Fills will be re-processed on the next cycle.', 'warn');
+                return { filledOrders: [], updatedOrders: [], partialFill: false, requiresOpenOrdersSync: false, deferred: true };
+            }
+            mgr.lockOrders(allOrderIds);
             try {
-                // Phase 3: Process accounting for each fill
-                const validEntries = [];
-                for (const entry of fillEntries) {
-                    try {
-                        const appliedAccounting = await mgr.accountant.processFillAccounting(entry.fillOp, entry.fillKey, { persistenceMode });
-                        if (!appliedAccounting) {
-                            mgr.logger.log(`[SYNC] Replay detected for fill ${entry.fillKey}; skipping duplicate order mutation`, 'debug');
+                mgr.pauseFundRecalc();
+                try {
+                    // Phase 3: Process accounting for each fill
+                    const validEntries = [];
+                    for (const entry of fillEntries) {
+                        try {
+                            const appliedAccounting = await mgr.accountant.processFillAccounting(entry.fillOp, entry.fillKey, { persistenceMode });
+                            if (!appliedAccounting) {
+                                mgr.logger.log(`[SYNC] Replay detected for fill ${entry.fillKey}; skipping duplicate order mutation`, 'debug');
+                                continue;
+                            }
+                            validEntries.push(entry);
+                        }
+                        catch (acctErr) {
+                            mgr.logger.log(`[SYNC] Accounting error for fill ${entry.fillKey}: ${(0, errors_1.getErrorMessage)(acctErr)}`, 'error');
                             continue;
                         }
-                        validEntries.push(entry);
                     }
-                    catch (acctErr) {
-                        mgr.logger.log(`[SYNC] Accounting error for fill ${entry.fillKey}: ${(0, errors_1.getErrorMessage)(acctErr)}`, 'error');
-                        continue;
+                    if (validEntries.length === 0) {
+                        return { filledOrders: [], updatedOrders: [], partialFill: false, requiresOpenOrdersSync: anyRequiresSync };
                     }
-                }
-                if (validEntries.length === 0) {
-                    return { filledOrders: [], updatedOrders: [], partialFill: false, requiresOpenOrdersSync: anyRequiresSync };
-                }
-                // Phase 4: Build per-fill context + identify drift candidates
-                const entryContexts = [];
-                const driftOrderIds = new Set();
-                const assetAPrecision = mgr.assets?.assetA?.precision;
-                const assetBPrecision = mgr.assets?.assetB?.precision;
-                if (assetAPrecision === undefined || assetBPrecision === undefined) {
-                    mgr.logger?.log?.('Error: manager.assets precision missing in syncFromFillHistoryBatch', 'error');
-                    return { filledOrders: [], updatedOrders: [], partialFill: false, requiresOpenOrdersSync: anyRequiresSync };
-                }
-                for (const entry of validEntries) {
-                    const { orderId, paysAmountRaw, paysAssetId } = entry;
-                    const matchedGridOrder = this._findMatchingGridOrder(mgr, orderId);
-                    if (!matchedGridOrder) {
-                        mgr.logger.log(`[SYNC] Fill for order ${orderId} ignored: order not found in active grid.`, 'debug');
-                        anyRequiresSync = true;
-                        continue;
+                    // Phase 4: Build per-fill context + identify drift candidates
+                    const entryContexts = [];
+                    const driftOrderIds = new Set();
+                    const assetAPrecision = mgr.assets?.assetA?.precision;
+                    const assetBPrecision = mgr.assets?.assetB?.precision;
+                    if (assetAPrecision === undefined || assetBPrecision === undefined) {
+                        mgr.logger?.log?.('Error: manager.assets precision missing in syncFromFillHistoryBatch', 'error');
+                        return { filledOrders: [], updatedOrders: [], partialFill: false, requiresOpenOrdersSync: anyRequiresSync };
                     }
-                    const ctx = this._computeFillContext(mgr, matchedGridOrder, paysAssetId, paysAmountRaw);
-                    mgr.logger.log(`[SYNC] Order ${orderId} (${ctx.orderType}) currentSize=${ctx.currentSize}, filledAmount=${ctx.filledAmount}`, 'debug');
-                    if (ctx.driftSignal) {
-                        driftOrderIds.add(orderId);
+                    for (const entry of validEntries) {
+                        const { orderId, paysAmountRaw, paysAssetId } = entry;
+                        const matchedGridOrder = this._findMatchingGridOrder(mgr, orderId);
+                        if (!matchedGridOrder) {
+                            mgr.logger.log(`[SYNC] Fill for order ${orderId} ignored: order not found in active grid.`, 'debug');
+                            anyRequiresSync = true;
+                            continue;
+                        }
+                        const ctx = this._computeFillContext(mgr, matchedGridOrder, paysAssetId, paysAmountRaw);
+                        mgr.logger.log(`[SYNC] Order ${orderId} (${ctx.orderType}) currentSize=${ctx.currentSize}, filledAmount=${ctx.filledAmount}`, 'debug');
+                        if (ctx.driftSignal) {
+                            driftOrderIds.add(orderId);
+                        }
+                        entryContexts.push({
+                            entry, matchedGridOrder,
+                            orderType: ctx.orderType,
+                            precision: ctx.precision,
+                            filledAmount: ctx.filledAmount,
+                            filledAmountInt: (0, math_1.floatToBlockchainInt)(ctx.filledAmount, ctx.precision),
+                            currentSizeIntFromGrid: ctx.currentSizeIntFromGrid,
+                            rawForSaleInt: ctx.rawForSaleInt
+                        });
                     }
-                    entryContexts.push({
-                        entry, matchedGridOrder,
-                        orderType: ctx.orderType,
-                        precision: ctx.precision,
-                        filledAmount: ctx.filledAmount,
-                        filledAmountInt: (0, math_1.floatToBlockchainInt)(ctx.filledAmount, ctx.precision),
-                        currentSizeIntFromGrid: ctx.currentSizeIntFromGrid,
-                        rawForSaleInt: ctx.rawForSaleInt
-                    });
-                }
-                // Phase 5: Batch drift refetch — one get_objects call for all order IDs
-                const refetchMap = new Map();
-                if (driftOrderIds.size > 0) {
-                    try {
-                        const batchResults = await chainOrders.batchReadOrders([...driftOrderIds], 3000);
-                        for (const [orderId, freshOrder] of batchResults) {
-                            if (freshOrder) {
-                                const freshForSale = toFiniteNumber(freshOrder.for_sale, undefined);
-                                if (Number.isFinite(freshForSale)) {
-                                    refetchMap.set(orderId, {
-                                        chainConfirmsEmpty: Math.round(freshForSale) <= 0,
-                                        chainRefetched: true,
-                                        effectiveRawForSale: freshForSale
-                                    });
+                    // Phase 5: Batch drift refetch — one get_objects call for all order IDs
+                    const refetchMap = new Map();
+                    if (driftOrderIds.size > 0) {
+                        try {
+                            const batchResults = await chainOrders.batchReadOrders([...driftOrderIds], 3000);
+                            for (const [orderId, freshOrder] of batchResults) {
+                                if (freshOrder) {
+                                    const freshForSale = toFiniteNumber(freshOrder.for_sale, undefined);
+                                    if (Number.isFinite(freshForSale)) {
+                                        refetchMap.set(orderId, {
+                                            chainConfirmsEmpty: Math.round(freshForSale) <= 0,
+                                            chainRefetched: true,
+                                            effectiveRawForSale: freshForSale
+                                        });
+                                    }
+                                    else {
+                                        refetchMap.set(orderId, {
+                                            chainConfirmsEmpty: false,
+                                            chainRefetched: true,
+                                            effectiveRawForSale: null
+                                        });
+                                    }
                                 }
                                 else {
                                     refetchMap.set(orderId, {
-                                        chainConfirmsEmpty: false,
+                                        chainConfirmsEmpty: true,
                                         chainRefetched: true,
                                         effectiveRawForSale: null
                                     });
                                 }
                             }
-                            else {
-                                refetchMap.set(orderId, {
-                                    chainConfirmsEmpty: true,
-                                    chainRefetched: true,
-                                    effectiveRawForSale: null
-                                });
+                            for (const [orderId, { chainRefetched, chainConfirmsEmpty, effectiveRawForSale }] of refetchMap) {
+                                if (chainRefetched && effectiveRawForSale != null) {
+                                    mgr.logger.log(`[SYNC] Drift detected for ${orderId}; batch-refetched for_sale=${effectiveRawForSale}`, 'warn');
+                                }
+                                else if (chainConfirmsEmpty) {
+                                    mgr.logger.log(`[SYNC] Drift refetch for ${orderId} returned null; chain confirms empty`, 'info');
+                                }
                             }
                         }
-                        for (const [orderId, { chainRefetched, chainConfirmsEmpty, effectiveRawForSale }] of refetchMap) {
-                            if (chainRefetched && effectiveRawForSale != null) {
-                                mgr.logger.log(`[SYNC] Drift detected for ${orderId}; batch-refetched for_sale=${effectiveRawForSale}`, 'warn');
-                            }
-                            else if (chainConfirmsEmpty) {
-                                mgr.logger.log(`[SYNC] Drift refetch for ${orderId} returned null; chain confirms empty`, 'info');
-                            }
+                        catch (refetchErr) {
+                            mgr.logger.log(`[SYNC] Batch drift refetch failed for ${driftOrderIds.size} orders; falling back to cache: ${refetchErr?.message || refetchErr}`, 'warn');
                         }
                     }
-                    catch (refetchErr) {
-                        mgr.logger.log(`[SYNC] Batch drift refetch failed for ${driftOrderIds.size} orders; falling back to cache: ${refetchErr?.message || refetchErr}`, 'warn');
-                    }
-                }
-                // Phase 6: Compute state transitions and collect grid updates
-                const gridUpdates = [];
-                const filledOrders = [];
-                const updatedOrders = [];
-                let anyPartialFill = false;
-                for (const ctx of entryContexts) {
-                    const { entry, matchedGridOrder, orderType, precision, filledAmount, filledAmountInt, currentSizeIntFromGrid, rawForSaleInt } = ctx;
-                    const { orderId, blockNum, historyId, isMaker } = entry;
-                    const refetchInfo = refetchMap.get(orderId);
-                    const chainRefetched = refetchInfo?.chainRefetched || false;
-                    const chainConfirmsEmpty = refetchInfo?.chainConfirmsEmpty || false;
-                    const effectiveRawForSale = refetchInfo?.effectiveRawForSale != null ? refetchInfo.effectiveRawForSale : rawForSaleInt;
-                    const result = await this._computeFillTransitionResult(mgr, {
-                        matchedGridOrder,
-                        orderType,
-                        precision,
-                        filledAmount,
-                        filledAmountInt,
-                        currentSizeIntFromGrid,
-                        rawForSaleInt,
-                        chainRefetched,
-                        chainConfirmsEmpty,
-                        effectiveRawForSale,
-                        blockNum,
-                        historyId,
-                        isMaker
-                    });
-                    if (result.isFull) {
-                        if (result.isGhost) {
-                            mgr.logger.log(`[SYNC] Ghost full fill for order ${orderId} (slot ${matchedGridOrder.id}): ` +
-                                `preserving orderId ${result.ghostOrderId} as PARTIAL to block duplicate CREATE.`, 'info');
-                            gridUpdates.push({ id: matchedGridOrder.id, ...result.ghostUpdate, context: 'handle-fill-ghost' });
-                        }
-                        else {
+                    // Phase 6: Compute state transitions and collect grid updates
+                    const gridUpdates = [];
+                    const filledOrders = [];
+                    const updatedOrders = [];
+                    let anyPartialFill = false;
+                    for (const ctx of entryContexts) {
+                        const { entry, matchedGridOrder, orderType, precision, filledAmount, filledAmountInt, currentSizeIntFromGrid, rawForSaleInt } = ctx;
+                        const { orderId, blockNum, historyId, isMaker } = entry;
+                        const refetchInfo = refetchMap.get(orderId);
+                        const chainRefetched = refetchInfo?.chainRefetched || false;
+                        const chainConfirmsEmpty = refetchInfo?.chainConfirmsEmpty || false;
+                        const effectiveRawForSale = refetchInfo?.effectiveRawForSale != null ? refetchInfo.effectiveRawForSale : rawForSaleInt;
+                        const result = await this._computeFillTransitionResult(mgr, {
+                            matchedGridOrder,
+                            orderType,
+                            precision,
+                            filledAmount,
+                            filledAmountInt,
+                            currentSizeIntFromGrid,
+                            rawForSaleInt,
+                            chainRefetched,
+                            chainConfirmsEmpty,
+                            effectiveRawForSale,
+                            blockNum,
+                            historyId,
+                            isMaker
+                        });
+                        if (result.isFull) {
                             mgr.logger.log(`[SYNC] Full fill for order ${orderId} (slot ${matchedGridOrder.id}).`, 'info');
                             gridUpdates.push({ id: matchedGridOrder.id, ...result.fullUpdate, context: 'handle-fill-full' });
+                            filledOrders.push(result.filledOrder);
+                        }
+                        else {
+                            mgr.logger.log(`[SYNC] Partial fill for order ${orderId} (slot ${matchedGridOrder.id}): newSize=${result.newSize}`, 'info');
+                            gridUpdates.push({ id: matchedGridOrder.id, ...result.partialUpdate, context: 'handle-fill-partial' });
+                            updatedOrders.push(result.partialUpdate);
+                            filledOrders.push(result.filledOrder);
+                            anyPartialFill = true;
                         }
-                        filledOrders.push(result.filledOrder);
                     }
-                    else {
-                        mgr.logger.log(`[SYNC] Partial fill for order ${orderId} (slot ${matchedGridOrder.id}): newSize=${result.newSize}`, 'info');
-                        gridUpdates.push({ id: matchedGridOrder.id, ...result.partialUpdate, context: 'handle-fill-partial' });
-                        updatedOrders.push(result.partialUpdate);
-                        filledOrders.push(result.filledOrder);
-                        anyPartialFill = true;
+                    // Phase 7: Single grid batch update — acquires _gridLock once
+                    if (gridUpdates.length > 0) {
+                        const updateObjects = gridUpdates.map(u => {
+                            const { context, ...orderData } = u;
+                            return orderData;
+                        });
+                        const batchOk = await mgr.applyGridUpdateBatch(updateObjects, 'handle-fill-batch', { skipAccounting: false, fee: 0 });
+                        if (batchOk === false) {
+                            mgr.logger.log('[SYNC] Batch grid update failed for some fills; marking totals stale for next sync cycle', 'warn');
+                            mgr.accountTotalsStale = true;
+                        }
                     }
+                    // Re-anchor accountTotals to authoritative post-fill chain truth
+                    // after the batch's accounting + grid mutation. The up-front
+                    // stale-totals refresh returns post-fill balances, so the batch's
+                    // processFillAccounting pays/receives adjustments would otherwise
+                    // double-count; the forced fetch overwrites them with the
+                    // authoritative values and hands re-commitments
+                    // (tryDeductFromChainFree) a fresh snapshot.
+                    await mgr.reanchorAccountTotals('fill-batch');
+                    return { filledOrders, updatedOrders, partialFill: anyPartialFill, requiresOpenOrdersSync: anyRequiresSync };
                 }
-                // Phase 7: Single grid batch update — acquires _gridLock once
-                if (gridUpdates.length > 0) {
-                    const updateObjects = gridUpdates.map(u => {
-                        const { context, ...orderData } = u;
-                        return orderData;
-                    });
-                    const batchOk = await mgr.applyGridUpdateBatch(updateObjects, 'handle-fill-batch', { skipAccounting: false, fee: 0 });
-                    if (batchOk === false) {
-                        mgr.logger.log('[SYNC] Batch grid update failed for some fills; marking totals stale for next sync cycle', 'warn');
-                        mgr.accountTotalsStale = true;
-                    }
+                finally {
+                    // Lower the guard before the final consolidated recalc so the
+                    // settled (re-anchored) state is still verified.
+                    mgr._fillBatchInFlight = Math.max(0, (mgr._fillBatchInFlight ?? 0) - 1);
+                    await mgr.resumeFundRecalc();
                 }
-                return { filledOrders, updatedOrders, partialFill: anyPartialFill, requiresOpenOrdersSync: anyRequiresSync };
             }
             finally {
-                await mgr.resumeFundRecalc();
+                mgr.unlockOrders(allOrderIds);
             }
         }
         finally {
-            mgr.unlockOrders(allOrderIds);
+            // Safety net: ensure the guard never leaks across cycles on early
+            // returns (deferral) or exceptions in the refresh/lock region.
+            if ((mgr._fillBatchInFlight ?? 0) > 0)
+                mgr._fillBatchInFlight--;
         }
     }
     /**
@@ -1555,14 +1630,21 @@ class SyncEngine {
                                 }
                             }
                             const newState = isPartialPlacement ? constants_1.ORDER_STATES.PARTIAL : constants_1.ORDER_STATES.ACTIVE;
-                            const normalizedExpectedType = (expectedType === constants_1.ORDER_TYPES.BUY || expectedType === constants_1.ORDER_TYPES.SELL)
+                            let normalizedExpectedType = (expectedType === constants_1.ORDER_TYPES.BUY || expectedType === constants_1.ORDER_TYPES.SELL)
                                 ? expectedType
                                 : null;
+                            // Defensive: a SPREAD slot must never transition to an on-chain
+                            // state (validateOrder rejects SPREAD+ACTIVE/PARTIAL as fatal).
+                            // Derive the side from the slot price vs start price — same
+                            // convention as the funds check (manager.ts).
+                            if (!normalizedExpectedType && gridOrder.type === constants_1.ORDER_TYPES.SPREAD) {
+                                normalizedExpectedType = (0, order_1.resolveSpreadOrderSide)(gridOrder.price, mgr.config.startPrice);
+                            }
                             const updatedOrder = {
                                 ...gridOrder,
                                 type: normalizedExpectedType || gridOrder.type,
                                 state: newState,
-                                orderId: chainOrderId
+                                orderId: chainOrderId,
                             };
                             // Restore btsFeeState from raw chain order data if provided.
                             // After a grid reset, in-memory orders have no fee state but the