dexbot 1.5.1 → 1.5.2

package/dist/modules/dexbot_cow_runtime.js

@@ -18,7 +18,7 @@ const { buildCreateOrderArgs, buildCreateOpFingerprint, extractBatchOperationRes
 import * as validate from './order/utils/validate.js';
 const { validateCreateTargetSlots, evaluateCommit, hasExecutableActions, stampGapEvacuationRotation } = validate;
 import * as math from './order/utils/math.js';
-const { validateOrderSize, findCrossedOrder, priceSlotEqual, isEvacuationRotationAllowed, getSellStartIdx, getPrecisionByOrderType, isSlotIndexInGapBand } = math;
+const { validateOrderSize, findCrossedOrder, priceSlotEqual, isEvacuationRotationAllowed, isEvacuationSizeStillValid, getSellStartIdx, getPrecisionByOrderType, isSlotIndexInGapBand } = math;
 /**
  * Re-verify a B-stamped gap-evacuation rotation against the LIVE committed
  * geometry (boundaryIdx/_gapSlots at execution time). The stamp freezes
@@ -280,28 +280,18 @@ function crossedOrderLabel(crossed) {
  * 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).
+ *
+ * Delegates to the shared order-utils builder so every crossing guard (COW
+ * create/rotation/fallback, startup reconcile placement, price-correction)
+ * sees the same set. Pending entries are pushed as wrappers (slotId +
+ * order): their inner order has no chain id yet, so orderId-only
+ * predicates would blind the guard to them — the shared
+ * isCrossingCheckCandidate predicate accepts slot-id-only wrappers.
  * @param {Object} bot
  * @returns {any[]}
  */
 function buildCrossingCandidates(bot) {
-    const mgr = bot?.manager;
-    if (!mgr)
-        return [];
-    const candidates = mgr.orders instanceof Map ? [...mgr.orders.values()] : [];
-    if (mgr._pendingBroadcasts instanceof Map) {
-        for (const entry of mgr._pendingBroadcasts.values()) {
-            const o = entry?.order;
-            if (o && o.type != null && o.price != null)
-                candidates.push(o);
-        }
-    }
-    if (Array.isArray(mgr._lastUnmatchedChainOrders)) {
-        for (const o of mgr._lastUnmatchedChainOrders) {
-            if (o && o.type != null && o.price != null)
-                candidates.push(o);
-        }
-    }
-    return candidates;
+    return orderUtils.buildCrossingCheckCandidates(bot?.manager);
 }
 /**
  * Drop only the pending-broadcast entries for the given CREATE slots.
@@ -1935,10 +1925,14 @@ async function pollChainForConfirmation(bot, opContexts, options = {}) {
     // Only CREATE operations can be confirmed by polling (they appear as new orders on chain)
     const createContexts = opContexts.filter((ctx) => ctx && ctx.kind === 'create' && ctx.finalInts && ctx.order);
     if (createContexts.length === 0) {
-        return { allConfirmed: false, confirmed: [], unconfirmed: [...opContexts] };
+        return { allConfirmed: false, confirmed: [], unconfirmed: [...opContexts], confirmedChainIds: [] };
     }
     const accountRef = bot.accountId || bot.account?.id || bot.account;
     let remaining = [...createContexts];
+    // Chain ids of the poll-matched fresh creates. Retained (not just
+    // logged) so the poll-confirmed adoption path can re-read them BY ID —
+    // the window fallback cannot prove a lagging node has them yet.
+    const matchedChainIds = [];
     for (let attempt = 1; attempt <= maxPollRetries; attempt++) {
         try {
             const chainRead = await readOpenOrdersWithMetaSafe(chainOrders, accountRef);
@@ -1978,6 +1972,8 @@ async function pollChainForConfirmation(bot, opContexts, options = {}) {
                 });
                 if (match) {
                     bot.manager.logger.log(`[COW][POLL] Confirmed CREATE for slot ${ctx.order.id} on chain as ${match.id}`, 'debug');
+                    if (match.id && /^1\.7\.\d+$/.test(String(match.id)))
+                        matchedChainIds.push(String(match.id));
                 }
                 else {
                     stillUnconfirmed.push(ctx);
@@ -1986,7 +1982,7 @@ async function pollChainForConfirmation(bot, opContexts, options = {}) {
             if (stillUnconfirmed.length === 0) {
                 const confirmed = createContexts;
                 bot.manager.logger.log(`[COW][POLL] All ${confirmed.length} CREATE(s) confirmed on chain after ${attempt} poll(s)`, 'info');
-                return { allConfirmed: true, confirmed, unconfirmed: [] };
+                return { allConfirmed: true, confirmed, unconfirmed: [], confirmedChainIds: [...matchedChainIds] };
             }
             remaining = stillUnconfirmed;
             if (attempt < maxPollRetries) {
@@ -2003,7 +1999,7 @@ async function pollChainForConfirmation(bot, opContexts, options = {}) {
     const confirmed = createContexts.filter((ctx) => !remaining.includes(ctx));
     bot.manager.logger.log(`[COW][POLL] ${confirmed.length}/${createContexts.length} CREATE(s) confirmed after ${maxPollRetries} polls; ` +
         `${remaining.length} unconfirmed. Falling back to reconciliation.`, 'warn');
-    return { allConfirmed: false, confirmed, unconfirmed: remaining };
+    return { allConfirmed: false, confirmed, unconfirmed: remaining, confirmedChainIds: [...matchedChainIds] };
 }
 /**
  * Restore skipped update slots in the working grid to master state.
@@ -2378,6 +2374,12 @@ async function updateOrdersOnChainBatchCOW(bot, cowResult, options = {}) {
                 case 'chain_orphan_collision':
                     reason = `unmatched on-chain order ${violation.currentOrderId} at same price`;
                     break;
+                case 'same_batch_price_duplicate':
+                    reason = `another CREATE in the same batch at same broadcast price (duplicate of ${violation.duplicateOf})`;
+                    break;
+                case 'create_price_invalid':
+                    reason = `broadcast price is not a finite number`;
+                    break;
                 default:
                     reason = `existing orderId=${violation.currentOrderId}`;
             }
@@ -2678,10 +2680,7 @@ async function updateOrdersOnChainBatchCOW(bot, cowResult, options = {}) {
                     // an opposite-side order cancelled in a later chunk would
                     // otherwise coexist with this create mid-broadcast and
                     // self-trade (production incident class).
-                    const createCrossed = findCrossedOrder(crossingCandidates, createPrice, order.type, bot.manager.assets, (o) => {
-                        const oid = o?.orderId || o?.chainOrderId;
-                        return o && oid && !cancelOpIndexByOrderId.has(oid);
-                    });
+                    const createCrossed = findCrossedOrder(crossingCandidates, createPrice, order.type, bot.manager.assets, (o) => orderUtils.isCrossingCheckCandidate(o, null, cancelOpIndexByOrderId));
                     const intraBatchCrossed = createCrossed ? null : findCrossedOrder(intraBatchCandidates, createPrice, order.type, bot.manager.assets);
                     const effectiveCrossed = createCrossed || intraBatchCrossed;
                     if (effectiveCrossed) {
@@ -2795,13 +2794,7 @@ async function updateOrdersOnChainBatchCOW(bot, cowResult, options = {}) {
                         // fatal fund assert). Skipping is safe: the slot keeps its
                         // old commitment and the next plan re-evaluates once
                         // the crossed order's cancel confirms.
-                        const crossedOrder = findCrossedOrder([...crossingCandidates, ...intraBatchCandidates], newPrice, orderType, bot.manager.assets, (o) => {
-                            const oid = o?.orderId || o?.chainOrderId;
-                            return o
-                                && oid
-                                && oid !== action.orderId
-                                && !cancelOpIndexByOrderId.has(oid);
-                        });
+                        const crossedOrder = findCrossedOrder([...crossingCandidates, ...intraBatchCandidates], newPrice, orderType, bot.manager.assets, (o) => orderUtils.isCrossingCheckCandidate(o, action.orderId, cancelOpIndexByOrderId));
                         if (crossedOrder) {
                             skippedUpdateCount++;
                             if (action.id)
@@ -2855,6 +2848,32 @@ async function updateOrdersOnChainBatchCOW(bot, cowResult, options = {}) {
                                             `boundary ${bot.manager?.boundaryIdx}/gap ${bot.manager?._gapSlots} — re-proving live`, 'warn');
                                     }
                                 }
+                                if (stampUsable) {
+                                    // Stamped-size re-proof: the stamp proved the
+                                    // plan-time size, but an unprocessed fill can
+                                    // land between plan-build and execution and
+                                    // shrink the booked remaining below the
+                                    // planned size (the PARTIAL-only growth guard
+                                    // above misses it when the slot is not yet
+                                    // PARTIAL). Re-prove against the LIVE master
+                                    // size; invalidating the stamp routes into
+                                    // the unstamped probe below, whose
+                                    // isEvacuationRotationAllowed also rejects
+                                    // growth and then falls through to the
+                                    // normal last-fill guard.
+                                    let stampPrecision = null;
+                                    try {
+                                        stampPrecision = getPrecisionByOrderType(bot.manager.assets, orderType);
+                                    }
+                                    catch {
+                                        stampPrecision = null;
+                                    }
+                                    if (!isEvacuationSizeStillValid(newSize, Number(masterOrder?.size), stampPrecision)) {
+                                        stampUsable = false;
+                                        bot.manager.logger.log(`[LAST-FILL-GUARD] Stamped evacuation for ${action.id} -> ${action.newGridId} lost its size cover: ` +
+                                            `planned ${Format.formatAmount(newSize)} exceeds booked remaining ${Format.formatAmount(Number(masterOrder?.size))} — re-proving live`, 'warn');
+                                    }
+                                }
                                 if (stampUsable) {
                                     bypassedEvacuation = true;
                                     bot.manager.logger.log(`[LAST-FILL-GUARD] Allowing ${orderType} evacuation UPDATE for ${action.id} -> ${action.newGridId} at ${Format.formatPrice6(newPrice)}: ` +
@@ -3034,10 +3053,7 @@ async function updateOrdersOnChainBatchCOW(bot, cowResult, options = {}) {
                                 // replaces — no crossing of an opposite-side
                                 // live order whose cancel is not already
                                 // queued at an earlier op position.
-                                const fbCrossed = findCrossedOrder(crossingCandidates, fbPrice, fbType, bot.manager.assets, (o) => {
-                                    const oid = o?.orderId || o?.chainOrderId;
-                                    return o && oid && !cancelOpIndexByOrderId.has(oid);
-                                });
+                                const fbCrossed = findCrossedOrder(crossingCandidates, fbPrice, fbType, bot.manager.assets, (o) => orderUtils.isCrossingCheckCandidate(o, null, cancelOpIndexByOrderId));
                                 if (fbCrossed) {
                                     bot.manager.logger.log(`[COW-CROSS-GUARD] Skipping CREATE fallback for ${targetSlotId} at ` +
                                         `${Format.formatPrice6(fbPrice)}: new ${fbType} crosses live ` +
@@ -3400,7 +3416,7 @@ async function updateOrdersOnChainBatchCOW(bot, cowResult, options = {}) {
                         // refused-commit path: adopt from chain, keep pending
                         // protection if adoption is unavailable.
                         bot.manager.logger.log(`[COW][UNCERTAIN] Poll-confirmed commit refused; adopting placed orders from chain`, 'warn');
-                        const pollAdopted = await adoptPlacedBatchFromChain(bot, chainOrders, '[COW][UNCERTAIN]');
+                        const pollAdopted = await adoptPlacedBatchFromChain(bot, chainOrders, '[COW][UNCERTAIN]', { placedContexts: opContexts, polledCreateIds: confirmation.confirmedChainIds });
                         if (!pollAdopted) {
                             bot.manager.logger.log('[COW][UNCERTAIN] Poll-refused commit with unavailable chain adoption; keeping pending protection pending structural resync', 'error');
                             await requestStructuralResync(bot, 'poll-confirmed commit refused (chain adoption unavailable)', { reason: 'chain-adoption-unavailable' });
@@ -3420,7 +3436,7 @@ async function updateOrdersOnChainBatchCOW(bot, cowResult, options = {}) {
                     // on a failed adoption would let the next cycle re-create the
                     // VIRTUAL slots as duplicate on-chain orders. Keep the
                     // protection and defer to a structural resync instead.
-                    const pollAdoptedOk = await adoptPlacedBatchFromChain(bot, chainOrders, '[COW][UNCERTAIN]');
+                    const pollAdoptedOk = await adoptPlacedBatchFromChain(bot, chainOrders, '[COW][UNCERTAIN]', { placedContexts: opContexts, polledCreateIds: confirmation.confirmedChainIds });
                     if (!pollAdoptedOk) {
                         bot.manager.logger.log('[COW][UNCERTAIN] Poll-confirmed commit with unavailable chain adoption; keeping pending protection pending structural resync', 'error');
                         await requestStructuralResync(bot, 'poll-confirmed commit (chain adoption unavailable)', { reason: 'chain-adoption-unavailable' });
@@ -3520,9 +3536,13 @@ async function requestStructuralResync(bot, reason, details = {}) {
  * @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) {
+function collectKnownOnChainOrderIds(mgr, placedResults, placedContexts, extraCreateIds = null) {
     const masterIds = new Set();
     const grid = mgr && mgr.grid;
     if (Array.isArray(grid)) {
@@ -3532,6 +3552,17 @@ function collectKnownOnChainOrderIds(mgr, placedResults, placedContexts) {
             }
         }
     }
+    // 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);
@@ -3547,6 +3578,33 @@ function collectKnownOnChainOrderIds(mgr, placedResults, placedContexts) {
             }
         }
     }
+    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] };
 }
@@ -3573,6 +3631,10 @@ function collectKnownOnChainOrderIds(mgr, placedResults, placedContexts) {
  * @param {Object} [opts]
  * @param {any} [opts.placedResults] - broadcast result carrying operation_results
  * @param {any[]} [opts.placedContexts] - opContexts aligned with operation_results
+ * @param {string[]} [opts.polledCreateIds] - fresh CREATE chain ids confirmed by
+ *   the uncertain-broadcast poll (no broadcast result exists on that path);
+ *   routes the poll call sites through the by-id path with its lagging-create
+ *   retry instead of the unguarded window fallback
  * @returns {Promise<boolean>} true if master was adopted from the chain
  */
 /**
@@ -3605,16 +3667,20 @@ async function restoreBoundaryAfterAdoption(bot, workingBoundary) {
     }
 }
 async function adoptPlacedBatchFromChain(bot, chainOrders, logPrefix, opts = {}) {
-    const { placedResults = null, placedContexts = null } = opts || {};
+    const { placedResults = null, placedContexts = null, polledCreateIds = null } = opts || {};
     try {
         const mgr = bot.manager;
         const accountRef = bot.accountId || bot.account?.id || bot.account;
-        // PREFERRED: re-read the exact placed/existing orders by id. Only when we
-        // have the broadcast result (so the set includes the freshest CREATE ids);
-        // without it the by-id set would be incomplete and would wrongly sync
-        // master against a partial picture.
-        const { all: knownIds, createIds } = placedResults
-            ? collectKnownOnChainOrderIds(mgr, placedResults, placedContexts)
+        // PREFERRED: re-read the exact placed/existing orders by id. The by-id
+        // set needs the broadcast result (freshest CREATE ids), the
+        // poll-confirmed CREATE ids, or at minimum the contexts referencing
+        // existing chain orders — without any id hints the set would be
+        // incomplete and would wrongly sync master against a partial picture.
+        const haveIdHints = Boolean(placedResults)
+            || (Array.isArray(placedContexts) && placedContexts.length > 0)
+            || (Array.isArray(polledCreateIds) && polledCreateIds.length > 0);
+        const { all: knownIds, createIds } = haveIdHints
+            ? collectKnownOnChainOrderIds(mgr, placedResults, placedContexts, polledCreateIds)
             : { all: [], createIds: [] };
         if (knownIds.length > 0 && typeof chainOrders.batchReadOrders === 'function') {
             // Retry/backoff (fix #6): a fresh CREATE absent from the first read