dexbot 1.4.24 → 1.5.0

package/dist/modules/order/sync_engine.js

@@ -101,7 +101,7 @@ 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 } from './utils/math.js';
+import { blockchainToFloat, floatToBlockchainInt, calculatePriceTolerance, getAssetFees, getBtsSide, slotIndexForPrice, isSlotInRail, priceSlotEqual } 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';
@@ -196,6 +196,58 @@ function describeNearestAdoptionCandidates(mgr, chainOrder, precision, calcToler
  * @param {Function} calcToleranceFn - calculatePriceTolerance function
  * @returns {{candidateSlotId: string, candidateSlotPrice: number, priceDiff: number, tolerance: number}|null}
  */
+async function adoptChainOrderIntoSlot(mgr, slot, chainOrder, chainOrderId, rawChainOrders, matchedGridOrderIds, chainOrderIdsOnGrid, filledOrders, updatedOrders, skipAccounting) {
+    let bestMatch = { ...slot };
+    const wasVirtual = slot.state === ORDER_STATES.VIRTUAL;
+    const wasPartial = slot.state === ORDER_STATES.PARTIAL;
+    bestMatch.orderId = chainOrderId;
+    bestMatch.state = wasVirtual ? ORDER_STATES.ACTIVE : slot.state;
+    const bestMatchRaw = rawChainOrders.get(chainOrderId);
+    bestMatch.rawOnChain = bestMatchRaw ? { ...bestMatchRaw, fetchedAt: Date.now() } : bestMatchRaw;
+    matchedGridOrderIds.add(bestMatch.id);
+    if (bestMatch.rawOnChain) {
+        const rawDeferredFee = toFiniteNumber(bestMatch.rawOnChain.deferred_fee, null);
+        if (rawDeferredFee !== null && rawDeferredFee > 0) {
+            bestMatch.btsFeeState = { deferredFee: blockchainToFloat(rawDeferredFee, BTS_PRECISION) };
+        }
+        else if (wasVirtual && rawDeferredFee !== null && rawDeferredFee <= 0 && bestMatch.rawOnChain.for_sale > 0) {
+            bestMatch.state = ORDER_STATES.PARTIAL;
+        }
+    }
+    const precision = (bestMatch.type === ORDER_TYPES.SELL) ? mgr.assets.assetA.precision : mgr.assets.assetB.precision;
+    const targetInt = floatToBlockchainInt(slot.size, precision);
+    const chainInt = floatToBlockchainInt(chainOrder.size, precision);
+    if (targetInt !== chainInt) {
+        const updated = await applyChainSizeToGridOrder(mgr, bestMatch, chainOrder.size);
+        if (updated)
+            bestMatch = { ...bestMatch, ...updated };
+        if (chainInt > 0) {
+            if (wasVirtual && bestMatch.state !== ORDER_STATES.PARTIAL)
+                bestMatch.state = ORDER_STATES.ACTIVE;
+            else if (chainInt < targetInt)
+                bestMatch.state = ORDER_STATES.PARTIAL;
+            else if (wasPartial)
+                bestMatch.state = ORDER_STATES.PARTIAL;
+            else
+                bestMatch.state = ORDER_STATES.ACTIVE;
+        }
+        else {
+            const spreadOrder = convertToSpreadPlaceholder(bestMatch);
+            filledOrders.push({ ...bestMatch });
+            await mgr._applyOrderUpdate(spreadOrder, 'sync-pass2-filled', { skipAccounting: skipAccounting, fee: 0 });
+            updatedOrders.push(spreadOrder);
+            chainOrderIdsOnGrid.add(chainOrderId);
+            return true; // filled path
+        }
+    }
+    else if (wasPartial) {
+        bestMatch.state = ORDER_STATES.PARTIAL;
+    }
+    await mgr._applyOrderUpdate(bestMatch, 'sync-pass2-orphan', { skipAccounting: skipAccounting, fee: 0 });
+    updatedOrders.push(bestMatch);
+    chainOrderIdsOnGrid.add(chainOrderId);
+    return false;
+}
 function computeOutOfToleranceDriftTag(mgr, chainOrder, calcToleranceFn) {
     if (!mgr?.orders || !chainOrder)
         return null;
@@ -508,6 +560,39 @@ class SyncEngine {
             }
         }
         mgr.logger?.log?.(`[SYNC] Starting synchronization from ${parsedChainOrders.size} blockchain orders...`, 'info');
+        // SUSPECT EMPTY READ GUARD (Fix C): an empty chain read while the grid
+        // still holds placed orders (slots with orderIds) is far more likely a
+        // lagging/partial node response than a genuinely emptied account — a
+        // 0-order read treated as authoritative has virtualized live orders
+        // ("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
+        // resets the counter.
+        if (parsedChainOrders.size === 0) {
+            const gridOrderIds = Array.from(mgr.orders.values()).filter((o) => o?.orderId).length;
+            if (gridOrderIds > 0) {
+                const suspect = mgr._suspectEmptyReads || { count: 0, firstAt: 0 };
+                suspect.count += 1;
+                if (!suspect.firstAt)
+                    suspect.firstAt = Date.now();
+                mgr._suspectEmptyReads = suspect;
+                const limit = Math.max(1, Number(TIMING.SYNC_SUSPECT_EMPTY_READ_LIMIT) || 3);
+                if (suspect.count < limit) {
+                    mgr.logger?.log?.(`[SYNC] Suspect empty read (${suspect.count}/${limit} consecutive) with ${gridOrderIds} grid orderIds — ` +
+                        `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');
+                mgr._suspectEmptyReads = { count: 0, firstAt: 0 };
+            }
+            else {
+                mgr._suspectEmptyReads = { count: 0, firstAt: 0 };
+            }
+        }
+        else {
+            mgr._suspectEmptyReads = { count: 0, firstAt: 0 };
+        }
         // Collect all order IDs that might be modified during reconciliation
         // Lock them to prevent concurrent modifications from createOrder/cancelOrder
         const orderIdsToLock = new Set();
@@ -644,10 +729,24 @@ class SyncEngine {
                     continue;
                 }
                 else {
-                    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) {
+                    const genesisForPass1 = mgr._genesis;
+                    let isPriceEqual = false;
+                    if (genesisForPass1 && Array.isArray(genesisForPass1.priceLevels)) {
+                        const precision = gridOrder.type === ORDER_TYPES.SELL ? assetAPrecision : assetBPrecision;
+                        // Genesis path: single epsilon via integer round-trip
+                        try {
+                            isPriceEqual = priceSlotEqual(chainOrder.price, gridOrder.price, precision);
+                        }
+                        catch {
+                            isPriceEqual = chainOrder.price === gridOrder.price;
+                        }
+                    }
+                    else {
+                        const priceTolerance = calculatePriceTolerance(gridOrder.price, gridOrder.size, gridOrder.type, mgr.assets);
+                        const normalizedTolerance = (priceTolerance === null) ? 0 : priceTolerance;
+                        isPriceEqual = Math.abs(chainOrder.price - gridOrder.price) <= normalizedTolerance;
+                    }
+                    if (!isPriceEqual) {
                         queueCorrection({
                             gridOrder: { ...gridOrder },
                             chainOrderId: gridOrder.orderId,
@@ -663,6 +762,84 @@ class SyncEngine {
                 const currentSizeInt = floatToBlockchainInt(gridOrder.size, precision);
                 const chainSizeInt = floatToBlockchainInt(chainOrder.size, precision);
                 if (currentSizeInt !== chainSizeInt) {
+                    // SIZE-CONSISTENCY TIEBREAK (mis-tracked duplicate): the
+                    // tracked order's chain size disagrees with the slot's
+                    // booked remaining size. Before adopting the chain size,
+                    // check whether ANOTHER chain order at this price level
+                    // matches the booked size exactly. The grid allows at most
+                    // one order per level, so a second order whose size equals
+                    // the booked remaining means the slot's orderId was
+                    // mis-assigned (duplicate-price order created by a stale
+                    // rebuild racing the fill booking) and the real order is
+                    // the other one. Rebind the slot to it; the previously
+                    // tracked order falls through to pass 2 as a duplicate-
+                    // price orphan and is queued for cancellation there.
+                    let swapMatch = null;
+                    if (currentSizeInt > 0) {
+                        for (const [candidateId, candidateOrder] of parsedChainOrders) {
+                            if (candidateId === gridOrder.orderId)
+                                continue;
+                            if (chainOrderIdsOnGrid.has(candidateId))
+                                continue;
+                            if (!candidateOrder || candidateOrder.type !== chainOrder.type)
+                                continue;
+                            // Per-candidate price check: genesis → priceSlotEqual, else tolerance
+                            const genesisForSwap = mgr._genesis;
+                            let swapPriceEqual = false;
+                            if (genesisForSwap && Array.isArray(genesisForSwap.priceLevels)) {
+                                const precision = gridOrder.type === ORDER_TYPES.SELL ? assetAPrecision : assetBPrecision;
+                                try {
+                                    swapPriceEqual = priceSlotEqual(candidateOrder.price, gridOrder.price, precision);
+                                }
+                                catch {
+                                    swapPriceEqual = candidateOrder.price === gridOrder.price;
+                                }
+                            }
+                            else {
+                                const candidateTolerance = calculatePriceTolerance(Math.min(candidateOrder.price, gridOrder.price), Math.max(candidateOrder.size, gridOrder.size), gridOrder.type, mgr.assets);
+                                swapPriceEqual = Math.abs(candidateOrder.price - gridOrder.price) <= (candidateTolerance ?? 0);
+                            }
+                            if (!swapPriceEqual)
+                                continue;
+                            if (floatToBlockchainInt(candidateOrder.size, precision) !== currentSizeInt)
+                                continue;
+                            swapMatch = { id: candidateId, order: candidateOrder };
+                            break;
+                        }
+                    }
+                    if (swapMatch) {
+                        const swapRaw = rawChainOrders.get(swapMatch.id);
+                        const reboundOrder = {
+                            ...gridOrder,
+                            orderId: swapMatch.id,
+                            rawOnChain: swapRaw
+                                ? { ...swapRaw, fetchedAt: Date.now() }
+                                : gridOrder.rawOnChain,
+                        };
+                        // Restore fee lifecycle / partial-fill evidence from the
+                        // adopted order's deferred_fee (same convention as the
+                        // pass-2 adoption path below: deferred_fee > 0 → fee
+                        // state; deferred_fee === 0 with for_sale > 0 → the
+                        // order was partially filled).
+                        const rawDeferredFee = toFiniteNumber(reboundOrder.rawOnChain?.deferred_fee, null);
+                        if (rawDeferredFee !== null && rawDeferredFee > 0) {
+                            reboundOrder.btsFeeState = { deferredFee: blockchainToFloat(rawDeferredFee, BTS_PRECISION) };
+                        }
+                        else if (rawDeferredFee !== null && rawDeferredFee <= 0
+                            && toFiniteNumber(reboundOrder.rawOnChain?.for_sale, 0) > 0) {
+                            reboundOrder.state = ORDER_STATES.PARTIAL;
+                        }
+                        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 ` +
+                            `duplicate-price order ${swapMatch.id} (chain size ${swapMatch.order.size}) matches ` +
+                            `it exactly — rebinding slot to ${swapMatch.id}; ${gridOrder.orderId} falls through ` +
+                            `to pass 2 as a duplicate-price orphan (queued for cancellation).`, 'warn');
+                        continue;
+                    }
                     const newSize = blockchainToFloat(chainSizeInt, precision);
                     const newInt = floatToBlockchainInt(newSize, precision);
                     if (newInt > 0) {
@@ -755,168 +932,99 @@ class SyncEngine {
             }
         }
         // ====================================================================
-        // PASS 2: CHAIN → GRID - Match unmatched chain orders to grid
+        // PASS 2: CHAIN → GRID - Nearest-slot deterministic adoption (genesis-frozen)
         // ====================================================================
-        for (const [chainOrderId, chainOrder] of parsedChainOrders) {
+        const genesis = mgr._genesis;
+        const hasGenesis = genesis && Array.isArray(genesis.priceLevels) && genesis.priceLevels.length > 0;
+        const anchorPrice = hasGenesis ? genesis.startPrice : mgr.config?.startPrice;
+        const sortedChainEntries = [...parsedChainOrders.entries()].sort((a, b) => {
+            const pa = toFiniteNumber(a[1].price);
+            const pb = toFiniteNumber(b[1].price);
+            const da = Number.isFinite(pa) && Number.isFinite(anchorPrice) ? Math.abs(pa - anchorPrice) : Infinity;
+            const db = Number.isFinite(pb) && Number.isFinite(anchorPrice) ? Math.abs(pb - anchorPrice) : Infinity;
+            return da - db;
+        });
+        for (const [chainOrderId, chainOrder] of sortedChainEntries) {
             if (chainOrderIdsOnGrid.has(chainOrderId))
                 continue;
-            // The grid allows at most one order per price level. If a placed
-            // grid order already exists at the orphan's price (within tolerance),
-            // 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
-            // otherwise silently adopt the orphan before the duplicate guard runs.
+            // Genesis path: nearest-slot is single authority (no tolerance)
+            if (hasGenesis) {
+                let idx;
+                try {
+                    idx = slotIndexForPrice(chainOrder.price, genesis);
+                }
+                catch {
+                    unmatchedChainOrders.push({ chainOrderId, type: chainOrder.type, price: chainOrder.price, size: chainOrder.size, raw: rawChainOrders.get(chainOrderId), reason: 'no-available-nearest-slot' });
+                    queueCorrection({ gridOrder: { id: `slot-unknown-${chainOrderId}`, type: chainOrder.type }, chainOrderId, expectedPrice: chainOrder.price, size: chainOrder.size, type: chainOrder.type, isSurplus: true, cancelOnly: true });
+                    continue;
+                }
+                const slotId = `slot-${idx}`;
+                const gapSlots = genesis.gapSlots ?? mgr._gapSlots ?? 0;
+                const boundaryIdx = mgr.boundaryIdx;
+                // 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) {
+                    unmatchedChainOrders.push({ chainOrderId, type: chainOrder.type, price: chainOrder.price, size: chainOrder.size, raw: rawChainOrders.get(chainOrderId), reason: 'duplicate-price-level', candidateSlotId: slotId });
+                    const { level, suffix } = duplicateOrphanLogInfo(chainOrderId);
+                    mgr.logger?.log?.(`[SYNC] Orphaned chain order ${chainOrderId} (${chainOrder.type}, price=${chainOrder.price}, size=${chainOrder.size}) — NOT adopted: duplicates slot ${slotId} (${occupying.orderId})${suffix}`, level);
+                    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))) {
+                    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 });
+                        queueCorrection({ gridOrder: { id: slotId, type: chainOrder.type }, chainOrderId, expectedPrice: chainOrder.price, size: chainOrder.size, type: chainOrder.type, isSurplus: true, cancelOnly: true });
+                        continue;
+                    }
+                }
+                const slot = mgr.orders.get(slotId);
+                if (!slot || matchedGridOrderIds.has(slot.id) || slot.orderId) {
+                    unmatchedChainOrders.push({ chainOrderId, type: chainOrder.type, price: chainOrder.price, size: chainOrder.size, raw: rawChainOrders.get(chainOrderId), reason: 'no-available-nearest-slot', candidateSlotId: slotId });
+                    const diag = describeNearestAdoptionCandidates(mgr, chainOrder, (chainOrder.type === ORDER_TYPES.SELL ? assetAPrecision : assetBPrecision), (p, s, t) => calculatePriceTolerance(p, s, t, mgr.assets), matchedGridOrderIds);
+                    mgr.logger?.log?.(`[SYNC] Unmatched chain order ${chainOrderId} (${chainOrder.type}, price=${chainOrder.price}, size=${chainOrder.size}): nearest slot ${slotId} not adoptable. Nearest candidates: ${diag}`, 'warn');
+                    continue;
+                }
+                const typeCompat = slot.type === chainOrder.type || slot.type === ORDER_TYPES.SPREAD;
+                if (!typeCompat) {
+                    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);
+                continue;
+            }
+            // Legacy fallback when genesis unavailable (migration)
             const duplicatePriceOrder = Array.from(mgr.orders.values()).find((o) => {
                 const co = chainOrder;
-                return o.type === co.type &&
-                    isOrderPlaced(o) &&
-                    co != null &&
-                    Math.abs(o.price - co.price) <= calculatePriceTolerance(Math.min(o.price, co.price), Math.max(o.size, co.size), o.type, mgr.assets);
+                return o.type === co.type && isOrderPlaced(o) && co != null && 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({
-                    chainOrderId,
-                    type: chainOrder.type,
-                    price: chainOrder.price,
-                    size: chainOrder.size,
-                    raw: rawChainOrders.get(chainOrderId),
-                    reason: 'duplicate-price-level',
-                    candidateSlotId: duplicatePriceOrder.id,
-                });
+                unmatchedChainOrders.push({ chainOrderId, type: chainOrder.type, price: chainOrder.price, size: chainOrder.size, raw: rawChainOrders.get(chainOrderId), 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})${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.
-                queueCorrection({
-                    gridOrder: duplicatePriceOrder,
-                    chainOrderId,
-                    expectedPrice: chainOrder.price,
-                    size: chainOrder.size,
-                    type: chainOrder.type,
-                    isSurplus: true,
-                    cancelOnly: true,
-                });
+                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})${suffix}`, level);
+                queueCorrection({ gridOrder: duplicatePriceOrder, chainOrderId, expectedPrice: chainOrder.price, size: chainOrder.size, type: chainOrder.type, isSurplus: true, cancelOnly: true });
                 continue;
             }
-            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
-            });
+            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)) {
-                let bestMatch = { ...match };
-                const wasVirtual = match.state === ORDER_STATES.VIRTUAL;
-                const wasPartial = match.state === ORDER_STATES.PARTIAL;
-                bestMatch.orderId = chainOrderId;
-                bestMatch.state = wasVirtual ? ORDER_STATES.ACTIVE : match.state;
-                const bestMatchRaw = rawChainOrders.get(chainOrderId);
-                bestMatch.rawOnChain = bestMatchRaw
-                    ? { ...bestMatchRaw, fetchedAt: Date.now() }
-                    : bestMatchRaw;
-                matchedGridOrderIds.add(bestMatch.id);
-                // Reconstruct btsFeeState from raw chain order's deferred_fee.
-                // After a grid reset, in-memory orders lose btsFeeState. The chain's
-                // limit_order_object stores the original deferred_fee (or 0 after a
-                // partial fill). Restoring it ensures correct fee lifecycle accounting
-                // (cancel refunds, fill maker discounts) on the reconciled order.
-                // Only set btsFeeState when deferred_fee > 0 — _resolveBtsFeeLifecycle
-                // 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);
-                    if (rawDeferredFee !== null && rawDeferredFee > 0) {
-                        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 = ORDER_STATES.PARTIAL;
-                    }
-                }
-                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 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;
-                            }
-                        }
-                        else if (chainInt < targetInt) {
-                            bestMatch.state = ORDER_STATES.PARTIAL;
-                        }
-                        else if (wasPartial) {
-                            bestMatch.state = ORDER_STATES.PARTIAL;
-                        }
-                        else {
-                            bestMatch.state = ORDER_STATES.ACTIVE;
-                        }
-                    }
-                    else {
-                        const spreadOrder = convertToSpreadPlaceholder(bestMatch);
-                        filledOrders.push({ ...bestMatch });
-                        await mgr._applyOrderUpdate(spreadOrder, 'sync-pass2-filled', { skipAccounting: skipAccounting, fee: 0 });
-                        updatedOrders.push(spreadOrder);
-                        chainOrderIdsOnGrid.add(chainOrderId);
-                        continue;
-                    }
-                }
-                else if (wasPartial) {
-                    bestMatch.state = ORDER_STATES.PARTIAL;
-                }
-                await mgr._applyOrderUpdate(bestMatch, 'sync-pass2-orphan', { skipAccounting: skipAccounting, fee: 0 });
-                updatedOrders.push(bestMatch);
-                chainOrderIdsOnGrid.add(chainOrderId);
+                await adoptChainOrderIntoSlot(mgr, match, chainOrder, chainOrderId, rawChainOrders, matchedGridOrderIds, chainOrderIdsOnGrid, filledOrders, updatedOrders, skipAccounting);
             }
             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');
-                queueCorrection({
-                    gridOrder: match,
-                    chainOrderId,
-                    expectedPrice: chainOrder.price,
-                    size: chainOrder.size,
-                    type: chainOrder.type,
-                    isSurplus: true,
-                    cancelOnly: true,
-                });
-                // Also push to unmatchedChainOrders so the existing auto-cancel
-                // path at dexbot_class.ts:4262 can pick it up if the correction
-                // mechanism does not fire first.
-                unmatchedChainOrders.push({
-                    chainOrderId,
-                    type: chainOrder.type,
-                    price: chainOrder.price,
-                    size: chainOrder.size,
-                    raw: rawChainOrders.get(chainOrderId),
-                    reason: 'already-matched-slot',
-                    candidateSlotId: match.id,
-                });
+                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');
+                queueCorrection({ gridOrder: match, chainOrderId, expectedPrice: chainOrder.price, size: chainOrder.size, type: chainOrder.type, isSurplus: true, cancelOnly: true });
+                unmatchedChainOrders.push({ chainOrderId, type: chainOrder.type, price: chainOrder.price, size: chainOrder.size, raw: rawChainOrders.get(chainOrderId), reason: 'already-matched-slot', candidateSlotId: match.id });
             }
             else {
-                // No grid slot matched by type+price+size in the first pass.
-                // Fallback: adopt into the nearest VIRTUAL/spread slot so the
-                // orphan becomes visible to checkWindowDust for dust auto-cancel.
-                // The duplicate-price-level guard already ran above so it is not
-                // repeated here.
+                // Legacy spread-orphan fallback: adopt into nearest VIRTUAL/spread slot (allowSpreadType + skipSizeMatch) with widened tolerance
                 const adoptedSlot = 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) => {
+                        const strict = calculatePriceTolerance(p, s, t, mgr.assets);
+                        const mult = mgr?.config?.gridLimits?.ORPHAN_ADOPTION_TOLERANCE_MULTIPLIER || 4;
+                        return strict == null ? null : strict * mult;
+                    },
                     allowSpreadType: true,
                     skipSizeMatch: true,
                     requireAvailableSlot: true,
@@ -938,30 +1046,20 @@ class SyncEngine {
                         state: adoptedState,
                         size: chainOrder.size,
                         price: chainOrder.price,
-                        rawOnChain: adoptedRaw
-                            ? { ...adoptedRaw, fetchedAt: Date.now() }
-                            : adoptedRaw,
+                        rawOnChain: adoptedRaw ? { ...adoptedRaw, fetchedAt: Date.now() } : adoptedRaw,
                         ...(adoptedBtsFeeState ? { btsFeeState: adoptedBtsFeeState } : {}),
                     };
                     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');
+                    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');
                 }
                 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 unmatchedEntry = {
-                        chainOrderId,
-                        type: chainOrder.type,
-                        price: chainOrder.price,
-                        size: chainOrder.size,
-                        raw: rawChainOrders.get(chainOrderId),
-                        candidateDiagnostics
-                    };
+                    const unmatchedEntry = { chainOrderId, type: chainOrder.type, price: chainOrder.price, size: chainOrder.size, raw: rawChainOrders.get(chainOrderId), candidateDiagnostics };
                     if (driftTag) {
                         unmatchedEntry.reason = 'price-drift-orphan';
                         unmatchedEntry.candidateSlotId = driftTag.candidateSlotId;
@@ -970,10 +1068,7 @@ class SyncEngine {
                         unmatchedEntry.tolerance = driftTag.tolerance;
                     }
                     unmatchedChainOrders.push(unmatchedEntry);
-                    mgr.logger?.log?.(`[SYNC] Unmatched chain order ${chainOrderId} (${chainOrder.type}, price=${chainOrder.price}, ` +
-                        `size=${chainOrder.size}): no adoptable slot found` +
-                        (driftTag ? ` (price-drift-orphan slot=${driftTag.candidateSlotId}@${driftTag.candidateSlotPrice} diff=${driftTag.priceDiff} tol=${driftTag.tolerance})` : '') +
-                        `. Nearest candidates: ${candidateDiagnostics}`, 'warn');
+                    mgr.logger?.log?.(`[SYNC] Unmatched chain order ${chainOrderId} (${chainOrder.type}, price=${chainOrder.price}, size=${chainOrder.size}): no adoptable slot found` + (driftTag ? ` (price-drift-orphan slot=${driftTag.candidateSlotId}@${driftTag.candidateSlotPrice} diff=${driftTag.priceDiff} tol=${driftTag.tolerance})` : '') + `. Nearest candidates: ${candidateDiagnostics}`, 'warn');
                 }
             }
         }
@@ -1492,7 +1587,7 @@ class SyncEngine {
                     // 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.
+                    // AAA-BBB log whenever a batch contained 2+ fills of one order.
                     const gridUpdates = [];
                     const filledOrders = [];
                     const updatedOrders = [];