backtest-kit 2.2.26 → 2.3.2

package/build/index.mjs

@@ -1,6 +1,6 @@
 import { createActivator } from 'di-kit';
 import { scoped } from 'di-scoped';
-import { Subject, makeExtendable, singleshot, getErrorMessage, memoize, errorData, not, trycatch, retry, queued, sleep, randomString, str, isObject, ToolRegistry, typo, and, resolveDocuments, timeout, TIMEOUT_SYMBOL as TIMEOUT_SYMBOL$1, compose, singlerun } from 'functools-kit';
+import { Subject, makeExtendable, singleshot, getErrorMessage, memoize, not, errorData, trycatch, retry, queued, sleep, randomString, str, isObject, ToolRegistry, typo, and, resolveDocuments, timeout, TIMEOUT_SYMBOL as TIMEOUT_SYMBOL$1, compose, singlerun } from 'functools-kit';
 import * as fs from 'fs/promises';
 import fs__default from 'fs/promises';
 import path, { join, dirname } from 'path';
@@ -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";
@@ -1544,60 +1558,73 @@ class PersistCandleUtils {
         ]));
         /**
          * Reads cached candles for a specific exchange, symbol, and interval.
-         * Returns candles only if cache contains exactly the requested limit.
+         * Returns candles only if cache contains ALL requested candles.
+         *
+         * Algorithm (matches ClientExchange.ts logic):
+         * 1. Calculate expected timestamps: sinceTimestamp, sinceTimestamp + stepMs, ..., sinceTimestamp + (limit-1) * stepMs
+         * 2. Try to read each expected candle by timestamp key
+         * 3. If ANY candle is missing, return null (cache miss)
+         * 4. If all candles found, return them in order
          *
          * @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 - Aligned start timestamp (openTime of first candle)
+         * @param _untilTimestamp - Unused, kept for API compatibility
          * @returns Promise resolving to array of candles or null if cache is incomplete
          */
-        this.readCandlesData = async (symbol, interval, exchangeName, limit, sinceTimestamp, untilTimestamp) => {
+        this.readCandlesData = async (symbol, interval, exchangeName, limit, sinceTimestamp, _untilTimestamp) => {
             bt.loggerService.info("PersistCandleUtils.readCandlesData", {
                 symbol,
                 interval,
                 exchangeName,
                 limit,
                 sinceTimestamp,
-                untilTimestamp,
             });
             const key = `${symbol}:${interval}:${exchangeName}`;
             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;
+            // Calculate expected timestamps and fetch each candle directly
             const cachedCandles = [];
-            for await (const timestamp of stateStorage.keys()) {
-                const ts = Number(timestamp);
-                if (ts >= sinceTimestamp && ts < untilTimestamp) {
-                    try {
-                        const candle = await stateStorage.readValue(timestamp);
-                        cachedCandles.push(candle);
-                    }
-                    catch (error) {
-                        const message = `PersistCandleUtils.readCandlesData found invalid candle symbol=${symbol} interval=${interval} timestamp=${timestamp}`;
-                        const payload = {
-                            error: errorData(error),
-                            message: getErrorMessage(error),
-                        };
-                        bt.loggerService.warn(message, payload);
-                        console.warn(message, payload);
-                        errorEmitter.next(error);
-                        continue;
-                    }
+            for (let i = 0; i < limit; i++) {
+                const expectedTimestamp = sinceTimestamp + i * stepMs;
+                const timestampKey = String(expectedTimestamp);
+                if (await not(stateStorage.hasValue(timestampKey))) {
+                    // Cache miss - candle not found
+                    return null;
+                }
+                try {
+                    const candle = await stateStorage.readValue(timestampKey);
+                    cachedCandles.push(candle);
+                }
+                catch (error) {
+                    // Invalid candle in cache - treat as cache miss
+                    const message = `PersistCandleUtils.readCandlesData found invalid candle symbol=${symbol} interval=${interval} timestamp=${expectedTimestamp}`;
+                    const payload = {
+                        error: errorData(error),
+                        message: getErrorMessage(error),
+                    };
+                    bt.loggerService.warn(message, payload);
+                    console.warn(message, payload);
+                    errorEmitter.next(error);
+                    return null;
                 }
             }
-            // Sort by timestamp ascending
-            cachedCandles.sort((a, b) => a.timestamp - b.timestamp);
             return cachedCandles;
         };
         /**
          * 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 should be validated candles from the adapter:
+         * - First candle.timestamp equals aligned sinceTimestamp (openTime)
+         * - Exact number of candles as requested
+         * - All candles are fully closed (timestamp + stepMs < untilTimestamp)
+         *
+         * @param candles - Array of candle data to cache (validated by the caller)
          * @param symbol - Trading pair symbol
          * @param interval - Candle interval
          * @param exchangeName - Exchange identifier
@@ -1614,8 +1641,25 @@ class PersistCandleUtils {
             const isInitial = !this.getCandlesStorage.has(key);
             const stateStorage = this.getCandlesStorage(symbol, interval, exchangeName);
             await stateStorage.waitForInit(isInitial);
-            // Write each candle as a separate file
+            // Calculate step in milliseconds to determine candle close time
+            const stepMs = INTERVAL_MINUTES$5[interval] * MS_PER_MINUTE$2;
+            const now = Date.now();
+            // Write each candle as a separate file, skipping incomplete candles
             for (const candle of candles) {
+                // Skip incomplete candles: candle is complete when closeTime <= now
+                // closeTime = timestamp + stepMs
+                const candleCloseTime = candle.timestamp + stepMs;
+                if (candleCloseTime > now) {
+                    bt.loggerService.debug("PersistCandleUtils.writeCandlesData: skipping incomplete candle", {
+                        symbol,
+                        interval,
+                        exchangeName,
+                        timestamp: candle.timestamp,
+                        closeTime: candleCloseTime,
+                        now,
+                    });
+                    continue;
+                }
                 if (await not(stateStorage.hasValue(String(candle.timestamp)))) {
                     await stateStorage.writeValue(String(candle.timestamp), candle);
                 }
@@ -1773,6 +1817,27 @@ const INTERVAL_MINUTES$4 = {
     "6h": 360,
     "8h": 480,
 };
+/**
+ * Aligns timestamp down to the nearest interval boundary.
+ * For example, for 15m interval: 00:17 -> 00:15, 00:44 -> 00:30
+ *
+ * Candle timestamp convention:
+ * - Candle timestamp = openTime (when candle opens)
+ * - Candle with timestamp 00:00 covers period [00:00, 00:15) for 15m interval
+ *
+ * Adapter contract:
+ * - Adapter must return candles with timestamp = openTime
+ * - First returned candle.timestamp must equal aligned since
+ * - Adapter must return exactly `limit` candles
+ *
+ * @param timestamp - Timestamp in milliseconds
+ * @param intervalMinutes - Interval in minutes
+ * @returns Aligned timestamp rounded down to interval boundary
+ */
+const ALIGN_TO_INTERVAL_FN$1 = (timestamp, intervalMinutes) => {
+    const intervalMs = intervalMinutes * MS_PER_MINUTE$1;
+    return Math.floor(timestamp / intervalMs) * intervalMs;
+};
 /**
  * Validates that all candles have valid OHLCV data without anomalies.
  * Detects incomplete candles from Binance API by checking for abnormally low prices or volumes.
@@ -1836,18 +1901,24 @@ const VALIDATE_NO_INCOMPLETE_CANDLES_FN = (candles) => {
 };
 /**
  * Attempts to read candles from cache.
- * Validates cache consistency (no gaps in timestamps) before returning.
+ *
+ * Cache lookup calculates expected timestamps:
+ * sinceTimestamp + i * stepMs for i = 0..limit-1
+ * Returns all candles if found, null if any missing.
  *
  * @param dto - Data transfer object containing symbol, interval, and limit
- * @param sinceTimestamp - Start timestamp in milliseconds
- * @param untilTimestamp - End timestamp in milliseconds
+ * @param sinceTimestamp - Aligned start timestamp (openTime of first candle)
+ * @param untilTimestamp - Unused, kept for API compatibility
  * @param self - Instance of ClientExchange
- * @returns Cached candles array or null if cache miss or inconsistent
+ * @returns Cached candles array (exactly limit) or null if cache miss
  */
 const READ_CANDLES_CACHE_FN$1 = trycatch(async (dto, sinceTimestamp, untilTimestamp, self) => {
+    // PersistCandleAdapter.readCandlesData calculates expected timestamps:
+    // sinceTimestamp + i * stepMs for i = 0..limit-1
+    // Returns all candles if found, null if any missing
     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) {
+    if (cachedCandles?.length === dto.limit) {
         self.params.logger.debug(`ClientExchange READ_CANDLES_CACHE_FN: cache hit for symbol=${dto.symbol}, interval=${dto.interval}, limit=${dto.limit}`);
         return cachedCandles;
     }
@@ -1869,7 +1940,12 @@ 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 should be validated:
+ * - First candle.timestamp equals aligned sinceTimestamp (openTime)
+ * - Exact number of candles as requested (limit)
+ * - Sequential timestamps: sinceTimestamp + i * stepMs
+ *
+ * @param candles - Array of validated candle data to cache
  * @param dto - Data transfer object containing symbol, interval, and limit
  * @param self - Instance of ClientExchange
  */
@@ -1996,6 +2072,13 @@ class ClientExchange {
     /**
      * Fetches historical candles backwards from execution context time.
      *
+     * Algorithm:
+     * 1. Align when down to interval boundary (e.g., 00:17 -> 00:15 for 15m)
+     * 2. Calculate since = alignedWhen - limit * step
+     * 3. Fetch candles starting from since
+     * 4. Validate first candle timestamp matches since (adapter must return inclusive data)
+     * 5. Slice to limit
+     *
      * @param symbol - Trading pair symbol
      * @param interval - Candle interval
      * @param limit - Number of candles to fetch
@@ -2008,11 +2091,16 @@ class ClientExchange {
             limit,
         });
         const step = INTERVAL_MINUTES$4[interval];
-        const adjust = step * limit;
-        if (!adjust) {
-            throw new Error(`ClientExchange unknown time adjust for interval=${interval}`);
+        if (!step) {
+            throw new Error(`ClientExchange unknown interval=${interval}`);
         }
-        const since = new Date(this.params.execution.context.when.getTime() - adjust * MS_PER_MINUTE$1);
+        const stepMs = step * MS_PER_MINUTE$1;
+        // Align when down to interval boundary
+        const whenTimestamp = this.params.execution.context.when.getTime();
+        const alignedWhen = ALIGN_TO_INTERVAL_FN$1(whenTimestamp, step);
+        // Calculate since: go back limit candles from aligned when
+        const sinceTimestamp = alignedWhen - limit * stepMs;
+        const since = new Date(sinceTimestamp);
         let allData = [];
         // If limit exceeds CC_MAX_CANDLES_PER_REQUEST, fetch data in chunks
         if (limit > GLOBAL_CONFIG.CC_MAX_CANDLES_PER_REQUEST) {
@@ -2025,29 +2113,34 @@ class ClientExchange {
                 remaining -= chunkLimit;
                 if (remaining > 0) {
                     // Move currentSince forward by the number of candles fetched
-                    currentSince = new Date(currentSince.getTime() + chunkLimit * step * MS_PER_MINUTE$1);
+                    currentSince = new Date(currentSince.getTime() + chunkLimit * stepMs);
                 }
             }
         }
         else {
             allData = await GET_CANDLES_FN({ symbol, interval, limit }, since, this);
         }
-        // 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);
         // 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) {
-            const msg = `ClientExchange Removed ${filteredData.length - uniqueData.length} duplicate candles by timestamp`;
+        const uniqueData = Array.from(new Map(allData.map((candle) => [candle.timestamp, candle])).values());
+        if (allData.length !== uniqueData.length) {
+            const msg = `ClientExchange getCandles: Removed ${allData.length - uniqueData.length} duplicate candles by timestamp`;
             this.params.logger.warn(msg);
             console.warn(msg);
         }
-        if (uniqueData.length < limit) {
-            const msg = `ClientExchange Expected ${limit} candles, got ${uniqueData.length}`;
-            this.params.logger.warn(msg);
-            console.warn(msg);
+        // Validate adapter returned data
+        if (uniqueData.length === 0) {
+            throw new Error(`ClientExchange getCandles: adapter returned empty array. ` +
+                `Expected ${limit} candles starting from openTime=${sinceTimestamp}.`);
+        }
+        if (uniqueData[0].timestamp !== sinceTimestamp) {
+            throw new Error(`ClientExchange getCandles: first candle timestamp mismatch. ` +
+                `Expected openTime=${sinceTimestamp}, got=${uniqueData[0].timestamp}. ` +
+                `Adapter must return candles with timestamp=openTime, starting from aligned since.`);
+        }
+        if (uniqueData.length !== limit) {
+            throw new Error(`ClientExchange getCandles: candle count mismatch. ` +
+                `Expected ${limit} candles, got ${uniqueData.length}. ` +
+                `Adapter must return exact number of candles requested.`);
         }
         await CALL_CANDLE_DATA_CALLBACKS_FN(this, symbol, interval, since, limit, uniqueData);
         return uniqueData;
@@ -2056,6 +2149,13 @@ class ClientExchange {
      * Fetches future candles forwards from execution context time.
      * Used in backtest mode to get candles for signal duration.
      *
+     * Algorithm:
+     * 1. Align when down to interval boundary (e.g., 00:17 -> 00:15 for 15m)
+     * 2. since = alignedWhen (start from aligned when)
+     * 3. Fetch candles starting from since
+     * 4. Validate first candle timestamp matches since (adapter must return inclusive data)
+     * 5. Slice to limit
+     *
      * @param symbol - Trading pair symbol
      * @param interval - Candle interval
      * @param limit - Number of candles to fetch
@@ -2068,12 +2168,24 @@ class ClientExchange {
             interval,
             limit,
         });
-        const since = new Date(this.params.execution.context.when.getTime());
-        const now = Date.now();
-        // Вычисляем конечное время запроса
+        if (!this.params.execution.context.backtest) {
+            throw new Error(`ClientExchange getNextCandles: cannot fetch future candles in live mode`);
+        }
         const step = INTERVAL_MINUTES$4[interval];
-        const endTime = since.getTime() + limit * step * MS_PER_MINUTE$1;
-        // Проверяем что запрошенный период не заходит за Date.now()
+        if (!step) {
+            throw new Error(`ClientExchange getNextCandles: unknown interval=${interval}`);
+        }
+        const stepMs = step * MS_PER_MINUTE$1;
+        const now = Date.now();
+        // Align when down to interval boundary
+        const whenTimestamp = this.params.execution.context.when.getTime();
+        const alignedWhen = ALIGN_TO_INTERVAL_FN$1(whenTimestamp, step);
+        // since = alignedWhen (start from aligned when, going forward)
+        const sinceTimestamp = alignedWhen;
+        const since = new Date(sinceTimestamp);
+        // Calculate end time for Date.now() check
+        const endTime = sinceTimestamp + limit * stepMs;
+        // Check that requested period does not exceed Date.now()
         if (endTime > now) {
             return [];
         }
@@ -2089,27 +2201,34 @@ class ClientExchange {
                 remaining -= chunkLimit;
                 if (remaining > 0) {
                     // Move currentSince forward by the number of candles fetched
-                    currentSince = new Date(currentSince.getTime() + chunkLimit * step * MS_PER_MINUTE$1);
+                    currentSince = new Date(currentSince.getTime() + chunkLimit * stepMs);
                 }
             }
         }
         else {
             allData = await GET_CANDLES_FN({ symbol, interval, limit }, since, this);
         }
-        // Filter candles to strictly match the requested range
-        const sinceTimestamp = since.getTime();
-        const filteredData = allData.filter((candle) => candle.timestamp >= sinceTimestamp && candle.timestamp < 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) {
-            const msg = `ClientExchange getNextCandles: Removed ${filteredData.length - uniqueData.length} duplicate candles by timestamp`;
+        const uniqueData = Array.from(new Map(allData.map((candle) => [candle.timestamp, candle])).values());
+        if (allData.length !== uniqueData.length) {
+            const msg = `ClientExchange getNextCandles: Removed ${allData.length - uniqueData.length} duplicate candles by timestamp`;
             this.params.logger.warn(msg);
             console.warn(msg);
         }
-        if (uniqueData.length < limit) {
-            const msg = `ClientExchange getNextCandles: Expected ${limit} candles, got ${uniqueData.length}`;
-            this.params.logger.warn(msg);
-            console.warn(msg);
+        // Validate adapter returned data
+        if (uniqueData.length === 0) {
+            throw new Error(`ClientExchange getNextCandles: adapter returned empty array. ` +
+                `Expected ${limit} candles starting from openTime=${sinceTimestamp}.`);
+        }
+        if (uniqueData[0].timestamp !== sinceTimestamp) {
+            throw new Error(`ClientExchange getNextCandles: first candle timestamp mismatch. ` +
+                `Expected openTime=${sinceTimestamp}, got=${uniqueData[0].timestamp}. ` +
+                `Adapter must return candles with timestamp=openTime, starting from aligned since.`);
+        }
+        if (uniqueData.length !== limit) {
+            throw new Error(`ClientExchange getNextCandles: candle count mismatch. ` +
+                `Expected ${limit} candles, got ${uniqueData.length}. ` +
+                `Adapter must return exact number of candles requested.`);
         }
         await CALL_CANDLE_DATA_CALLBACKS_FN(this, symbol, interval, since, limit, uniqueData);
         return uniqueData;
@@ -2184,6 +2303,12 @@ class ClientExchange {
     /**
      * Fetches raw candles with flexible date/limit parameters.
      *
+     * Algorithm:
+     * 1. Align all timestamps down to interval boundary
+     * 2. Fetch candles starting from aligned since
+     * 3. Validate first candle timestamp matches aligned since (adapter must return inclusive data)
+     * 4. Slice to limit
+     *
      * All modes respect execution context and prevent look-ahead bias.
      *
      * Parameter combinations:
@@ -2218,9 +2343,10 @@ class ClientExchange {
         if (!step) {
             throw new Error(`ClientExchange getRawCandles: unknown interval=${interval}`);
         }
+        const stepMs = step * MS_PER_MINUTE$1;
         const whenTimestamp = this.params.execution.context.when.getTime();
+        const alignedWhen = ALIGN_TO_INTERVAL_FN$1(whenTimestamp, step);
         let sinceTimestamp;
-        let untilTimestamp;
         let calculatedLimit;
         // Case 1: all three parameters provided
         if (sDate !== undefined && eDate !== undefined && limit !== undefined) {
@@ -2230,8 +2356,8 @@ class ClientExchange {
             if (eDate > whenTimestamp) {
                 throw new Error(`ClientExchange getRawCandles: eDate (${eDate}) exceeds execution context when (${whenTimestamp}). Look-ahead bias protection.`);
             }
-            sinceTimestamp = sDate;
-            untilTimestamp = eDate;
+            // Align sDate down to interval boundary
+            sinceTimestamp = ALIGN_TO_INTERVAL_FN$1(sDate, step);
             calculatedLimit = limit;
         }
         // Case 2: sDate + eDate (no limit) - calculate limit from date range
@@ -2242,9 +2368,10 @@ class ClientExchange {
             if (eDate > whenTimestamp) {
                 throw new Error(`ClientExchange getRawCandles: eDate (${eDate}) exceeds execution context when (${whenTimestamp}). Look-ahead bias protection.`);
             }
-            sinceTimestamp = sDate;
-            untilTimestamp = eDate;
-            calculatedLimit = Math.ceil((eDate - sDate) / (step * MS_PER_MINUTE$1));
+            // Align sDate down to interval boundary
+            sinceTimestamp = ALIGN_TO_INTERVAL_FN$1(sDate, step);
+            const alignedEDate = ALIGN_TO_INTERVAL_FN$1(eDate, step);
+            calculatedLimit = Math.ceil((alignedEDate - sinceTimestamp) / stepMs);
             if (calculatedLimit <= 0) {
                 throw new Error(`ClientExchange getRawCandles: calculated limit is ${calculatedLimit}, must be > 0`);
             }
@@ -2254,23 +2381,24 @@ class ClientExchange {
             if (eDate > whenTimestamp) {
                 throw new Error(`ClientExchange getRawCandles: eDate (${eDate}) exceeds execution context when (${whenTimestamp}). Look-ahead bias protection.`);
             }
-            untilTimestamp = eDate;
-            sinceTimestamp = eDate - limit * step * MS_PER_MINUTE$1;
+            // Align eDate down and calculate sinceTimestamp
+            const alignedEDate = ALIGN_TO_INTERVAL_FN$1(eDate, step);
+            sinceTimestamp = alignedEDate - limit * stepMs;
             calculatedLimit = limit;
         }
         // Case 4: sDate + limit (no eDate) - calculate eDate forward from sDate
         else if (sDate !== undefined && eDate === undefined && limit !== undefined) {
-            sinceTimestamp = sDate;
-            untilTimestamp = sDate + limit * step * MS_PER_MINUTE$1;
-            if (untilTimestamp > whenTimestamp) {
-                throw new Error(`ClientExchange getRawCandles: calculated endTimestamp (${untilTimestamp}) exceeds execution context when (${whenTimestamp}). Look-ahead bias protection.`);
+            // Align sDate down to interval boundary
+            sinceTimestamp = ALIGN_TO_INTERVAL_FN$1(sDate, step);
+            const endTimestamp = sinceTimestamp + limit * stepMs;
+            if (endTimestamp > whenTimestamp) {
+                throw new Error(`ClientExchange getRawCandles: calculated endTimestamp (${endTimestamp}) exceeds execution context when (${whenTimestamp}). Look-ahead bias protection.`);
             }
             calculatedLimit = limit;
         }
         // Case 5: Only limit - use execution.context.when as reference (backward like getCandles)
         else if (sDate === undefined && eDate === undefined && limit !== undefined) {
-            untilTimestamp = whenTimestamp;
-            sinceTimestamp = whenTimestamp - limit * step * MS_PER_MINUTE$1;
+            sinceTimestamp = alignedWhen - limit * stepMs;
             calculatedLimit = limit;
         }
         // Invalid: no parameters or only sDate or only eDate
@@ -2291,27 +2419,34 @@ class ClientExchange {
                 allData.push(...chunkData);
                 remaining -= chunkLimit;
                 if (remaining > 0) {
-                    currentSince = new Date(currentSince.getTime() + chunkLimit * step * MS_PER_MINUTE$1);
+                    currentSince = new Date(currentSince.getTime() + chunkLimit * stepMs);
                 }
             }
         }
         else {
             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);
         // 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) {
-            const msg = `ClientExchange getRawCandles: Removed ${filteredData.length - uniqueData.length} duplicate candles by timestamp`;
+        const uniqueData = Array.from(new Map(allData.map((candle) => [candle.timestamp, candle])).values());
+        if (allData.length !== uniqueData.length) {
+            const msg = `ClientExchange getRawCandles: Removed ${allData.length - uniqueData.length} duplicate candles by timestamp`;
             this.params.logger.warn(msg);
             console.warn(msg);
         }
-        if (uniqueData.length < calculatedLimit) {
-            const msg = `ClientExchange getRawCandles: Expected ${calculatedLimit} candles, got ${uniqueData.length}`;
-            this.params.logger.warn(msg);
-            console.warn(msg);
+        // Validate adapter returned data
+        if (uniqueData.length === 0) {
+            throw new Error(`ClientExchange getRawCandles: adapter returned empty array. ` +
+                `Expected ${calculatedLimit} candles starting from openTime=${sinceTimestamp}.`);
+        }
+        if (uniqueData[0].timestamp !== sinceTimestamp) {
+            throw new Error(`ClientExchange getRawCandles: first candle timestamp mismatch. ` +
+                `Expected openTime=${sinceTimestamp}, got=${uniqueData[0].timestamp}. ` +
+                `Adapter must return candles with timestamp=openTime, starting from aligned since.`);
+        }
+        if (uniqueData.length !== calculatedLimit) {
+            throw new Error(`ClientExchange getRawCandles: candle count mismatch. ` +
+                `Expected ${calculatedLimit} candles, got ${uniqueData.length}. ` +
+                `Adapter must return exact number of candles requested.`);
         }
         await CALL_CANDLE_DATA_CALLBACKS_FN(this, symbol, interval, since, calculatedLimit, uniqueData);
         return uniqueData;
@@ -13819,6 +13954,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 +14090,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 +14224,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 +14514,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 +14680,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 +16083,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 +16115,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 +16157,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 +16186,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 +16217,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 +16254,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 +16746,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 +16776,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 +16811,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 +19953,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 +19987,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 +21086,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 +23473,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 +23890,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 +25834,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 +26139,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 +33096,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).
@@ -32901,6 +33162,27 @@ const INTERVAL_MINUTES$1 = {
     "6h": 360,
     "8h": 480,
 };
+/**
+ * Aligns timestamp down to the nearest interval boundary.
+ * For example, for 15m interval: 00:17 -> 00:15, 00:44 -> 00:30
+ *
+ * Candle timestamp convention:
+ * - Candle timestamp = openTime (when candle opens)
+ * - Candle with timestamp 00:00 covers period [00:00, 00:15) for 15m interval
+ *
+ * Adapter contract:
+ * - Adapter must return candles with timestamp = openTime
+ * - First returned candle.timestamp must equal aligned since
+ * - Adapter must return exactly `limit` candles
+ *
+ * @param timestamp - Timestamp in milliseconds
+ * @param intervalMinutes - Interval in minutes
+ * @returns Aligned timestamp rounded down to interval boundary
+ */
+const ALIGN_TO_INTERVAL_FN = (timestamp, intervalMinutes) => {
+    const intervalMs = intervalMinutes * MS_PER_MINUTE;
+    return Math.floor(timestamp / intervalMs) * intervalMs;
+};
 /**
  * Creates exchange instance with methods resolved once during construction.
  * Applies default implementations where schema methods are not provided.
@@ -32922,18 +33204,24 @@ const CREATE_EXCHANGE_INSTANCE_FN = (schema) => {
 };
 /**
  * Attempts to read candles from cache.
- * Validates cache consistency (no gaps in timestamps) before returning.
+ *
+ * Cache lookup calculates expected timestamps:
+ * sinceTimestamp + i * stepMs for i = 0..limit-1
+ * Returns all candles if found, null if any missing.
  *
  * @param dto - Data transfer object containing symbol, interval, and limit
- * @param sinceTimestamp - Start timestamp in milliseconds
- * @param untilTimestamp - End timestamp in milliseconds
+ * @param sinceTimestamp - Aligned start timestamp (openTime of first candle)
+ * @param untilTimestamp - Unused, kept for API compatibility
  * @param exchangeName - Exchange name
- * @returns Cached candles array or null if cache miss or inconsistent
+ * @returns Cached candles array (exactly limit) or null if cache miss
  */
 const READ_CANDLES_CACHE_FN = trycatch(async (dto, sinceTimestamp, untilTimestamp, exchangeName) => {
+    // PersistCandleAdapter.readCandlesData calculates expected timestamps:
+    // sinceTimestamp + i * stepMs for i = 0..limit-1
+    // Returns all candles if found, null if any missing
     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) {
+    if (cachedCandles?.length === dto.limit) {
         bt.loggerService.debug(`ExchangeInstance READ_CANDLES_CACHE_FN: cache hit for exchangeName=${exchangeName}, symbol=${dto.symbol}, interval=${dto.interval}, limit=${dto.limit}`);
         return cachedCandles;
     }
@@ -32955,7 +33243,12 @@ 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 should be validated:
+ * - First candle.timestamp equals aligned sinceTimestamp (openTime)
+ * - Exact number of candles as requested (limit)
+ * - Sequential timestamps: sinceTimestamp + i * stepMs
+ *
+ * @param candles - Array of validated candle data to cache
  * @param dto - Data transfer object containing symbol, interval, and limit
  * @param exchangeName - Exchange name
  */
@@ -33026,14 +33319,18 @@ class ExchangeInstance {
             });
             const getCandles = this._methods.getCandles;
             const step = INTERVAL_MINUTES$1[interval];
-            const adjust = step * limit;
-            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 sinceTimestamp = since.getTime();
-            const untilTimestamp = sinceTimestamp + limit * step * 60 * 1000;
+            if (!step) {
+                throw new Error(`ExchangeInstance unknown interval=${interval}`);
+            }
+            const stepMs = step * MS_PER_MINUTE;
+            // Align when down to interval boundary
+            const when = await GET_TIMESTAMP_FN();
+            const whenTimestamp = when.getTime();
+            const alignedWhen = ALIGN_TO_INTERVAL_FN(whenTimestamp, step);
+            // Calculate since: go back limit candles from aligned when
+            const sinceTimestamp = alignedWhen - limit * stepMs;
+            const since = new Date(sinceTimestamp);
+            const untilTimestamp = alignedWhen;
             // 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 +33349,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 * stepMs);
                     }
                 }
             }
@@ -33060,17 +33357,25 @@ class ExchangeInstance {
                 const isBacktest = await GET_BACKTEST_FN();
                 allData = await getCandles(symbol, interval, since, limit, isBacktest);
             }
-            // 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);
             // 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) {
-                bt.loggerService.warn(`ExchangeInstance Removed ${filteredData.length - uniqueData.length} duplicate candles by timestamp`);
+            const uniqueData = Array.from(new Map(allData.map((candle) => [candle.timestamp, candle])).values());
+            if (allData.length !== uniqueData.length) {
+                bt.loggerService.warn(`ExchangeInstance getCandles: Removed ${allData.length - uniqueData.length} duplicate candles by timestamp`);
             }
-            if (uniqueData.length < limit) {
-                bt.loggerService.warn(`ExchangeInstance Expected ${limit} candles, got ${uniqueData.length}`);
+            // Validate adapter returned data
+            if (uniqueData.length === 0) {
+                throw new Error(`ExchangeInstance getCandles: adapter returned empty array. ` +
+                    `Expected ${limit} candles starting from openTime=${sinceTimestamp}.`);
+            }
+            if (uniqueData[0].timestamp !== sinceTimestamp) {
+                throw new Error(`ExchangeInstance getCandles: first candle timestamp mismatch. ` +
+                    `Expected openTime=${sinceTimestamp}, got=${uniqueData[0].timestamp}. ` +
+                    `Adapter must return candles with timestamp=openTime, starting from aligned since.`);
+            }
+            if (uniqueData.length !== limit) {
+                throw new Error(`ExchangeInstance getCandles: candle count mismatch. ` +
+                    `Expected ${limit} candles, got ${uniqueData.length}. ` +
+                    `Adapter must return exact number of candles requested.`);
             }
             // Write to cache after successful fetch
             await WRITE_CANDLES_CACHE_FN(uniqueData, { symbol, interval, limit }, this.exchangeName);
@@ -33193,8 +33498,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,9 +33546,11 @@ class ExchangeInstance {
             if (!step) {
                 throw new Error(`ExchangeInstance getRawCandles: unknown interval=${interval}`);
             }
-            const nowTimestamp = Date.now();
+            const stepMs = step * MS_PER_MINUTE;
+            const when = await GET_TIMESTAMP_FN();
+            const nowTimestamp = when.getTime();
+            const alignedNow = ALIGN_TO_INTERVAL_FN(nowTimestamp, step);
             let sinceTimestamp;
-            let untilTimestamp;
             let calculatedLimit;
             // Case 1: all three parameters provided
             if (sDate !== undefined && eDate !== undefined && limit !== undefined) {
@@ -33253,8 +33560,8 @@ class ExchangeInstance {
                 if (eDate > nowTimestamp) {
                     throw new Error(`ExchangeInstance getRawCandles: eDate (${eDate}) exceeds current time (${nowTimestamp}). Look-ahead bias protection.`);
                 }
-                sinceTimestamp = sDate;
-                untilTimestamp = eDate;
+                // Align sDate down to interval boundary
+                sinceTimestamp = ALIGN_TO_INTERVAL_FN(sDate, step);
                 calculatedLimit = limit;
             }
             // Case 2: sDate + eDate (no limit) - calculate limit from date range
@@ -33265,9 +33572,10 @@ class ExchangeInstance {
                 if (eDate > nowTimestamp) {
                     throw new Error(`ExchangeInstance getRawCandles: eDate (${eDate}) exceeds current time (${nowTimestamp}). Look-ahead bias protection.`);
                 }
-                sinceTimestamp = sDate;
-                untilTimestamp = eDate;
-                calculatedLimit = Math.ceil((eDate - sDate) / (step * MS_PER_MINUTE));
+                // Align sDate down to interval boundary
+                sinceTimestamp = ALIGN_TO_INTERVAL_FN(sDate, step);
+                const alignedEDate = ALIGN_TO_INTERVAL_FN(eDate, step);
+                calculatedLimit = Math.ceil((alignedEDate - sinceTimestamp) / stepMs);
                 if (calculatedLimit <= 0) {
                     throw new Error(`ExchangeInstance getRawCandles: calculated limit is ${calculatedLimit}, must be > 0`);
                 }
@@ -33277,23 +33585,24 @@ class ExchangeInstance {
                 if (eDate > nowTimestamp) {
                     throw new Error(`ExchangeInstance getRawCandles: eDate (${eDate}) exceeds current time (${nowTimestamp}). Look-ahead bias protection.`);
                 }
-                untilTimestamp = eDate;
-                sinceTimestamp = eDate - limit * step * MS_PER_MINUTE;
+                // Align eDate down and calculate sinceTimestamp
+                const alignedEDate = ALIGN_TO_INTERVAL_FN(eDate, step);
+                sinceTimestamp = alignedEDate - limit * stepMs;
                 calculatedLimit = limit;
             }
             // Case 4: sDate + limit (no eDate) - calculate eDate forward from sDate
             else if (sDate !== undefined && eDate === undefined && limit !== undefined) {
-                sinceTimestamp = sDate;
-                untilTimestamp = sDate + limit * step * MS_PER_MINUTE;
-                if (untilTimestamp > nowTimestamp) {
-                    throw new Error(`ExchangeInstance getRawCandles: calculated endTimestamp (${untilTimestamp}) exceeds current time (${nowTimestamp}). Look-ahead bias protection.`);
+                // Align sDate down to interval boundary
+                sinceTimestamp = ALIGN_TO_INTERVAL_FN(sDate, step);
+                const endTimestamp = sinceTimestamp + limit * stepMs;
+                if (endTimestamp > nowTimestamp) {
+                    throw new Error(`ExchangeInstance getRawCandles: calculated endTimestamp (${endTimestamp}) exceeds current time (${nowTimestamp}). Look-ahead bias protection.`);
                 }
                 calculatedLimit = limit;
             }
             // Case 5: Only limit - use Date.now() as reference (backward)
             else if (sDate === undefined && eDate === undefined && limit !== undefined) {
-                untilTimestamp = nowTimestamp;
-                sinceTimestamp = nowTimestamp - limit * step * MS_PER_MINUTE;
+                sinceTimestamp = alignedNow - limit * stepMs;
                 calculatedLimit = limit;
             }
             // Invalid: no parameters or only sDate or only eDate
@@ -33303,6 +33612,7 @@ class ExchangeInstance {
                     `Got: sDate=${sDate}, eDate=${eDate}, limit=${limit}`);
             }
             // Try to read from cache first
+            const untilTimestamp = sinceTimestamp + calculatedLimit * stepMs;
             const cachedCandles = await READ_CANDLES_CACHE_FN({ symbol, interval, limit: calculatedLimit }, sinceTimestamp, untilTimestamp, this.exchangeName);
             if (cachedCandles !== null) {
                 return cachedCandles;
@@ -33321,23 +33631,32 @@ class ExchangeInstance {
                     allData.push(...chunkData);
                     remaining -= chunkLimit;
                     if (remaining > 0) {
-                        currentSince = new Date(currentSince.getTime() + chunkLimit * step * MS_PER_MINUTE);
+                        currentSince = new Date(currentSince.getTime() + chunkLimit * stepMs);
                     }
                 }
             }
             else {
                 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);
             // 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) {
-                bt.loggerService.warn(`ExchangeInstance getRawCandles: Removed ${filteredData.length - uniqueData.length} duplicate candles by timestamp`);
+            const uniqueData = Array.from(new Map(allData.map((candle) => [candle.timestamp, candle])).values());
+            if (allData.length !== uniqueData.length) {
+                bt.loggerService.warn(`ExchangeInstance getRawCandles: Removed ${allData.length - uniqueData.length} duplicate candles by timestamp`);
+            }
+            // Validate adapter returned data
+            if (uniqueData.length === 0) {
+                throw new Error(`ExchangeInstance getRawCandles: adapter returned empty array. ` +
+                    `Expected ${calculatedLimit} candles starting from openTime=${sinceTimestamp}.`);
+            }
+            if (uniqueData[0].timestamp !== sinceTimestamp) {
+                throw new Error(`ExchangeInstance getRawCandles: first candle timestamp mismatch. ` +
+                    `Expected openTime=${sinceTimestamp}, got=${uniqueData[0].timestamp}. ` +
+                    `Adapter must return candles with timestamp=openTime, starting from aligned since.`);
             }
-            if (uniqueData.length < calculatedLimit) {
-                bt.loggerService.warn(`ExchangeInstance getRawCandles: Expected ${calculatedLimit} candles, got ${uniqueData.length}`);
+            if (uniqueData.length !== calculatedLimit) {
+                throw new Error(`ExchangeInstance getRawCandles: candle count mismatch. ` +
+                    `Expected ${calculatedLimit} candles, got ${uniqueData.length}. ` +
+                    `Adapter must return exact number of candles requested.`);
             }
             // Write to cache after successful fetch
             await WRITE_CANDLES_CACHE_FN(uniqueData, { symbol, interval, limit: calculatedLimit }, this.exchangeName);
@@ -34933,4 +35252,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 };