backtest-kit 2.2.26 → 2.3.1

package/build/index.cjs

@@ -700,6 +700,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";
@@ -1566,12 +1580,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) => {
@@ -1587,11 +1606,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);
@@ -1617,7 +1640,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
@@ -1858,13 +1885,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 = functoolsKit.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) {
@@ -1889,7 +1923,11 @@ const READ_CANDLES_CACHE_FN$1 = functoolsKit.trycatch(async (dto, sinceTimestamp
 /**
  * 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
  */
@@ -2055,8 +2093,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) {
@@ -2088,6 +2136,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();
         // Вычисляем конечное время запроса
@@ -2118,7 +2169,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) {
@@ -2319,8 +2372,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) {
@@ -12288,6 +12343,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.
  *
@@ -12553,7 +12615,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);
@@ -13839,6 +13901,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,
+    },
 ];
 
 /**
@@ -13963,6 +14037,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",
@@ -14085,6 +14171,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",
@@ -14363,6 +14461,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",
@@ -14513,6 +14627,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,
+    },
 ];
 
 /**
@@ -15904,6 +16030,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) {
@@ -15934,6 +16062,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);
@@ -15974,6 +16104,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
@@ -16001,6 +16133,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) {
@@ -16031,6 +16164,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);
@@ -16067,6 +16201,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) {
@@ -16558,6 +16693,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) {
@@ -16587,6 +16723,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
@@ -16620,6 +16758,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
@@ -19761,6 +19900,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
@@ -19793,6 +19934,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
@@ -20890,6 +21033,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
@@ -23275,9 +23420,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,
@@ -23686,6 +23837,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,
@@ -25628,6 +25781,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).
  *
@@ -25932,6 +26086,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";
@@ -32865,6 +33043,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).
@@ -32944,13 +33132,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 = functoolsKit.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) {
@@ -32975,7 +33170,11 @@ const READ_CANDLES_CACHE_FN = functoolsKit.trycatch(async (dto, sinceTimestamp,
 /**
  * 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
  */
@@ -33050,10 +33249,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) {
@@ -33072,7 +33271,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);
                     }
                 }
             }
@@ -33082,8 +33281,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) {
@@ -33213,8 +33422,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);
         };
@@ -33261,7 +33470,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;
@@ -33349,8 +33559,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) {
@@ -35018,6 +35230,7 @@ exports.getDefaultConfig = getDefaultConfig;
 exports.getExchangeSchema = getExchangeSchema;
 exports.getFrameSchema = getFrameSchema;
 exports.getMode = getMode;
+exports.getNextCandles = getNextCandles;
 exports.getOrderBook = getOrderBook;
 exports.getRawCandles = getRawCandles;
 exports.getRiskSchema = getRiskSchema;