dexbot 1.5.0 → 1.5.2

package/dist/modules/order/sync_engine.js

@@ -95,16 +95,84 @@
  */
 import { ORDER_TYPES, ORDER_STATES, TIMING, BTS_PRECISION } from '../constants.js';
 import * as Format from './format.js';
-import { lookupAsset } from './utils/system.js';
+import { lookupAsset, sleep, resolveAccountRef } from './utils/system.js';
 import * as chainOrders from '../chain_orders.js';
 import * as client from '../bitshares_client.js';
 const { BitShares } = client;
 import { NATIVE_CLIENT } from '../constants.js';
 const { toFiniteNumber } = Format;
-import { blockchainToFloat, floatToBlockchainInt, calculatePriceTolerance, getAssetFees, getBtsSide, slotIndexForPrice, isSlotInRail, priceSlotEqual } from './utils/math.js';
+import { blockchainToFloat, floatToBlockchainInt, calculatePriceTolerance, getAssetFees, getBtsSide, getSellStartIdx, slotIndexForPrice, isSlotInRail, isSlotIndexInGapBand, priceSlotEqual } from './utils/math.js';
 import { parseChainOrder, findMatchingGridOrderByOpenOrder, applyChainSizeToGridOrder, convertToSpreadPlaceholder, virtualizeOrder, buildFillKey, isOrderPlaced, hasOnChainId, isOrderVirtual, resolveSpreadOrderSide, duplicateOrphanLogInfo } from './utils/order.js';
+import { parseSlotIndex } from './utils/slot.js';
 import { resolveProcessedFillPersistenceMode } from './processed_fill_store.js';
 import { getErrorMessage } from '../utils/errors.js';
+/**
+ * Confirming re-read for the suspect-empty-read guard: after
+ * SYNC_SUSPECT_EMPTY_READ_LIMIT consecutive 0-order snapshots with placed
+ * grid orders still present, one more read after
+ * SYNC_EMPTY_READ_CONFIRM_DELAY_MS decides whether the account is genuinely
+ * empty. A lagging node serves consecutive empties, so the count alone is
+ * not authoritative.
+ *
+ * Test seam: when manager._confirmEmptyReadFn is a function it is used
+ * instead of the chain read (must resolve to a raw order array, or null
+ * when the re-read itself is ambiguous). A throwing seam is 'ambiguous'.
+ *
+ * @param {Object} mgr - OrderManager instance (accountId, config, logger).
+ * @returns {Promise<string>} 'confirmed' (still empty — accept),
+ *   'contradicted' (non-empty — reset counter, refuse this round),
+ *   'ambiguous' (truncated/read-error — refuse, re-confirm next round), or
+ *   'unavailable' (no chain identity or dry-run — caller falls back to the
+ *   legacy count-based acceptance, preserving unit-test semantics).
+ */
+async function confirmSuspectEmptyRead(mgr) {
+    try {
+        if (mgr?.config?.dryRun)
+            return 'unavailable';
+        const seam = mgr?._confirmEmptyReadFn;
+        const delay = Math.max(0, Number(TIMING.SYNC_EMPTY_READ_CONFIRM_DELAY_MS) || 0);
+        if (typeof seam === 'function') {
+            if (delay > 0)
+                await sleep(delay);
+            let fresh = null;
+            try {
+                fresh = await seam();
+            }
+            catch {
+                return 'ambiguous';
+            }
+            if (fresh === null || fresh === undefined)
+                return 'ambiguous';
+            if (Array.isArray(fresh) && fresh.length > 0)
+                return 'contradicted';
+            return 'confirmed';
+        }
+        let accountRef = null;
+        try {
+            accountRef = resolveAccountRef(mgr, null);
+        }
+        catch {
+            return 'unavailable';
+        }
+        if (!accountRef)
+            return 'unavailable';
+        if (delay > 0)
+            await sleep(delay);
+        const fresh = await chainOrders.readOpenOrdersGuarded(chainOrders, accountRef, {
+            log: (message, level) => mgr?.logger?.log?.(message, level),
+            label: 'SYNC-CONFIRM',
+            detail: 'suspect-empty confirm re-read',
+        });
+        if (fresh === null)
+            return 'ambiguous';
+        if (Array.isArray(fresh) && fresh.length > 0)
+            return 'contradicted';
+        return 'confirmed';
+    }
+    catch {
+        return 'ambiguous';
+    }
+}
 function describeNearestAdoptionCandidates(mgr, chainOrder, precision, calcTolerance, matchedGridOrderIds = null) {
     if (!mgr?.orders || !chainOrder || typeof precision !== 'number')
         return 'candidate diagnostics unavailable';
@@ -200,6 +268,15 @@ async function adoptChainOrderIntoSlot(mgr, slot, chainOrder, chainOrderId, rawC
     let bestMatch = { ...slot };
     const wasVirtual = slot.state === ORDER_STATES.VIRTUAL;
     const wasPartial = slot.state === ORDER_STATES.PARTIAL;
+    // SPREAD slots are legitimate adoption targets (typeCompat allows them),
+    // but the slot must be re-typed to the real on-chain side BEFORE activation:
+    // validateOrder treats SPREAD + orderId/on-chain state as fatal
+    // ILLEGAL_SPREAD_STATE, and the size precision below depends on the
+    // resolved side. Every other activation path (COW rotation destinations,
+    // legacy fallback adoption, grid load) performs the same re-type.
+    if (bestMatch.type === ORDER_TYPES.SPREAD && (chainOrder.type === ORDER_TYPES.BUY || chainOrder.type === ORDER_TYPES.SELL)) {
+        bestMatch.type = chainOrder.type;
+    }
     bestMatch.orderId = chainOrderId;
     bestMatch.state = wasVirtual ? ORDER_STATES.ACTIVE : slot.state;
     const bestMatchRaw = rawChainOrders.get(chainOrderId);
@@ -233,8 +310,17 @@ async function adoptChainOrderIntoSlot(mgr, slot, chainOrder, chainOrderId, rawC
         }
         else {
             const spreadOrder = convertToSpreadPlaceholder(bestMatch);
+            const applied = await mgr._applyOrderUpdate(spreadOrder, 'sync-pass2-filled', { skipAccounting: skipAccounting, fee: 0 });
+            if (applied === false) {
+                // Rejected adoption must not poison the slot for the next
+                // chain order: the slot was marked matched above, so release
+                // it — B's adoption re-fails the same validation and gets
+                // the existing cancelOnly handling if the rejection was
+                // slot-specific.
+                matchedGridOrderIds.delete(bestMatch.id);
+                return false;
+            }
             filledOrders.push({ ...bestMatch });
-            await mgr._applyOrderUpdate(spreadOrder, 'sync-pass2-filled', { skipAccounting: skipAccounting, fee: 0 });
             updatedOrders.push(spreadOrder);
             chainOrderIdsOnGrid.add(chainOrderId);
             return true; // filled path
@@ -243,10 +329,16 @@ async function adoptChainOrderIntoSlot(mgr, slot, chainOrder, chainOrderId, rawC
     else if (wasPartial) {
         bestMatch.state = ORDER_STATES.PARTIAL;
     }
-    await mgr._applyOrderUpdate(bestMatch, 'sync-pass2-orphan', { skipAccounting: skipAccounting, fee: 0 });
+    const applied = await mgr._applyOrderUpdate(bestMatch, 'sync-pass2-orphan', { skipAccounting: skipAccounting, fee: 0 });
+    if (applied === false) {
+        // Same un-poisoning as the filled path above: the slot counts as
+        // matched only once the update lands.
+        matchedGridOrderIds.delete(bestMatch.id);
+        return false;
+    }
     updatedOrders.push(bestMatch);
     chainOrderIdsOnGrid.add(chainOrderId);
-    return false;
+    return true;
 }
 function computeOutOfToleranceDriftTag(mgr, chainOrder, calcToleranceFn) {
     if (!mgr?.orders || !chainOrder)
@@ -567,7 +659,8 @@ class SyncEngine {
         // ("phantom" resets). Refuse to reconcile on a
         // suspect empty; the guard is self-expiring: after
         // TIMING.SYNC_SUSPECT_EMPTY_READ_LIMIT consecutive empty reads the
-        // account really is empty and the sync accepts it. Any non-empty read
+        // account really is empty and the sync accepts it — but only after one
+        // confirming re-read (see below). Any non-empty read
         // resets the counter.
         if (parsedChainOrders.size === 0) {
             const gridOrderIds = Array.from(mgr.orders.values()).filter((o) => o?.orderId).length;
@@ -583,7 +676,33 @@ class SyncEngine {
                         `refusing reconciliation (phantom protection); accepting after ${limit} consecutive empties or next non-empty read`, 'warn');
                     return { filledOrders: [], updatedOrders: [], ordersNeedingCorrection: [], unmatchedChainOrders: [] };
                 }
-                mgr.logger?.log?.(`[SYNC] Empty read confirmed after ${suspect.count} consecutive attempts — reconciling to empty account`, 'warn');
+                // Limit reached: a lagging node serves CONSECUTIVE 0-order
+                // snapshots, so the count alone is not authoritative. Require
+                // one confirming re-read after SYNC_EMPTY_READ_CONFIRM_DELAY_MS
+                // before reconciling to empty; a contradicted re-read
+                // (non-empty) resets the counter and refuses this round (the
+                // next sync reconciles against the fresh snapshot), while an
+                // ambiguous re-read (truncated/read-error) refuses and retries
+                // the confirm on the next empty round.
+                const confirm = await confirmSuspectEmptyRead(mgr);
+                if (confirm === 'contradicted') {
+                    mgr.logger?.log?.(`[SYNC] Suspect empty read contradicted by confirm re-read with ${gridOrderIds} grid orderIds — ` +
+                        `resetting empty-read counter; reconciling on the next non-empty sync`, 'warn');
+                    mgr._suspectEmptyReads = { count: 0, firstAt: 0 };
+                    return { filledOrders: [], updatedOrders: [], ordersNeedingCorrection: [], unmatchedChainOrders: [] };
+                }
+                if (confirm === 'ambiguous') {
+                    mgr.logger?.log?.(`[SYNC] Suspect empty read confirm re-read ambiguous with ${gridOrderIds} grid orderIds — ` +
+                        `refusing reconciliation; re-confirming on the next empty read`, 'warn');
+                    mgr._suspectEmptyReads = { count: limit, firstAt: suspect.firstAt || Date.now() };
+                    return { filledOrders: [], updatedOrders: [], ordersNeedingCorrection: [], unmatchedChainOrders: [] };
+                }
+                // 'confirmed' (still empty on re-read) or 'unavailable' (no
+                // chain identity / dry-run — legacy count-based acceptance,
+                // preserving unit-test semantics): reconcile to empty.
+                mgr.logger?.log?.(`[SYNC] Empty read confirmed after ${suspect.count} consecutive attempts` +
+                    (confirm === 'unavailable' ? ' (no chain identity for confirm re-read)' : ' (+ confirming re-read)') +
+                    ` — reconciling to empty account`, 'warn');
                 mgr._suspectEmptyReads = { count: 0, firstAt: 0 };
             }
             else {
@@ -829,9 +948,17 @@ class SyncEngine {
                             && toFiniteNumber(reboundOrder.rawOnChain?.for_sale, 0) > 0) {
                             reboundOrder.state = ORDER_STATES.PARTIAL;
                         }
+                        const applied = await mgr._applyOrderUpdate(reboundOrder, 'sync-pass1-duplicate-swap', { skipAccounting: skipAccounting, fee: 0 });
+                        if (applied === false) {
+                            // Rejected rebind: the slot keeps its old binding
+                            // (set ops must run only after the apply lands), so
+                            // the old orderId stays matched on-grid and the swap
+                            // candidate stays unmatched → pass 2 cancels it.
+                            mgr.logger?.log?.(`[SYNC] Size tiebreak for ${gridOrder.id}: rebind to ${swapMatch.id} rejected — slot keeps ${gridOrder.orderId}; duplicate falls to pass 2`, 'warn');
+                            continue;
+                        }
                         chainOrderIdsOnGrid.delete(gridOrder.orderId);
                         chainOrderIdsOnGrid.add(swapMatch.id);
-                        await mgr._applyOrderUpdate(reboundOrder, 'sync-pass1-duplicate-swap', { skipAccounting: skipAccounting, fee: 0 });
                         updatedOrders.push(reboundOrder);
                         mgr.logger?.log?.(`[SYNC] Size tiebreak for ${gridOrder.id}: tracked order ${gridOrder.orderId} ` +
                             `(chain size ${chainOrder.size}) disagrees with booked size ${gridOrder.size}, but ` +
@@ -855,11 +982,23 @@ class SyncEngine {
                         updatedOrder.state = (chainSizeInt < currentSizeInt)
                             ? ORDER_STATES.PARTIAL
                             : gridOrder.state;
-                        await mgr._applyOrderUpdate(updatedOrder, 'sync-pass1-partial', { skipAccounting: skipAccounting, fee: 0 });
+                        const partialApplied = await mgr._applyOrderUpdate(updatedOrder, 'sync-pass1-partial', { skipAccounting: skipAccounting, fee: 0 });
+                        if (partialApplied === false) {
+                            // Rejected resize: the slot keeps its booked size;
+                            // divergence re-detects on the next sync.
+                            mgr.logger?.log?.(`[SYNC] Partial-size update for ${gridOrder.id} rejected — slot keeps booked size ${gridOrder.size}`, 'warn');
+                        }
                     }
                     else {
                         const spreadOrder = convertToSpreadPlaceholder(gridOrder);
-                        await mgr._applyOrderUpdate(spreadOrder, 'sync-pass1-filled', { skipAccounting: skipAccounting, fee: 0 });
+                        const filledApplied = await mgr._applyOrderUpdate(spreadOrder, 'sync-pass1-filled', { skipAccounting: skipAccounting, fee: 0 });
+                        if (filledApplied === false) {
+                            // Rejected virtualization must not book a fill:
+                            // neither the filled order nor the placeholder
+                            // update leaves this path.
+                            mgr.logger?.log?.(`[SYNC] Filled virtualization for ${gridOrder.id} rejected — fill NOT booked`, 'error');
+                            continue;
+                        }
                         // Push the filled order with its REAL side (chain order
                         // type), not the SPREAD placeholder: downstream fill
                         // processing (deriveTargetBoundary) derives boundary
@@ -913,7 +1052,14 @@ class SyncEngine {
                 const currentGridOrder = mgr.orders.get(gridOrder.id) || gridOrder;
                 const hadOrderId = Boolean(currentGridOrder?.orderId);
                 const spreadOrder = convertToSpreadPlaceholder(currentGridOrder);
-                await mgr._applyOrderUpdate(spreadOrder, 'sync-cleanup-phantom', { skipAccounting: skipAccounting, fee: 0 });
+                const phantomApplied = await mgr._applyOrderUpdate(spreadOrder, 'sync-cleanup-phantom', { skipAccounting: skipAccounting, fee: 0 });
+                if (phantomApplied === false) {
+                    // Rejected virtualization books no phantom fill: the slot
+                    // keeps its order and the disappearance re-detects next
+                    // sync.
+                    mgr.logger?.log?.(`[SYNC] Phantom cleanup for ${gridOrder.id} rejected — fill NOT booked`, 'warn');
+                    continue;
+                }
                 // Only genuine disappearances (had orderId) count as fills.
                 if (hadOrderId) {
                     // A SPREAD slot can carry an on-chain order (spread-correction
@@ -961,6 +1107,19 @@ class SyncEngine {
                 const slotId = `slot-${idx}`;
                 const gapSlots = genesis.gapSlots ?? mgr._gapSlots ?? 0;
                 const boundaryIdx = mgr.boundaryIdx;
+                // Pre-boundary sync: gap geometry is unknown, so adoption is
+                // deferred entirely — touch nothing (no adopt, no cancelOnly).
+                // The orphan stays visible to the crossing guards and the
+                // validate orphan layer via _lastUnmatchedChainOrders and is
+                // re-evaluated once the boundary commits. Accepted cost: a
+                // legitimate in-rail orphan waits one sync cycle
+                // post-boundary-commit before adoption. Strictly better than
+                // adopting a gap stray into the wrong slot.
+                if (boundaryIdx == null || !Number.isFinite(Number(boundaryIdx))) {
+                    unmatchedChainOrders.push({ chainOrderId, type: chainOrder.type, price: chainOrder.price, size: chainOrder.size, raw: rawChainOrders.get(chainOrderId), reason: 'boundary-unknown-deferred', candidateSlotId: slotId });
+                    mgr.logger?.log?.(`[SYNC] Orphaned chain order ${chainOrderId} (${chainOrder.type}, price=${chainOrder.price}, size=${chainOrder.size}) — NOT adopted: boundary unknown, deferred until boundary commits (nearest slot ${slotId})`, 'warn');
+                    continue;
+                }
                 // Duplicate-price guard becomes slotId equality: if placed order already occupies this slot
                 const occupying = mgr.orders.get(slotId);
                 if (occupying && isOrderPlaced(occupying) && occupying.type === chainOrder.type) {
@@ -970,8 +1129,9 @@ class SyncEngine {
                     queueCorrection({ gridOrder: occupying, chainOrderId, expectedPrice: chainOrder.price, size: chainOrder.size, type: chainOrder.type, isSurplus: true, cancelOnly: true });
                     continue;
                 }
-                // Gap exclusion: nearest slot in SPREAD gap → no adopt. When boundaryIdx == null (pre-boundary sync) the gap is unknown so we allow adoption — the next reconcile will relocate gap stray per §10 table's cancelOnly intent (documented hole).
-                if (boundaryIdx != null && Number.isFinite(Number(boundaryIdx))) {
+                // Gap exclusion: nearest slot in SPREAD gap → no adopt (boundary
+                // is known here — the pre-boundary case continued above).
+                {
                     const inRail = isSlotInRail(boundaryIdx, gapSlots, chainOrder.type, { id: slotId });
                     if (!inRail) {
                         unmatchedChainOrders.push({ chainOrderId, type: chainOrder.type, price: chainOrder.price, size: chainOrder.size, raw: rawChainOrders.get(chainOrderId), reason: 'no-available-nearest-slot', candidateSlotId: slotId });
@@ -991,7 +1151,14 @@ class SyncEngine {
                     unmatchedChainOrders.push({ chainOrderId, type: chainOrder.type, price: chainOrder.price, size: chainOrder.size, raw: rawChainOrders.get(chainOrderId), reason: 'no-available-nearest-slot', candidateSlotId: slotId });
                     continue;
                 }
-                await adoptChainOrderIntoSlot(mgr, slot, chainOrder, chainOrderId, rawChainOrders, matchedGridOrderIds, chainOrderIdsOnGrid, filledOrders, updatedOrders, skipAccounting);
+                const adopted = await adoptChainOrderIntoSlot(mgr, slot, chainOrder, chainOrderId, rawChainOrders, matchedGridOrderIds, chainOrderIdsOnGrid, filledOrders, updatedOrders, skipAccounting);
+                if (!adopted) {
+                    // Order update was rejected (fatal validation) — the chain
+                    // order stays untracked and must not dangle on the book.
+                    unmatchedChainOrders.push({ chainOrderId, type: chainOrder.type, price: chainOrder.price, size: chainOrder.size, raw: rawChainOrders.get(chainOrderId), reason: 'adoption-rejected', candidateSlotId: slotId });
+                    queueCorrection({ gridOrder: slot, chainOrderId, expectedPrice: chainOrder.price, size: chainOrder.size, type: chainOrder.type, isSurplus: true, cancelOnly: true });
+                    mgr.logger?.log?.(`[SYNC] Chain order ${chainOrderId} (${chainOrder.type}, price=${chainOrder.price}) NOT adopted into slot ${slotId}: order update rejected — queued for cancellation`, 'error');
+                }
                 continue;
             }
             // Legacy fallback when genesis unavailable (migration)
@@ -1008,7 +1175,12 @@ class SyncEngine {
             }
             const match = 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), logger: mgr.logger, allowSmallerChainSize: true, requireAvailableSlot: true, excludeGridOrderIds: matchedGridOrderIds });
             if (match && !matchedGridOrderIds.has(match.id)) {
-                await adoptChainOrderIntoSlot(mgr, match, chainOrder, chainOrderId, rawChainOrders, matchedGridOrderIds, chainOrderIdsOnGrid, filledOrders, updatedOrders, skipAccounting);
+                const adopted = await adoptChainOrderIntoSlot(mgr, match, chainOrder, chainOrderId, rawChainOrders, matchedGridOrderIds, chainOrderIdsOnGrid, filledOrders, updatedOrders, skipAccounting);
+                if (!adopted) {
+                    unmatchedChainOrders.push({ chainOrderId, type: chainOrder.type, price: chainOrder.price, size: chainOrder.size, raw: rawChainOrders.get(chainOrderId), reason: 'adoption-rejected', candidateSlotId: match.id });
+                    queueCorrection({ gridOrder: match, chainOrderId, expectedPrice: chainOrder.price, size: chainOrder.size, type: chainOrder.type, isSurplus: true, cancelOnly: true });
+                    mgr.logger?.log?.(`[SYNC] Chain order ${chainOrderId} (${chainOrder.type}, price=${chainOrder.price}) NOT adopted into slot ${match.id}: order update rejected — queued for cancellation`, 'error');
+                }
             }
             else if (match) {
                 mgr.logger?.log?.(`Warning: Orphan chain order ${chainOrderId} matched grid order ${match.id}, but grid order was already matched to another chain order. Queuing orphan for cancellation.`, 'warn');
@@ -1049,11 +1221,35 @@ class SyncEngine {
                         rawOnChain: adoptedRaw ? { ...adoptedRaw, fetchedAt: Date.now() } : adoptedRaw,
                         ...(adoptedBtsFeeState ? { btsFeeState: adoptedBtsFeeState } : {}),
                     };
+                    const applied = await mgr._applyOrderUpdate(adoptedOrder, 'sync-pass2-adopt-orphan', { skipAccounting: skipAccounting, fee: 0 });
+                    if (applied === false) {
+                        // Fatal rejection: parity with the genesis adoption path —
+                        // the slot must not be marked matched and the chain order
+                        // must not dangle untracked on the book.
+                        unmatchedChainOrders.push({ chainOrderId, type: chainOrder.type, price: chainOrder.price, size: chainOrder.size, raw: rawChainOrders.get(chainOrderId), reason: 'adoption-rejected', candidateSlotId: adoptedSlot.id });
+                        queueCorrection({ gridOrder: adoptedSlot, chainOrderId, expectedPrice: chainOrder.price, size: chainOrder.size, type: chainOrder.type, isSurplus: true, cancelOnly: true });
+                        mgr.logger?.log?.(`[SYNC] Chain order ${chainOrderId} (${chainOrder.type}, price=${chainOrder.price}) NOT adopted into slot ${adoptedSlot.id}: order update rejected — queued for cancellation`, 'error');
+                        continue;
+                    }
                     matchedGridOrderIds.add(adoptedSlot.id);
                     chainOrderIdsOnGrid.add(chainOrderId);
-                    await mgr._applyOrderUpdate(adoptedOrder, 'sync-pass2-adopt-orphan', { skipAccounting: skipAccounting, fee: 0 });
                     updatedOrders.push(adoptedOrder);
-                    mgr.logger?.log?.(`[SYNC] Orphaned chain order ${chainOrderId} (${chainOrder.type}, price=${chainOrder.price}, size=${chainOrder.size}) adopted into slot ${adoptedSlot.id} (was ${adoptedSlot.type})`, 'warn');
+                    // Phase 4 attribution: log the adoption slot's geometry
+                    // (idx vs frozen boundary/gap) so the next re-map incident
+                    // can tell an in-rail adoption from a gap-band re-map
+                    // without on-chain archaeology.
+                    let adoptGeo = '';
+                    try {
+                        const adoptIdx = parseSlotIndex(adoptedSlot.id);
+                        const adoptB = Number(mgr?.boundaryIdx);
+                        const adoptG = Number(mgr?._gapSlots);
+                        if (adoptIdx !== null && adoptIdx !== undefined && Number.isFinite(adoptB) && Number.isFinite(adoptG)) {
+                            const inBand = isSlotIndexInGapBand(adoptIdx, adoptB, adoptG);
+                            adoptGeo = ` geo(idx=${adoptIdx},boundary=${adoptB},gap=${adoptG},sellStart=${getSellStartIdx(adoptB, adoptG)},band=${inBand ? 'gap' : 'rail'})`;
+                        }
+                    }
+                    catch { /* geometry is diagnostic-only */ }
+                    mgr.logger?.log?.(`[SYNC] Orphaned chain order ${chainOrderId} (${chainOrder.type}, price=${chainOrder.price}, size=${chainOrder.size}) adopted into slot ${adoptedSlot.id} (was ${adoptedSlot.type})${adoptGeo}`, 'warn');
                 }
                 else {
                     const precision = (chainOrder.type === ORDER_TYPES.SELL) ? assetAPrecision : assetBPrecision;