backtest-kit 2.2.25 → 2.3.1

package/build/index.mjs

@@ -680,6 +680,20 @@ async function writeFileAtomic(file, data, options = {}) {
 
 var _a$2;
 const BASE_WAIT_FOR_INIT_SYMBOL = Symbol("wait-for-init");
+// Calculate step in milliseconds for candle close time validation
+const INTERVAL_MINUTES$5 = {
+    "1m": 1,
+    "3m": 3,
+    "5m": 5,
+    "15m": 15,
+    "30m": 30,
+    "1h": 60,
+    "2h": 120,
+    "4h": 240,
+    "6h": 360,
+    "8h": 480,
+};
+const MS_PER_MINUTE$2 = 60000;
 const PERSIST_SIGNAL_UTILS_METHOD_NAME_USE_PERSIST_SIGNAL_ADAPTER = "PersistSignalUtils.usePersistSignalAdapter";
 const PERSIST_SIGNAL_UTILS_METHOD_NAME_READ_DATA = "PersistSignalUtils.readSignalData";
 const PERSIST_SIGNAL_UTILS_METHOD_NAME_WRITE_DATA = "PersistSignalUtils.writeSignalData";
@@ -1546,12 +1560,17 @@ class PersistCandleUtils {
          * Reads cached candles for a specific exchange, symbol, and interval.
          * Returns candles only if cache contains exactly the requested limit.
          *
+         * Boundary semantics (EXCLUSIVE):
+         * - sinceTimestamp: candle.timestamp must be > sinceTimestamp
+         * - untilTimestamp: candle.timestamp + stepMs must be < untilTimestamp
+         * - Only fully closed candles within the exclusive range are returned
+         *
          * @param symbol - Trading pair symbol
          * @param interval - Candle interval
          * @param exchangeName - Exchange identifier
          * @param limit - Number of candles requested
-         * @param sinceTimestamp - Start timestamp (inclusive)
-         * @param untilTimestamp - End timestamp (exclusive)
+         * @param sinceTimestamp - Exclusive start timestamp in milliseconds
+         * @param untilTimestamp - Exclusive end timestamp in milliseconds
          * @returns Promise resolving to array of candles or null if cache is incomplete
          */
         this.readCandlesData = async (symbol, interval, exchangeName, limit, sinceTimestamp, untilTimestamp) => {
@@ -1567,11 +1586,15 @@ class PersistCandleUtils {
             const isInitial = !this.getCandlesStorage.has(key);
             const stateStorage = this.getCandlesStorage(symbol, interval, exchangeName);
             await stateStorage.waitForInit(isInitial);
-            // Collect all cached candles within the time range
+            const stepMs = INTERVAL_MINUTES$5[interval] * MS_PER_MINUTE$2;
+            // Collect all cached candles within the time range using EXCLUSIVE boundaries
             const cachedCandles = [];
             for await (const timestamp of stateStorage.keys()) {
                 const ts = Number(timestamp);
-                if (ts >= sinceTimestamp && ts < untilTimestamp) {
+                // EXCLUSIVE boundaries:
+                // - candle.timestamp > sinceTimestamp
+                // - candle.timestamp + stepMs < untilTimestamp (fully closed before untilTimestamp)
+                if (ts > sinceTimestamp && ts + stepMs < untilTimestamp) {
                     try {
                         const candle = await stateStorage.readValue(timestamp);
                         cachedCandles.push(candle);
@@ -1597,7 +1620,11 @@ class PersistCandleUtils {
          * Writes candles to cache with atomic file writes.
          * Each candle is stored as a separate JSON file named by its timestamp.
          *
-         * @param candles - Array of candle data to cache
+         * The candles passed to this function must already be filtered using EXCLUSIVE boundaries:
+         * - candle.timestamp > sinceTimestamp
+         * - candle.timestamp + stepMs < untilTimestamp
+         *
+         * @param candles - Array of candle data to cache (already filtered with exclusive boundaries)
          * @param symbol - Trading pair symbol
          * @param interval - Candle interval
          * @param exchangeName - Exchange identifier
@@ -1838,13 +1865,20 @@ const VALIDATE_NO_INCOMPLETE_CANDLES_FN = (candles) => {
  * Attempts to read candles from cache.
  * Validates cache consistency (no gaps in timestamps) before returning.
  *
+ * Boundary semantics:
+ * - sinceTimestamp: EXCLUSIVE lower bound (candle.timestamp > sinceTimestamp)
+ * - untilTimestamp: EXCLUSIVE upper bound (candle.timestamp + stepMs < untilTimestamp)
+ * - Only fully closed candles within the exclusive range are returned
+ *
  * @param dto - Data transfer object containing symbol, interval, and limit
- * @param sinceTimestamp - Start timestamp in milliseconds
- * @param untilTimestamp - End timestamp in milliseconds
+ * @param sinceTimestamp - Exclusive start timestamp in milliseconds
+ * @param untilTimestamp - Exclusive end timestamp in milliseconds
  * @param self - Instance of ClientExchange
  * @returns Cached candles array or null if cache miss or inconsistent
  */
 const READ_CANDLES_CACHE_FN$1 = trycatch(async (dto, sinceTimestamp, untilTimestamp, self) => {
+    // PersistCandleAdapter.readCandlesData uses EXCLUSIVE boundaries:
+    // Returns candles where: timestamp > sinceTimestamp AND timestamp + stepMs < untilTimestamp
     const cachedCandles = await PersistCandleAdapter.readCandlesData(dto.symbol, dto.interval, self.params.exchangeName, dto.limit, sinceTimestamp, untilTimestamp);
     // Return cached data only if we have exactly the requested limit
     if (cachedCandles.length === dto.limit) {
@@ -1869,7 +1903,11 @@ const READ_CANDLES_CACHE_FN$1 = trycatch(async (dto, sinceTimestamp, untilTimest
 /**
  * Writes candles to cache with error handling.
  *
- * @param candles - Array of candle data to cache
+ * The candles passed to this function must already be filtered using EXCLUSIVE boundaries:
+ * - candle.timestamp > sinceTimestamp
+ * - candle.timestamp + stepMs < untilTimestamp
+ *
+ * @param candles - Array of candle data to cache (already filtered with exclusive boundaries)
  * @param dto - Data transfer object containing symbol, interval, and limit
  * @param self - Instance of ClientExchange
  */
@@ -2035,8 +2073,18 @@ class ClientExchange {
         // Filter candles to strictly match the requested range
         const whenTimestamp = this.params.execution.context.when.getTime();
         const sinceTimestamp = since.getTime();
-        const filteredData = allData.filter((candle) => candle.timestamp >= sinceTimestamp &&
-            candle.timestamp < whenTimestamp);
+        const stepMs = step * MS_PER_MINUTE$1;
+        const filteredData = allData.filter((candle) => {
+            // EXCLUSIVE boundaries:
+            // - candle.timestamp > sinceTimestamp (exclude exact boundary)
+            // - candle.timestamp + stepMs < whenTimestamp (fully closed before "when")
+            if (candle.timestamp <= sinceTimestamp) {
+                return false;
+            }
+            // Check against current time (when)
+            // Only allow candles that have fully CLOSED before "when"
+            return candle.timestamp + stepMs < whenTimestamp;
+        });
         // Apply distinct by timestamp to remove duplicates
         const uniqueData = Array.from(new Map(filteredData.map((candle) => [candle.timestamp, candle])).values());
         if (filteredData.length !== uniqueData.length) {
@@ -2068,6 +2116,9 @@ class ClientExchange {
             interval,
             limit,
         });
+        if (!this.params.execution.context.backtest) {
+            throw new Error(`ClientExchange getNextCandles: cannot fetch future candles in live mode`);
+        }
         const since = new Date(this.params.execution.context.when.getTime());
         const now = Date.now();
         // Вычисляем конечное время запроса
@@ -2098,7 +2149,9 @@ class ClientExchange {
         }
         // Filter candles to strictly match the requested range
         const sinceTimestamp = since.getTime();
-        const filteredData = allData.filter((candle) => candle.timestamp >= sinceTimestamp && candle.timestamp < endTime);
+        const stepMs = step * MS_PER_MINUTE$1;
+        const filteredData = allData.filter((candle) => candle.timestamp > sinceTimestamp &&
+            candle.timestamp + stepMs < endTime);
         // Apply distinct by timestamp to remove duplicates
         const uniqueData = Array.from(new Map(filteredData.map((candle) => [candle.timestamp, candle])).values());
         if (filteredData.length !== uniqueData.length) {
@@ -2299,8 +2352,10 @@ class ClientExchange {
             allData = await GET_CANDLES_FN({ symbol, interval, limit: calculatedLimit }, since, this);
         }
         // Filter candles to strictly match the requested range
-        const filteredData = allData.filter((candle) => candle.timestamp >= sinceTimestamp &&
-            candle.timestamp < untilTimestamp);
+        // Only include candles that have fully CLOSED before untilTimestamp
+        const stepMs = step * MS_PER_MINUTE$1;
+        const filteredData = allData.filter((candle) => candle.timestamp > sinceTimestamp &&
+            candle.timestamp + stepMs < untilTimestamp);
         // Apply distinct by timestamp to remove duplicates
         const uniqueData = Array.from(new Map(filteredData.map((candle) => [candle.timestamp, candle])).values());
         if (filteredData.length !== uniqueData.length) {
@@ -12268,6 +12323,13 @@ class WalkerSchemaService {
     }
 }
 
+/**
+ * Компенсация для exclusive boundaries при фильтрации свечей.
+ * ClientExchange.getNextCandles использует фильтр:
+ *   timestamp > since && timestamp + stepMs < endTime
+ * который исключает первую и последнюю свечи из запрошенного диапазона.
+ */
+const CANDLE_EXCLUSIVE_BOUNDARY_OFFSET = 2;
 /**
  * Private service for backtest orchestration using async generators.
  *
@@ -12533,7 +12595,7 @@ class BacktestLogicPrivateService {
                 // Запрашиваем minuteEstimatedTime + буфер свечей одним запросом
                 const bufferMinutes = GLOBAL_CONFIG.CC_AVG_PRICE_CANDLES_COUNT - 1;
                 const bufferStartTime = new Date(when.getTime() - bufferMinutes * 60 * 1000);
-                const totalCandles = signal.minuteEstimatedTime + GLOBAL_CONFIG.CC_AVG_PRICE_CANDLES_COUNT;
+                const totalCandles = signal.minuteEstimatedTime + GLOBAL_CONFIG.CC_AVG_PRICE_CANDLES_COUNT + CANDLE_EXCLUSIVE_BOUNDARY_OFFSET;
                 let candles;
                 try {
                     candles = await this.exchangeCoreService.getNextCandles(symbol, "1m", totalCandles, bufferStartTime, true);
@@ -13819,6 +13881,18 @@ const live_columns = [
         format: (data) => data.duration !== undefined ? `${data.duration}` : "N/A",
         isVisible: () => true,
     },
+    {
+        key: "pendingAt",
+        label: "Pending At",
+        format: (data) => data.pendingAt !== undefined ? new Date(data.pendingAt).toISOString() : "N/A",
+        isVisible: () => true,
+    },
+    {
+        key: "scheduledAt",
+        label: "Scheduled At",
+        format: (data) => data.scheduledAt !== undefined ? new Date(data.scheduledAt).toISOString() : "N/A",
+        isVisible: () => true,
+    },
 ];
 
 /**
@@ -13943,6 +14017,18 @@ const partial_columns = [
         format: (data) => data.note || "",
         isVisible: () => GLOBAL_CONFIG.CC_REPORT_SHOW_SIGNAL_NOTE,
     },
+    {
+        key: "pendingAt",
+        label: "Pending At",
+        format: (data) => (data.pendingAt ? new Date(data.pendingAt).toISOString() : "N/A"),
+        isVisible: () => true,
+    },
+    {
+        key: "scheduledAt",
+        label: "Scheduled At",
+        format: (data) => (data.scheduledAt ? new Date(data.scheduledAt).toISOString() : "N/A"),
+        isVisible: () => true,
+    },
     {
         key: "timestamp",
         label: "Timestamp",
@@ -14065,6 +14151,18 @@ const breakeven_columns = [
         format: (data) => data.note || "",
         isVisible: () => GLOBAL_CONFIG.CC_REPORT_SHOW_SIGNAL_NOTE,
     },
+    {
+        key: "pendingAt",
+        label: "Pending At",
+        format: (data) => (data.pendingAt ? new Date(data.pendingAt).toISOString() : "N/A"),
+        isVisible: () => true,
+    },
+    {
+        key: "scheduledAt",
+        label: "Scheduled At",
+        format: (data) => (data.scheduledAt ? new Date(data.scheduledAt).toISOString() : "N/A"),
+        isVisible: () => true,
+    },
     {
         key: "timestamp",
         label: "Timestamp",
@@ -14343,6 +14441,22 @@ const risk_columns = [
         format: (data) => data.rejectionNote,
         isVisible: () => true,
     },
+    {
+        key: "pendingAt",
+        label: "Pending At",
+        format: (data) => data.currentSignal.pendingAt !== undefined
+            ? new Date(data.currentSignal.pendingAt).toISOString()
+            : "N/A",
+        isVisible: () => true,
+    },
+    {
+        key: "scheduledAt",
+        label: "Scheduled At",
+        format: (data) => data.currentSignal.scheduledAt !== undefined
+            ? new Date(data.currentSignal.scheduledAt).toISOString()
+            : "N/A",
+        isVisible: () => true,
+    },
     {
         key: "timestamp",
         label: "Timestamp",
@@ -14493,6 +14607,18 @@ const schedule_columns = [
         format: (data) => data.cancelId ?? "N/A",
         isVisible: () => true,
     },
+    {
+        key: "pendingAt",
+        label: "Pending At",
+        format: (data) => data.pendingAt !== undefined ? new Date(data.pendingAt).toISOString() : "N/A",
+        isVisible: () => true,
+    },
+    {
+        key: "scheduledAt",
+        label: "Scheduled At",
+        format: (data) => data.scheduledAt !== undefined ? new Date(data.scheduledAt).toISOString() : "N/A",
+        isVisible: () => true,
+    },
 ];
 
 /**
@@ -15884,6 +16010,8 @@ let ReportStorage$6 = class ReportStorage {
             originalPriceTakeProfit: data.signal.originalPriceTakeProfit,
             originalPriceStopLoss: data.signal.originalPriceStopLoss,
             partialExecuted: data.signal.partialExecuted,
+            pendingAt: data.signal.pendingAt,
+            scheduledAt: data.signal.scheduledAt,
         });
         // Trim queue if exceeded MAX_EVENTS
         if (this._eventList.length > MAX_EVENTS$7) {
@@ -15914,6 +16042,8 @@ let ReportStorage$6 = class ReportStorage {
             percentTp: data.percentTp,
             percentSl: data.percentSl,
             pnl: data.pnl.pnlPercentage,
+            pendingAt: data.signal.pendingAt,
+            scheduledAt: data.signal.scheduledAt,
         };
         // Find the last active event with the same signalId
         const lastActiveIndex = this._eventList.findLastIndex((event) => event.action === "active" && event.signalId === data.signal.id);
@@ -15954,6 +16084,8 @@ let ReportStorage$6 = class ReportStorage {
             pnl: data.pnl.pnlPercentage,
             closeReason: data.closeReason,
             duration: durationMin,
+            pendingAt: data.signal.pendingAt,
+            scheduledAt: data.signal.scheduledAt,
         };
         this._eventList.unshift(newEvent);
         // Trim queue if exceeded MAX_EVENTS
@@ -15981,6 +16113,7 @@ let ReportStorage$6 = class ReportStorage {
             originalPriceTakeProfit: data.signal.originalPriceTakeProfit,
             originalPriceStopLoss: data.signal.originalPriceStopLoss,
             partialExecuted: data.signal.partialExecuted,
+            scheduledAt: data.signal.scheduledAt,
         });
         // Trim queue if exceeded MAX_EVENTS
         if (this._eventList.length > MAX_EVENTS$7) {
@@ -16011,6 +16144,7 @@ let ReportStorage$6 = class ReportStorage {
             percentTp: data.percentTp,
             percentSl: data.percentSl,
             pnl: data.pnl.pnlPercentage,
+            scheduledAt: data.signal.scheduledAt,
         };
         // Find the last waiting event with the same signalId
         const lastWaitingIndex = this._eventList.findLastIndex((event) => event.action === "waiting" && event.signalId === data.signal.id);
@@ -16047,6 +16181,7 @@ let ReportStorage$6 = class ReportStorage {
             originalPriceStopLoss: data.signal.originalPriceStopLoss,
             partialExecuted: data.signal.partialExecuted,
             cancelReason: data.reason,
+            scheduledAt: data.signal.scheduledAt,
         });
         // Trim queue if exceeded MAX_EVENTS
         if (this._eventList.length > MAX_EVENTS$7) {
@@ -16538,6 +16673,7 @@ let ReportStorage$5 = class ReportStorage {
             originalPriceTakeProfit: data.signal.originalPriceTakeProfit,
             originalPriceStopLoss: data.signal.originalPriceStopLoss,
             partialExecuted: data.signal.partialExecuted,
+            scheduledAt: data.signal.scheduledAt,
         });
         // Trim queue if exceeded MAX_EVENTS
         if (this._eventList.length > MAX_EVENTS$6) {
@@ -16567,6 +16703,8 @@ let ReportStorage$5 = class ReportStorage {
             originalPriceStopLoss: data.signal.originalPriceStopLoss,
             partialExecuted: data.signal.partialExecuted,
             duration: durationMin,
+            pendingAt: data.signal.pendingAt,
+            scheduledAt: data.signal.scheduledAt,
         };
         this._eventList.unshift(newEvent);
         // Trim queue if exceeded MAX_EVENTS
@@ -16600,6 +16738,7 @@ let ReportStorage$5 = class ReportStorage {
             duration: durationMin,
             cancelReason: data.reason,
             cancelId: data.cancelId,
+            scheduledAt: data.signal.scheduledAt,
         };
         this._eventList.unshift(newEvent);
         // Trim queue if exceeded MAX_EVENTS
@@ -19741,6 +19880,8 @@ let ReportStorage$3 = class ReportStorage {
             originalPriceStopLoss: data.originalPriceStopLoss,
             partialExecuted: data.partialExecuted,
             note: data.note,
+            pendingAt: data.pendingAt,
+            scheduledAt: data.scheduledAt,
             backtest,
         });
         // Trim queue if exceeded MAX_EVENTS
@@ -19773,6 +19914,8 @@ let ReportStorage$3 = class ReportStorage {
             originalPriceStopLoss: data.originalPriceStopLoss,
             partialExecuted: data.partialExecuted,
             note: data.note,
+            pendingAt: data.pendingAt,
+            scheduledAt: data.scheduledAt,
             backtest,
         });
         // Trim queue if exceeded MAX_EVENTS
@@ -20870,6 +21013,8 @@ let ReportStorage$2 = class ReportStorage {
             originalPriceStopLoss: data.originalPriceStopLoss,
             partialExecuted: data.partialExecuted,
             note: data.note,
+            pendingAt: data.pendingAt,
+            scheduledAt: data.scheduledAt,
             backtest,
         });
         // Trim queue if exceeded MAX_EVENTS
@@ -23255,9 +23400,15 @@ class HeatReportService {
                 signalId: data.signal?.id,
                 position: data.signal?.position,
                 note: data.signal?.note,
+                priceOpen: data.signal?.priceOpen,
+                priceTakeProfit: data.signal?.priceTakeProfit,
+                priceStopLoss: data.signal?.priceStopLoss,
+                originalPriceTakeProfit: data.signal?.originalPriceTakeProfit,
+                originalPriceStopLoss: data.signal?.originalPriceStopLoss,
                 pnl: data.pnl.pnlPercentage,
                 closeReason: data.closeReason,
                 openTime: data.signal?.pendingAt,
+                scheduledAt: data.signal?.scheduledAt,
                 closeTime: data.closeTimestamp,
             }, {
                 symbol: data.symbol,
@@ -23666,6 +23817,8 @@ class RiskReportService {
                 originalPriceStopLoss: data.currentSignal?.originalPriceStopLoss,
                 partialExecuted: data.currentSignal?.partialExecuted,
                 note: data.currentSignal?.note,
+                pendingAt: data.currentSignal?.pendingAt,
+                scheduledAt: data.currentSignal?.scheduledAt,
                 minuteEstimatedTime: data.currentSignal?.minuteEstimatedTime,
             }, {
                 symbol: data.symbol,
@@ -25608,6 +25761,7 @@ const GET_CONTEXT_METHOD_NAME = "exchange.getContext";
 const HAS_TRADE_CONTEXT_METHOD_NAME = "exchange.hasTradeContext";
 const GET_ORDER_BOOK_METHOD_NAME = "exchange.getOrderBook";
 const GET_RAW_CANDLES_METHOD_NAME = "exchange.getRawCandles";
+const GET_NEXT_CANDLES_METHOD_NAME = "exchange.getNextCandles";
 /**
  * Checks if trade context is active (execution and method contexts).
  *
@@ -25912,6 +26066,30 @@ async function getRawCandles(symbol, interval, limit, sDate, eDate) {
     }
     return await bt.exchangeConnectionService.getRawCandles(symbol, interval, limit, sDate, eDate);
 }
+/**
+ * Fetches the set of candles after current time based on execution context.
+ *
+ * Uses the exchange's getNextCandles implementation to retrieve candles
+ * that occur after the current context time.
+ * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+ * @param interval - Candle interval ("1m" | "3m" | "5m" | "15m" | "30m" | "1h" | "2h" | "4h" | "6h" | "8h")
+ * @param limit - Number of candles to fetch
+ * @returns Promise resolving to array of candle data
+ */
+async function getNextCandles(symbol, interval, limit) {
+    bt.loggerService.info(GET_NEXT_CANDLES_METHOD_NAME, {
+        symbol,
+        interval,
+        limit,
+    });
+    if (!ExecutionContextService.hasContext()) {
+        throw new Error("getNextCandles requires an execution context");
+    }
+    if (!MethodContextService.hasContext()) {
+        throw new Error("getNextCandles requires a method context");
+    }
+    return await bt.exchangeConnectionService.getNextCandles(symbol, interval, limit);
+}
 
 const CANCEL_SCHEDULED_METHOD_NAME = "strategy.commitCancelScheduled";
 const CLOSE_PENDING_METHOD_NAME = "strategy.commitClosePending";
@@ -32845,6 +33023,16 @@ const EXCHANGE_METHOD_NAME_FORMAT_PRICE = "ExchangeUtils.formatPrice";
 const EXCHANGE_METHOD_NAME_GET_ORDER_BOOK = "ExchangeUtils.getOrderBook";
 const EXCHANGE_METHOD_NAME_GET_RAW_CANDLES = "ExchangeUtils.getRawCandles";
 const MS_PER_MINUTE = 60000;
+/**
+ * Gets current timestamp from execution context if available.
+ * Returns current Date() if no execution context exists (non-trading GUI).
+ */
+const GET_TIMESTAMP_FN = async () => {
+    if (ExecutionContextService.hasContext()) {
+        return new Date(bt.executionContextService.context.when);
+    }
+    return new Date();
+};
 /**
  * Gets backtest mode flag from execution context if available.
  * Returns false if no execution context exists (live mode).
@@ -32924,13 +33112,20 @@ const CREATE_EXCHANGE_INSTANCE_FN = (schema) => {
  * Attempts to read candles from cache.
  * Validates cache consistency (no gaps in timestamps) before returning.
  *
+ * Boundary semantics:
+ * - sinceTimestamp: EXCLUSIVE lower bound (candle.timestamp > sinceTimestamp)
+ * - untilTimestamp: EXCLUSIVE upper bound (candle.timestamp + stepMs < untilTimestamp)
+ * - Only fully closed candles within the exclusive range are returned
+ *
  * @param dto - Data transfer object containing symbol, interval, and limit
- * @param sinceTimestamp - Start timestamp in milliseconds
- * @param untilTimestamp - End timestamp in milliseconds
+ * @param sinceTimestamp - Exclusive start timestamp in milliseconds
+ * @param untilTimestamp - Exclusive end timestamp in milliseconds
  * @param exchangeName - Exchange name
  * @returns Cached candles array or null if cache miss or inconsistent
  */
 const READ_CANDLES_CACHE_FN = trycatch(async (dto, sinceTimestamp, untilTimestamp, exchangeName) => {
+    // PersistCandleAdapter.readCandlesData uses EXCLUSIVE boundaries:
+    // Returns candles where: timestamp > sinceTimestamp AND timestamp + stepMs < untilTimestamp
     const cachedCandles = await PersistCandleAdapter.readCandlesData(dto.symbol, dto.interval, exchangeName, dto.limit, sinceTimestamp, untilTimestamp);
     // Return cached data only if we have exactly the requested limit
     if (cachedCandles.length === dto.limit) {
@@ -32955,7 +33150,11 @@ const READ_CANDLES_CACHE_FN = trycatch(async (dto, sinceTimestamp, untilTimestam
 /**
  * Writes candles to cache with error handling.
  *
- * @param candles - Array of candle data to cache
+ * The candles passed to this function must already be filtered using EXCLUSIVE boundaries:
+ * - candle.timestamp > sinceTimestamp
+ * - candle.timestamp + stepMs < untilTimestamp
+ *
+ * @param candles - Array of candle data to cache (already filtered with exclusive boundaries)
  * @param dto - Data transfer object containing symbol, interval, and limit
  * @param exchangeName - Exchange name
  */
@@ -33030,10 +33229,10 @@ class ExchangeInstance {
             if (!adjust) {
                 throw new Error(`ExchangeInstance unknown time adjust for interval=${interval}`);
             }
-            const when = new Date(Date.now());
-            const since = new Date(when.getTime() - adjust * 60 * 1000);
+            const when = await GET_TIMESTAMP_FN();
+            const since = new Date(when.getTime() - adjust * MS_PER_MINUTE);
             const sinceTimestamp = since.getTime();
-            const untilTimestamp = sinceTimestamp + limit * step * 60 * 1000;
+            const untilTimestamp = sinceTimestamp + limit * step * MS_PER_MINUTE;
             // Try to read from cache first
             const cachedCandles = await READ_CANDLES_CACHE_FN({ symbol, interval, limit }, sinceTimestamp, untilTimestamp, this.exchangeName);
             if (cachedCandles !== null) {
@@ -33052,7 +33251,7 @@ class ExchangeInstance {
                     remaining -= chunkLimit;
                     if (remaining > 0) {
                         // Move currentSince forward by the number of candles fetched
-                        currentSince = new Date(currentSince.getTime() + chunkLimit * step * 60 * 1000);
+                        currentSince = new Date(currentSince.getTime() + chunkLimit * step * MS_PER_MINUTE);
                     }
                 }
             }
@@ -33062,8 +33261,18 @@ class ExchangeInstance {
             }
             // Filter candles to strictly match the requested range
             const whenTimestamp = when.getTime();
-            const stepMs = step * 60 * 1000;
-            const filteredData = allData.filter((candle) => candle.timestamp >= sinceTimestamp && candle.timestamp < whenTimestamp + stepMs);
+            const stepMs = step * MS_PER_MINUTE;
+            const filteredData = allData.filter((candle) => {
+                // EXCLUSIVE boundaries:
+                // - candle.timestamp > sinceTimestamp (exclude exact boundary)
+                // - candle.timestamp + stepMs < whenTimestamp (fully closed before "when")
+                if (candle.timestamp <= sinceTimestamp) {
+                    return false;
+                }
+                // Check against current time (when)
+                // Only allow candles that have fully CLOSED before "when"
+                return candle.timestamp + stepMs < whenTimestamp;
+            });
             // Apply distinct by timestamp to remove duplicates
             const uniqueData = Array.from(new Map(filteredData.map((candle) => [candle.timestamp, candle])).values());
             if (filteredData.length !== uniqueData.length) {
@@ -33193,8 +33402,8 @@ class ExchangeInstance {
                 symbol,
                 depth,
             });
-            const to = new Date(Date.now());
-            const from = new Date(to.getTime() - GLOBAL_CONFIG.CC_ORDER_BOOK_TIME_OFFSET_MINUTES * 60 * 1000);
+            const to = await GET_TIMESTAMP_FN();
+            const from = new Date(to.getTime() - GLOBAL_CONFIG.CC_ORDER_BOOK_TIME_OFFSET_MINUTES * MS_PER_MINUTE);
             const isBacktest = await GET_BACKTEST_FN();
             return await this._methods.getOrderBook(symbol, depth, from, to, isBacktest);
         };
@@ -33241,7 +33450,8 @@ class ExchangeInstance {
             if (!step) {
                 throw new Error(`ExchangeInstance getRawCandles: unknown interval=${interval}`);
             }
-            const nowTimestamp = Date.now();
+            const when = await GET_TIMESTAMP_FN();
+            const nowTimestamp = when.getTime();
             let sinceTimestamp;
             let untilTimestamp;
             let calculatedLimit;
@@ -33329,8 +33539,10 @@ class ExchangeInstance {
                 allData = await getCandles(symbol, interval, since, calculatedLimit, isBacktest);
             }
             // Filter candles to strictly match the requested range
-            const filteredData = allData.filter((candle) => candle.timestamp >= sinceTimestamp &&
-                candle.timestamp < untilTimestamp);
+            // Only include candles that have fully CLOSED before untilTimestamp
+            const stepMs = step * MS_PER_MINUTE;
+            const filteredData = allData.filter((candle) => candle.timestamp > sinceTimestamp &&
+                candle.timestamp + stepMs < untilTimestamp);
             // Apply distinct by timestamp to remove duplicates
             const uniqueData = Array.from(new Map(filteredData.map((candle) => [candle.timestamp, candle])).values());
             if (filteredData.length !== uniqueData.length) {
@@ -33920,6 +34132,7 @@ class NotificationInstance {
                     exchangeName: data.exchangeName,
                     signalId: data.signal.id,
                     position: data.signal.position,
+                    priceOpen: data.signal.priceOpen,
                     priceTakeProfit: data.signal.priceTakeProfit,
                     priceStopLoss: data.signal.priceStopLoss,
                     originalPriceTakeProfit: data.signal.originalPriceTakeProfit,
@@ -34932,4 +35145,4 @@ const set = (object, path, value) => {
     }
 };
 
-export { ActionBase, Backtest, Breakeven, Cache, Constant, Exchange, ExecutionContextService, Heat, Live, Markdown, MarkdownFileBase, MarkdownFolderBase, MethodContextService, Notification, Partial, Performance, PersistBase, PersistBreakevenAdapter, PersistCandleAdapter, PersistPartialAdapter, PersistRiskAdapter, PersistScheduleAdapter, PersistSignalAdapter, PersistStorageAdapter, PositionSize, Report, ReportBase, Risk, Schedule, Storage, StorageBacktest, StorageLive, Strategy, Walker, addActionSchema, addExchangeSchema, addFrameSchema, addRiskSchema, addSizingSchema, addStrategySchema, addWalkerSchema, commitBreakeven, commitCancelScheduled, commitClosePending, commitPartialLoss, commitPartialProfit, commitTrailingStop, commitTrailingTake, emitters, formatPrice, formatQuantity, get, getActionSchema, getAveragePrice, getBacktestTimeframe, getCandles, getColumns, getConfig, getContext, getDate, getDefaultColumns, getDefaultConfig, getExchangeSchema, getFrameSchema, getMode, getOrderBook, getRawCandles, getRiskSchema, getSizingSchema, getStrategySchema, getSymbol, getWalkerSchema, hasTradeContext, backtest as lib, listExchangeSchema, listFrameSchema, listRiskSchema, listSizingSchema, listStrategySchema, listWalkerSchema, listenActivePing, listenActivePingOnce, listenBacktestProgress, listenBreakevenAvailable, listenBreakevenAvailableOnce, listenDoneBacktest, listenDoneBacktestOnce, listenDoneLive, listenDoneLiveOnce, listenDoneWalker, listenDoneWalkerOnce, listenError, listenExit, listenPartialLossAvailable, listenPartialLossAvailableOnce, listenPartialProfitAvailable, listenPartialProfitAvailableOnce, listenPerformance, listenRisk, listenRiskOnce, listenSchedulePing, listenSchedulePingOnce, listenSignal, listenSignalBacktest, listenSignalBacktestOnce, listenSignalLive, listenSignalLiveOnce, listenSignalOnce, listenStrategyCommit, listenStrategyCommitOnce, listenValidation, listenWalker, listenWalkerComplete, listenWalkerOnce, listenWalkerProgress, overrideActionSchema, overrideExchangeSchema, overrideFrameSchema, overrideRiskSchema, overrideSizingSchema, overrideStrategySchema, overrideWalkerSchema, parseArgs, roundTicks, set, setColumns, setConfig, setLogger, stopStrategy, validate };
+export { ActionBase, Backtest, Breakeven, Cache, Constant, Exchange, ExecutionContextService, Heat, Live, Markdown, MarkdownFileBase, MarkdownFolderBase, MethodContextService, Notification, Partial, Performance, PersistBase, PersistBreakevenAdapter, PersistCandleAdapter, PersistPartialAdapter, PersistRiskAdapter, PersistScheduleAdapter, PersistSignalAdapter, PersistStorageAdapter, PositionSize, Report, ReportBase, Risk, Schedule, Storage, StorageBacktest, StorageLive, Strategy, Walker, addActionSchema, addExchangeSchema, addFrameSchema, addRiskSchema, addSizingSchema, addStrategySchema, addWalkerSchema, commitBreakeven, commitCancelScheduled, commitClosePending, commitPartialLoss, commitPartialProfit, commitTrailingStop, commitTrailingTake, emitters, formatPrice, formatQuantity, get, getActionSchema, getAveragePrice, getBacktestTimeframe, getCandles, getColumns, getConfig, getContext, getDate, getDefaultColumns, getDefaultConfig, getExchangeSchema, getFrameSchema, getMode, getNextCandles, getOrderBook, getRawCandles, getRiskSchema, getSizingSchema, getStrategySchema, getSymbol, getWalkerSchema, hasTradeContext, backtest as lib, listExchangeSchema, listFrameSchema, listRiskSchema, listSizingSchema, listStrategySchema, listWalkerSchema, listenActivePing, listenActivePingOnce, listenBacktestProgress, listenBreakevenAvailable, listenBreakevenAvailableOnce, listenDoneBacktest, listenDoneBacktestOnce, listenDoneLive, listenDoneLiveOnce, listenDoneWalker, listenDoneWalkerOnce, listenError, listenExit, listenPartialLossAvailable, listenPartialLossAvailableOnce, listenPartialProfitAvailable, listenPartialProfitAvailableOnce, listenPerformance, listenRisk, listenRiskOnce, listenSchedulePing, listenSchedulePingOnce, listenSignal, listenSignalBacktest, listenSignalBacktestOnce, listenSignalLive, listenSignalLiveOnce, listenSignalOnce, listenStrategyCommit, listenStrategyCommitOnce, listenValidation, listenWalker, listenWalkerComplete, listenWalkerOnce, listenWalkerProgress, overrideActionSchema, overrideExchangeSchema, overrideFrameSchema, overrideRiskSchema, overrideSizingSchema, overrideStrategySchema, overrideWalkerSchema, parseArgs, roundTicks, set, setColumns, setConfig, setLogger, stopStrategy, validate };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "backtest-kit",
-  "version": "2.2.25",
+  "version": "2.3.1",
   "description": "A TypeScript library for trading system backtest",
   "author": {
     "name": "Petr Tripolsky",