dexbot 1.4.1 → 1.4.3

package/dist/modules/order/grid.js

@@ -172,6 +172,7 @@ function _snapshotFundState(manager) {
 const math_1 = require("./utils/math");
 const order_1 = require("./utils/order");
 const system_1 = require("./utils/system");
+const withPoolRef_1 = require("./utils/withPoolRef");
 const market_adapter_whitelist_1 = require("../market_adapter_whitelist");
 const errors_1 = require("../utils/errors");
 function calculateGapSlots(incrementPercent, targetSpreadPercent, gridLimitsOverride) {
@@ -499,7 +500,7 @@ async function loadGrid(manager, grid, boundaryIdx = null) {
         return;
     return await manager._gridLock.acquire(async () => {
         try {
-            await manager._initializeAssets();
+            await (0, system_1.withBlockchainRetry)(() => manager._initializeAssets(), 'initializeAssets', { logger: manager.logger });
         }
         catch (e) {
             manager.logger?.log?.(`Asset initialization failed during grid load: ${(0, errors_1.getErrorMessage)(e)}`, 'warn');
@@ -596,7 +597,12 @@ async function loadGrid(manager, grid, boundaryIdx = null) {
 async function initializeGrid(manager) {
     if (!manager)
         throw new Error('initializeGrid requires a manager instance');
-    await manager._initializeAssets();
+    try {
+        await (0, system_1.withBlockchainRetry)(() => manager._initializeAssets(), 'initializeAssets', { logger: manager.logger });
+    }
+    catch (e) {
+        manager.logger?.log?.(`Asset initialization failed during grid init: ${(0, errors_1.getErrorMessage)(e)}`, 'warn');
+    }
     // FIX: Add explicit state validation to prevent cryptic errors later
     if (!manager.assets || !manager.assets.assetA || !manager.assets.assetB) {
         throw new Error('Asset initialization did not complete properly - assetA or assetB undefined');
@@ -610,7 +616,7 @@ async function initializeGrid(manager) {
     if (typeof mpRaw !== 'number' || isNaN(mpRaw)) {
         try {
             const { BitShares } = require('../bitshares_client');
-            const derived = await (0, system_1.derivePrice)(BitShares, manager.config.assetA, manager.config.assetB, manager.config.priceMode || 'auto');
+            const derived = await (0, withPoolRef_1.derivePriceWithPoolRef)(BitShares, manager.config.assetA, manager.config.assetB, manager.config.priceMode || 'auto', manager.config.poolRef);
             if (derived) {
                 manager.logger?.log?.(`[DIAGNOSTIC] initializeGrid: Derived new startPrice=${derived.toFixed(8)} (mode=${manager.config.priceMode || 'auto'})`, 'info');
                 manager.config.startPrice = Number(derived);
@@ -649,7 +655,7 @@ async function initializeGrid(manager) {
     else if (gpMode === 'pool' || gpMode === 'book') {
         try {
             const { BitShares } = require('../bitshares_client');
-            const derived = await (0, system_1.derivePrice)(BitShares, manager.config.assetA, manager.config.assetB, gpMode);
+            const derived = await (0, withPoolRef_1.derivePriceWithPoolRef)(BitShares, manager.config.assetA, manager.config.assetB, gpMode, manager.config.poolRef);
             if (derived) {
                 gp = Number(derived);
                 gpSource = gpMode;
@@ -870,49 +876,79 @@ async function recalculateGrid(manager, opts) {
     // Total timeout across all steps — prevents indefinite hang even if
     // an individual withBlockchainRetry step pins the event loop.
     const totalTimeoutMs = constants_1.PIPELINE_TIMING.TIMEOUT_MS * 2; // 10 min
+    let _resyncAborted = false;
     const work = (async () => {
-        manager.logger?.log?.('Starting full resync...', 'info');
-        // #1: Initialize assets (returns immediately if already loaded)
-        await manager._initializeAssets();
-        // #2: Fetch account totals with timeout + retry + node failover
-        await (0, system_1.withBlockchainRetry)(() => manager.fetchAccountTotals(), 'fetchAccountTotals', { logger: manager.logger });
-        // #3: Read open orders with timeout + retry + node failover
-        const chainOpenOrders = await (0, system_1.withBlockchainRetry)(() => readOpenOrdersFn(), 'readOpenOrders', { logger: manager.logger });
-        if (!Array.isArray(chainOpenOrders))
-            return;
-        await (0, system_1.withBlockchainRetry)(() => manager.syncFromOpenOrders(chainOpenOrders, { skipAccounting: true }), 'syncFromOpenOrders', { logger: manager.logger });
-        manager.resetFunds();
-        await manager.persistGrid();
-        await initializeGrid(manager);
-        const { reconcileGridOrders } = require('./grid_reconcile');
-        // #5: Reconcile grid orders with timeout + retry + node failover
         try {
-            await (0, system_1.withBlockchainRetry)(() => reconcileGridOrders({ manager, config: manager.config, account, privateKey, chainOrders, chainOpenOrders }), 'reconcileGridOrders', 
-            // 5 min: Phase 2 of reconcile does sequential creates (~3s each);
-            // the default 30s timeout would kill mid-batch and cause duplicate-
-            // accumulation death spirals. PIPELINE_TIMING.TIMEOUT_MS gives enough
-            // headroom for all pending creates+updates to finish in one shot.
-            { logger: manager.logger, timeoutMs: constants_1.PIPELINE_TIMING.TIMEOUT_MS });
+            manager.logger?.log?.('Starting full resync...', 'info');
+            if (_resyncAborted)
+                return;
+            // #1: Initialize assets with timeout + retry + node failover
+            try {
+                await (0, system_1.withBlockchainRetry)(() => manager._initializeAssets(), 'initializeAssets', { logger: manager.logger });
+            }
+            catch (e) {
+                manager.logger?.log?.(`Asset initialization failed during resync: ${(0, errors_1.getErrorMessage)(e)}`, 'warn');
+            }
+            if (_resyncAborted)
+                return;
+            // #2: Fetch account totals with timeout + retry + node failover
+            await (0, system_1.withBlockchainRetry)(() => manager.fetchAccountTotals(), 'fetchAccountTotals', { logger: manager.logger });
+            if (_resyncAborted)
+                return;
+            // #3: Read open orders with timeout + retry + node failover
+            const chainOpenOrders = await (0, system_1.withBlockchainRetry)(() => readOpenOrdersFn(), 'readOpenOrders', { logger: manager.logger });
+            if (_resyncAborted)
+                return;
+            if (!Array.isArray(chainOpenOrders))
+                return;
+            await (0, system_1.withBlockchainRetry)(() => manager.syncFromOpenOrders(chainOpenOrders, { skipAccounting: true }), 'syncFromOpenOrders', { logger: manager.logger });
+            if (_resyncAborted)
+                return;
+            manager.resetFunds();
+            if (_resyncAborted)
+                return;
+            await manager.persistGrid();
+            if (_resyncAborted)
+                return;
+            await initializeGrid(manager);
+            if (_resyncAborted)
+                return;
+            const { reconcileGridOrders } = require('./grid_reconcile');
+            // #5: Reconcile grid orders with timeout + retry + node failover
+            try {
+                await (0, system_1.withBlockchainRetry)(() => reconcileGridOrders({ manager, config: manager.config, account, privateKey, chainOrders, chainOpenOrders }), 'reconcileGridOrders', 
+                // 5 min: Phase 2 of reconcile does sequential creates (~3s each);
+                // the default 30s timeout would kill mid-batch and cause duplicate-
+                // accumulation death spirals. PIPELINE_TIMING.TIMEOUT_MS gives enough
+                // headroom for all pending creates+updates to finish in one shot.
+                { logger: manager.logger, timeoutMs: constants_1.PIPELINE_TIMING.TIMEOUT_MS });
+            }
+            catch (err) {
+                manager.logger?.log?.(`Error during startup order reconciliation: ${(0, errors_1.getErrorMessage)(err)}`, 'error');
+                throw new Error(`Grid recalculation failed during order reconciliation: ${(0, errors_1.getErrorMessage)(err)}`);
+            }
+            if (_resyncAborted)
+                return;
+            manager.logger?.log?.('Full resync complete.', 'info');
         }
-        catch (err) {
-            manager.logger?.log?.(`Error during startup order reconciliation: ${(0, errors_1.getErrorMessage)(err)}`, 'error');
-            throw new Error(`Grid recalculation failed during order reconciliation: ${(0, errors_1.getErrorMessage)(err)}`);
+        finally {
+            manager.finishBootstrap();
         }
-        manager.logger?.log?.('Full resync complete.', 'info');
     })();
-    try {
-        // Swallow late rejection if timeout wins the race
-        Promise.resolve(work).catch(() => { });
-        return await Promise.race([
-            work,
-            new Promise((_, reject) => {
-                setTimeout(() => reject(new Error(`recalculateGrid timed out after ${totalTimeoutMs}ms`)), totalTimeoutMs);
-            })
-        ]);
-    }
-    finally {
-        manager.finishBootstrap();
-    }
+    // Swallow late rejection if timeout wins the race
+    Promise.resolve(work).catch(() => { });
+    let timeoutId;
+    const result = await Promise.race([
+        work,
+        new Promise((_, reject) => {
+            timeoutId = setTimeout(() => {
+                _resyncAborted = true;
+                reject(new Error(`recalculateGrid timed out after ${totalTimeoutMs}ms`));
+            }, totalTimeoutMs);
+        })
+    ]);
+    clearTimeout(timeoutId);
+    return result;
 }
 /**
  * Check for grid divergence and trigger update if threshold is met.
@@ -1018,10 +1054,18 @@ async function _recalculateGridOrderSizesFromBlockchain(manager, orderType, opti
     const ctx = await _getSizingContext(manager, sideName);
     if (!ctx)
         return collectActions ? { actions: [], changed: false } : undefined;
-    // Get ALL slots for this side, sorted for calculateRotationOrderSizes
+    // Get ALL slots for this side, sorted for calculateRotationOrderSizes.
     // SELL: sorted ASC (Market to Edge)
     // BUY: sorted ASC (Edge to Market)
-    const allSideSlots = Array.from(manager.orders.values())
+    //
+    // When a working grid is available (COW mode), read types from it
+    // instead of manager.orders.  This ensures slots whose type changed
+    // due to a boundary shift (e.g. SPREAD→BUY) are included in the
+    // correct side's size calculation — using manager.orders here would
+    // filter by stale pre-shift types and miss the crossers, producing a
+    // budget allocation that doesn't match the post-shift grid structure.
+    const orderSource = collectActions ? workingGrid : manager.orders;
+    const allSideSlots = Array.from(orderSource.values())
         .filter((o) => o.type === orderType)
         .sort((a, b) => a.price - b.price);
     if (allSideSlots.length === 0)
@@ -1133,32 +1177,37 @@ async function updateGridFromBlockchainSnapshot(manager, orderType = 'both', fro
     const workingGrid = new WorkingGrid(manager.orders, { baseVersion: manager._gridVersion });
     const allActions = [];
     let hasWorkingChanges = false;
-    // Calculate size updates for each side (via existing sizing function in COW mode)
-    if (orderType === constants_1.ORDER_TYPES.BUY || orderType === 'both') {
-        const buyResult = await _recalculateGridOrderSizesFromBlockchain(manager, constants_1.ORDER_TYPES.BUY, { workingGrid });
-        allActions.push(...buyResult.actions);
-        hasWorkingChanges = hasWorkingChanges || buyResult.changed;
-    }
-    if (orderType === constants_1.ORDER_TYPES.SELL || orderType === 'both') {
-        const sellResult = await _recalculateGridOrderSizesFromBlockchain(manager, constants_1.ORDER_TYPES.SELL, { workingGrid });
-        allActions.push(...sellResult.actions);
-        hasWorkingChanges = hasWorkingChanges || sellResult.changed;
-    }
-    // If the boundary is shifting, reassign slot types in the WorkingGrid now.
-    // This ensures the COW commit delivers consistent types + boundaryIdx in one
-    // atomic operation — manager.boundaryIdx must not be touched before the commit.
     const newBoundary = (overrideBoundaryIdx !== null) ? overrideBoundaryIdx : manager.boundaryIdx;
+    // REASSIGN SLOT TYPES FIRST when the boundary is shifting.
+    // _recalculateGridOrderSizesFromBlockchain needs to see the corrected
+    // types so that slots which cross the boundary (e.g. SPREAD→BUY) are
+    // included in the correct side's budget allocation.  Running assignGridRoles
+    // after the size calc means crossers keep their pre-shift sizes, producing
+    // an allocation that doesn't match the post-shift grid structure.
     if (overrideBoundaryIdx !== null && overrideBoundaryIdx !== manager.boundaryIdx) {
         const gapSlots = calculateGapSlots(manager.config.incrementPercent, manager.config.targetSpreadPercent, manager.config.gridLimits);
         const allSlots = Array.from(workingGrid.values())
             .filter((s) => s.price != null)
             .sort((a, b) => a.price - b.price);
-        const updatedSlots = (0, order_1.assignGridRoles)(allSlots, newBoundary, gapSlots, constants_1.ORDER_TYPES, constants_1.ORDER_STATES);
+        const updatedSlots = (0, order_1.assignGridRoles)(allSlots, newBoundary, gapSlots, constants_1.ORDER_TYPES, constants_1.ORDER_STATES, { assignOnChain: true });
         for (const slot of updatedSlots) {
             workingGrid.set(slot.id, slot);
         }
         hasWorkingChanges = true;
     }
+    // Calculate size updates for each side (via existing sizing function in COW mode).
+    // _recalculateGridOrderSizesFromBlockchain reads types from the working grid when
+    // one is passed, so boundary-crossing slots are now correctly classified.
+    if (orderType === constants_1.ORDER_TYPES.BUY || orderType === 'both') {
+        const buyResult = await _recalculateGridOrderSizesFromBlockchain(manager, constants_1.ORDER_TYPES.BUY, { workingGrid });
+        allActions.push(...buyResult.actions);
+        hasWorkingChanges = hasWorkingChanges || buyResult.changed;
+    }
+    if (orderType === constants_1.ORDER_TYPES.SELL || orderType === 'both') {
+        const sellResult = await _recalculateGridOrderSizesFromBlockchain(manager, constants_1.ORDER_TYPES.SELL, { workingGrid });
+        allActions.push(...sellResult.actions);
+        hasWorkingChanges = hasWorkingChanges || sellResult.changed;
+    }
     // Return COW result only if there are changes
     if (allActions.length === 0 && !hasWorkingChanges) {
         return null;
@@ -1468,8 +1517,21 @@ async function checkSpreadCondition(manager, _BitShares, updateOrdersOnChainBatc
         correction = await prepareSpreadCorrectionOrders(manager, decision.side);
         if (!correction)
             return false;
-        const placeCount = correction.ordersToPlace?.length || 0;
-        const updateCount = correction.ordersToUpdate?.length || 0;
+        let placeCount = correction.ordersToPlace?.length || 0;
+        let updateCount = correction.ordersToUpdate?.length || 0;
+        // STARVATION FALLBACK: If the selected side has no correctable slots (e.g.
+        // all SPREAD slots already filled or misaligned), try the opposite side.
+        if ((placeCount + updateCount) === 0) {
+            const oppositeSide = decision.side === constants_1.ORDER_TYPES.BUY ? constants_1.ORDER_TYPES.SELL : constants_1.ORDER_TYPES.BUY;
+            manager.logger?.log?.(`[SPREAD] Side ${decision.side} produced zero candidates; ` +
+                `trying opposite side ${oppositeSide}.`, 'debug');
+            const oppositeCorrection = await prepareSpreadCorrectionOrders(manager, oppositeSide);
+            if (oppositeCorrection) {
+                correction = oppositeCorrection;
+                placeCount = correction.ordersToPlace?.length || 0;
+                updateCount = correction.ordersToUpdate?.length || 0;
+            }
+        }
         // Capture fund snapshot under lock for pre-flight verification before broadcast
         fundSnapshot = _snapshotFundState(manager);
         return (placeCount + updateCount) > 0;
@@ -1730,29 +1792,7 @@ function determineOrderSideByFunds(manager, currentMarketPrice) {
         const sellInBuyUnits = (Number.isFinite(marketPrice) && marketPrice > 0)
             ? sellAvailable * marketPrice
             : sellAvailable;
-        // Determine market direction from current price vs grid center price.
-        // When the market is below the grid center, the bot should prefer SELL
-        // (to narrow the spread from above — sells are too high). When the market
-        // is above the grid center, prefer BUY (buys are too low). This prevents
-        // spread correction from placing orders on the retreating side, which would
-        // compound inventory in the wrong direction after a batch of fill-induced
-        // boundary shifts.
-        const centerPrice = manager._lastGridPricingContext?.startPrice
-            ?? Number(manager.config.startPrice)
-            ?? null;
-        const hasDirection = Number.isFinite(marketPrice)
-            && marketPrice > 0
-            && Number.isFinite(centerPrice)
-            && centerPrice > 0;
-        if (hasDirection && marketPrice < centerPrice) {
-            side = constants_1.ORDER_TYPES.SELL;
-        }
-        else if (hasDirection && marketPrice > centerPrice) {
-            side = constants_1.ORDER_TYPES.BUY;
-        }
-        else {
-            side = buyAvailable >= sellInBuyUnits ? constants_1.ORDER_TYPES.BUY : constants_1.ORDER_TYPES.SELL;
-        }
+        side = buyAvailable >= sellInBuyUnits ? constants_1.ORDER_TYPES.BUY : constants_1.ORDER_TYPES.SELL;
     }
     else if (buyViable) {
         side = constants_1.ORDER_TYPES.BUY;
@@ -1852,27 +1892,27 @@ async function prepareSpreadCorrectionOrders(manager, preferredSide) {
     // 1. Priority: Update existing PARTIAL orders at the edge (Highest Buy / Lowest Sell).
     // 2. Fallback: Activate SPREAD slots at the edge (Lowest Spread for Buy / Highest Spread for Sell).
     const allOrders = Array.from(manager.orders.values());
-    let edgePartial = null;
-    const partials = allOrders
-        .filter((o) => o.type === railType && o.state === constants_1.ORDER_STATES.PARTIAL)
-        .sort((a, b) => railType === constants_1.ORDER_TYPES.BUY ? b.price - a.price : a.price - b.price);
-    if (partials.length > 0) {
-        edgePartial = partials[0];
-        manager.logger?.log?.(`[SPREAD-CORRECTION] Identified partial order at ${edgePartial.price} for update`, 'debug');
-    }
-    // Boundary-correct type computation.  Used by both candidate pools below to ensure
-    // spread correction does not re-activate slots whose current boundary position
-    // places them on the wrong side or in the spread zone — doing so would compound
-    // inventory at prices where the bot already traded.
+    // Boundary-correct type computation — hoisted before edge-partial and
+    // candidate filters so all call sites (including the edge-partial filter
+    // which now uses getSlotCorrectType) can access it.
     //
-    // The natural type of a slot is derived from its position in the price-sorted rail
-    // relative to boundaryIdx + gapSlots: indices in [0, boundaryIdx] are BUY, indices
-    // in [boundaryIdx + gapSlots + 1, N-1] are SELL, the middle band is SPREAD.
+    // The natural type of a slot is derived from its position in the price-sorted
+    // rail relative to boundaryIdx + gapSlots: indices in [0, boundaryIdx] are
+    // BUY, indices in [boundaryIdx + gapSlots + 1, N-1] are SELL, the middle
+    // band is SPREAD.
     const allSlotsByPrice = allOrders
         .filter((o) => o.price != null && Number.isFinite(o.price))
         .sort((a, b) => a.price - b.price);
     const slotIndexMap = new Map(allSlotsByPrice.map((o, i) => [o.id, i]));
     const gapSlots = calculateGapSlots(manager.config?.incrementPercent, manager.config?.targetSpreadPercent, manager.config?.gridLimits);
+    // Sync boundary from current fund state to avoid stale boundaryIdx causing
+    // getSlotCorrectType to misclassify slots (e.g. after fills shifted the
+    // boundary but the COW commit hasn't updated it yet).  This is safe under
+    // the grid lock — no concurrent modifications can race with this read.
+    const boundarySync = (0, system_1.syncBoundaryToFunds)(manager);
+    if (boundarySync.changed && boundarySync.newIdx !== undefined) {
+        manager.boundaryIdx = boundarySync.newIdx;
+    }
     const bIdx = manager.boundaryIdx ?? 0;
     const buyEndIdx = bIdx;
     const sellStartIdx = bIdx + Number(gapSlots) + 1;
@@ -1886,6 +1926,15 @@ async function prepareSpreadCorrectionOrders(manager, preferredSide) {
             return constants_1.ORDER_TYPES.SELL;
         return constants_1.ORDER_TYPES.SPREAD;
     };
+    let edgePartial = null;
+    const partials = allOrders
+        .filter((o) => getSlotCorrectType(o) === railType
+        && o.state === constants_1.ORDER_STATES.PARTIAL)
+        .sort((a, b) => railType === constants_1.ORDER_TYPES.BUY ? b.price - a.price : a.price - b.price);
+    if (partials.length > 0) {
+        edgePartial = partials[0];
+        manager.logger?.log?.(`[SPREAD-CORRECTION] Identified partial order at ${edgePartial.price} for update`, 'debug');
+    }
     // Primary candidates: SPREAD-type slots adjacent to the gap.  Filter by
     // boundary-correct type so a SPREAD slot that, after a boundary shift, now sits
     // in the BUY or SELL zone is excluded — it would otherwise be placed on the