dexbot 1.4.11 → 1.4.12

package/dist/modules/order/sync_engine.js

@@ -1,4 +1,3 @@
-"use strict";
 /**
  * modules/order/sync_engine.ts - SyncEngine
  *
@@ -94,71 +93,37 @@
  *
  * ===============================================================================
  */
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-const constants_1 = require("../constants");
-const Format = __importStar(require("./format"));
-const system_1 = require("./utils/system");
-const chainOrders = __importStar(require("../chain_orders"));
-const client = __importStar(require("../bitshares_client"));
+import { ORDER_TYPES, ORDER_STATES, TIMING, BTS_PRECISION } from '../constants.js';
+import * as Format from './format.js';
+import { lookupAsset } from './utils/system.js';
+import * as chainOrders from '../chain_orders.js';
+import * as client from '../bitshares_client.js';
 const { BitShares } = client;
-const constants_2 = require("../constants");
+import { NATIVE_CLIENT } from '../constants.js';
 const { toFiniteNumber } = Format;
-const math_1 = require("./utils/math");
-const order_1 = require("./utils/order");
-const processed_fill_store_1 = require("./processed_fill_store");
-const errors_1 = require("../utils/errors");
+import { blockchainToFloat, floatToBlockchainInt, calculatePriceTolerance, getAssetFees, getBtsSide } from './utils/math.js';
+import { parseChainOrder, findMatchingGridOrderByOpenOrder, applyChainSizeToGridOrder, convertToSpreadPlaceholder, virtualizeOrder, buildFillKey, isOrderPlaced, hasOnChainId, isOrderVirtual, resolveSpreadOrderSide, duplicateOrphanLogInfo } from './utils/order.js';
+import { resolveProcessedFillPersistenceMode } from './processed_fill_store.js';
+import { getErrorMessage } from '../utils/errors.js';
 function describeNearestAdoptionCandidates(mgr, chainOrder, precision, calcTolerance, matchedGridOrderIds = null) {
     if (!mgr?.orders || !chainOrder || typeof precision !== 'number')
         return 'candidate diagnostics unavailable';
     const chainPrice = toFiniteNumber(chainOrder.price);
     const chainSize = toFiniteNumber(chainOrder.size);
-    const chainInt = (0, math_1.floatToBlockchainInt)(chainSize, precision);
+    const chainInt = floatToBlockchainInt(chainSize, precision);
     const candidates = [];
     for (const slot of mgr.orders.values()) {
-        if (!slot || ![constants_1.ORDER_STATES.ACTIVE, constants_1.ORDER_STATES.PARTIAL, constants_1.ORDER_STATES.VIRTUAL].includes(slot.state))
+        if (!slot || ![ORDER_STATES.ACTIVE, ORDER_STATES.PARTIAL, ORDER_STATES.VIRTUAL].includes(slot.state))
             continue;
         const typeMatch = slot.type === chainOrder.type;
-        const spreadMatch = slot.type === constants_1.ORDER_TYPES.SPREAD;
+        const spreadMatch = slot.type === ORDER_TYPES.SPREAD;
         if (!typeMatch && !spreadMatch)
             continue;
         const price = toFiniteNumber(slot.price);
         const priceDiff = Math.abs(price - chainPrice);
         const effectiveSize = slot.size > 0 ? toFiniteNumber(slot.size) : chainSize;
         const tolerance = calcTolerance(price, effectiveSize, chainOrder.type) || 0;
-        const gridInt = (0, math_1.floatToBlockchainInt)(toFiniteNumber(slot.size), precision);
+        const gridInt = floatToBlockchainInt(toFiniteNumber(slot.size), precision);
         const sizeDiffInt = chainInt - gridInt;
         const hasOrderId = Boolean(slot.orderId);
         const alreadyMatched = Boolean(matchedGridOrderIds?.has?.(slot.id));
@@ -239,17 +204,17 @@ function computeOutOfToleranceDriftTag(mgr, chainOrder, calcToleranceFn) {
         return null;
     const chainSize = toFiniteNumber(chainOrder.size);
     const orderType = chainOrder.type;
-    if (orderType !== constants_1.ORDER_TYPES.BUY && orderType !== constants_1.ORDER_TYPES.SELL)
+    if (orderType !== ORDER_TYPES.BUY && orderType !== ORDER_TYPES.SELL)
         return null;
     let bestDrift = null;
     for (const slot of mgr.orders.values()) {
         if (!slot)
             continue;
-        if (slot.type !== orderType && slot.type !== constants_1.ORDER_TYPES.SPREAD)
+        if (slot.type !== orderType && slot.type !== ORDER_TYPES.SPREAD)
             continue;
         if (slot.orderId)
             continue;
-        if (![constants_1.ORDER_STATES.ACTIVE, constants_1.ORDER_STATES.PARTIAL, constants_1.ORDER_STATES.VIRTUAL].includes(slot.state))
+        if (![ORDER_STATES.ACTIVE, ORDER_STATES.PARTIAL, ORDER_STATES.VIRTUAL].includes(slot.state))
             continue;
         const slotPrice = toFiniteNumber(slot.price);
         if (!Number.isFinite(slotPrice))
@@ -359,17 +324,18 @@ class SyncEngine {
             mgr.logger?.log?.('Error: syncLock not initialized', 'error');
             return { filledOrders: [], updatedOrders: [], ordersNeedingCorrection: [], unmatchedChainOrders: [] };
         }
-        // Skip re-acquiring if we're already inside _fillProcessingLock's
-        // execution context (the lock is re-entrant). The old fillLockAlreadyHeld
-        // flag achieved the same goal by being passed through the call chain;
-        // now the lock knows whether the caller already holds it.
+        // CRITICAL: The gate below is the recursion breaker. syncFromOpenOrders
+        // re-invokes itself as the acquire() callback, so without this check the
+        // acquire() re-entrant short-circuit alone would recurse forever (each
+        // nested call is re-entrant and runs the body again). Only run through
+        // the lock when the caller does NOT already hold it.
         if (mgr._fillProcessingLock && !mgr._fillProcessingLock.isReentrant()) {
             return mgr._fillProcessingLock.acquire(async () => {
                 return this.syncFromOpenOrders(chainOrders, options);
             });
         }
-        const timeoutMs = constants_1.TIMING.SYNC_LOCK_TIMEOUT_MS;
-        const forceReleaseMs = constants_1.TIMING.SYNC_LOCK_FORCE_RELEASE_AGE_MS;
+        const timeoutMs = TIMING.SYNC_LOCK_TIMEOUT_MS;
+        const forceReleaseMs = TIMING.SYNC_LOCK_FORCE_RELEASE_AGE_MS;
         let timedOut = false;
         let timeoutHandle;
         let forceReleaseHandle;
@@ -401,7 +367,7 @@ class SyncEngine {
                             await mgr.fetchAccountTotals(mgr.accountId || mgr.config?.accountId);
                         }
                         catch (fetchErr) {
-                            mgr.logger?.log?.(`[SYNC] Stale-totals refresh failed: ${(0, errors_1.getErrorMessage)(fetchErr)}`, 'warn');
+                            mgr.logger?.log?.(`[SYNC] Stale-totals refresh failed: ${getErrorMessage(fetchErr)}`, 'warn');
                         }
                     }
                     const innerResult = await this._doSyncFromOpenOrders(chainOrders, options);
@@ -449,7 +415,7 @@ class SyncEngine {
         catch (err) {
             clearTimeout(timeoutHandle);
             clearTimeout(forceReleaseHandle);
-            if ((0, errors_1.getErrorMessage)(err)?.includes('timed out')) {
+            if (getErrorMessage(err)?.includes('timed out')) {
                 // Gap 3: Schedule a force-release of the sync lock if the inner
                 // operation doesn't complete within the grace window. This prevents
                 // a single stuck sync from permanently blocking all subsequent syncs.
@@ -466,7 +432,7 @@ class SyncEngine {
                 }
                 mgr.logger?.log?.('[SYNC] Lock may be held by orphan after timeout; will release when inner work completes', 'warn');
             }
-            mgr.logger?.log?.(`Sync lock error: ${(0, errors_1.getErrorMessage)(err)}`, 'error');
+            mgr.logger?.log?.(`Sync lock error: ${getErrorMessage(err)}`, 'error');
             throw err;
         }
     }
@@ -530,7 +496,7 @@ class SyncEngine {
         const rawChainOrders = new Map();
         for (const order of chainOrders) {
             try {
-                const parsed = (0, order_1.parseChainOrder)(order, mgr.assets);
+                const parsed = parseChainOrder(order, mgr.assets);
                 if (!parsed)
                     continue;
                 // Store parsed (converted) data in parsedChainOrders
@@ -539,7 +505,7 @@ class SyncEngine {
                 rawChainOrders.set(order.id, order);
             }
             catch (e) {
-                mgr.logger?.log?.(`Warning: Error parsing chain order ${order.id}: ${(0, errors_1.getErrorMessage)(e)}`, 'warn');
+                mgr.logger?.log?.(`Warning: Error parsing chain order ${order.id}: ${getErrorMessage(e)}`, 'warn');
                 continue;
             }
         }
@@ -554,7 +520,7 @@ class SyncEngine {
                 orderIdsToLock.add(gridOrder.orderId);
             }
             // Also lock ACTIVE/PARTIAL orders that might transition to/from SPREAD
-            if (gridOrder.state === constants_1.ORDER_STATES.ACTIVE || gridOrder.state === constants_1.ORDER_STATES.PARTIAL) {
+            if (gridOrder.state === ORDER_STATES.ACTIVE || gridOrder.state === ORDER_STATES.PARTIAL) {
                 orderIdsToLock.add(gridOrder.id);
             }
         }
@@ -582,9 +548,9 @@ class SyncEngine {
         // Lock orders before reconciliation
         mgr.lockOrders(orderIdsToLockFinal);
         // Keep lock leases alive during long reconciliation runs.
-        const refreshEveryMs = Math.max(constants_1.TIMING.LOCK_REFRESH_MIN_MS, Math.floor(constants_1.TIMING.LOCK_TIMEOUT_MS / 3));
+        const refreshEveryMs = Math.max(TIMING.LOCK_REFRESH_MIN_MS, Math.floor(TIMING.LOCK_TIMEOUT_MS / 3));
         const refreshLockLeases = () => {
-            const expiresAt = Date.now() + constants_1.TIMING.LOCK_TIMEOUT_MS;
+            const expiresAt = Date.now() + TIMING.LOCK_TIMEOUT_MS;
             for (const id of orderIdsToLockFinal) {
                 mgr.shadowOrderIds.set(id, expiresAt);
             }
@@ -680,7 +646,7 @@ class SyncEngine {
                     continue;
                 }
                 else {
-                    const priceTolerance = (0, math_1.calculatePriceTolerance)(gridOrder.price, gridOrder.size, gridOrder.type, mgr.assets);
+                    const priceTolerance = calculatePriceTolerance(gridOrder.price, gridOrder.size, gridOrder.type, mgr.assets);
                     const normalizedTolerance = (priceTolerance === null) ? 0 : priceTolerance;
                     // Null tolerance is strict mode (0).
                     if (Math.abs(chainOrder.price - gridOrder.price) > normalizedTolerance) {
@@ -695,14 +661,14 @@ class SyncEngine {
                     }
                 }
                 // Chain side determines which precision applies to for_sale.
-                const precision = (chainOrder.type === constants_1.ORDER_TYPES.SELL) ? assetAPrecision : assetBPrecision;
-                const currentSizeInt = (0, math_1.floatToBlockchainInt)(gridOrder.size, precision);
-                const chainSizeInt = (0, math_1.floatToBlockchainInt)(chainOrder.size, precision);
+                const precision = (chainOrder.type === ORDER_TYPES.SELL) ? assetAPrecision : assetBPrecision;
+                const currentSizeInt = floatToBlockchainInt(gridOrder.size, precision);
+                const chainSizeInt = floatToBlockchainInt(chainOrder.size, precision);
                 if (currentSizeInt !== chainSizeInt) {
-                    const newSize = (0, math_1.blockchainToFloat)(chainSizeInt, precision);
-                    const newInt = (0, math_1.floatToBlockchainInt)(newSize, precision);
+                    const newSize = blockchainToFloat(chainSizeInt, precision);
+                    const newInt = floatToBlockchainInt(newSize, precision);
                     if (newInt > 0) {
-                        const nextOrder = await (0, order_1.applyChainSizeToGridOrder)(mgr, updatedOrder, newSize);
+                        const nextOrder = await applyChainSizeToGridOrder(mgr, updatedOrder, newSize);
                         if (nextOrder) {
                             // Merge updated state if size actually changed
                             updatedOrder = { ...updatedOrder, ...nextOrder };
@@ -712,12 +678,12 @@ class SyncEngine {
                         // downtime fills detected during open-orders sync must also update
                         // state so that checkWindowDust can identify dust orders.
                         updatedOrder.state = (chainSizeInt < currentSizeInt)
-                            ? constants_1.ORDER_STATES.PARTIAL
+                            ? ORDER_STATES.PARTIAL
                             : gridOrder.state;
                         await mgr._applyOrderUpdate(updatedOrder, 'sync-pass1-partial', { skipAccounting: skipAccounting, fee: 0 });
                     }
                     else {
-                        const spreadOrder = (0, order_1.convertToSpreadPlaceholder)(gridOrder);
+                        const spreadOrder = convertToSpreadPlaceholder(gridOrder);
                         await mgr._applyOrderUpdate(spreadOrder, 'sync-pass1-filled', { skipAccounting: skipAccounting, fee: 0 });
                         // Push the filled order with its REAL side (chain order
                         // type), not the SPREAD placeholder: downstream fill
@@ -729,19 +695,19 @@ class SyncEngine {
                     }
                 }
             }
-            else if (gridOrder.state === constants_1.ORDER_STATES.ACTIVE || gridOrder.state === constants_1.ORDER_STATES.PARTIAL) {
+            else if (gridOrder.state === ORDER_STATES.ACTIVE || gridOrder.state === ORDER_STATES.PARTIAL) {
                 // Don't virtualize orders placed by a successful COW commit.
                 // The chain snapshot may lag behind confirmed transactions,
                 // causing correctly-placed orders to appear missing. _committedOrderIds
                 // is atomically rebuilt from every successful COW commit
-                // (manager.ts:_commitCowPlan) and is always active for all sync
+                // (manager.ts:_commitWorkingGrid) and is always active for all sync
                 // paths — previously gated on options.protectCommittedOrders.
                 // Always-on is safe because committed IDs are self-cleaning:
                 // filled/virtualized orders are absent from the next commit's
                 // finalMap, so their IDs drop out on the next atomic rebuild.
                 //
                 // SAFETY: _committedOrderIds is replaced atomically (reference swap)
-                // by _commitCowPlan. The sync reads has(gridOrder.orderId) against the
+                // by _commitWorkingGrid. The sync reads has(gridOrder.orderId) against the
                 // current reference. If a concurrent COW commit replaces the set mid-sync,
                 // the new set is a superset (only adds entries for newly committed orders).
                 // An order in the superset was just committed, so it is genuinely on-chain
@@ -765,14 +731,14 @@ class SyncEngine {
                 // this open-orders sync.
                 if (mgr._committedOrderIds?.has(gridOrder.orderId)) {
                     const commitAge = Date.now() - (mgr._committedOrderIdsBuiltAt || 0);
-                    const isGhost = gridOrder.size <= 0 && gridOrder.state === constants_1.ORDER_STATES.PARTIAL;
-                    if (!isGhost && commitAge < constants_1.TIMING.SYNC_LOCK_TIMEOUT_MS) {
+                    const isGhost = gridOrder.size <= 0 && gridOrder.state === ORDER_STATES.PARTIAL;
+                    if (!isGhost && commitAge < TIMING.SYNC_LOCK_TIMEOUT_MS) {
                         continue;
                     }
                 }
                 const currentGridOrder = mgr.orders.get(gridOrder.id) || gridOrder;
                 const hadOrderId = Boolean(currentGridOrder?.orderId);
-                const spreadOrder = (0, order_1.convertToSpreadPlaceholder)(currentGridOrder);
+                const spreadOrder = convertToSpreadPlaceholder(currentGridOrder);
                 await mgr._applyOrderUpdate(spreadOrder, 'sync-cleanup-phantom', { skipAccounting: skipAccounting, fee: 0 });
                 // Only genuine disappearances (had orderId) count as fills.
                 if (hadOrderId) {
@@ -784,8 +750,8 @@ class SyncEngine {
                     // 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);
+                    if (resolvedType === ORDER_TYPES.SPREAD) {
+                        resolvedType = resolveSpreadOrderSide(currentGridOrder.price, mgr.config.startPrice);
                     }
                     filledOrders.push({ ...currentGridOrder, type: resolvedType });
                 }
@@ -807,9 +773,9 @@ class SyncEngine {
             const duplicatePriceOrder = Array.from(mgr.orders.values()).find((o) => {
                 const co = chainOrder;
                 return o.type === co.type &&
-                    (0, order_1.isOrderPlaced)(o) &&
+                    isOrderPlaced(o) &&
                     co != null &&
-                    Math.abs(o.price - co.price) <= math_1.calculatePriceTolerance(Math.min(o.price, co.price), Math.max(o.size, co.size), o.type, mgr.assets);
+                    Math.abs(o.price - co.price) <= calculatePriceTolerance(Math.min(o.price, co.price), Math.max(o.size, co.size), o.type, mgr.assets);
             });
             if (duplicatePriceOrder) {
                 unmatchedChainOrders.push({
@@ -821,9 +787,10 @@ class SyncEngine {
                     reason: 'duplicate-price-level',
                     candidateSlotId: duplicatePriceOrder.id,
                 });
+                const { level, suffix } = duplicateOrphanLogInfo(chainOrderId);
                 mgr.logger?.log?.(`[SYNC] Orphaned chain order ${chainOrderId} (${chainOrder.type}, price=${chainOrder.price}, ` +
                     `size=${chainOrder.size}) — NOT adopted: duplicates price level of active ` +
-                    `${duplicatePriceOrder.id} (${duplicatePriceOrder.orderId} at ${duplicatePriceOrder.price})`, 'warn');
+                    `${duplicatePriceOrder.id} (${duplicatePriceOrder.orderId} at ${duplicatePriceOrder.price})${suffix}`, level);
                 // Gap 2: Queue duplicate chain order for cancellation via the correction
                 // mechanism (called from _performSyncFromOpenOrders). Duplicate price levels
                 // block new placements. Cancelling proactively unblocks CREATEs.
@@ -838,10 +805,10 @@ class SyncEngine {
                 });
                 continue;
             }
-            const match = (0, order_1.findMatchingGridOrderByOpenOrder)({ orderId: chainOrderId, type: chainOrder.type, price: chainOrder.price, size: chainOrder.size }, {
+            const match = findMatchingGridOrderByOpenOrder({ orderId: chainOrderId, type: chainOrder.type, price: chainOrder.price, size: chainOrder.size }, {
                 orders: mgr.orders,
                 assets: mgr.assets,
-                calcToleranceFn: (p, s, t) => (0, math_1.calculatePriceTolerance)(p, s, t, mgr.assets),
+                calcToleranceFn: (p, s, t) => calculatePriceTolerance(p, s, t, mgr.assets),
                 logger: mgr.logger,
                 allowSmallerChainSize: true,
                 requireAvailableSlot: true,
@@ -849,10 +816,10 @@ class SyncEngine {
             });
             if (match && !matchedGridOrderIds.has(match.id)) {
                 let bestMatch = { ...match };
-                const wasVirtual = match.state === constants_1.ORDER_STATES.VIRTUAL;
-                const wasPartial = match.state === constants_1.ORDER_STATES.PARTIAL;
+                const wasVirtual = match.state === ORDER_STATES.VIRTUAL;
+                const wasPartial = match.state === ORDER_STATES.PARTIAL;
                 bestMatch.orderId = chainOrderId;
-                bestMatch.state = wasVirtual ? constants_1.ORDER_STATES.ACTIVE : match.state;
+                bestMatch.state = wasVirtual ? ORDER_STATES.ACTIVE : match.state;
                 const bestMatchRaw = rawChainOrders.get(chainOrderId);
                 bestMatch.rawOnChain = bestMatchRaw
                     ? { ...bestMatchRaw, fetchedAt: Date.now() }
@@ -869,41 +836,41 @@ class SyncEngine {
                 if (bestMatch.rawOnChain) {
                     const rawDeferredFee = toFiniteNumber(bestMatch.rawOnChain.deferred_fee, undefined);
                     if (rawDeferredFee !== null && rawDeferredFee > 0) {
-                        bestMatch.btsFeeState = { deferredFee: (0, math_1.blockchainToFloat)(rawDeferredFee, constants_1.BTS_PRECISION) };
+                        bestMatch.btsFeeState = { deferredFee: blockchainToFloat(rawDeferredFee, BTS_PRECISION) };
                     }
                     else if (wasVirtual && rawDeferredFee !== null && rawDeferredFee <= 0 && bestMatch.rawOnChain.for_sale > 0) {
                         // Core zeros deferred_fee on every fill (fill_limit_order db_market.cpp:1895).
                         // If deferred_fee is 0 while for_sale > 0, the order was partially filled.
-                        bestMatch.state = constants_1.ORDER_STATES.PARTIAL;
+                        bestMatch.state = ORDER_STATES.PARTIAL;
                     }
                 }
-                const precision = (bestMatch.type === constants_1.ORDER_TYPES.SELL) ? assetAPrecision : assetBPrecision;
-                const targetInt = (0, math_1.floatToBlockchainInt)(match.size, precision);
-                const chainInt = (0, math_1.floatToBlockchainInt)(chainOrder.size, precision);
+                const precision = (bestMatch.type === ORDER_TYPES.SELL) ? assetAPrecision : assetBPrecision;
+                const targetInt = floatToBlockchainInt(match.size, precision);
+                const chainInt = floatToBlockchainInt(chainOrder.size, precision);
                 if (targetInt !== chainInt) {
-                    const updated = await (0, order_1.applyChainSizeToGridOrder)(mgr, bestMatch, chainOrder.size);
+                    const updated = await applyChainSizeToGridOrder(mgr, bestMatch, chainOrder.size);
                     if (updated)
                         bestMatch = { ...bestMatch, ...updated };
                     if (chainInt > 0) {
                         if (wasVirtual) {
                             // Only override to ACTIVE if partial-fill check above didn't already
                             // set PARTIAL via deferred_fee === 0. Skip override to preserve signal.
-                            if (bestMatch.state !== constants_1.ORDER_STATES.PARTIAL) {
-                                bestMatch.state = constants_1.ORDER_STATES.ACTIVE;
+                            if (bestMatch.state !== ORDER_STATES.PARTIAL) {
+                                bestMatch.state = ORDER_STATES.ACTIVE;
                             }
                         }
                         else if (chainInt < targetInt) {
-                            bestMatch.state = constants_1.ORDER_STATES.PARTIAL;
+                            bestMatch.state = ORDER_STATES.PARTIAL;
                         }
                         else if (wasPartial) {
-                            bestMatch.state = constants_1.ORDER_STATES.PARTIAL;
+                            bestMatch.state = ORDER_STATES.PARTIAL;
                         }
                         else {
-                            bestMatch.state = constants_1.ORDER_STATES.ACTIVE;
+                            bestMatch.state = ORDER_STATES.ACTIVE;
                         }
                     }
                     else {
-                        const spreadOrder = (0, order_1.convertToSpreadPlaceholder)(bestMatch);
+                        const spreadOrder = convertToSpreadPlaceholder(bestMatch);
                         filledOrders.push({ ...bestMatch });
                         await mgr._applyOrderUpdate(spreadOrder, 'sync-pass2-filled', { skipAccounting: skipAccounting, fee: 0 });
                         updatedOrders.push(spreadOrder);
@@ -912,7 +879,7 @@ class SyncEngine {
                     }
                 }
                 else if (wasPartial) {
-                    bestMatch.state = constants_1.ORDER_STATES.PARTIAL;
+                    bestMatch.state = ORDER_STATES.PARTIAL;
                 }
                 await mgr._applyOrderUpdate(bestMatch, 'sync-pass2-orphan', { skipAccounting: skipAccounting, fee: 0 });
                 updatedOrders.push(bestMatch);
@@ -949,23 +916,23 @@ class SyncEngine {
                 // orphan becomes visible to checkWindowDust for dust auto-cancel.
                 // The duplicate-price-level guard already ran above so it is not
                 // repeated here.
-                const adoptedSlot = (0, order_1.findMatchingGridOrderByOpenOrder)({ orderId: chainOrderId, type: chainOrder.type, price: chainOrder.price, size: chainOrder.size }, {
+                const adoptedSlot = findMatchingGridOrderByOpenOrder({ orderId: chainOrderId, type: chainOrder.type, price: chainOrder.price, size: chainOrder.size }, {
                     orders: mgr.orders,
                     assets: mgr.assets,
-                    calcToleranceFn: (p, s, t) => (0, math_1.calculatePriceTolerance)(p, s, t, mgr.assets),
+                    calcToleranceFn: (p, s, t) => calculatePriceTolerance(p, s, t, mgr.assets),
                     allowSpreadType: true,
                     skipSizeMatch: true,
                     requireAvailableSlot: true,
                     excludeGridOrderIds: matchedGridOrderIds
                 });
                 if (adoptedSlot && !matchedGridOrderIds.has(adoptedSlot.id) && !adoptedSlot.orderId) {
-                    const precision = (chainOrder.type === constants_1.ORDER_TYPES.SELL) ? assetAPrecision : assetBPrecision;
-                    const chainInt = (0, math_1.floatToBlockchainInt)(chainOrder.size, precision);
+                    const precision = (chainOrder.type === ORDER_TYPES.SELL) ? assetAPrecision : assetBPrecision;
+                    const chainInt = floatToBlockchainInt(chainOrder.size, precision);
                     const adoptedRaw = rawChainOrders.get(chainOrderId);
-                    const adoptedState = chainInt > 0 ? constants_1.ORDER_STATES.PARTIAL : constants_1.ORDER_STATES.VIRTUAL;
+                    const adoptedState = chainInt > 0 ? ORDER_STATES.PARTIAL : ORDER_STATES.VIRTUAL;
                     const adoptedBtsFeeState = (adoptedRaw) ? (() => {
                         const rawFee = toFiniteNumber(adoptedRaw.deferred_fee, undefined);
-                        return rawFee !== null && rawFee > 0 ? { deferredFee: (0, math_1.blockchainToFloat)(rawFee, constants_1.BTS_PRECISION) } : undefined;
+                        return rawFee !== null && rawFee > 0 ? { deferredFee: blockchainToFloat(rawFee, BTS_PRECISION) } : undefined;
                     })() : undefined;
                     const adoptedOrder = {
                         ...adoptedSlot,
@@ -987,9 +954,9 @@ class SyncEngine {
                         `size=${chainOrder.size}) adopted into slot ${adoptedSlot.id} (was ${adoptedSlot.type})`, 'warn');
                 }
                 else {
-                    const precision = (chainOrder.type === constants_1.ORDER_TYPES.SELL) ? assetAPrecision : assetBPrecision;
-                    const candidateDiagnostics = describeNearestAdoptionCandidates(mgr, chainOrder, precision, (p, s, t) => (0, math_1.calculatePriceTolerance)(p, s, t, mgr.assets), matchedGridOrderIds);
-                    const driftTag = computeOutOfToleranceDriftTag(mgr, chainOrder, (p, s, t) => (0, math_1.calculatePriceTolerance)(p, s, t, mgr.assets));
+                    const precision = (chainOrder.type === ORDER_TYPES.SELL) ? assetAPrecision : assetBPrecision;
+                    const candidateDiagnostics = describeNearestAdoptionCandidates(mgr, chainOrder, precision, (p, s, t) => calculatePriceTolerance(p, s, t, mgr.assets), matchedGridOrderIds);
+                    const driftTag = computeOutOfToleranceDriftTag(mgr, chainOrder, (p, s, t) => calculatePriceTolerance(p, s, t, mgr.assets));
                     const unmatchedEntry = {
                         chainOrderId,
                         type: chainOrder.type,
@@ -1021,7 +988,7 @@ class SyncEngine {
     // ------------------------------------------------------------------
     _findMatchingGridOrder(mgr, orderId) {
         for (const gridOrder of mgr.orders.values()) {
-            if (gridOrder.orderId === orderId && (gridOrder.state === constants_1.ORDER_STATES.ACTIVE || gridOrder.state === constants_1.ORDER_STATES.PARTIAL)) {
+            if (gridOrder.orderId === orderId && (gridOrder.state === ORDER_STATES.ACTIVE || gridOrder.state === ORDER_STATES.PARTIAL)) {
                 return gridOrder;
             }
         }
@@ -1036,26 +1003,26 @@ class SyncEngine {
         // 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 (orderType === ORDER_TYPES.SPREAD) {
             if (paysAssetId === mgr.assets.assetB.id)
-                orderType = constants_1.ORDER_TYPES.BUY;
+                orderType = ORDER_TYPES.BUY;
             else if (paysAssetId === mgr.assets.assetA.id)
-                orderType = constants_1.ORDER_TYPES.SELL;
+                orderType = ORDER_TYPES.SELL;
             else
-                orderType = (0, order_1.resolveSpreadOrderSide)(matchedGridOrder.price, mgr.config.startPrice);
+                orderType = 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;
+        const precision = (orderType === ORDER_TYPES.SELL) ? mgr.assets.assetA.precision : mgr.assets.assetB.precision;
         let filledAmount = 0;
-        if (orderType === constants_1.ORDER_TYPES.SELL) {
+        if (orderType === ORDER_TYPES.SELL) {
             if (paysAssetId === mgr.assets.assetA.id)
-                filledAmount = (0, math_1.blockchainToFloat)(paysAmountRaw, precision);
+                filledAmount = blockchainToFloat(paysAmountRaw, precision);
         }
         else {
             if (paysAssetId === mgr.assets.assetB.id)
-                filledAmount = (0, math_1.blockchainToFloat)(paysAmountRaw, precision);
+                filledAmount = blockchainToFloat(paysAmountRaw, precision);
         }
-        const currentSizeIntFromGrid = (0, math_1.floatToBlockchainInt)(currentSize, precision);
+        const currentSizeIntFromGrid = floatToBlockchainInt(currentSize, precision);
         const rawForSale = matchedGridOrder?.rawOnChain?.for_sale;
         const rawForSaleInt = rawForSale !== undefined && rawForSale !== null ? toFiniteNumber(rawForSale) : NaN;
         const driftSignal = Number.isFinite(rawForSaleInt) && Math.round(rawForSaleInt) < currentSizeIntFromGrid;
@@ -1071,40 +1038,86 @@ class SyncEngine {
             ? Math.max(0, Math.round(effectiveRawForSale))
             : currentSizeIntFromGrid;
         const newSizeInt = Math.max(0, currentSizeInt - filledAmountInt);
-        const newSize = (0, math_1.blockchainToFloat)(newSizeInt, precision);
+        const newSize = blockchainToFloat(newSizeInt, precision);
         if (Number.isFinite(effectiveRawForSale) && currentSizeInt !== currentSizeIntFromGrid) {
             mgr.logger.log(`[SYNC] Using rawOnChain.for_sale baseline for ${matchedGridOrder.orderId}: raw=${currentSizeInt}, grid=${currentSizeIntFromGrid}` +
                 (chainRefetched ? ' (refetched)' : ''), 'debug');
         }
         const gridAlsoEmpty = currentSizeIntFromGrid <= 0;
         let isEffectivelyFull = resolvedChainConfirmsEmpty || gridAlsoEmpty;
+        // If the chain retains a real residual order after this fill, the bot
+        // must cancel it explicitly. The chain only auto-culls ("culls small")
+        // an order when its residual value in the QUOTE asset truncates to 0
+        // (amount_to_receive() == 0, i.e. for_sale × price == 0 in quote units,
+        // see maybe_cull_small_order in bitshares-core). A residual of >= 1 base
+        // unit whose quote value is non-zero is NOT culled — it would be
+        // orphaned on-chain once the slot is converted to a SPREAD placeholder.
+        // Verified fills stay authoritative (rotation proceeds), but the leftover
+        // dust is handled by an explicit cancel rather than trusting the chain to
+        // sweep it.
+        let residualCancel = null;
         if (!isEffectivelyFull) {
-            const otherPrecision = (orderType === constants_1.ORDER_TYPES.SELL) ? mgr.assets.assetB.precision : mgr.assets.assetA.precision;
+            const otherPrecision = (orderType === ORDER_TYPES.SELL) ? mgr.assets.assetB.precision : mgr.assets.assetA.precision;
             const otherSidePrice = matchedGridOrder.price;
-            const otherSize = (orderType === constants_1.ORDER_TYPES.SELL) ? newSize * otherSidePrice : newSize / otherSidePrice;
-            if ((0, math_1.floatToBlockchainInt)(otherSize, otherPrecision) <= 0) {
+            const otherSize = (orderType === ORDER_TYPES.SELL) ? newSize * otherSidePrice : newSize / otherSidePrice;
+            if (floatToBlockchainInt(otherSize, otherPrecision) <= 0) {
                 // 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; chain culls sub-dust residual (no cancel needed).`, 'info');
+                // a duplicate CREATE. 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.
+                //
+                // However, the chain does NOT reliably cull the leftover residual:
+                // maybe_cull_small_order only removes an order whose QUOTE-side
+                // value rounds to zero. Verify the order against the chain; if it
+                // still exists with for_sale > 0, schedule an explicit cancel so
+                // the dust is not stranded on the book (previously it could remain
+                // forever because the slot was virtualized and nothing referenced
+                // the orderId anymore).
                 isEffectivelyFull = true;
+                // Reuse a drift-refetch result when present: it is a live
+                // post-fill read, so for_sale > 0 already proves a real residual
+                // remains. Avoids a second RPC for the same order in the exact
+                // scenario that triggered this branch.
+                let residualForSale = null;
+                if (chainRefetched && Number.isFinite(effectiveRawForSale)) {
+                    residualForSale = Math.round(effectiveRawForSale);
+                }
+                else {
+                    try {
+                        const residualOrder = await chainOrders.readSingleOrder(matchedGridOrder.orderId, 3000);
+                        residualForSale = residualOrder ? toFiniteNumber(residualOrder.for_sale, undefined) : null;
+                    }
+                    catch (residualErr) {
+                        // The read is best-effort: if it fails, fall back to the old
+                        // behavior (rely on reconciliation) rather than blocking the
+                        // authoritative fill transition.
+                        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 verification read failed (${getErrorMessage(residualErr)}); ` +
+                            `relying on reconciliation for any residual.`, 'warn');
+                    }
+                }
+                if (Number.isFinite(residualForSale) && Math.round(residualForSale) > 0) {
+                    residualCancel = { orderId: matchedGridOrder.orderId, id: matchedGridOrder.id };
+                    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, but chain still holds residual for_sale=${residualForSale} ` +
+                        `(not culled); scheduling explicit cancel.`, 'warn');
+                }
+                else {
+                    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; chain confirms residual gone (for_sale=0), no cancel needed.`, 'info');
+                }
             }
         }
         let fullUpdate;
         let partialUpdate;
         let filledOrderResult;
         if (isEffectivelyFull) {
-            fullUpdate = (0, order_1.convertToSpreadPlaceholder)(matchedGridOrder);
+            fullUpdate = convertToSpreadPlaceholder(matchedGridOrder);
             filledOrderResult = {
                 ...matchedGridOrder,
                 type: orderType,
@@ -1124,7 +1137,7 @@ class SyncEngine {
                 isMaker
             };
             const { btsFeeState, ...matchedWithoutDeferredFee } = matchedGridOrder;
-            let updatedOrder = { ...matchedWithoutDeferredFee, type: orderType, state: constants_1.ORDER_STATES.PARTIAL };
+            let updatedOrder = { ...matchedWithoutDeferredFee, type: orderType, state: ORDER_STATES.PARTIAL };
             if (updatedOrder.rawOnChain && updatedOrder.rawOnChain.for_sale !== undefined) {
                 const baselineForSale = (chainRefetched && Number.isFinite(effectiveRawForSale))
                     ? effectiveRawForSale
@@ -1136,7 +1149,7 @@ class SyncEngine {
                     fetchedAt: Date.now()
                 };
             }
-            const nextOrder = await (0, order_1.applyChainSizeToGridOrder)(mgr, updatedOrder, newSize);
+            const nextOrder = await applyChainSizeToGridOrder(mgr, updatedOrder, newSize);
             if (nextOrder) {
                 updatedOrder = { ...updatedOrder, ...nextOrder };
             }
@@ -1147,7 +1160,8 @@ class SyncEngine {
             filledOrder: filledOrderResult,
             fullUpdate,
             partialUpdate,
-            newSize
+            newSize,
+            residualCancel
         };
     }
     /**
@@ -1158,7 +1172,7 @@ class SyncEngine {
      */
     async syncFromFillHistory(fill, options = {}) {
         const mgr = this.manager;
-        const persistenceMode = (0, processed_fill_store_1.resolveProcessedFillPersistenceMode)(options);
+        const persistenceMode = resolveProcessedFillPersistenceMode(options);
         if (!fill || !fill.op || !fill.op[1])
             return { filledOrders: [], updatedOrders: [], partialFill: false };
         const fillOp = fill.op[1];
@@ -1169,7 +1183,7 @@ class SyncEngine {
             mgr.logger.log(`[SYNC] is_maker flag missing from fill data for order ${orderId}; defaulting to maker`, 'warn');
         }
         const isMaker = fillOp.is_maker !== false;
-        const fillKey = (0, order_1.buildFillKey)({ orderId, blockNum, historyId });
+        const fillKey = buildFillKey({ orderId, blockNum, historyId });
         const paysAmountRaw = toFiniteNumber(fillOp.pays?.amount);
         const paysAssetId = fillOp.pays ? fillOp.pays.asset_id : null;
         const receivesAmountRaw = toFiniteNumber(fillOp.receives?.amount);
@@ -1244,7 +1258,7 @@ class SyncEngine {
                         orderType: ctx.orderType,
                         precision: ctx.precision,
                         filledAmount: ctx.filledAmount,
-                        filledAmountInt: (0, math_1.floatToBlockchainInt)(ctx.filledAmount, ctx.precision),
+                        filledAmountInt: floatToBlockchainInt(ctx.filledAmount, ctx.precision),
                         currentSizeIntFromGrid: ctx.currentSizeIntFromGrid,
                         rawForSaleInt: ctx.rawForSaleInt,
                         chainRefetched,
@@ -1279,7 +1293,12 @@ class SyncEngine {
                     // 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 };
+                    return {
+                        filledOrders,
+                        updatedOrders,
+                        partialFill: result.isFull ? false : true,
+                        residualCancels: result.residualCancel ? [result.residualCancel] : []
+                    };
                 }
                 finally {
                     // Lower the guard before the final consolidated recalc so the
@@ -1310,7 +1329,7 @@ class SyncEngine {
      */
     async syncFromFillHistoryBatch(fills, options = {}) {
         const mgr = this.manager;
-        const persistenceMode = (0, processed_fill_store_1.resolveProcessedFillPersistenceMode)(options);
+        const persistenceMode = resolveProcessedFillPersistenceMode(options);
         if (!Array.isArray(fills) || fills.length === 0) {
             return { filledOrders: [], updatedOrders: [], partialFill: false };
         }
@@ -1328,7 +1347,7 @@ class SyncEngine {
                 mgr.logger.log(`[SYNC] is_maker flag missing from fill data for order ${orderId}; defaulting to maker`, 'warn');
             }
             const isMaker = fillOp.is_maker !== false;
-            const fillKey = (0, order_1.buildFillKey)({ orderId, blockNum, historyId });
+            const fillKey = buildFillKey({ orderId, blockNum, historyId });
             if (!fillKey) {
                 mgr.logger.log(`[SYNC] Missing replay-safe fill key for order ${orderId} block ${blockNum}; deferring to open-orders sync`, 'warn');
                 anyRequiresSync = true;
@@ -1379,7 +1398,7 @@ class SyncEngine {
                             validEntries.push(entry);
                         }
                         catch (acctErr) {
-                            mgr.logger.log(`[SYNC] Accounting error for fill ${entry.fillKey}: ${(0, errors_1.getErrorMessage)(acctErr)}`, 'error');
+                            mgr.logger.log(`[SYNC] Accounting error for fill ${entry.fillKey}: ${getErrorMessage(acctErr)}`, 'error');
                             continue;
                         }
                     }
@@ -1413,7 +1432,7 @@ class SyncEngine {
                             orderType: ctx.orderType,
                             precision: ctx.precision,
                             filledAmount: ctx.filledAmount,
-                            filledAmountInt: (0, math_1.floatToBlockchainInt)(ctx.filledAmount, ctx.precision),
+                            filledAmountInt: floatToBlockchainInt(ctx.filledAmount, ctx.precision),
                             currentSizeIntFromGrid: ctx.currentSizeIntFromGrid,
                             rawForSaleInt: ctx.rawForSaleInt
                         });
@@ -1462,14 +1481,44 @@ class SyncEngine {
                             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
+                    // Phase 6: Compute state transitions and collect grid updates.
+                    // Multiple fills for the SAME order inside one batch are
+                    // aggregated into a single cumulative transition. Each fill is
+                    // still accounted individually (Phase 3), but the grid mutation
+                    // must reflect the COMBINED consumption. Without aggregation every
+                    // fill recomputes newSize from the same stale pre-batch baseline
+                    // and the last update wins (`applyGridUpdateBatch` is last-wins
+                    // per slot), leaving a phantom residual equal to the earlier
+                    // fills' sum — exactly the fund-invariant CRITICAL seen in the
+                    // XRP-BTS log whenever a batch contained 2+ fills of one order.
                     const gridUpdates = [];
                     const filledOrders = [];
                     const updatedOrders = [];
+                    const residualCancels = [];
                     let anyPartialFill = false;
+                    const fillContextsBySlot = new Map();
                     for (const ctx of entryContexts) {
-                        const { entry, matchedGridOrder, orderType, precision, filledAmount, filledAmountInt, currentSizeIntFromGrid, rawForSaleInt } = ctx;
-                        const { orderId, blockNum, historyId, isMaker } = entry;
+                        const slotId = ctx.matchedGridOrder.id;
+                        const group = fillContextsBySlot.get(slotId);
+                        if (group)
+                            group.push(ctx);
+                        else
+                            fillContextsBySlot.set(slotId, [ctx]);
+                    }
+                    for (const group of fillContextsBySlot.values()) {
+                        const lastCtx = group[group.length - 1];
+                        const { matchedGridOrder, orderType, precision, currentSizeIntFromGrid, rawForSaleInt } = lastCtx;
+                        const { orderId } = lastCtx.entry;
+                        // Sum the integer filled amounts across this order's fills so
+                        // the single transition reflects the total consumption.
+                        let totalFilledAmountInt = 0;
+                        for (const ctx of group) {
+                            totalFilledAmountInt += ctx.filledAmountInt;
+                        }
+                        const totalFilledAmount = blockchainToFloat(totalFilledAmountInt, precision);
+                        if (group.length > 1) {
+                            mgr.logger.log(`[SYNC] Aggregated ${group.length} fill(s) for order ${orderId} (slot ${matchedGridOrder.id}): total filled=${totalFilledAmount}`, 'debug');
+                        }
                         const refetchInfo = refetchMap.get(orderId);
                         const chainRefetched = refetchInfo?.chainRefetched || false;
                         const chainConfirmsEmpty = refetchInfo?.chainConfirmsEmpty || false;
@@ -1478,21 +1527,23 @@ class SyncEngine {
                             matchedGridOrder,
                             orderType,
                             precision,
-                            filledAmount,
-                            filledAmountInt,
+                            filledAmount: totalFilledAmount,
+                            filledAmountInt: totalFilledAmountInt,
                             currentSizeIntFromGrid,
                             rawForSaleInt,
                             chainRefetched,
                             chainConfirmsEmpty,
                             effectiveRawForSale,
-                            blockNum,
-                            historyId,
-                            isMaker
+                            blockNum: lastCtx.entry.blockNum,
+                            historyId: lastCtx.entry.historyId,
+                            isMaker: lastCtx.entry.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);
+                            if (result.residualCancel)
+                                residualCancels.push(result.residualCancel);
                         }
                         else {
                             mgr.logger.log(`[SYNC] Partial fill for order ${orderId} (slot ${matchedGridOrder.id}): newSize=${result.newSize}`, 'info');
@@ -1522,7 +1573,7 @@ class SyncEngine {
                     // authoritative values and hands re-commitments
                     // (tryDeductFromChainFree) a fresh snapshot.
                     await mgr.reanchorAccountTotals('fill-batch');
-                    return { filledOrders, updatedOrders, partialFill: anyPartialFill, requiresOpenOrdersSync: anyRequiresSync };
+                    return { filledOrders, updatedOrders, partialFill: anyPartialFill, requiresOpenOrdersSync: anyRequiresSync, residualCancels };
                 }
                 finally {
                     // Lower the guard before the final consolidated recalc so the
@@ -1612,33 +1663,33 @@ class SyncEngine {
                             const isRotation = !!existingOrder;
                             // For rotation: transition the old order to VIRTUAL, freeing its capital
                             if (isRotation && existingOrder) {
-                                if (!(0, order_1.isOrderVirtual)(existingOrder)) {
-                                    const oldVirtualOrder = (0, order_1.convertToSpreadPlaceholder)(existingOrder);
+                                if (!isOrderVirtual(existingOrder)) {
+                                    const oldVirtualOrder = convertToSpreadPlaceholder(existingOrder);
                                     await mgr._applyOrderUpdate(oldVirtualOrder, 'rotation-cleanup', {
                                         skipAccounting: chainData.skipAccounting || false,
                                         fee: 0
                                     });
                                 }
-                                else if ((0, order_1.hasOnChainId)(existingOrder)) {
+                                else if (hasOnChainId(existingOrder)) {
                                     // Already VIRTUAL but still has orderId (from rebalance)
                                     // Just clear the orderId to reflect blockchain state
-                                    const clearedOrder = (0, order_1.convertToSpreadPlaceholder)(existingOrder);
+                                    const clearedOrder = convertToSpreadPlaceholder(existingOrder);
                                     await mgr._applyOrderUpdate(clearedOrder, 'fill-cleanup', {
                                         skipAccounting: chainData.skipAccounting || false,
                                         fee: 0
                                     });
                                 }
                             }
-                            const newState = isPartialPlacement ? constants_1.ORDER_STATES.PARTIAL : constants_1.ORDER_STATES.ACTIVE;
-                            let normalizedExpectedType = (expectedType === constants_1.ORDER_TYPES.BUY || expectedType === constants_1.ORDER_TYPES.SELL)
+                            const newState = isPartialPlacement ? ORDER_STATES.PARTIAL : ORDER_STATES.ACTIVE;
+                            let normalizedExpectedType = (expectedType === ORDER_TYPES.BUY || expectedType === 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);
+                            if (!normalizedExpectedType && gridOrder.type === ORDER_TYPES.SPREAD) {
+                                normalizedExpectedType = resolveSpreadOrderSide(gridOrder.price, mgr.config.startPrice);
                             }
                             const updatedOrder = {
                                 ...gridOrder,
@@ -1679,10 +1730,10 @@ class SyncEngine {
                 const clearSize = !!chainData.clearSize;
                 let btsFeeData;
                 try {
-                    btsFeeData = (0, math_1.getAssetFees)('BTS');
+                    btsFeeData = getAssetFees('BTS');
                 }
                 catch (err) {
-                    mgr.logger?.log?.(`[FILL-FEE] Failed to load BTS cancel fee cache: ${(0, errors_1.getErrorMessage)(err)}. Using zero-fee fallback.`, 'warn');
+                    mgr.logger?.log?.(`[FILL-FEE] Failed to load BTS cancel fee cache: ${getErrorMessage(err)}. Using zero-fee fallback.`, 'warn');
                     btsFeeData = {
                         total: 0,
                         createFee: 0,
@@ -1695,7 +1746,7 @@ class SyncEngine {
                     };
                 }
                 const runCancel = async () => {
-                    const gridOrder = (0, order_1.findMatchingGridOrderByOpenOrder)({ orderId }, { orders: mgr.orders, assets: mgr.assets, calcToleranceFn: (p, s, t) => (0, math_1.calculatePriceTolerance)(p, s, t, mgr.assets), logger: mgr.logger });
+                    const gridOrder = findMatchingGridOrderByOpenOrder({ orderId }, { orders: mgr.orders, assets: mgr.assets, calcToleranceFn: (p, s, t) => calculatePriceTolerance(p, s, t, mgr.assets), logger: mgr.logger });
                     if (gridOrder) {
                         // Lock both chain orderId and grid order ID to prevent concurrent modifications
                         const orderIds = [orderId, gridOrder.id].filter(Boolean);
@@ -1705,8 +1756,8 @@ class SyncEngine {
                             const currentGridOrder = mgr.orders.get(gridOrder.id);
                             if (currentGridOrder && currentGridOrder.orderId === orderId) {
                                 const nextOrder = clearSize
-                                    ? (0, order_1.convertToSpreadPlaceholder)(currentGridOrder)
-                                    : (0, order_1.virtualizeOrder)(currentGridOrder);
+                                    ? convertToSpreadPlaceholder(currentGridOrder)
+                                    : virtualizeOrder(currentGridOrder);
                                 await mgr._applyOrderUpdate(nextOrder, 'cancel-order', {
                                     skipAccounting: false,
                                     fee: btsFeeData?.cancelFee || 0
@@ -1720,7 +1771,7 @@ class SyncEngine {
                     else {
                         // CRITICAL: Even if order not in grid, the cancellation fee was still paid on blockchain
                         // Deduct it from account totals to prevent drift.
-                        const btsSide = (0, math_1.getBtsSide)(mgr.config?.assetA, mgr.config?.assetB);
+                        const btsSide = getBtsSide(mgr.config?.assetA, mgr.config?.assetB);
                         if (btsSide && btsFeeData?.cancelFee > 0) {
                             await mgr.accountant.adjustTotalBalance(btsSide, -btsFeeData.cancelFee, 'cancel-order-unmatched-fee');
                         }
@@ -1814,7 +1865,7 @@ class SyncEngine {
                 await this.initializeAssets();
             }
             catch (err) {
-                mgr.logger.log(`[SYNC] initializeAssets failed: ${(0, errors_1.getErrorMessage)(err)}`, 'warn');
+                mgr.logger.log(`[SYNC] initializeAssets failed: ${getErrorMessage(err)}`, 'warn');
             }
             const assetAId = mgr.assets?.assetA?.id;
             const assetBId = mgr.assets?.assetB?.id;
@@ -1823,7 +1874,7 @@ class SyncEngine {
             const assetList = [assetAId, assetBId];
             // For non-BTS pairs, also fetch core asset (BTS) balance for fee management
             if (mgr.config.assetA !== 'BTS' && mgr.config.assetB !== 'BTS') {
-                assetList.push(constants_2.NATIVE_CLIENT.CHAIN.CORE_ASSET_ID);
+                assetList.push(NATIVE_CLIENT.CHAIN.CORE_ASSET_ID);
             }
             const lookup = await chainOrders.getOnChainAssetBalances(accountIdOrName, assetList);
             const aInfo = lookup?.[assetAId] || lookup?.[mgr.config.assetA];
@@ -1833,14 +1884,14 @@ class SyncEngine {
             }
             // Store BTS balance for non-BTS pairs
             if (mgr.config.assetA !== 'BTS' && mgr.config.assetB !== 'BTS') {
-                const btsInfo = lookup?.[constants_2.NATIVE_CLIENT.CHAIN.CORE_ASSET_ID];
+                const btsInfo = lookup?.[NATIVE_CLIENT.CHAIN.CORE_ASSET_ID];
                 if (btsInfo) {
                     mgr.btsBalance = { free: btsInfo.free, total: btsInfo.total, locked: 0 };
                 }
             }
         }
         catch (err) {
-            mgr.logger.log(`Failed to fetch on-chain balances: ${(0, errors_1.getErrorMessage)(err)}`, 'warn');
+            mgr.logger.log(`Failed to fetch on-chain balances: ${getErrorMessage(err)}`, 'warn');
         }
     }
     /**
@@ -1894,7 +1945,7 @@ class SyncEngine {
             return;
         const fetchAssetWithFallback = async (symbol, side) => {
             try {
-                return await (0, system_1.lookupAsset)(BitShares, symbol);
+                return await lookupAsset(BitShares, symbol);
             }
             catch (err) {
                 // If blockchain lookup fails, check for persisted fallback
@@ -1902,7 +1953,7 @@ class SyncEngine {
                     const persistedAssets = mgr.accountOrders.loadPersistedAssets();
                     const assetData = (side === 'A') ? persistedAssets?.assetA : persistedAssets?.assetB;
                     if (assetData && assetData.symbol === symbol && typeof assetData.precision === 'number') {
-                        mgr.logger.log(`Blockchain lookup failed for ${symbol}: ${(0, errors_1.getErrorMessage)(err)}. Persisted data: id=${assetData.id}, precision=${assetData.precision} — refusing stale fallback`, 'error');
+                        mgr.logger.log(`Blockchain lookup failed for ${symbol}: ${getErrorMessage(err)}. Persisted data: id=${assetData.id}, precision=${assetData.precision} — refusing stale fallback`, 'error');
                     }
                 }
                 throw err;
@@ -1915,10 +1966,10 @@ class SyncEngine {
             };
         }
         catch (err) {
-            mgr.logger.log(`Asset metadata lookup failed: ${(0, errors_1.getErrorMessage)(err)}`, 'error');
+            mgr.logger.log(`Asset metadata lookup failed: ${getErrorMessage(err)}`, 'error');
             throw err;
         }
     }
 }
-exports.default = SyncEngine;
+export default SyncEngine;
 //# sourceMappingURL=sync_engine.js.map