dexbot 1.3.3 → 1.4.1

package/dist/modules/order/sync_engine.js

@@ -89,33 +89,71 @@
  *
  * ===============================================================================
  */
-const { ORDER_TYPES, ORDER_STATES, TIMING, BTS_PRECISION } = require('../constants');
-const Format = require('./format');
+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"));
+const { BitShares } = client;
+const constants_2 = require("../constants");
 const { toFiniteNumber } = Format;
-const { blockchainToFloat, floatToBlockchainInt, hasValidAccountTotals, calculatePriceTolerance, getAssetFees } = require('./utils/math');
-const { parseChainOrder, findMatchingGridOrderByOpenOrder, applyChainSizeToGridOrder, convertToSpreadPlaceholder, virtualizeOrder, buildFillKey, isOrderPlaced, isOrderOnChain, hasOnChainId, isOrderVirtual, isPhantomOrder } = require('./utils/order');
-const { resolveProcessedFillPersistenceMode } = require('./processed_fill_store');
-const { lookupAsset } = require('./utils/system');
-const chainOrders = require('../chain_orders');
+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");
 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 = floatToBlockchainInt(chainSize, precision);
+    const chainInt = (0, math_1.floatToBlockchainInt)(chainSize, precision);
     const candidates = [];
     for (const slot of mgr.orders.values()) {
-        if (!slot || ![ORDER_STATES.ACTIVE, ORDER_STATES.PARTIAL, ORDER_STATES.VIRTUAL].includes(slot.state))
+        if (!slot || ![constants_1.ORDER_STATES.ACTIVE, constants_1.ORDER_STATES.PARTIAL, constants_1.ORDER_STATES.VIRTUAL].includes(slot.state))
             continue;
         const typeMatch = slot.type === chainOrder.type;
-        const spreadMatch = slot.type === ORDER_TYPES.SPREAD;
+        const spreadMatch = slot.type === constants_1.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 = floatToBlockchainInt(toFiniteNumber(slot.size), precision);
+        const gridInt = (0, math_1.floatToBlockchainInt)(toFiniteNumber(slot.size), precision);
         const sizeDiffInt = chainInt - gridInt;
         const hasOrderId = Boolean(slot.orderId);
         const alreadyMatched = Boolean(matchedGridOrderIds?.has?.(slot.id));
@@ -196,17 +234,17 @@ function computeOutOfToleranceDriftTag(mgr, chainOrder, calcToleranceFn) {
         return null;
     const chainSize = toFiniteNumber(chainOrder.size);
     const orderType = chainOrder.type;
-    if (orderType !== ORDER_TYPES.BUY && orderType !== ORDER_TYPES.SELL)
+    if (orderType !== constants_1.ORDER_TYPES.BUY && orderType !== constants_1.ORDER_TYPES.SELL)
         return null;
     let bestDrift = null;
     for (const slot of mgr.orders.values()) {
         if (!slot)
             continue;
-        if (slot.type !== orderType && slot.type !== ORDER_TYPES.SPREAD)
+        if (slot.type !== orderType && slot.type !== constants_1.ORDER_TYPES.SPREAD)
             continue;
         if (slot.orderId)
             continue;
-        if (![ORDER_STATES.ACTIVE, ORDER_STATES.PARTIAL, ORDER_STATES.VIRTUAL].includes(slot.state))
+        if (![constants_1.ORDER_STATES.ACTIVE, constants_1.ORDER_STATES.PARTIAL, constants_1.ORDER_STATES.VIRTUAL].includes(slot.state))
             continue;
         const slotPrice = toFiniteNumber(slot.price);
         if (!Number.isFinite(slotPrice))
@@ -325,9 +363,8 @@ class SyncEngine {
                 return this.syncFromOpenOrders(chainOrders, options);
             });
         }
-        mgr.logger?.log?.(`[SYNC] Starting synchronization from ${chainOrders?.length || 0} blockchain orders...`, 'info');
-        const timeoutMs = TIMING.SYNC_LOCK_TIMEOUT_MS;
-        const forceReleaseMs = TIMING.SYNC_LOCK_FORCE_RELEASE_AGE_MS;
+        const timeoutMs = constants_1.TIMING.SYNC_LOCK_TIMEOUT_MS;
+        const forceReleaseMs = constants_1.TIMING.SYNC_LOCK_FORCE_RELEASE_AGE_MS;
         let timedOut = false;
         let timeoutHandle;
         let forceReleaseHandle;
@@ -373,7 +410,7 @@ class SyncEngine {
                         ? innerResult.unmatchedChainOrders.length
                         : 0;
                     mgr._lastUnmatchedChainOrders = unmatchedCount > 0
-                        ? innerResult.unmatchedChainOrders.map(order => ({ ...order }))
+                        ? innerResult.unmatchedChainOrders.map((order) => ({ ...order }))
                         : [];
                     mgr._lastUnmatchedChainOrdersAt = unmatchedCount > 0 ? Date.now() : 0;
                     mgr.logger?.log?.(`[SYNC] Synchronization complete: ${innerResult.filledOrders.length} filled, ` +
@@ -395,7 +432,7 @@ class SyncEngine {
         catch (err) {
             clearTimeout(timeoutHandle);
             clearTimeout(forceReleaseHandle);
-            if (err.message?.includes('timed out')) {
+            if ((0, errors_1.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.
@@ -412,7 +449,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: ${err.message}`, 'error');
+            mgr.logger?.log?.(`Sync lock error: ${(0, errors_1.getErrorMessage)(err)}`, 'error');
             throw err;
         }
     }
@@ -476,7 +513,7 @@ class SyncEngine {
         const rawChainOrders = new Map();
         for (const order of chainOrders) {
             try {
-                const parsed = parseChainOrder(order, mgr.assets);
+                const parsed = (0, order_1.parseChainOrder)(order, mgr.assets);
                 if (!parsed)
                     continue;
                 // Store parsed (converted) data in parsedChainOrders
@@ -485,10 +522,11 @@ class SyncEngine {
                 rawChainOrders.set(order.id, order);
             }
             catch (e) {
-                mgr.logger?.log?.(`Warning: Error parsing chain order ${order.id}: ${e.message}`, 'warn');
+                mgr.logger?.log?.(`Warning: Error parsing chain order ${order.id}: ${(0, errors_1.getErrorMessage)(e)}`, 'warn');
                 continue;
             }
         }
+        mgr.logger?.log?.(`[SYNC] Starting synchronization from ${parsedChainOrders.size} blockchain orders...`, 'info');
         // Collect all order IDs that might be modified during reconciliation
         // Lock them to prevent concurrent modifications from createOrder/cancelOrder
         const orderIdsToLock = new Set();
@@ -499,7 +537,7 @@ class SyncEngine {
                 orderIdsToLock.add(gridOrder.orderId);
             }
             // Also lock ACTIVE/PARTIAL orders that might transition to/from SPREAD
-            if (gridOrder.state === ORDER_STATES.ACTIVE || gridOrder.state === ORDER_STATES.PARTIAL) {
+            if (gridOrder.state === constants_1.ORDER_STATES.ACTIVE || gridOrder.state === constants_1.ORDER_STATES.PARTIAL) {
                 orderIdsToLock.add(gridOrder.id);
             }
         }
@@ -527,9 +565,9 @@ class SyncEngine {
         // Lock orders before reconciliation
         mgr.lockOrders(orderIdsToLockFinal);
         // Keep lock leases alive during long reconciliation runs.
-        const refreshEveryMs = Math.max(TIMING.LOCK_REFRESH_MIN_MS, Math.floor(TIMING.LOCK_TIMEOUT_MS / 3));
+        const refreshEveryMs = Math.max(constants_1.TIMING.LOCK_REFRESH_MIN_MS, Math.floor(constants_1.TIMING.LOCK_TIMEOUT_MS / 3));
         const refreshLockLeases = () => {
-            const expiresAt = Date.now() + TIMING.LOCK_TIMEOUT_MS;
+            const expiresAt = Date.now() + constants_1.TIMING.LOCK_TIMEOUT_MS;
             for (const id of orderIdsToLockFinal) {
                 mgr.shadowOrderIds.set(id, expiresAt);
             }
@@ -630,7 +668,7 @@ class SyncEngine {
                     continue;
                 }
                 else {
-                    const priceTolerance = calculatePriceTolerance(gridOrder.price, gridOrder.size, gridOrder.type, mgr.assets);
+                    const priceTolerance = (0, math_1.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) {
@@ -645,14 +683,14 @@ class SyncEngine {
                     }
                 }
                 // Chain side determines which precision applies to for_sale.
-                const precision = (chainOrder.type === ORDER_TYPES.SELL) ? assetAPrecision : assetBPrecision;
-                const currentSizeInt = floatToBlockchainInt(gridOrder.size, precision);
-                const chainSizeInt = floatToBlockchainInt(chainOrder.size, precision);
+                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);
                 if (currentSizeInt !== chainSizeInt) {
-                    const newSize = blockchainToFloat(chainSizeInt, precision, true);
-                    const newInt = floatToBlockchainInt(newSize, precision);
+                    const newSize = (0, math_1.blockchainToFloat)(chainSizeInt, precision);
+                    const newInt = (0, math_1.floatToBlockchainInt)(newSize, precision);
                     if (newInt > 0) {
-                        const nextOrder = await applyChainSizeToGridOrder(mgr, updatedOrder, newSize);
+                        const nextOrder = await (0, order_1.applyChainSizeToGridOrder)(mgr, updatedOrder, newSize);
                         if (nextOrder) {
                             // Merge updated state if size actually changed
                             updatedOrder = { ...updatedOrder, ...nextOrder };
@@ -662,19 +700,19 @@ class SyncEngine {
                         // downtime fills detected during open-orders sync must also update
                         // state so that checkWindowDust can identify dust orders.
                         updatedOrder.state = (chainSizeInt < currentSizeInt)
-                            ? ORDER_STATES.PARTIAL
+                            ? constants_1.ORDER_STATES.PARTIAL
                             : gridOrder.state;
                         await mgr._applyOrderUpdate(updatedOrder, 'sync-pass1-partial', { skipAccounting: skipAccounting, fee: 0 });
                     }
                     else {
-                        const spreadOrder = convertToSpreadPlaceholder(gridOrder);
+                        const spreadOrder = (0, order_1.convertToSpreadPlaceholder)(gridOrder);
                         await mgr._applyOrderUpdate(spreadOrder, 'sync-pass1-filled', { skipAccounting: skipAccounting, fee: 0 });
                         filledOrders.push(spreadOrder);
                         updatedOrders.push(spreadOrder);
                     }
                 }
             }
-            else if (gridOrder.state === ORDER_STATES.ACTIVE || gridOrder.state === ORDER_STATES.PARTIAL) {
+            else if (gridOrder.state === constants_1.ORDER_STATES.ACTIVE || gridOrder.state === constants_1.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
@@ -710,14 +748,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 === ORDER_STATES.PARTIAL;
-                    if (!isGhost && commitAge < TIMING.SYNC_LOCK_TIMEOUT_MS) {
+                    const isGhost = gridOrder.size <= 0 && gridOrder.state === constants_1.ORDER_STATES.PARTIAL;
+                    if (!isGhost && commitAge < constants_1.TIMING.SYNC_LOCK_TIMEOUT_MS) {
                         continue;
                     }
                 }
                 const currentGridOrder = mgr.orders.get(gridOrder.id) || gridOrder;
                 const hadOrderId = Boolean(currentGridOrder?.orderId);
-                const spreadOrder = convertToSpreadPlaceholder(currentGridOrder);
+                const spreadOrder = (0, order_1.convertToSpreadPlaceholder)(currentGridOrder);
                 await mgr._applyOrderUpdate(spreadOrder, 'sync-cleanup-phantom', { skipAccounting: skipAccounting, fee: 0 });
                 // Only genuine disappearances (had orderId) count as fills.
                 if (hadOrderId) {
@@ -736,11 +774,15 @@ class SyncEngine {
             // this orphan is a stale duplicate — skip adoption so the reconcile
             // layer cancels it. Size is irrelevant; any duplicate violates the
             // invariant. Check BEFORE any adoption attempt, including the first
-            // match (line 684), because a VIRTUAL slot at a nearby price can
+            // match (line 684), because a VIRTUAL slot at a nearby price can
             // otherwise silently adopt the orphan before the duplicate guard runs.
-            const duplicatePriceOrder = Array.from(mgr.orders.values()).find((o) => o.type === chainOrder.type &&
-                isOrderPlaced(o) &&
-                Math.abs(o.price - chainOrder.price) <= calculatePriceTolerance(Math.min(o.price, chainOrder.price), Math.max(o.size, chainOrder.size), o.type, mgr.assets));
+            const duplicatePriceOrder = Array.from(mgr.orders.values()).find((o) => {
+                const co = chainOrder;
+                return o.type === co.type &&
+                    (0, order_1.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);
+            });
             if (duplicatePriceOrder) {
                 unmatchedChainOrders.push({
                     chainOrderId,
@@ -768,10 +810,10 @@ class SyncEngine {
                 });
                 continue;
             }
-            const match = findMatchingGridOrderByOpenOrder({ orderId: chainOrderId, type: chainOrder.type, price: chainOrder.price, size: chainOrder.size }, {
+            const match = (0, order_1.findMatchingGridOrderByOpenOrder)({ orderId: chainOrderId, type: chainOrder.type, price: chainOrder.price, size: chainOrder.size }, {
                 orders: mgr.orders,
                 assets: mgr.assets,
-                calcToleranceFn: (p, s, t) => calculatePriceTolerance(p, s, t, mgr.assets),
+                calcToleranceFn: (p, s, t) => (0, math_1.calculatePriceTolerance)(p, s, t, mgr.assets),
                 logger: mgr.logger,
                 allowSmallerChainSize: true,
                 requireAvailableSlot: true,
@@ -779,10 +821,10 @@ class SyncEngine {
             });
             if (match && !matchedGridOrderIds.has(match.id)) {
                 let bestMatch = { ...match };
-                const wasVirtual = match.state === ORDER_STATES.VIRTUAL;
-                const wasPartial = match.state === ORDER_STATES.PARTIAL;
+                const wasVirtual = match.state === constants_1.ORDER_STATES.VIRTUAL;
+                const wasPartial = match.state === constants_1.ORDER_STATES.PARTIAL;
                 bestMatch.orderId = chainOrderId;
-                bestMatch.state = wasVirtual ? ORDER_STATES.ACTIVE : match.state;
+                bestMatch.state = wasVirtual ? constants_1.ORDER_STATES.ACTIVE : match.state;
                 const bestMatchRaw = rawChainOrders.get(chainOrderId);
                 bestMatch.rawOnChain = bestMatchRaw
                     ? { ...bestMatchRaw, fetchedAt: Date.now() }
@@ -797,43 +839,43 @@ class SyncEngine {
                 // deletes btsFeeState when nextDeferred is 0, so setting it to 0 here
                 // would be an unnecessary set-then-delete cycle.
                 if (bestMatch.rawOnChain) {
-                    const rawDeferredFee = toFiniteNumber(bestMatch.rawOnChain.deferred_fee, null);
+                    const rawDeferredFee = toFiniteNumber(bestMatch.rawOnChain.deferred_fee, undefined);
                     if (rawDeferredFee !== null && rawDeferredFee > 0) {
-                        bestMatch.btsFeeState = { deferredFee: blockchainToFloat(rawDeferredFee, BTS_PRECISION) };
+                        bestMatch.btsFeeState = { deferredFee: (0, math_1.blockchainToFloat)(rawDeferredFee, constants_1.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 = ORDER_STATES.PARTIAL;
+                        bestMatch.state = constants_1.ORDER_STATES.PARTIAL;
                     }
                 }
-                const precision = (bestMatch.type === ORDER_TYPES.SELL) ? assetAPrecision : assetBPrecision;
-                const targetInt = floatToBlockchainInt(match.size, precision);
-                const chainInt = floatToBlockchainInt(chainOrder.size, precision);
+                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);
                 if (targetInt !== chainInt) {
-                    const updated = await applyChainSizeToGridOrder(mgr, bestMatch, chainOrder.size);
+                    const updated = await (0, order_1.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 !== ORDER_STATES.PARTIAL) {
-                                bestMatch.state = ORDER_STATES.ACTIVE;
+                            if (bestMatch.state !== constants_1.ORDER_STATES.PARTIAL) {
+                                bestMatch.state = constants_1.ORDER_STATES.ACTIVE;
                             }
                         }
                         else if (chainInt < targetInt) {
-                            bestMatch.state = ORDER_STATES.PARTIAL;
+                            bestMatch.state = constants_1.ORDER_STATES.PARTIAL;
                         }
                         else if (wasPartial) {
-                            bestMatch.state = ORDER_STATES.PARTIAL;
+                            bestMatch.state = constants_1.ORDER_STATES.PARTIAL;
                         }
                         else {
-                            bestMatch.state = ORDER_STATES.ACTIVE;
+                            bestMatch.state = constants_1.ORDER_STATES.ACTIVE;
                         }
                     }
                     else {
-                        const spreadOrder = convertToSpreadPlaceholder(bestMatch);
+                        const spreadOrder = (0, order_1.convertToSpreadPlaceholder)(bestMatch);
                         filledOrders.push({ ...bestMatch });
                         await mgr._applyOrderUpdate(spreadOrder, 'sync-pass2-filled', { skipAccounting: skipAccounting, fee: 0 });
                         updatedOrders.push(spreadOrder);
@@ -842,7 +884,7 @@ class SyncEngine {
                     }
                 }
                 else if (wasPartial) {
-                    bestMatch.state = ORDER_STATES.PARTIAL;
+                    bestMatch.state = constants_1.ORDER_STATES.PARTIAL;
                 }
                 await mgr._applyOrderUpdate(bestMatch, 'sync-pass2-orphan', { skipAccounting: skipAccounting, fee: 0 });
                 updatedOrders.push(bestMatch);
@@ -879,23 +921,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 = findMatchingGridOrderByOpenOrder({ orderId: chainOrderId, type: chainOrder.type, price: chainOrder.price, size: chainOrder.size }, {
+                const adoptedSlot = (0, order_1.findMatchingGridOrderByOpenOrder)({ orderId: chainOrderId, type: chainOrder.type, price: chainOrder.price, size: chainOrder.size }, {
                     orders: mgr.orders,
                     assets: mgr.assets,
-                    calcToleranceFn: (p, s, t) => calculatePriceTolerance(p, s, t, mgr.assets),
+                    calcToleranceFn: (p, s, t) => (0, math_1.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 === ORDER_TYPES.SELL) ? assetAPrecision : assetBPrecision;
-                    const chainInt = floatToBlockchainInt(chainOrder.size, precision);
+                    const precision = (chainOrder.type === constants_1.ORDER_TYPES.SELL) ? assetAPrecision : assetBPrecision;
+                    const chainInt = (0, math_1.floatToBlockchainInt)(chainOrder.size, precision);
                     const adoptedRaw = rawChainOrders.get(chainOrderId);
-                    const adoptedState = chainInt > 0 ? ORDER_STATES.PARTIAL : ORDER_STATES.VIRTUAL;
+                    const adoptedState = chainInt > 0 ? constants_1.ORDER_STATES.PARTIAL : constants_1.ORDER_STATES.VIRTUAL;
                     const adoptedBtsFeeState = (adoptedRaw) ? (() => {
-                        const rawFee = toFiniteNumber(adoptedRaw.deferred_fee, null);
-                        return rawFee !== null && rawFee > 0 ? { deferredFee: blockchainToFloat(rawFee, BTS_PRECISION) } : undefined;
+                        const rawFee = toFiniteNumber(adoptedRaw.deferred_fee, undefined);
+                        return rawFee !== null && rawFee > 0 ? { deferredFee: (0, math_1.blockchainToFloat)(rawFee, constants_1.BTS_PRECISION) } : undefined;
                     })() : undefined;
                     const adoptedOrder = {
                         ...adoptedSlot,
@@ -917,9 +959,9 @@ class SyncEngine {
                         `size=${chainOrder.size}) adopted into slot ${adoptedSlot.id} (was ${adoptedSlot.type})`, 'warn');
                 }
                 else {
-                    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 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 unmatchedEntry = {
                         chainOrderId,
                         type: chainOrder.type,
@@ -951,7 +993,7 @@ class SyncEngine {
     // ------------------------------------------------------------------
     _findMatchingGridOrder(mgr, orderId) {
         for (const gridOrder of mgr.orders.values()) {
-            if (gridOrder.orderId === orderId && (gridOrder.state === ORDER_STATES.ACTIVE || gridOrder.state === ORDER_STATES.PARTIAL)) {
+            if (gridOrder.orderId === orderId && (gridOrder.state === constants_1.ORDER_STATES.ACTIVE || gridOrder.state === constants_1.ORDER_STATES.PARTIAL)) {
                 return gridOrder;
             }
         }
@@ -960,23 +1002,24 @@ class SyncEngine {
     _computeFillContext(mgr, matchedGridOrder, paysAssetId, paysAmountRaw) {
         const orderType = matchedGridOrder.type;
         const currentSize = toFiniteNumber(matchedGridOrder.size);
-        const precision = (orderType === ORDER_TYPES.SELL) ? mgr.assets.assetA.precision : mgr.assets.assetB.precision;
+        const precision = (orderType === constants_1.ORDER_TYPES.SELL) ? mgr.assets.assetA.precision : mgr.assets.assetB.precision;
         let filledAmount = 0;
-        if (orderType === ORDER_TYPES.SELL) {
+        if (orderType === constants_1.ORDER_TYPES.SELL) {
             if (paysAssetId === mgr.assets.assetA.id)
-                filledAmount = blockchainToFloat(paysAmountRaw, precision, true);
+                filledAmount = (0, math_1.blockchainToFloat)(paysAmountRaw, precision);
         }
         else {
             if (paysAssetId === mgr.assets.assetB.id)
-                filledAmount = blockchainToFloat(paysAmountRaw, precision, true);
+                filledAmount = (0, math_1.blockchainToFloat)(paysAmountRaw, precision);
         }
-        const currentSizeIntFromGrid = floatToBlockchainInt(currentSize, precision);
-        const rawForSaleInt = toFiniteNumber(matchedGridOrder?.rawOnChain?.for_sale, null);
+        const currentSizeIntFromGrid = (0, math_1.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;
         return { orderType, currentSize, precision, filledAmount, currentSizeIntFromGrid, rawForSaleInt, driftSignal };
     }
     async _computeFillTransitionResult(mgr, params) {
-        const { matchedGridOrder, orderType, precision, filledAmount, filledAmountInt, currentSizeIntFromGrid, rawForSaleInt, chainRefetched, chainConfirmsEmpty, effectiveRawForSale, blockNum, historyId, isMaker } = params;
+        const { matchedGridOrder, orderType, precision, filledAmount, filledAmountInt, currentSizeIntFromGrid, chainRefetched, chainConfirmsEmpty, effectiveRawForSale, blockNum, historyId, isMaker } = params;
         let resolvedChainConfirmsEmpty = chainConfirmsEmpty;
         if (chainRefetched && Number.isFinite(effectiveRawForSale) && Math.round(effectiveRawForSale) <= 0) {
             resolvedChainConfirmsEmpty = true;
@@ -985,7 +1028,7 @@ class SyncEngine {
             ? Math.max(0, Math.round(effectiveRawForSale))
             : currentSizeIntFromGrid;
         const newSizeInt = Math.max(0, currentSizeInt - filledAmountInt);
-        const newSize = blockchainToFloat(newSizeInt, precision, true);
+        const newSize = (0, math_1.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');
@@ -993,11 +1036,22 @@ class SyncEngine {
         const gridAlsoEmpty = currentSizeIntFromGrid <= 0;
         let isEffectivelyFull = resolvedChainConfirmsEmpty || gridAlsoEmpty;
         let ghostOrderId;
+        // P4: Inline dust detection — if remaining size is below the minimum
+        // absolute order size, treat as full fill to trigger rotation instead
+        // of leaving a sub-minimum remnant on chain that would accumulate as dust.
+        if (!isEffectivelyFull && newSize > 0) {
+            const minSize = (0, math_1.getMinAbsoluteOrderSize)(orderType, mgr.assets);
+            if (newSize < minSize) {
+                mgr.logger.log(`[SYNC] Order ${matchedGridOrder.orderId} (slot ${matchedGridOrder.id}) ` +
+                    `remaining size ${newSize} below minimum ${minSize}. Treating as full fill.`, 'info');
+                isEffectivelyFull = true;
+            }
+        }
         if (!isEffectivelyFull) {
-            const otherPrecision = (orderType === ORDER_TYPES.SELL) ? mgr.assets.assetB.precision : mgr.assets.assetA.precision;
+            const otherPrecision = (orderType === constants_1.ORDER_TYPES.SELL) ? mgr.assets.assetB.precision : mgr.assets.assetA.precision;
             const price = matchedGridOrder.price;
-            const otherSize = (orderType === ORDER_TYPES.SELL) ? newSize * price : newSize / price;
-            if (floatToBlockchainInt(otherSize, otherPrecision) <= 0) {
+            const otherSize = (orderType === constants_1.ORDER_TYPES.SELL) ? newSize * price : newSize / price;
+            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');
                 isEffectivelyFull = true;
                 ghostOrderId = matchedGridOrder.orderId;
@@ -1012,12 +1066,12 @@ class SyncEngine {
                 ghostUpdate = {
                     ...matchedGridOrder,
                     size: 0,
-                    state: ORDER_STATES.PARTIAL,
+                    state: constants_1.ORDER_STATES.PARTIAL,
                     orderId: ghostOrderId,
                 };
             }
             else {
-                fullUpdate = convertToSpreadPlaceholder(matchedGridOrder);
+                fullUpdate = (0, order_1.convertToSpreadPlaceholder)(matchedGridOrder);
             }
             filledOrderResult = { ...matchedGridOrder, blockNum, historyId, isMaker };
         }
@@ -1031,7 +1085,7 @@ class SyncEngine {
                 isMaker
             };
             const { btsFeeState, ...matchedWithoutDeferredFee } = matchedGridOrder;
-            let updatedOrder = { ...matchedWithoutDeferredFee, state: ORDER_STATES.PARTIAL };
+            let updatedOrder = { ...matchedWithoutDeferredFee, state: constants_1.ORDER_STATES.PARTIAL };
             if (updatedOrder.rawOnChain && updatedOrder.rawOnChain.for_sale !== undefined) {
                 const baselineForSale = (chainRefetched && Number.isFinite(effectiveRawForSale))
                     ? effectiveRawForSale
@@ -1043,7 +1097,7 @@ class SyncEngine {
                     fetchedAt: Date.now()
                 };
             }
-            const nextOrder = await applyChainSizeToGridOrder(mgr, updatedOrder, newSize);
+            const nextOrder = await (0, order_1.applyChainSizeToGridOrder)(mgr, updatedOrder, newSize);
             if (nextOrder) {
                 updatedOrder = { ...updatedOrder, ...nextOrder };
             }
@@ -1068,7 +1122,7 @@ class SyncEngine {
      */
     async syncFromFillHistory(fill, options = {}) {
         const mgr = this.manager;
-        const persistenceMode = resolveProcessedFillPersistenceMode(options);
+        const persistenceMode = (0, processed_fill_store_1.resolveProcessedFillPersistenceMode)(options);
         if (!fill || !fill.op || !fill.op[1])
             return { filledOrders: [], updatedOrders: [], partialFill: false };
         const fillOp = fill.op[1];
@@ -1079,7 +1133,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 = buildFillKey({ orderId, blockNum, historyId });
+        const fillKey = (0, order_1.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);
@@ -1119,7 +1173,7 @@ class SyncEngine {
                     try {
                         const fresh = await chainOrders.readSingleOrder(orderId, 3000);
                         if (fresh) {
-                            const freshForSale = toFiniteNumber(fresh.for_sale, null);
+                            const freshForSale = toFiniteNumber(fresh.for_sale, undefined);
                             if (Number.isFinite(freshForSale)) {
                                 effectiveRawForSale = freshForSale;
                                 chainRefetched = true;
@@ -1141,7 +1195,7 @@ class SyncEngine {
                     orderType: ctx.orderType,
                     precision: ctx.precision,
                     filledAmount: ctx.filledAmount,
-                    filledAmountInt: floatToBlockchainInt(ctx.filledAmount, ctx.precision),
+                    filledAmountInt: (0, math_1.floatToBlockchainInt)(ctx.filledAmount, ctx.precision),
                     currentSizeIntFromGrid: ctx.currentSizeIntFromGrid,
                     rawForSaleInt: ctx.rawForSaleInt,
                     chainRefetched,
@@ -1161,7 +1215,7 @@ class SyncEngine {
                             mgr.logger.log(`[SYNC] Failed to apply ghost fill state for order ${orderId}`, 'warn');
                         }
                         filledOrders.push(result.filledOrder);
-                        return { filledOrders, updatedOrders, partialFill: false, ghostOrderId: result.ghostOrderId };
+                        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 });
@@ -1201,9 +1255,9 @@ class SyncEngine {
      */
     async syncFromFillHistoryBatch(fills, options = {}) {
         const mgr = this.manager;
-        const persistenceMode = resolveProcessedFillPersistenceMode(options);
+        const persistenceMode = (0, processed_fill_store_1.resolveProcessedFillPersistenceMode)(options);
         if (!Array.isArray(fills) || fills.length === 0) {
-            return { filledOrders: [], updatedOrders: [], partialFill: false, ghostOrderIds: [] };
+            return { filledOrders: [], updatedOrders: [], partialFill: false };
         }
         // Phase 1: Extract & validate fill data
         const fillEntries = [];
@@ -1219,7 +1273,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 = buildFillKey({ orderId, blockNum, historyId });
+            const fillKey = (0, order_1.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;
@@ -1236,7 +1290,7 @@ class SyncEngine {
             });
         }
         if (fillEntries.length === 0) {
-            return { filledOrders: [], updatedOrders: [], partialFill: false, ghostOrderIds: [], requiresOpenOrdersSync: anyRequiresSync };
+            return { filledOrders: [], updatedOrders: [], partialFill: false, requiresOpenOrdersSync: anyRequiresSync };
         }
         // Phase 2: Lock all unique order IDs once
         const allOrderIds = [...new Set(fillEntries.map(e => e.orderId))];
@@ -1256,12 +1310,12 @@ class SyncEngine {
                         validEntries.push(entry);
                     }
                     catch (acctErr) {
-                        mgr.logger.log(`[SYNC] Accounting error for fill ${entry.fillKey}: ${acctErr.message}`, 'error');
+                        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, ghostOrderIds: [], requiresOpenOrdersSync: anyRequiresSync };
+                    return { filledOrders: [], updatedOrders: [], partialFill: false, requiresOpenOrdersSync: anyRequiresSync };
                 }
                 // Phase 4: Build per-fill context + identify drift candidates
                 const entryContexts = [];
@@ -1270,7 +1324,7 @@ class SyncEngine {
                 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, ghostOrderIds: [], requiresOpenOrdersSync: anyRequiresSync };
+                    return { filledOrders: [], updatedOrders: [], partialFill: false, requiresOpenOrdersSync: anyRequiresSync };
                 }
                 for (const entry of validEntries) {
                     const { orderId, paysAmountRaw, paysAssetId } = entry;
@@ -1290,7 +1344,7 @@ class SyncEngine {
                         orderType: ctx.orderType,
                         precision: ctx.precision,
                         filledAmount: ctx.filledAmount,
-                        filledAmountInt: floatToBlockchainInt(ctx.filledAmount, ctx.precision),
+                        filledAmountInt: (0, math_1.floatToBlockchainInt)(ctx.filledAmount, ctx.precision),
                         currentSizeIntFromGrid: ctx.currentSizeIntFromGrid,
                         rawForSaleInt: ctx.rawForSaleInt
                     });
@@ -1302,7 +1356,7 @@ class SyncEngine {
                         const batchResults = await chainOrders.batchReadOrders([...driftOrderIds], 3000);
                         for (const [orderId, freshOrder] of batchResults) {
                             if (freshOrder) {
-                                const freshForSale = toFiniteNumber(freshOrder.for_sale, null);
+                                const freshForSale = toFiniteNumber(freshOrder.for_sale, undefined);
                                 if (Number.isFinite(freshForSale)) {
                                     refetchMap.set(orderId, {
                                         chainConfirmsEmpty: Math.round(freshForSale) <= 0,
@@ -1343,7 +1397,6 @@ class SyncEngine {
                 const gridUpdates = [];
                 const filledOrders = [];
                 const updatedOrders = [];
-                const ghostOrderIds = [];
                 let anyPartialFill = false;
                 for (const ctx of entryContexts) {
                     const { entry, matchedGridOrder, orderType, precision, filledAmount, filledAmountInt, currentSizeIntFromGrid, rawForSaleInt } = ctx;
@@ -1372,7 +1425,6 @@ class SyncEngine {
                             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' });
-                            ghostOrderIds.push(result.ghostOrderId);
                         }
                         else {
                             mgr.logger.log(`[SYNC] Full fill for order ${orderId} (slot ${matchedGridOrder.id}).`, 'info');
@@ -1399,7 +1451,7 @@ class SyncEngine {
                         mgr.logger.log('[SYNC] Batch grid update failed for some fills; next sync cycle will reconcile', 'warn');
                     }
                 }
-                return { filledOrders, updatedOrders, partialFill: anyPartialFill, ghostOrderIds, requiresOpenOrdersSync: anyRequiresSync };
+                return { filledOrders, updatedOrders, partialFill: anyPartialFill, requiresOpenOrdersSync: anyRequiresSync };
             }
             finally {
                 await mgr.resumeFundRecalc();
@@ -1480,25 +1532,25 @@ class SyncEngine {
                             const isRotation = !!existingOrder;
                             // For rotation: transition the old order to VIRTUAL, freeing its capital
                             if (isRotation && existingOrder) {
-                                if (!isOrderVirtual(existingOrder)) {
-                                    const oldVirtualOrder = { ...virtualizeOrder(existingOrder), size: 0 };
+                                if (!(0, order_1.isOrderVirtual)(existingOrder)) {
+                                    const oldVirtualOrder = { ...(0, order_1.virtualizeOrder)(existingOrder), size: 0 };
                                     await mgr._applyOrderUpdate(oldVirtualOrder, 'rotation-cleanup', {
                                         skipAccounting: chainData.skipAccounting || false,
                                         fee: 0
                                     });
                                 }
-                                else if (hasOnChainId(existingOrder)) {
+                                else if ((0, order_1.hasOnChainId)(existingOrder)) {
                                     // Already VIRTUAL but still has orderId (from rebalance)
                                     // Just clear the orderId to reflect blockchain state
-                                    const clearedOrder = { ...virtualizeOrder(existingOrder), size: 0 };
+                                    const clearedOrder = { ...(0, order_1.virtualizeOrder)(existingOrder), size: 0 };
                                     await mgr._applyOrderUpdate(clearedOrder, 'fill-cleanup', {
                                         skipAccounting: chainData.skipAccounting || false,
                                         fee: 0
                                     });
                                 }
                             }
-                            const newState = isPartialPlacement ? ORDER_STATES.PARTIAL : ORDER_STATES.ACTIVE;
-                            const normalizedExpectedType = (expectedType === ORDER_TYPES.BUY || expectedType === ORDER_TYPES.SELL)
+                            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)
                                 ? expectedType
                                 : null;
                             const updatedOrder = {
@@ -1548,10 +1600,10 @@ class SyncEngine {
                 const clearSize = !!chainData.clearSize;
                 let btsFeeData;
                 try {
-                    btsFeeData = getAssetFees('BTS');
+                    btsFeeData = (0, math_1.getAssetFees)('BTS');
                 }
                 catch (err) {
-                    mgr.logger?.log?.(`[FILL-FEE] Failed to load BTS cancel fee cache: ${err.message}. Using zero-fee fallback.`, 'warn');
+                    mgr.logger?.log?.(`[FILL-FEE] Failed to load BTS cancel fee cache: ${(0, errors_1.getErrorMessage)(err)}. Using zero-fee fallback.`, 'warn');
                     btsFeeData = {
                         total: 0,
                         createFee: 0,
@@ -1564,7 +1616,7 @@ class SyncEngine {
                     };
                 }
                 const runCancel = async () => {
-                    const gridOrder = findMatchingGridOrderByOpenOrder({ orderId }, { orders: mgr.orders, assets: mgr.assets, calcToleranceFn: (p, s, t) => calculatePriceTolerance(p, s, t, mgr.assets), logger: mgr.logger });
+                    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 });
                     if (gridOrder) {
                         // Lock both chain orderId and grid order ID to prevent concurrent modifications
                         const orderIds = [orderId, gridOrder.id].filter(Boolean);
@@ -1574,8 +1626,8 @@ class SyncEngine {
                             const currentGridOrder = mgr.orders.get(gridOrder.id);
                             if (currentGridOrder && currentGridOrder.orderId === orderId) {
                                 const nextOrder = clearSize
-                                    ? { ...virtualizeOrder(currentGridOrder), size: 0 }
-                                    : virtualizeOrder(currentGridOrder);
+                                    ? { ...(0, order_1.virtualizeOrder)(currentGridOrder), size: 0 }
+                                    : (0, order_1.virtualizeOrder)(currentGridOrder);
                                 await mgr._applyOrderUpdate(nextOrder, 'cancel-order', {
                                     skipAccounting: false,
                                     fee: btsFeeData?.cancelFee || 0
@@ -1589,7 +1641,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 = (mgr.config.assetA === 'BTS') ? ORDER_TYPES.SELL : (mgr.config.assetB === 'BTS') ? ORDER_TYPES.BUY : null;
+                        const btsSide = (mgr.config.assetA === 'BTS') ? constants_1.ORDER_TYPES.SELL : (mgr.config.assetB === 'BTS') ? constants_1.ORDER_TYPES.BUY : null;
                         if (btsSide && btsFeeData?.cancelFee > 0) {
                             await mgr.accountant.adjustTotalBalance(btsSide, -btsFeeData.cancelFee, 'cancel-order-unmatched-fee');
                         }
@@ -1678,7 +1730,6 @@ class SyncEngine {
     async fetchAccountBalancesAndSetTotals() {
         const mgr = this.manager;
         try {
-            const { BitShares } = require('../bitshares_client');
             if (!BitShares || !BitShares.db)
                 return;
             const accountIdOrName = mgr.accountId || mgr.account || null;
@@ -1688,17 +1739,16 @@ class SyncEngine {
                 await this.initializeAssets();
             }
             catch (err) {
-                mgr.logger.log(`[SYNC] initializeAssets failed: ${err.message}`, 'warn');
+                mgr.logger.log(`[SYNC] initializeAssets failed: ${(0, errors_1.getErrorMessage)(err)}`, 'warn');
             }
             const assetAId = mgr.assets?.assetA?.id;
             const assetBId = mgr.assets?.assetB?.id;
             if (!assetAId || !assetBId)
                 return;
-            const { NATIVE_CLIENT } = require('../constants');
             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(NATIVE_CLIENT.CHAIN.CORE_ASSET_ID);
+                assetList.push(constants_2.NATIVE_CLIENT.CHAIN.CORE_ASSET_ID);
             }
             const lookup = await chainOrders.getOnChainAssetBalances(accountIdOrName, assetList);
             const aInfo = lookup?.[assetAId] || lookup?.[mgr.config.assetA];
@@ -1708,14 +1758,14 @@ class SyncEngine {
             }
             // Store BTS balance for non-BTS pairs
             if (mgr.config.assetA !== 'BTS' && mgr.config.assetB !== 'BTS') {
-                const btsInfo = lookup?.[NATIVE_CLIENT.CHAIN.CORE_ASSET_ID];
+                const btsInfo = lookup?.[constants_2.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: ${err.message}`, 'warn');
+            mgr.logger.log(`Failed to fetch on-chain balances: ${(0, errors_1.getErrorMessage)(err)}`, 'warn');
         }
     }
     /**
@@ -1767,10 +1817,9 @@ class SyncEngine {
         const mgr = this.manager;
         if (mgr.assets)
             return;
-        const { BitShares } = require('../bitshares_client');
         const fetchAssetWithFallback = async (symbol, side) => {
             try {
-                return await lookupAsset(BitShares, symbol);
+                return await (0, system_1.lookupAsset)(BitShares, symbol);
             }
             catch (err) {
                 // If blockchain lookup fails, check for persisted fallback
@@ -1778,7 +1827,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}: ${err.message}. Persisted data: id=${assetData.id}, precision=${assetData.precision} — refusing stale fallback`, 'error');
+                        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');
                     }
                 }
                 throw err;
@@ -1791,10 +1840,11 @@ class SyncEngine {
             };
         }
         catch (err) {
-            mgr.logger.log(`Asset metadata lookup failed: ${err.message}`, 'error');
+            mgr.logger.log(`Asset metadata lookup failed: ${(0, errors_1.getErrorMessage)(err)}`, 'error');
             throw err;
         }
     }
 }
+exports.default = SyncEngine;
 module.exports = SyncEngine;
 //# sourceMappingURL=sync_engine.js.map