dexbot 1.4.25 → 1.5.0

package/dist/modules/dexbot_cow_runtime.js

@@ -1445,7 +1445,8 @@ function validateOrderSizeForExecution(bot, size, type, orderLike = null, fallba
  * LAST-FILL-GUARD helper — pivot ± halfIncrement (replaces price-tolerance).
  *  last fill @x with increment i: BUY < x*(1 - i/2/100), SELL > x*(1 + i/2/100)
  *  e.g. x=1000, i=0.5% => BUY < 997.5, SELL > 1002.5
- * Cold (pivot null or lastType null) => disabled. Spread correction bypasses via cowResult.origin === 'spread-correction'.
+ * Cold (pivot null or lastType null) => disabled. Spread-correction CREATES
+ * bypass per-action (see broadcast sites); rotations never bypass.
  * @param {number} price - Target order price
  * @param {number} size - Order size (unused, kept for compat)
  * @param {string} type - ORDER_TYPES.BUY/SELL
@@ -1478,6 +1479,123 @@ function isLastFillGuardBlocked(price, _size, type, lastPrice, lastType, increme
         return { blocked: true, pivot, halfInc, threshold: sellThreshold };
     return { blocked: false, pivot: null, halfInc, threshold: null };
 }
+/**
+ * Refresh the LAST-FILL guard pivot from fills that arrived while the current
+ * batch was being planned or broadcast but have not been ingested yet.
+ *
+ * The pivot (_lastFilledPrice) is recorded per fill-processing batch, but a
+ * multi-chunk COW broadcast spans tens of seconds — fills detected mid-cycle
+ * sit in _incomingFillQueue until the cycle ends, so ops built for later
+ * chunks would be checked against a stale pivot (production incident: a chunk
+ * planned with a pre-crash pivot placed asks 0.6% below the true latest fill
+ * that was already queued). Peek-only: never drains the queue, the owning
+ * fill cycle still processes every entry. Best-effort: returns false when no
+ * queued fill yields a usable side + price.
+ * @param {import('./dexbot_class.js').DEXBot} bot
+ * @returns {boolean} True when the pivot was refreshed from queued fills
+ */
+function refreshLastFillPivotFromQueue(bot) {
+    try {
+        const queue = bot?._incomingFillQueue;
+        if (!Array.isArray(queue) || queue.length === 0)
+            return false;
+        const mgr = bot?.manager;
+        if (!mgr || !mgr.orders)
+            return false;
+        const assets = mgr.assets;
+        const findSlotByOrderId = (orderId) => {
+            if (!orderId)
+                return null;
+            try {
+                for (const o of mgr.orders.values()) {
+                    if (o?.orderId === orderId)
+                        return o;
+                }
+            }
+            catch { /* ignore iteration errors */ }
+            return null;
+        };
+        let latest = null;
+        for (const fill of queue) {
+            const fillOp = fill?.op?.[1] || fill;
+            const orderId = fillOp?.order_id || fill?.orderId;
+            let type = null;
+            let price = null;
+            // Prefer the grid slot: a limit fill executes at (or better than)
+            // its slot price, which is exactly the guard's price convention.
+            const slot = findSlotByOrderId(orderId);
+            if (slot && (slot.type === ORDER_TYPES.BUY || slot.type === ORDER_TYPES.SELL)) {
+                type = slot.type;
+                const slotPrice = Number(slot.price);
+                if (Number.isFinite(slotPrice) && slotPrice > 0)
+                    price = slotPrice;
+            }
+            // Fall back to fill economics (B/A convention, mirroring
+            // _computeFillContext's pays-asset side resolution, including
+            // SPREAD slots carrying on-chain orders).
+            if ((type == null || price == null) && fillOp?.pays && fillOp?.receives && assets?.assetA && assets?.assetB) {
+                try {
+                    const paysId = fillOp.pays.asset_id;
+                    const paysAmt = Number(fillOp.pays.amount);
+                    const recvAmt = Number(fillOp.receives.amount);
+                    if (Number.isFinite(paysAmt) && paysAmt > 0 && Number.isFinite(recvAmt) && recvAmt > 0) {
+                        const paysFloat = (base, precision) => base / Math.pow(10, precision);
+                        if (paysId === assets.assetA.id) {
+                            type = ORDER_TYPES.SELL;
+                            price = paysFloat(recvAmt, assets.assetB.precision) / paysFloat(paysAmt, assets.assetA.precision);
+                        }
+                        else if (paysId === assets.assetB.id) {
+                            type = ORDER_TYPES.BUY;
+                            price = paysFloat(paysAmt, assets.assetB.precision) / paysFloat(recvAmt, assets.assetA.precision);
+                        }
+                    }
+                }
+                catch { /* best-effort */ }
+            }
+            if ((type === ORDER_TYPES.BUY || type === ORDER_TYPES.SELL)
+                && Number.isFinite(price) && price > 0) {
+                latest = { price: price, type };
+            }
+        }
+        if (!latest)
+            return false;
+        mgr._lastFilledPrice = latest.price;
+        mgr._lastFilledType = latest.type;
+        if (latest.type === ORDER_TYPES.BUY) {
+            mgr._lastFilledBuyPrice = latest.price;
+        }
+        else {
+            mgr._lastFilledSellPrice = latest.price;
+        }
+        try {
+            mgr.logger?.log?.(`[LAST-FILL-GUARD] Pivot refreshed from ${queue.length} pending queued fill(s): ` +
+                `${latest.type} @${Format.formatPrice6(latest.price)}`, 'debug');
+        }
+        catch { /* ignore logging errors */ }
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Resolve the grid increment percent for the LAST-FILL guard in one place so
+ * every check site and the batch summary use (and print) the same value.
+ * Falls back to the default 0.5 when unset/invalid.
+ * @param {import('./dexbot_class.js').DEXBot} bot
+ * @returns {number} Positive increment percent
+ */
+function resolveLastFillGuardIncrement(bot) {
+    const raw = Number(bot?.manager?.config?.incrementPercent
+        ?? bot?.config?.incrementPercent
+        ?? constantsModule?.DEFAULT_CONFIG?.incrementPercent
+        ?? 0.5);
+    if (Number.isFinite(raw) && raw > 0)
+        return raw;
+    return Number(constantsModule?.DEFAULT_CONFIG?.incrementPercent) > 0
+        ? Number(constantsModule?.DEFAULT_CONFIG?.incrementPercent)
+        : 0.5;
+}
 /**
  * Build COW actions array from a simple plan object.
  * @param {import('./dexbot_class.js').DEXBot} bot
@@ -1489,6 +1607,12 @@ function buildActionsFromPlan(_bot, plan) {
         ? { ordersToPlace: plan }
         : (plan || {});
     const { ordersToPlace = [], ordersToRotate = [], ordersToUpdate = [], ordersToCancel = [] } = normalizedPlan;
+    // Per-action origin: guard bypasses are scoped per action (not per batch),
+    // so a future rotation entry merged into a correction plan cannot silently
+    // inherit the spread-correction bypass. Actions built outside this helper
+    // carry no origin and default to guarded (safe default).
+    const planOrigin = normalizedPlan?.origin;
+    const withOrigin = (action) => (planOrigin ? { ...action, origin: planOrigin } : action);
     const actions = [];
     for (const o of ordersToCancel) {
         if (o?.orderId) {
@@ -1509,7 +1633,7 @@ function buildActionsFromPlan(_bot, plan) {
         const orderType = r?.type || oldOrder?.type;
         if (!id || !orderId || !newGridId || !orderType || !Number.isFinite(newPrice) || !(newSize > 0))
             continue;
-        actions.push({
+        actions.push(withOrigin({
             type: COW_ACTIONS.UPDATE,
             id,
             orderId,
@@ -1522,7 +1646,7 @@ function buildActionsFromPlan(_bot, plan) {
                 price: newPrice,
                 size: newSize
             }
-        });
+        }));
     }
     for (const o of ordersToUpdate) {
         const partialOrder = o?.partialOrder || o;
@@ -1534,7 +1658,7 @@ function buildActionsFromPlan(_bot, plan) {
             : Number(partialOrder?.size || 0);
         if (!id || !orderId)
             continue;
-        actions.push({
+        actions.push(withOrigin({
             type: COW_ACTIONS.UPDATE,
             id,
             orderId,
@@ -1546,12 +1670,12 @@ function buildActionsFromPlan(_bot, plan) {
                 type: orderType,
                 size: newSize
             }
-        });
+        }));
     }
     for (const o of ordersToPlace) {
         if (!o?.id)
             continue;
-        actions.push({ type: COW_ACTIONS.CREATE, id: o.id, order: o });
+        actions.push(withOrigin({ type: COW_ACTIONS.CREATE, id: o.id, order: o }));
     }
     return actions;
 }
@@ -2343,6 +2467,14 @@ async function updateOrdersOnChainBatchCOW(bot, cowResult, options = {}) {
     const opContexts = [];
     const skippedUpdateSlotIds = new Set();
     let skippedUpdateCount = 0;
+    // Per-batch LAST-FILL-GUARD disposition counters. Per-action pass lines
+    // would spam big batches, so the guard emits one batch summary instead
+    // (see the summary after the action loop below).
+    const lastFillGuardStats = { checked: 0, passed: 0, skipped: 0, bypassed: 0 };
+    // Whether any guard check in this batch refreshed the pivot from
+    // still-queued fills — reported in the batch summary so a pivot change
+    // that altered a guard decision is visible at info, not just debug.
+    let lastFillGuardPivotRefreshed = false;
     // Slots whose size-update op was broadcast with a post-fill-clamped
     // target: the working grid still holds the planned (larger) size, so the
     // slots are re-synced from master before commit to keep the committed
@@ -2458,18 +2590,35 @@ async function updateOrdersOnChainBatchCOW(bot, cowResult, options = {}) {
                         continue;
                     }
                     // LAST-FILL PRICE GUARD: pivot ± halfIncrement (BUY < pivot*(1-half), SELL > pivot*(1+half)).
-                    // Spread correction bypasses so gap repair can close. Cold (null) => disabled.
+                    // Bypass is per-action: only spread-correction CREATES skip so gap repair can close.
+                    // The batch-level origin is honored only for actions without their own origin stamp
+                    // (back-compat for plans that bypass buildActionsFromPlan). Cold (null) => disabled.
                     try {
-                        if (cowResult?.origin !== 'spread-correction') {
+                        const actionOrigin = action?.origin;
+                        const batchOrigin = cowResult?.origin;
+                        const isCorrectionCreate = actionOrigin === 'spread-correction'
+                            || (actionOrigin == null && batchOrigin === 'spread-correction');
+                        if (!isCorrectionCreate) {
+                            try {
+                                if (refreshLastFillPivotFromQueue(bot))
+                                    lastFillGuardPivotRefreshed = true;
+                            }
+                            catch { /* best-effort */ }
                             const lastPrice = bot.manager?._lastFilledPrice;
                             const lastType = bot.manager?._lastFilledType;
-                            const inc = Number(bot.manager?.config?.incrementPercent ?? bot?.config?.incrementPercent ?? constantsModule?.DEFAULT_CONFIG?.incrementPercent ?? 0.5);
+                            const inc = resolveLastFillGuardIncrement(bot);
                             const check = isLastFillGuardBlocked(createPrice, order.size, order.type, lastPrice, lastType, inc);
+                            lastFillGuardStats.checked++;
                             if (check.blocked) {
+                                lastFillGuardStats.skipped++;
                                 const dir = order.type === ORDER_TYPES.BUY ? 'above' : 'below';
                                 bot.manager.logger.log(`[LAST-FILL-GUARD] Skipping ${order.type} CREATE for ${order.id} at ${Format.formatPrice6(createPrice)}: ${dir} last filled ${Format.formatPrice6(check.pivot)} (halfInc ${check.halfInc}% thr ${Format.formatPrice6(check.threshold)}); re-planned after market moves`, 'warn');
                                 continue;
                             }
+                            lastFillGuardStats.passed++;
+                        }
+                        else {
+                            lastFillGuardStats.bypassed++;
                         }
                     }
                     catch (_e) { /* guard is best-effort */ }
@@ -2564,23 +2713,34 @@ async function updateOrdersOnChainBatchCOW(bot, cowResult, options = {}) {
                             continue;
                         }
                         // LAST-FILL PRICE GUARD (UPDATE rotation): pivot ± halfIncrement — same as CREATE.
+                        // No origin bypass here, ever: a rotation reprices, so it always obeys the guard —
+                        // even if a future correction plan carries rotation entries (per-action scoping).
+                        // The pivot is refreshed from still-queued fills first: fills detected mid-broadcast
+                        // sit in _incomingFillQueue until the fill cycle ends, and without this the later
+                        // chunks of a long broadcast would be checked against a stale pivot.
                         try {
-                            if (cowResult?.origin !== 'spread-correction') {
-                                const lastPrice = bot.manager?._lastFilledPrice;
-                                const lastType = bot.manager?._lastFilledType;
-                                const inc = Number(bot.manager?.config?.incrementPercent ?? bot?.config?.incrementPercent ?? constantsModule?.DEFAULT_CONFIG?.incrementPercent ?? 0.5);
-                                const check = isLastFillGuardBlocked(newPrice, newSize, orderType, lastPrice, lastType, inc);
-                                if (check.blocked) {
-                                    skippedUpdateCount++;
-                                    if (action.id)
-                                        skippedUpdateSlotIds.add(action.id);
-                                    if (action.newGridId)
-                                        skippedUpdateSlotIds.add(action.newGridId);
-                                    const dir = orderType === ORDER_TYPES.BUY ? 'above' : 'below';
-                                    bot.manager.logger.log(`[LAST-FILL-GUARD] Skipping ${orderType} UPDATE for ${action.id} -> ${action.newGridId} at ${Format.formatPrice6(newPrice)}: ${dir} last filled ${Format.formatPrice6(check.pivot)} (halfInc ${check.halfInc}% thr ${Format.formatPrice6(check.threshold)})`, 'warn');
-                                    continue;
-                                }
+                            try {
+                                if (refreshLastFillPivotFromQueue(bot))
+                                    lastFillGuardPivotRefreshed = true;
+                            }
+                            catch { /* best-effort */ }
+                            const lastPrice = bot.manager?._lastFilledPrice;
+                            const lastType = bot.manager?._lastFilledType;
+                            const inc = resolveLastFillGuardIncrement(bot);
+                            const check = isLastFillGuardBlocked(newPrice, newSize, orderType, lastPrice, lastType, inc);
+                            lastFillGuardStats.checked++;
+                            if (check.blocked) {
+                                lastFillGuardStats.skipped++;
+                                skippedUpdateCount++;
+                                if (action.id)
+                                    skippedUpdateSlotIds.add(action.id);
+                                if (action.newGridId)
+                                    skippedUpdateSlotIds.add(action.newGridId);
+                                const dir = orderType === ORDER_TYPES.BUY ? 'above' : 'below';
+                                bot.manager.logger.log(`[LAST-FILL-GUARD] Skipping ${orderType} UPDATE for ${action.id} -> ${action.newGridId} at ${Format.formatPrice6(newPrice)}: ${dir} last filled ${Format.formatPrice6(check.pivot)} (halfInc ${check.halfInc}% thr ${Format.formatPrice6(check.threshold)})`, 'warn');
+                                continue;
                             }
+                            lastFillGuardStats.passed++;
                         }
                         catch (_e) { /* best-effort */ }
                         const { amountToSell, minToReceive } = buildCreateOrderArgs({ type: orderType, size: newSize, price: newPrice }, assetA, assetB);
@@ -2693,6 +2853,31 @@ async function updateOrdersOnChainBatchCOW(bot, cowResult, options = {}) {
                                         `${crossedOrderLabel(fbCrossed)}; re-planned after its cancel confirms.`, 'warn');
                                     continue;
                                 }
+                                // LAST-FILL GUARD (fallback variant): this CREATE
+                                // replaces a rotation UPDATE at a repriced level,
+                                // so it obeys the same guard with a refreshed
+                                // pivot — no origin bypass, same as rotations.
+                                try {
+                                    if (refreshLastFillPivotFromQueue(bot))
+                                        lastFillGuardPivotRefreshed = true;
+                                }
+                                catch { /* best-effort */ }
+                                try {
+                                    const fbInc = resolveLastFillGuardIncrement(bot);
+                                    const fbCheck = isLastFillGuardBlocked(fbPrice, fbSize, fbType, bot.manager?._lastFilledPrice, bot.manager?._lastFilledType, fbInc);
+                                    lastFillGuardStats.checked++;
+                                    if (fbCheck.blocked) {
+                                        lastFillGuardStats.skipped++;
+                                        const fbDir = fbType === ORDER_TYPES.BUY ? 'above' : 'below';
+                                        bot.manager.logger.log(`[LAST-FILL-GUARD] Skipping CREATE fallback for ${targetSlotId} at ` +
+                                            `${Format.formatPrice6(fbPrice)}: ${fbDir} last filled ` +
+                                            `${Format.formatPrice6(fbCheck.pivot)} (halfInc ${fbCheck.halfInc}% thr ` +
+                                            `${Format.formatPrice6(fbCheck.threshold)}); re-planned after market moves`, 'warn');
+                                        continue;
+                                    }
+                                    lastFillGuardStats.passed++;
+                                }
+                                catch (_fbGuardErr) { /* guard is best-effort */ }
                                 const fbArgs = buildCreateOrderArgs({ type: fbType, size: fbSize, price: fbPrice }, assetA, assetB);
                                 const fbResult = await chainOrders.buildCreateOrderOp(bot.account, fbArgs.amountToSell, fbArgs.sellAssetId, fbArgs.minToReceive, fbArgs.receiveAssetId, null);
                                 if (fbResult) {
@@ -2723,6 +2908,39 @@ async function updateOrdersOnChainBatchCOW(bot, cowResult, options = {}) {
                 }
             }
         }
+        // Batch-level LAST-FILL-GUARD summary: per-action pass lines would spam
+        // big batches, so one line per batch records the mode, pivot, resolved
+        // increment, and pass/skip/bypass counts — the guard's pass decisions
+        // are what incident reconstruction needs. Origin folds in here as
+        // mode=bypassed(<origin>); there is no second source of truth.
+        // Cold (guard off) is warn, not info — a disabled guard must say so.
+        // pivotRefreshed surfaces whether a mid-broadcast queued fill moved the
+        // pivot under this batch's checks (the refresh itself stays debug).
+        // Note the printed pivot is end-of-batch state: when pivotRefreshed is
+        // true, early actions were checked against the older pivot.
+        try {
+            const totalGuarded = lastFillGuardStats.checked + lastFillGuardStats.bypassed;
+            if (totalGuarded > 0) {
+                const sumPivotRaw = bot.manager?._lastFilledPrice;
+                const sumType = bot.manager?._lastFilledType;
+                const sumInc = resolveLastFillGuardIncrement(bot);
+                const cold = sumPivotRaw == null || !Number.isFinite(Number(sumPivotRaw)) || sumType == null;
+                const batchOrigin = cowResult?.origin;
+                const mode = cold
+                    ? 'disabled(cold)'
+                    : (lastFillGuardStats.bypassed > 0 && lastFillGuardStats.checked === 0)
+                        ? `bypassed(${batchOrigin || 'unknown'})`
+                        : (lastFillGuardStats.bypassed > 0
+                            ? `active+bypassed(${batchOrigin || 'unknown'})`
+                            : 'active');
+                const pivotStr = cold ? 'none' : `${Format.formatPrice6(Number(sumPivotRaw))}(${sumType})`;
+                bot.manager.logger.log(`[LAST-FILL-GUARD] mode=${mode} pivot=${pivotStr} inc=${sumInc}% ` +
+                    `pivotRefreshed=${lastFillGuardPivotRefreshed} ` +
+                    `checked=${lastFillGuardStats.checked} passed=${lastFillGuardStats.passed} ` +
+                    `skipped=${lastFillGuardStats.skipped} bypassed=${lastFillGuardStats.bypassed}`, cold ? 'warn' : 'info');
+            }
+        }
+        catch { /* summary is best-effort */ }
         if (skippedUpdateCount > 0) {
             restoreSkippedUpdateSlotsInWorkingGrid(bot, workingGrid, skippedUpdateSlotIds, skippedUpdateCount);
         }
@@ -3470,7 +3688,12 @@ async function processBatchResults(bot, result, opContexts) {
                         });
                     }
                 }
-                bot.manager.logger.log(`Placed ${ctx.order.type} order ${ctx.order.id} -> ${chainOrderId}`, 'info');
+                // Success line mirrors the failure-path fingerprint below
+                // (type/price/size) so both are greppable by the same keys —
+                // this is what ties a fill back to the slot that placed it.
+                bot.manager.logger.log(`Placed ${ctx.order.type} order ${ctx.order.id} ` +
+                    `@${Format.formatPrice6(ctx.order.price)} x${Format.formatAmount(ctx.order.size)} ` +
+                    `-> ${chainOrderId}`, 'info');
             }
             else {
                 const fingerprint = [
@@ -3571,7 +3794,7 @@ async function processBatchResults(bot, result, opContexts) {
         updateOperationCount
     };
 }
-export { isLastFillGuardBlocked, buildOutsideInPairGroupsForOrders, buildOutsideInPairGroupsForCreateEntries, extractOperationResults, findMissingCreateResultContexts, markMissingCreateResultsAsStructuralBlocker, formatUnmatchedChainOrderForLog, recordPendingBroadcast, clearPendingBroadcasts, clearPendingBroadcastsForSlots, popPushedWorkingGrid, buildChainOrderFingerprint, normalizeChainOrderForPendingMatch, findChainOrderForSlot, reconcileAfterUncertainBroadcast, reconcileAfterUncertainBroadcastImpl, autoCancelOneUnmatchedOrphan, shouldExecuteCreatePairMode, executeWithRetryOnUncertain, executeChunkedWithRetryOnUncertain, formatPartialBroadcastSummary, executeOperationsWithStrategy, validateOperationFunds, resolveIdealSizeForValidation, validateOrderSizeForExecution, buildActionsFromPlan, buildCowResultFromPlan, restoreSkippedUpdateSlotsInWorkingGrid, applyRotationTransitionsToWorkingGrid, pollChainForConfirmation, updateOrdersOnChainBatchCOW, processBatchResults, adoptPlacedBatchFromChain };
+export { isLastFillGuardBlocked, refreshLastFillPivotFromQueue, buildOutsideInPairGroupsForOrders, buildOutsideInPairGroupsForCreateEntries, extractOperationResults, findMissingCreateResultContexts, markMissingCreateResultsAsStructuralBlocker, formatUnmatchedChainOrderForLog, recordPendingBroadcast, clearPendingBroadcasts, clearPendingBroadcastsForSlots, popPushedWorkingGrid, buildChainOrderFingerprint, normalizeChainOrderForPendingMatch, findChainOrderForSlot, reconcileAfterUncertainBroadcast, reconcileAfterUncertainBroadcastImpl, autoCancelOneUnmatchedOrphan, shouldExecuteCreatePairMode, executeWithRetryOnUncertain, executeChunkedWithRetryOnUncertain, formatPartialBroadcastSummary, executeOperationsWithStrategy, validateOperationFunds, resolveIdealSizeForValidation, validateOrderSizeForExecution, buildActionsFromPlan, buildCowResultFromPlan, restoreSkippedUpdateSlotsInWorkingGrid, applyRotationTransitionsToWorkingGrid, pollChainForConfirmation, updateOrdersOnChainBatchCOW, processBatchResults, adoptPlacedBatchFromChain };
 export default {
     buildOutsideInPairGroupsForOrders,
     buildOutsideInPairGroupsForCreateEntries,