dexbot 1.3.3 → 1.4.1

package/dist/modules/dexbot_cow_runtime.js

@@ -10,14 +10,15 @@
  */
 const chainOrders = require('./chain_orders');
 const { BroadcastUncertainError } = require('./dexbot_credential_client');
-const { buildCreateOrderArgs, buildCreateOpFingerprint, extractBatchOperationResults, formatUnmatchedChainOrder, convertToSpreadPlaceholder, buildOutsideInPairGroups, } = require('./order/utils/order');
+const { buildCreateOrderArgs, buildCreateOpFingerprint, extractBatchOperationResults, formatUnmatchedChainOrder, convertToSpreadPlaceholder, buildOutsideInPairGroups, isOrderPlaced, } = require('./order/utils/order');
 const { validateCreateTargetSlots } = require('./order/utils/validate');
-const { validateOrderSize } = require('./order/utils/math');
+const { validateOrderSize, findPriceCollision } = require('./order/utils/math');
 // Lazy accessor so test mocks on the math module export take effect at call time.
 function getAssetFees(...args) { return require('./order/utils/math').getAssetFees(...args); }
-const { COW_ACTIONS, ORDER_STATES, ORDER_TYPES, REBALANCE_STATES, FILL_PROCESSING, } = require('./constants');
+const { COW_ACTIONS, ORDER_STATES, ORDER_TYPES, REBALANCE_STATES, } = require('./constants');
 const Format = require('./order/format');
 const { WorkingGrid } = require('./order/working_grid');
+const { getErrorMessage } = require('./utils/errors');
 /**
  * Group orders into outside-in pairs for atomic create execution.
  * @param {Array} orders
@@ -26,8 +27,8 @@ const { WorkingGrid } = require('./order/working_grid');
 function buildOutsideInPairGroupsForOrders(orders) {
     return buildOutsideInPairGroups(orders, {
         isValid: Boolean,
-        getType: o => o.type,
-        getPrice: o => o.price,
+        getType: (o) => o.type,
+        getPrice: (o) => o.price,
     });
 }
 /**
@@ -37,9 +38,9 @@ function buildOutsideInPairGroupsForOrders(orders) {
  */
 function buildOutsideInPairGroupsForCreateEntries(createEntries) {
     return buildOutsideInPairGroups(createEntries, {
-        isValid: e => Boolean(e?.context?.order),
-        getType: e => e.context.order.type,
-        getPrice: e => e.context.order.price,
+        isValid: (e) => Boolean(e?.context?.order),
+        getType: (e) => e.context.order.type,
+        getPrice: (e) => e.context.order.price,
     });
 }
 /**
@@ -100,8 +101,8 @@ async function recoverAfterMissingCreateResults(bot, reason = 'missing create op
         }
         const preRecoveryMissingCreateBlockers = Array.isArray(bot.manager._lastUnmatchedChainOrders)
             ? bot.manager._lastUnmatchedChainOrders
-                .filter(order => order?.reason === 'missing-create-result')
-                .map(order => ({ ...order }))
+                .filter((order) => order?.reason === 'missing-create-result')
+                .map((order) => ({ ...order }))
             : [];
         const openOrders = await chainOrders.readOpenOrders(accountRef);
         const recoveryResult = await bot.manager.syncFromOpenOrders(openOrders, {
@@ -113,15 +114,15 @@ async function recoverAfterMissingCreateResults(bot, reason = 'missing create op
         }
     }
     catch (err) {
-        bot.manager?.logger?.log?.(`[COW] CRITICAL: Recovery sync failed after ${reason}: ${err.message}`, 'error');
+        bot.manager?.logger?.log?.(`[COW] CRITICAL: Recovery sync failed after ${reason}: ${getErrorMessage(err)}`, 'error');
         if (typeof bot.manager?.requestStructuralGridResync === 'function') {
             try {
                 await bot.manager.requestStructuralGridResync(`recovery sync failed after ${reason}`, {
-                    error: err.message
+                    error: getErrorMessage(err)
                 });
             }
             catch (scheduleErr) {
-                bot.manager?.logger?.log?.(`[COW] CRITICAL: Failed to schedule structural resync after recovery failure: ${scheduleErr.message}`, 'error');
+                bot.manager?.logger?.log?.(`[COW] CRITICAL: Failed to schedule structural resync after recovery failure: ${getErrorMessage(scheduleErr)}`, 'error');
             }
         }
     }
@@ -136,15 +137,15 @@ function preserveMissingCreateBlockersAfterRecovery(bot, blockers, recoveryResul
     if (!Array.isArray(blockers) || blockers.length === 0 || !bot.manager)
         return;
     const adoptedSlotIds = new Set((Array.isArray(recoveryResult?.updatedOrders) ? recoveryResult.updatedOrders : [])
-        .filter(order => order?.id && order?.orderId)
-        .map(order => order.id));
-    const unresolvedBlockers = blockers.filter(blocker => !blocker.slotId || !adoptedSlotIds.has(blocker.slotId));
+        .filter((order) => order?.id && order?.orderId)
+        .map((order) => order.id));
+    const unresolvedBlockers = blockers.filter((blocker) => !blocker.slotId || !adoptedSlotIds.has(blocker.slotId));
     if (unresolvedBlockers.length === 0)
         return;
     const currentUnmatched = Array.isArray(bot.manager._lastUnmatchedChainOrders)
         ? bot.manager._lastUnmatchedChainOrders
         : [];
-    const currentKeys = new Set(currentUnmatched.map(order => `${order.reason || ''}:${order.slotId || ''}:${order.operationIndex ?? ''}`));
+    const currentKeys = new Set(currentUnmatched.map((order) => `${order.reason || ''}:${order.slotId || ''}:${order.operationIndex ?? ''}`));
     const restored = [...currentUnmatched];
     for (const blocker of unresolvedBlockers) {
         const key = `${blocker.reason || ''}:${blocker.slotId || ''}:${blocker.operationIndex ?? ''}`;
@@ -165,7 +166,7 @@ function preserveMissingCreateBlockersAfterRecovery(bot, blockers, recoveryResul
  */
 function markMissingCreateResultsAsStructuralBlocker(bot, missingCreateResults) {
     const blockers = Array.isArray(missingCreateResults)
-        ? missingCreateResults.map(item => {
+        ? missingCreateResults.map((item) => {
             const order = item.ctx?.order || {};
             const fingerprint = [
                 `type=${order.type || 'unknown'}`,
@@ -188,7 +189,7 @@ function markMissingCreateResultsAsStructuralBlocker(bot, missingCreateResults)
         const existing = Array.isArray(bot.manager._lastUnmatchedChainOrders)
             ? bot.manager._lastUnmatchedChainOrders
             : [];
-        const keys = new Set(existing.map(order => `${order.reason || ''}:${order.slotId || ''}:${order.operationIndex ?? ''}`));
+        const keys = new Set(existing.map((order) => `${order.reason || ''}:${order.slotId || ''}:${order.operationIndex ?? ''}`));
         const merged = [...existing];
         for (const blocker of blockers) {
             const key = `${blocker.reason || ''}:${blocker.slotId || ''}:${blocker.operationIndex ?? ''}`;
@@ -406,12 +407,12 @@ async function reconcileAfterUncertainBroadcast(bot, err, opContexts, options =
  * @param {Object} options
  * @returns {Promise<Object>}
  */
-async function reconcileAfterUncertainBroadcastImpl(bot, err, opContexts, options) {
+async function reconcileAfterUncertainBroadcastImpl(bot, err, opContexts, _options) {
     const startedAt = Date.now();
     const pending = (bot.manager && bot.manager._pendingBroadcasts instanceof Map)
         ? Array.from(bot.manager._pendingBroadcasts.values())
         : [];
-    const createContextCount = opContexts.filter(c => c && c.kind === 'create').length;
+    const createContextCount = opContexts.filter((c) => c && c.kind === 'create').length;
     const nonCreateContextCount = opContexts.length - createContextCount;
     bot.manager.logger.log(`[COW][UNCERTAIN] batchId=${err?.batchId || 'n/a'} ops=${opContexts.length} ` +
         `creates=${createContextCount} nonCreates=${nonCreateContextCount} ` +
@@ -459,9 +460,9 @@ async function reconcileAfterUncertainBroadcastImpl(bot, err, opContexts, option
     // 2b. Second pass: search for any unmatched chain orders by fingerprint
     // across all known pending slots.
     if (adopted.length < pending.length) {
-        const adoptedSlotIds = new Set(adopted.map(a => a.entry.slotId));
+        const adoptedSlotIds = new Set(adopted.map((a) => a.entry.slotId));
         for (const o of chainSnapshot) {
-            if (adopted.some(a => a.match.id === o.id))
+            if (adopted.some((a) => a.match.id === o.id))
                 continue;
             for (const entry of pending) {
                 if (adoptedSlotIds.has(entry.slotId))
@@ -475,10 +476,49 @@ async function reconcileAfterUncertainBroadcastImpl(bot, err, opContexts, option
             }
         }
         // Rebuild discarded list to remove newly adopted entries.
-        const newlyAdoptedSlotIds = new Set(adopted.map(a => a.entry.slotId));
-        discarded = pending.filter(e => !newlyAdoptedSlotIds.has(e.slotId));
+        const newlyAdoptedSlotIds = new Set(adopted.map((a) => a.entry.slotId));
+        discarded = pending.filter((e) => !newlyAdoptedSlotIds.has(e.slotId));
+    }
+    // 3a. Re-read chain for discarded CREATE entries to catch broadcasts that
+    // landed between the initial read and this point (TOCTOU window).
+    if (discarded.length > 0 && typeof chainOrders.readOpenOrders === 'function') {
+        const createDiscarded = discarded.filter((e) => {
+            const ctx = opContexts[e.ctxIndex];
+            return ctx && ctx.kind === 'create';
+        });
+        if (createDiscarded.length > 0) {
+            try {
+                const freshChain = await chainOrders.readOpenOrders(accountRef);
+                const remainingDiscarded = [];
+                for (const entry of discarded) {
+                    const ctx = opContexts[entry.ctxIndex];
+                    if (ctx && ctx.kind === 'create') {
+                        const match = findChainOrderForSlot(bot, freshChain, entry.slotId, {
+                            sell: entry.finalInts?.sell,
+                            receive: entry.finalInts?.receive,
+                            orderType: entry.orderType,
+                            fingerprint: entry.fingerprint,
+                        });
+                        if (match) {
+                            adopted.push({ entry, match });
+                            bot.manager.logger.log(`[COW][UNCERTAIN] Late-adopted discarded CREATE for slot ${entry.slotId} (${match.id}) via fresh chain read`, 'info');
+                        }
+                        else {
+                            remainingDiscarded.push(entry);
+                        }
+                    }
+                    else {
+                        remainingDiscarded.push(entry);
+                    }
+                }
+                discarded = remainingDiscarded;
+            }
+            catch {
+                bot.manager.logger.log('[COW][UNCERTAIN] Fresh chain read for late adoption failed; proceeding with original discard decisions.', 'warn');
+            }
+        }
     }
-    // 3. Apply decisions
+    // 3b. Apply decisions
     let adoptedCount = 0;
     let discardedCount = 0;
     for (const { entry, match } of adopted) {
@@ -574,8 +614,8 @@ async function reconcileAfterUncertainBroadcastImpl(bot, err, opContexts, option
     // chain snapshot.
     const alreadyScheduled = bot._structuralGridResyncRunning || bot._structuralGridResyncTimer;
     if (!alreadyScheduled && chainSnapshot.length > 0) {
-        const reconciledOrderIds = new Set(adopted.map(a => a.match?.id).filter(Boolean));
-        const unreconciledCount = chainSnapshot.filter(o => !reconciledOrderIds.has(o.id)).length;
+        const reconciledOrderIds = new Set(adopted.map((a) => a.match?.id).filter(Boolean));
+        const unreconciledCount = chainSnapshot.filter((o) => !reconciledOrderIds.has(o.id)).length;
         if (unreconciledCount > 0) {
             bot.manager.logger.log(`[COW][UNCERTAIN] ${unreconciledCount} chain order(s) remain unreconciled after uncertain broadcast recovery. ` +
                 `These may be legitimate pre-existing orders or leftovers from a prior cycle. Requesting structural resync.`, 'warn');
@@ -625,11 +665,11 @@ async function autoCancelOneUnmatchedOrphan(bot) {
     if (unmatched.length === 0) {
         return { cancelled: false, reason: 'no-unmatched' };
     }
-    const fingerprinted = unmatched.find(u => u && u.fingerprint);
+    const fingerprinted = unmatched.find((u) => u && u.fingerprint);
     if (fingerprinted) {
         return { cancelled: false, reason: 'fingerprinted-handle-via-recovery' };
     }
-    const target = unmatched.find(u => u && u.reason === 'price-drift-orphan');
+    const target = unmatched.find((u) => u && u.reason === 'price-drift-orphan');
     if (!target) {
         return { cancelled: false, reason: 'no-price-drift-orphan', message: 'no price-drift orphan to cancel; other unmatched orders are adoptable' };
     }
@@ -661,10 +701,10 @@ async function autoCancelOneUnmatchedOrphan(bot) {
  * @param {Array} opContexts
  * @returns {boolean}
  */
-function shouldExecuteCreatePairMode(bot, opContexts) {
+function shouldExecuteCreatePairMode(_bot, opContexts) {
     if (!Array.isArray(opContexts) || opContexts.length < 2)
         return false;
-    if (!opContexts.every(ctx => ctx?.kind === 'create' && ctx?.order))
+    if (!opContexts.every((ctx) => ctx?.kind === 'create' && ctx?.order))
         return false;
     let hasBuy = false;
     let hasSell = false;
@@ -741,8 +781,8 @@ async function executeOperationsWithStrategy(bot, operations, opContexts) {
     const mergedContexts = [];
     for (let idx = 0; idx < groups.length; idx++) {
         const group = groups[idx];
-        const groupOps = group.map(e => e.operation);
-        const groupContexts = group.map(e => e.context);
+        const groupOps = group.map((e) => e.operation);
+        const groupContexts = group.map((e) => e.context);
         bot.manager.logger.log(`[COW] Broadcasting create pair group ${idx + 1}/${groups.length} (${groupOps.length} op${groupOps.length > 1 ? 's' : ''}, outside->center)`, 'info');
         let groupResult;
         try {
@@ -877,7 +917,7 @@ function validateOperationFunds(bot, operations, assetA, assetB) {
  * @param {number|null} [fallbackSize=null]
  * @returns {number|null}
  */
-function resolveIdealSizeForValidation(bot, orderLike, fallbackSize = null) {
+function resolveIdealSizeForValidation(_bot, orderLike, fallbackSize = null) {
     const candidates = [
         orderLike?.idealSize,
         orderLike?.order?.idealSize,
@@ -911,7 +951,7 @@ function validateOrderSizeForExecution(bot, size, type, orderLike = null, fallba
  * @param {Object|Array} plan
  * @returns {Array}
  */
-function buildActionsFromPlan(bot, plan) {
+function buildActionsFromPlan(_bot, plan) {
     const normalizedPlan = Array.isArray(plan)
         ? { ordersToPlace: plan }
         : (plan || {});
@@ -1089,9 +1129,9 @@ async function updateOrdersOnChainBatchCOW(bot, cowResult) {
     bot._currentCycleId = (Number.isFinite(Number(bot._currentCycleId)) ? Number(bot._currentCycleId) : 0) + 1;
     const { workingGrid, workingIndexes, workingBoundary, actions } = cowResult;
     if (bot.config.dryRun) {
-        const cancelCount = actions.filter(a => a.type === COW_ACTIONS.CANCEL).length;
-        const createCount = actions.filter(a => a.type === COW_ACTIONS.CREATE).length;
-        const updateCount = actions.filter(a => a.type === COW_ACTIONS.UPDATE).length;
+        const cancelCount = actions.filter((a) => a.type === COW_ACTIONS.CANCEL).length;
+        const createCount = actions.filter((a) => a.type === COW_ACTIONS.CREATE).length;
+        const updateCount = actions.filter((a) => a.type === COW_ACTIONS.UPDATE).length;
         if (cancelCount > 0)
             bot.manager.logger.log(`Dry run: would cancel ${cancelCount} orders`, 'info');
         if (createCount > 0)
@@ -1100,11 +1140,28 @@ async function updateOrdersOnChainBatchCOW(bot, cowResult) {
             bot.manager.logger.log(`Dry run: would update ${updateCount} orders`, 'info');
         return { executed: true, hadRotation: false };
     }
-    const createSlotValidation = validateCreateTargetSlots(actions, bot.manager?.orders);
+    const chainOrderCandidates = Array.isArray(bot.manager?._lastUnmatchedChainOrders)
+        ? bot.manager._lastUnmatchedChainOrders
+        : [];
+    const createSlotValidation = validateCreateTargetSlots(actions, bot.manager?.orders, bot.manager?.assets, chainOrderCandidates);
     if (!createSlotValidation.isValid) {
         for (const violation of createSlotValidation.violations) {
-            bot.manager.logger.log(`[COW] Rejecting CREATE for occupied slot ${violation.targetId}: ` +
-                `existing orderId=${violation.currentOrderId}, type=${violation.currentType}, state=${violation.currentState}`, 'error');
+            let reason;
+            switch (violation.reason) {
+                case 'price_collision':
+                    reason = `existing placed order ${violation.currentOrderId} at same price`;
+                    break;
+                case 'same_batch_price_collision':
+                    reason = `another CREATE in the same batch at same price`;
+                    break;
+                case 'chain_orphan_collision':
+                    reason = `unmatched on-chain order ${violation.currentOrderId} at same price`;
+                    break;
+                default:
+                    reason = `existing orderId=${violation.currentOrderId}`;
+            }
+            bot.manager.logger.log(`[COW] Rejecting CREATE for slot ${violation.targetId}: ${reason} ` +
+                `(type=${violation.currentType}, state=${violation.currentState})`, 'error');
         }
         return {
             executed: false,
@@ -1114,10 +1171,10 @@ async function updateOrdersOnChainBatchCOW(bot, cowResult) {
             hadRotation: false
         };
     }
-    const hasCreateActions = actions.some(action => action.type === COW_ACTIONS.CREATE);
+    const hasCreateActions = actions.some((action) => action.type === COW_ACTIONS.CREATE);
     if (hasCreateActions && bot.manager?._recoveryExhaustedAt) {
         const exhaustedAge = Date.now() - bot.manager._recoveryExhaustedAt;
-        bot.manager.logger.log?.(`[RECOVERY-EXHAUSTED] Blocking ${actions.filter(a => a.type === COW_ACTIONS.CREATE).length} CREATE(s) ` +
+        bot.manager.logger.log?.(`[RECOVERY-EXHAUSTED] Blocking ${actions.filter((a) => a.type === COW_ACTIONS.CREATE).length} CREATE(s) ` +
             `(exhausted ${(exhaustedAge / 1000).toFixed(0)}s ago). ` +
             `Waiting for next fill or sync cycle to reset recovery state.`, 'warn');
         return {
@@ -1140,11 +1197,11 @@ async function updateOrdersOnChainBatchCOW(bot, cowResult) {
             if (typeof bot.manager.requestStructuralGridResync === 'function') {
                 if (bot.manager._recoveryState)
                     bot.manager._recoveryState = { ...bot.manager._recoveryState, structuralResyncRequested: true };
-                await bot.manager.requestStructuralGridResync('pending broadcasts before COW create', { pendingBroadcasts: pendingBroadcasts.map(p => p.slotId) });
+                await bot.manager.requestStructuralGridResync('pending broadcasts before COW create', { pendingBroadcasts: pendingBroadcasts.map((p) => p.slotId) });
             }
             try {
                 await reconcileAfterUncertainBroadcast(bot, new BroadcastUncertainError('rejected CREATE batch had pending broadcasts', {
-                    operations: pendingBroadcasts.map(p => p.order),
+                    operations: pendingBroadcasts.map((p) => p.order),
                     accountName: bot.account,
                     batchId: bot._currentBatchId || null,
                     payload: null,
@@ -1163,7 +1220,7 @@ async function updateOrdersOnChainBatchCOW(bot, cowResult) {
         }
         const unmatchedSample = unmatchedChainOrders
             .slice(0, 3)
-            .map(o => formatUnmatchedChainOrderForLog(o))
+            .map((o) => formatUnmatchedChainOrderForLog(o))
             .join(' | ');
         bot.manager.logger.log(`[COW] ${unmatchedChainOrders.length} unmatched chain order(s) blocking CREATES ` +
             (unmatchedSample ? `(${unmatchedSample})` : '') +
@@ -1251,12 +1308,12 @@ async function updateOrdersOnChainBatchCOW(bot, cowResult) {
                     opContexts.push({ kind: 'cancel', order });
                 }
                 catch (err) {
-                    const orderNotFound = /\bnot found\b/i.test(err.message) || /\bdoes not exist\b/i.test(err.message);
+                    const orderNotFound = /\bnot found\b/i.test(getErrorMessage(err)) || /\bdoes not exist\b/i.test(getErrorMessage(err));
                     if (orderNotFound) {
                         bot.manager.logger.log(`[COW] Cancel skipped for ${action.id} (${action.orderId}): order already removed from chain`, 'debug');
                     }
                     else {
-                        bot.manager.logger.log(`Failed to prepare cancel op for ${action.id}: ${err.message}`, 'error');
+                        bot.manager.logger.log(`Failed to prepare cancel op for ${action.id}: ${getErrorMessage(err)}`, 'error');
                     }
                 }
             }
@@ -1282,6 +1339,16 @@ async function updateOrdersOnChainBatchCOW(bot, cowResult) {
                             `drifted from planned=${plannedPrice} to live=${livePrice} ` +
                             `(diff=${priceDrift}); rebuilding CREATE op with live price.`, 'debug');
                     }
+                    const createPrice = effectiveOrder.price;
+                    const createSize = effectiveOrder.size;
+                    const batchCollision = findPriceCollision(opContexts, order.id, createPrice, createSize, order.type, bot.manager.assets, (ctx) => ctx.kind === 'create');
+                    if (batchCollision) {
+                        bot.manager.logger.log(`[COW] Skipping CREATE for ${order.id} at ${Format.formatPrice6(createPrice)}: ` +
+                            `same-batch CREATE ${batchCollision.id} already at ` +
+                            `price ${Format.formatPrice6(batchCollision.order.price)}. ` +
+                            `The next reconcile cycle will resolve the mismatch.`, 'warn');
+                        continue;
+                    }
                     const args = buildCreateOrderArgs(effectiveOrder, assetA, assetB);
                     const buildResult = await chainOrders.buildCreateOrderOp(bot.account, args.amountToSell, args.sellAssetId, args.minToReceive, args.receiveAssetId, null);
                     if (!buildResult) {
@@ -1298,7 +1365,7 @@ async function updateOrdersOnChainBatchCOW(bot, cowResult) {
                     });
                 }
                 catch (err) {
-                    bot.manager.logger.log(`Failed to prepare create op for ${action.id}: ${err.message}`, 'error');
+                    bot.manager.logger.log(`Failed to prepare create op for ${action.id}: ${getErrorMessage(err)}`, 'error');
                 }
             }
             else if (action.type === COW_ACTIONS.UPDATE) {
@@ -1370,7 +1437,7 @@ async function updateOrdersOnChainBatchCOW(bot, cowResult) {
                     opContexts.push({ kind: 'size-update', updateInfo: { partialOrder, newSize }, finalInts: op.finalInts });
                 }
                 catch (err) {
-                    const orderNotFound = /\bnot found\b/i.test(err.message) || /\bdoes not exist\b/i.test(err.message);
+                    const orderNotFound = /\bnot found\b/i.test(getErrorMessage(err)) || /\bdoes not exist\b/i.test(getErrorMessage(err));
                     if (orderNotFound) {
                         try {
                             const fbOrder = action.order || bot.manager.orders.get(action.id);
@@ -1393,6 +1460,20 @@ async function updateOrdersOnChainBatchCOW(bot, cowResult) {
                                 bot.manager.logger.log(`[COW] CREATE fallback for ${action.id} rejected by size validation: ${sizeCheck.reason}`, 'warn');
                             }
                             else if (fbType && fbSize > 0 && fbPrice > 0) {
+                                const fbCollision = findPriceCollision(bot.manager.orders.values(), targetSlotId, fbPrice, fbSize, fbType, bot.manager.assets, isOrderPlaced);
+                                if (fbCollision) {
+                                    bot.manager.logger.log(`[COW] Skipping CREATE fallback for ${targetSlotId} at ${Format.formatPrice6(fbPrice)}: ` +
+                                        `existing placed order ${fbCollision.id} (${fbCollision.orderId}) ` +
+                                        `already at price ${Format.formatPrice6(fbCollision.price)}.`, 'warn');
+                                    continue;
+                                }
+                                const fbBatchCollision = findPriceCollision(opContexts, targetSlotId, fbPrice, fbSize, fbType, bot.manager.assets, (ctx) => ctx.kind === 'create');
+                                if (fbBatchCollision) {
+                                    bot.manager.logger.log(`[COW] Skipping CREATE fallback for ${targetSlotId} at ${Format.formatPrice6(fbPrice)}: ` +
+                                        `same-batch CREATE ${fbBatchCollision.id} already at ` +
+                                        `price ${Format.formatPrice6(fbBatchCollision.order.price)}.`, 'warn');
+                                    continue;
+                                }
                                 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) {
@@ -1416,10 +1497,10 @@ async function updateOrdersOnChainBatchCOW(bot, cowResult) {
                             }
                         }
                         catch (fbErr) {
-                            bot.manager.logger.log(`[COW] CREATE fallback also failed for ${action.id}: ${fbErr.message}`, 'warn');
+                            bot.manager.logger.log(`[COW] CREATE fallback also failed for ${action.id}: ${getErrorMessage(fbErr)}`, 'warn');
                         }
                     }
-                    bot.manager.logger.log(`Failed to prepare update op for ${action.id}: ${err.message}`, 'error');
+                    bot.manager.logger.log(`Failed to prepare update op for ${action.id}: ${getErrorMessage(err)}`, 'error');
                 }
             }
         }
@@ -1451,7 +1532,7 @@ async function updateOrdersOnChainBatchCOW(bot, cowResult) {
                 const missingCreateResults = findMissingCreateResultContexts(preCommitResults, executedContexts);
                 if (missingCreateResults.length > 0) {
                     const missingSlots = missingCreateResults
-                        .map(item => item.ctx?.order?.id || item.ctx?.id || `op-${item.index}`)
+                        .map((item) => item.ctx?.order?.id || item.ctx?.id || `op-${item.index}`)
                         .join(', ');
                     bot.manager.logger.log(`[COW] Refusing to commit working grid: ${missingCreateResults.length} CREATE op(s) ` +
                         `returned no chainOrderId (${missingSlots}). Discarding working grid and syncing from chain.`, 'error');
@@ -1462,7 +1543,7 @@ async function updateOrdersOnChainBatchCOW(bot, cowResult) {
                     return {
                         executed: false,
                         hadRotation: false,
-                        missingCreateResults: missingCreateResults.map(item => ({
+                        missingCreateResults: missingCreateResults.map((item) => ({
                             index: item.index,
                             slotId: item.ctx?.order?.id || item.ctx?.id || null
                         }))
@@ -1498,26 +1579,26 @@ async function updateOrdersOnChainBatchCOW(bot, cowResult) {
                 bot._metrics.batchesExecuted++;
                 bot.manager._clearWorkingGridRef();
                 clearPendingBroadcasts(bot.manager?._pendingBroadcasts);
-                return { executed: true, hadRotation: true, ...batchResult };
+                return { ...batchResult, executed: true, hadRotation: true };
             }
             else {
                 bot.manager.logger.log('[COW] Blockchain failed - working grid discarded, master unchanged', 'warn');
                 bot.manager._clearWorkingGridRef();
                 clearPendingBroadcasts(bot.manager?._pendingBroadcasts);
-                return { executed: false, hadRotation: false, ...result };
+                return { ...result, executed: false, hadRotation: false };
             }
         }
         finally {
             bot.manager._throwOnIllegalState = false;
             await bot.manager.resumeFundRecalc();
             bot.manager.stopBroadcasting();
-            const createCount = actions.filter(a => a.type === COW_ACTIONS.CREATE).length;
-            const cancelCount = actions.filter(a => a.type === COW_ACTIONS.CANCEL).length;
+            const createCount = actions.filter((a) => a.type === COW_ACTIONS.CREATE).length;
+            const cancelCount = actions.filter((a) => a.type === COW_ACTIONS.CANCEL).length;
             bot.manager.logger.logFundsStatus(bot.manager, `AFTER COW batch (created=${createCount}, cancelled=${cancelCount})`);
         }
     }
     catch (err) {
-        bot.manager.logger.log(`[COW] Batch transaction failed: ${err.message}`, 'error');
+        bot.manager.logger.log(`[COW] Batch transaction failed: ${getErrorMessage(err)}`, 'error');
         if (err?.partialOnChainState) {
             bot.manager.logger.log(`[COW] Non-atomic grouped execution detected (${err.groupsBroadcast}/${err.groupsTotal} groups broadcast). Local rollback cannot undo confirmed on-chain operations; next sync/reconcile will converge state.`, 'warn');
         }
@@ -1537,11 +1618,11 @@ async function updateOrdersOnChainBatchCOW(bot, cowResult) {
         ];
         for (const pattern of patterns) {
             let m;
-            while ((m = pattern.exec(err.message)) !== null) {
+            while ((m = pattern.exec(getErrorMessage(err))) !== null) {
                 staleOrderIds.add(m[1]);
             }
         }
-        if (/Cannot deduct all or more from order than order contains/.test(err.message)) {
+        if (/Cannot deduct all or more from order than order contains/.test(getErrorMessage(err))) {
             return await bot._recoverBatchSizeDrift(err, opContexts);
         }
         if (staleOrderIds.size > 0) {
@@ -1724,7 +1805,7 @@ async function processBatchResults(bot, result, opContexts) {
         }
     }
     if (updatesToApply.length > 0) {
-        await bot.manager.applyGridUpdateBatch(updatesToApply.map(u => u.order), 'batch-results-process', { skipAccounting: true });
+        await bot.manager.applyGridUpdateBatch(updatesToApply.map((u) => u.order), 'batch-results-process', { skipAccounting: true });
     }
     return {
         executed: true,