dexbot 1.5.1 → 1.5.3

package/dist/modules/order/utils/order.js

@@ -5,7 +5,7 @@
  * Includes grid indexing, order comparison, delta building, and strategy calculations.
  *
  * ===============================================================================
- * TABLE OF CONTENTS (36 exported functions)
+ * TABLE OF CONTENTS (35 exported functions)
  * ===============================================================================
  *
  * SECTION 1: CHAIN ORDER MATCHING & RECONCILIATION (5 functions)
@@ -46,9 +46,8 @@
  *   - checkSizeThreshold(size, threshold) - Check if size exceeds threshold
  *   - checkSizesBeforeMinimum(sizes, minSize) - Check sizes against minimum
  *
- * SECTION 7: GRID BOUNDARY & ROLES (4 functions)
+ * SECTION 7: GRID BOUNDARY & ROLES (3 functions)
  *   - calculateIdealBoundary(allSlots, startPrice, gapSlots) - Calculate ideal boundary
- *   - calculateFundDrivenBoundary(allSlots, availA, availB, startPrice, gapSlots) - Fund-driven boundary
  *   - assignGridRoles(allSlots, boundaryIdx, gapSlots, ...) - Assign BUY/SELL roles
  *   - shouldFlagOutOfSpread(order, startPrice, configSpread) - Check if order is out of spread
  *
@@ -68,7 +67,7 @@
  *
  * ===============================================================================
  */
-import { ORDER_TYPES, ORDER_STATES, TIMING, FEE_PARAMETERS, GRID_LIMITS, NATIVE_CLIENT, COW_PERFORMANCE } from '../../constants.js';
+import { ORDER_TYPES, ORDER_STATES, TIMING, FEE_PARAMETERS, GRID_LIMITS, NATIVE_CLIENT, COW_PERFORMANCE, COW_ACTIONS } from '../../constants.js';
 import * as Format from '../format.js';
 import * as MathUtils from './math.js';
 import Logger from '../../order/logger.js';
@@ -461,11 +460,13 @@ async function correctOrderPriceOnChain(manager, correctionInfo, accountName, pr
     let shouldRemove = false;
     // CROSSING-PLACEMENT GUARD: re-pricing the chain order to its slot's
     // committed price must not cross an opposite-side live order (only
-    // reachable when the grid geometry itself is broken). Drop the entry —
+    // reachable when the grid geometry itself is broken). Candidates are the
+    // shared master + pending-broadcast + orphan set so a re-price cannot
+    // cross a pending CREATE from an earlier uncertain batch. Drop the entry —
     // the next sync's price-mismatch detection re-queues the correction
     // once the crossed order is resolved (same lifecycle as a 'skipped'
     // update below).
-    const crossed = MathUtils.findCrossedOrder(manager.orders.values(), expectedPrice, type, manager.assets, (o) => o && o.orderId && o.orderId !== chainOrderId);
+    const crossed = MathUtils.findCrossedOrder(buildCrossingCheckCandidates(manager), expectedPrice, type, manager.assets, (o) => isCrossingCheckCandidate(o, chainOrderId));
     if (crossed) {
         manager.logger?.log?.(`[CROSS-GUARD] Skipping price correction for ${chainOrderId} -> ${type} @${expectedPrice}: ` +
             `crosses live ${crossed.type} ${crossed.id} (${crossed.orderId}) @${crossed.price}; ` +
@@ -1001,10 +1002,14 @@ function parseSlotIndex(id) {
     return parseSlotIndexShared(id);
 }
 /**
- * Whether a parsed chain order matches a grid slot within tolerance:
- * type-compatible (slot may be SPREAD), price within tolerance, size within
- * 1% quantum tolerance (floor 2 units). Shared by the startup adoption paths
- * that match an uncertain-landed chain order to the slot it was created for.
+ * Whether a parsed chain order matches a grid slot exactly:
+ * type-compatible (slot may be SPREAD), price strictly equal via integer
+ * round-trip (single epsilon), size within 1% quantum tolerance (floor 2
+ * units). STRICT genesis-slot-mapping matcher — use only where the slot is
+ * derived from the price (nearest-slot authority). Uncertain-landed
+ * adoption (a broadcast whose on-chain price may have drifted by dust)
+ * must use chainOrderMatchesSlotWithTolerance instead, or the drifted
+ * order is never adopted and gets re-broadcast as a duplicate.
  * @param {Object} parsed - parseChainOrder output ({type, price, size, ...})
  * @param {Object} slot - Grid slot order object
  * @param {Object} assets - Manager assets ({assetA, assetB} with precision)
@@ -1027,6 +1032,131 @@ function chainOrderMatchesSlot(parsed, slot, assets) {
         return false;
     return true;
 }
+/**
+ * Whether a parsed chain order matches a grid slot within price tolerance:
+ * type-compatible (slot may be SPREAD), price within calculatePriceTolerance
+ * (clamped to ~2 price quanta so dust-inflated tolerances cannot adopt a
+ * wrong order), size within the same 1% quantum tolerance as the strict
+ * matcher. For the UNCERTAIN-ADOPT paths only (a just-broadcast create whose
+ * on-chain price may have drifted by rounding dust): the strict
+ * chainOrderMatchesSlot would miss the drifted order, the slot would stay
+ * VIRTUAL, and the next cycle would re-broadcast it as a duplicate.
+ * Genesis slot mapping keeps the strict matcher (nearest-slot authority).
+ * @param {Object} parsed - parseChainOrder output ({type, price, size, ...})
+ * @param {Object} slot - Grid slot order object
+ * @param {Object} assets - Manager assets ({assetA, assetB} with precision)
+ * @returns {boolean}
+ */
+function chainOrderMatchesSlotWithTolerance(parsed, slot, assets) {
+    if (!parsed || !slot || !assets)
+        return false;
+    if (parsed.type !== slot.type && slot.type !== ORDER_TYPES.SPREAD)
+        return false;
+    const precision = parsed.type === ORDER_TYPES.SELL ? assets.assetA.precision : assets.assetB.precision;
+    let tolerance = null;
+    try {
+        tolerance = MathUtils.calculatePriceTolerance(Math.min(parsed.price, slot.price), Math.max(parsed.size, slot.size), parsed.type, assets);
+    }
+    catch {
+        tolerance = null;
+    }
+    // Clamp to ~2 price quanta (relative): dust-sized orders inflate the
+    // tolerance past the grid increment, which would adopt a wrong order.
+    // A null tolerance (invalid inputs) falls back to the clamp itself.
+    const quantumCap = 2 * MathUtils.quantumForPrecision(precision) * Math.max(1, Math.max(parsed.price, slot.price));
+    if (tolerance == null || !Number.isFinite(tolerance))
+        tolerance = quantumCap;
+    else
+        tolerance = Math.min(tolerance, quantumCap);
+    if (Math.abs(parsed.price - slot.price) > tolerance)
+        return false;
+    const sizeTolerance = Math.max(2, Math.floor(floatToBlockchainInt(slot.size, precision) * 0.01));
+    if (Math.abs(floatToBlockchainInt(parsed.size, precision) - floatToBlockchainInt(slot.size, precision)) > sizeTolerance)
+        return false;
+    return true;
+}
+/**
+ * Identity of a crossing-check candidate. Master orders carry orderId,
+ * unmatched chain orders carry chainOrderId, pending-broadcast wrappers
+ * carry slotId + order (their inner order has no chain id yet — it may not
+ * even be on chain). All three classes must be visible to crossing guards:
+ * an UPDATE-only rotation batch can otherwise re-price across a pending
+ * CREATE from an earlier uncertain batch and self-trade (BitShares has no
+ * self-trade prevention).
+ * @param {Object} o - Candidate order or pending-broadcast wrapper entry
+ * @returns {string|null} Chain/slot identity, or null when not placeable
+ */
+function crossingCandidateChainId(o) {
+    if (!o)
+        return null;
+    if (o.orderId)
+        return o.orderId;
+    if (o.chainOrderId)
+        return o.chainOrderId;
+    if (o.slotId && o.order)
+        return o.slotId;
+    return null;
+}
+/**
+ * Shared predicate for every crossing-placement guard (COW create/rotation/
+ * fallback, startup reconcile placement, price-correction re-queue). Accepts
+ * master orders (orderId), unmatched chain orders (chainOrderId), AND
+ * pending-broadcast wrappers (slotId + order) — pending entries can never be
+ * in cancelOpIndexByOrderId (keyed by chain ids; wrapper orderIds are slot
+ * ids in a disjoint namespace), so the exclusion check is harmless for them.
+ * VIRTUAL slots (no orderId) are rejected: they have no chain presence and
+ * must never block placements.
+ * @param {Object} o - Candidate order or pending-broadcast wrapper entry
+ * @param {string|null} [excludeChainOrderId=null] - Chain id to exempt (the order being relocated itself)
+ * @param {Map|null} [cancelOpIndexByOrderId=null] - orderId -> op index of its already-queued cancel
+ * @returns {boolean} True when the candidate participates in crossing checks
+ */
+function isCrossingCheckCandidate(o, excludeChainOrderId = null, cancelOpIndexByOrderId = null) {
+    if (!o)
+        return false;
+    const oid = crossingCandidateChainId(o);
+    if (!oid)
+        return false;
+    if (excludeChainOrderId && oid === excludeChainOrderId)
+        return false;
+    if (cancelOpIndexByOrderId instanceof Map && cancelOpIndexByOrderId.has(oid))
+        return false;
+    const price = o.price ?? o.order?.price;
+    if (price == null || !Number.isFinite(Number(price)))
+        return false;
+    return true;
+}
+/**
+ * Shared candidate set for crossing-placement checks: master orders plus
+ * chain-side orders that may exist on chain but are not (yet) adopted into
+ * the master grid — pending-broadcast wrappers from earlier uncertain
+ * batches (pushed as wrappers so the predicate can see their slotId; their
+ * inner order carries type/price via findCrossedOrder's item.order fallback)
+ * and unmatched chain orders (orphans). Without these, an UPDATE-only
+ * rotation batch can re-price across an un-adopted chain order that
+ * master-grid-only checks cannot see (the pending/unmatched batch guards
+ * fire only for CREATE batches).
+ * @param {Object} manager - OrderManager instance (orders Map, _pendingBroadcasts, _lastUnmatchedChainOrders)
+ * @returns {any[]} Candidate orders/wrappers for findCrossedOrder
+ */
+function buildCrossingCheckCandidates(manager) {
+    if (!manager)
+        return [];
+    const candidates = manager.orders instanceof Map ? [...manager.orders.values()] : [];
+    if (manager._pendingBroadcasts instanceof Map) {
+        for (const entry of manager._pendingBroadcasts.values()) {
+            if (entry && entry.slotId && entry.order)
+                candidates.push(entry);
+        }
+    }
+    if (Array.isArray(manager._lastUnmatchedChainOrders)) {
+        for (const o of manager._lastUnmatchedChainOrders) {
+            if (o && o.type != null && o.price != null)
+                candidates.push(o);
+        }
+    }
+    return candidates;
+}
 // ================================================================================
 // SECTION 4-6: FILTERING, PREDICATES & SIZE VALIDATION
 // ================================================================================
@@ -1300,26 +1430,6 @@ function calculateIdealBoundary(allSlots, referencePrice, gapSlots) {
     const buySpread = Math.floor(gapSlots / 2);
     return Math.max(0, Math.min(allSlots.length - 1, splitIdx - buySpread - 1));
 }
-/**
- * Calculate grid boundary based on available funds ratio.
- * Distributes buy/sell slots proportional to fund values.
- *
- * @param {Array<Object>} allSlots - All grid slots sorted by price
- * @param {number} availA - Available assetA (sell-side capital)
- * @param {number} availB - Available assetB (buy-side capital)
- * @param {number} price - Current reference price for valuation
- * @param {number} gapSlots - Number of gap slots between buy and sell
- * @returns {number} Fund-driven boundary index
- */
-function calculateFundDrivenBoundary(allSlots, availA, availB, price, gapSlots) {
-    const valA = toFiniteNumber(availA) * toFiniteNumber(price);
-    const valB = toFiniteNumber(availB);
-    const totalVal = valA + valB;
-    if (totalVal <= 0)
-        return Math.floor((allSlots.length - gapSlots) / 2);
-    const targetBuySlots = Math.round((allSlots.length - gapSlots) * (valB / totalVal));
-    return Math.max(0, Math.min(allSlots.length - gapSlots - 1, targetBuySlots - 1));
-}
 /**
  * Assign BUY/SELL/SPREAD roles to grid slots based on boundary.
  * Slots below boundary are BUY, above boundary are SELL, between are SPREAD.
@@ -1675,10 +1785,10 @@ function deriveTargetBoundary(fills, currentBoundaryIdx, allSlots, config, gapSl
     }
     const remainingBudget = effectiveBudget - Math.abs(netShift);
     newBoundaryIdx += netShift;
-    // Clamp boundary — cap at one slot before the gap band's SELL rail,
-    // matching calculateFundDrivenBoundary's geometry. Degenerate geometries
-    // (fewer slots than the gap needs) fall back to the legacy length-1
-    // ceiling instead of collapsing the boundary below its current position.
+    // Clamp boundary — cap at one slot before the gap band's SELL rail.
+    // Degenerate geometries (fewer slots than the gap needs) fall back to the
+    // legacy length-1 ceiling instead of collapsing the boundary below its
+    // current position.
     const gapAwareCeiling = allSlots.length - gapSlots - 1;
     const legacyCeiling = allSlots.length - 1;
     const ceiling = gapAwareCeiling >= 0
@@ -1754,5 +1864,200 @@ function calculateBudgetedSizes(slots, side, budget, weightDist, incrementPercen
     0, precision);
 }
 // ================================================================================
-export { parseChainOrder, findMatchingGridOrderByOpenOrder, applyChainSizeToGridOrder, buildFillKey, correctOrderPriceOnChain, correctAllPriceMismatches, buildCreateOrderArgs, getOrderTypeFromUpdatedFlags, resolveConfiguredPriceBound, virtualizeOrder, convertToSpreadPlaceholder, toRailHolePlaceholder, geometryTypeForSlotIndex, detectGapEvacuationCandidates, updateGapEvacuationStreaks, resolveSpreadOrderSide, chainOrderMatchesSlot, parseSlotIndex, filterOrdersByType, buildOutsideInPairGroups, extractBatchOperationResults, formatUnmatchedChainOrder, isOrderOnChain, isOrderVirtual, hasOnChainId, isOrderPlaced, isPhantomOrder, isSlotAvailable, isEmptyGridSlot, isOrderHealthy, checkSizeThreshold, checkSizesBeforeMinimum, calculateIdealBoundary, calculateFundDrivenBoundary, assignGridRoles, resolveOnChainRetypeType, shouldFlagOutOfSpread, buildIndexes, validateIndexes, ordersEqual, buildDelta, getOrderSize, deriveTargetBoundary, isShiftEligibleFill, getActiveOrdersTotal, getSideBudget, calculateBudgetedSizes, buildCreateOpFingerprint, isOrderGoneErrorMessage, recordDuplicateOrphanDetection, clearDuplicateOrphanDetection, duplicateOrphanLogInfo };
+// SECTION: COW batch-shared pure helpers (moved from dexbot_cow_runtime.ts —
+// no bot dependency; shared by the COW runtime and any future consumer).
+// ================================================================================
+/**
+ * Whether a chain order still matches the cached pre-update state the
+ * limit_order_update delta was built from. Only a provably-unchanged order
+ * makes a re-broadcast of the identical delta safe (it applies to the same
+ * base). Any other state (target applied, filled, resized) must defer.
+ * @param {Object} chainOrder - Raw chain order object (get_full_accounts)
+ * @param {Object|null} cachedRaw - The rawOnChain cache captured at build time
+ * @returns {boolean}
+ */
+function chainOrderUnchangedFromCache(chainOrder, cachedRaw) {
+    if (!chainOrder || !cachedRaw)
+        return false;
+    const base = chainOrder.sell_price?.base;
+    const quote = chainOrder.sell_price?.quote;
+    const cachedBase = cachedRaw.sell_price?.base?.amount;
+    const cachedQuote = cachedRaw.sell_price?.quote?.amount;
+    const cachedForSale = cachedRaw.for_sale;
+    if (base === undefined || quote === undefined)
+        return false;
+    if (cachedForSale === undefined || cachedBase === undefined || cachedQuote === undefined)
+        return false;
+    return String(base.amount ?? '') === String(cachedBase)
+        && String(quote.amount ?? '') === String(cachedQuote)
+        && String(chainOrder.for_sale ?? '') === String(cachedForSale);
+}
+/**
+ * PRE-BROADCAST CROSSED-BOOK ASSERT (defense-in-depth, any-writer detection).
+ *
+ * Simulates the post-batch book: currently placed master orders plus this
+ * batch's action overlay (CREATEs add, CANCELs remove, UPDATEs reprice/move).
+ * Returns a detail string when a planned BUY would price at-or-above a planned
+ * SELL — a state no honest planner produces — so the caller can refuse the
+ * broadcast instead of paying for adverse fills.  Placed order prices are
+ * independent of grid geometry, so this catches boundary overruns regardless
+ * of which writer produced them.
+ *
+ * Detector only: any internal failure returns null (never blocks a broadcast).
+ */
+function detectCrossedBookPlan(manager, actions) {
+    try {
+        const startPrice = Number(manager?.config?.startPrice);
+        const book = new Map();
+        for (const o of Array.from(manager?.orders?.values?.() ?? [])) {
+            if (!o || !o.orderId || o.price == null)
+                continue;
+            const price = Number(o.price);
+            if (!Number.isFinite(price))
+                continue;
+            let type = o.type;
+            if (type !== ORDER_TYPES.BUY && type !== ORDER_TYPES.SELL) {
+                // Legacy SPREAD-typed placed order: derive side from the same
+                // price-vs-startPrice convention used across the codebase.
+                if (!Number.isFinite(startPrice))
+                    continue;
+                type = price < startPrice ? ORDER_TYPES.BUY : ORDER_TYPES.SELL;
+            }
+            book.set(String(o.id), { type, price });
+        }
+        for (const a of actions ?? []) {
+            const id = String(a.id ?? a.orderId ?? '');
+            if (a.type === COW_ACTIONS.CANCEL) {
+                if (id)
+                    book.delete(id);
+            }
+            else if (a.type === COW_ACTIONS.UPDATE) {
+                const newPrice = Number(a.newPrice ?? a.order?.price);
+                const newType = a.order?.type;
+                if (id && Number.isFinite(newPrice)) {
+                    const entry = book.get(id);
+                    const type = (newType === ORDER_TYPES.BUY || newType === ORDER_TYPES.SELL)
+                        ? newType
+                        : entry?.type;
+                    if (entry)
+                        book.delete(id);
+                    const key = String(a.newGridId ?? id);
+                    if (type === ORDER_TYPES.BUY || type === ORDER_TYPES.SELL) {
+                        book.set(key, { type, price: newPrice });
+                    }
+                }
+            }
+            else if (a.type === COW_ACTIONS.CREATE) {
+                const price = Number(a.order?.price);
+                const type = a.order?.type;
+                if (!Number.isFinite(price) || (type !== ORDER_TYPES.BUY && type !== ORDER_TYPES.SELL))
+                    continue;
+                if (id)
+                    book.set(id, { type, price });
+            }
+        }
+        let maxBuy = -Infinity;
+        let minSell = Infinity;
+        for (const { type, price } of book.values()) {
+            if (type === ORDER_TYPES.BUY && price > maxBuy)
+                maxBuy = price;
+            else if (type === ORDER_TYPES.SELL && price < minSell)
+                minSell = price;
+        }
+        if (Number.isFinite(maxBuy) && Number.isFinite(minSell) && minSell <= maxBuy) {
+            return `bestPlacedBuy=${maxBuy} >= bestPlacedSell=${minSell}`;
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Collect every on-chain order id master currently needs to converge against,
+ * so adoption can re-read them by id (immune to the get_full_accounts window
+ * truncation) instead of relying on a partial window read.
+ *
+ * Sources:
+ *  - master's own tracked order ids (existing on-chain orders);
+ *  - the batch's fresh CREATE ids extracted from the broadcast result
+ *    (operation_results[i][1] aligns positionally with placedContexts[i]).
+ *
+ * @param {any} mgr - bot.manager
+ * @param {any} placedResults - broadcast result (has operation_results); null when unavailable
+ * @param {any[]} placedContexts - opContexts (aligned with operation_results); null when unavailable
+ * @param {string[]|null} [extraCreateIds=null] - fresh CREATE chain ids from another
+ *   authoritative source (e.g. the uncertain-broadcast poll confirmation) when
+ *   no broadcast result exists; merged into createIds so the lagging-create
+ *   retry guards them
+ * @returns {string[]} Unique, well-formed 1.7.x order ids
+ */
+function collectKnownOnChainOrderIds(mgr, placedResults, placedContexts, extraCreateIds = null) {
+    const masterIds = new Set();
+    const grid = mgr && mgr.grid;
+    if (Array.isArray(grid)) {
+        for (const slot of grid) {
+            if (slot && slot.orderId && /^1\.7\.\d+$/.test(String(slot.orderId))) {
+                masterIds.add(String(slot.orderId));
+            }
+        }
+    }
+    // Master tracked ids live in the orders Map (mgr.grid is legacy and
+    // unset on OrderManager — without this the by-id set omits every
+    // pre-existing ACTIVE order and pass-1 phantom cleanup would virtualize
+    // them as fills on a partial snapshot).
+    if (mgr && mgr.orders instanceof Map) {
+        for (const slot of mgr.orders.values()) {
+            if (slot && slot.orderId && /^1\.7\.\d+$/.test(String(slot.orderId))) {
+                masterIds.add(String(slot.orderId));
+            }
+        }
+    }
+    const createIds = new Set();
+    if (placedResults && Array.isArray(placedContexts)) {
+        const opResults = extractBatchOperationResults(placedResults);
+        if (Array.isArray(opResults)) {
+            for (let i = 0; i < placedContexts.length; i++) {
+                const ctx = placedContexts[i];
+                if (!ctx || ctx.kind !== 'create')
+                    continue;
+                const opResult = opResults[i] && opResults[i][1];
+                if (opResult && /^1\.7\.\d+$/.test(String(opResult))) {
+                    createIds.add(String(opResult));
+                }
+            }
+        }
+    }
+    if (Array.isArray(extraCreateIds)) {
+        for (const id of extraCreateIds) {
+            if (id && /^1\.7\.\d+$/.test(String(id)))
+                createIds.add(String(id));
+        }
+    }
+    // Existing chain ids referenced by non-create op contexts (cancel /
+    // rotation / size-update). Pre-existing orders whose absence is expected
+    // (cancels/fills in this batch), so they join the by-id set but never
+    // the lagging-create guard.
+    if (Array.isArray(placedContexts)) {
+        for (const ctx of placedContexts) {
+            if (!ctx || ctx.kind === 'create')
+                continue;
+            const refs = [];
+            if (ctx.kind === 'cancel' && ctx.order)
+                refs.push(ctx.order.orderId);
+            else if (ctx.kind === 'rotation' && ctx.rotation?.oldOrder)
+                refs.push(ctx.rotation.oldOrder.orderId);
+            else if (ctx.kind === 'size-update' && ctx.updateInfo?.partialOrder)
+                refs.push(ctx.updateInfo.partialOrder.orderId);
+            for (const id of refs) {
+                if (id && /^1\.7\.\d+$/.test(String(id)))
+                    masterIds.add(String(id));
+            }
+        }
+    }
+    const all = new Set([...masterIds, ...createIds]);
+    return { masterIds: [...masterIds], createIds: [...createIds], all: [...all] };
+}
+// ================================================================================
+export { parseChainOrder, findMatchingGridOrderByOpenOrder, applyChainSizeToGridOrder, buildFillKey, correctOrderPriceOnChain, correctAllPriceMismatches, buildCreateOrderArgs, getOrderTypeFromUpdatedFlags, resolveConfiguredPriceBound, virtualizeOrder, convertToSpreadPlaceholder, toRailHolePlaceholder, geometryTypeForSlotIndex, detectGapEvacuationCandidates, updateGapEvacuationStreaks, resolveSpreadOrderSide, chainOrderMatchesSlot, chainOrderMatchesSlotWithTolerance, crossingCandidateChainId, isCrossingCheckCandidate, buildCrossingCheckCandidates, parseSlotIndex, filterOrdersByType, buildOutsideInPairGroups, extractBatchOperationResults, formatUnmatchedChainOrder, isOrderOnChain, isOrderVirtual, hasOnChainId, isOrderPlaced, isPhantomOrder, isSlotAvailable, isEmptyGridSlot, isOrderHealthy, checkSizeThreshold, checkSizesBeforeMinimum, calculateIdealBoundary, assignGridRoles, resolveOnChainRetypeType, shouldFlagOutOfSpread, buildIndexes, validateIndexes, ordersEqual, buildDelta, getOrderSize, deriveTargetBoundary, isShiftEligibleFill, getActiveOrdersTotal, getSideBudget, calculateBudgetedSizes, buildCreateOpFingerprint, isOrderGoneErrorMessage, recordDuplicateOrphanDetection, clearDuplicateOrphanDetection, duplicateOrphanLogInfo, chainOrderUnchangedFromCache, detectCrossedBookPlan, collectKnownOnChainOrderIds };
 //# sourceMappingURL=order.js.map