backtest-kit 2.2.26 → 2.3.2

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";
@@ -1564,60 +1578,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: functoolsKit.errorData(error),
-                            message: functoolsKit.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 functoolsKit.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: functoolsKit.errorData(error),
+                        message: functoolsKit.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
@@ -1634,8 +1661,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 functoolsKit.not(stateStorage.hasValue(String(candle.timestamp)))) {
                     await stateStorage.writeValue(String(candle.timestamp), candle);
                 }
@@ -1793,6 +1837,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.
@@ -1856,18 +1921,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 = functoolsKit.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;
     }
@@ -1889,7 +1960,12 @@ 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 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
  */
@@ -2016,6 +2092,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
@@ -2028,11 +2111,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) {
@@ -2045,29 +2133,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;
@@ -2076,6 +2169,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
@@ -2088,12 +2188,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 [];
         }
@@ -2109,27 +2221,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;
@@ -2204,6 +2323,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:
@@ -2238,9 +2363,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) {
@@ -2250,8 +2376,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
@@ -2262,9 +2388,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`);
             }
@@ -2274,23 +2401,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
@@ -2311,27 +2439,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;
@@ -13839,6 +13974,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 +14110,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 +14244,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 +14534,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 +14700,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 +16103,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 +16135,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 +16177,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 +16206,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 +16237,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 +16274,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 +16766,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 +16796,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 +16831,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 +19973,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 +20007,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 +21106,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 +23493,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 +23910,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 +25854,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 +26159,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 +33116,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).
@@ -32921,6 +33182,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.
@@ -32942,18 +33224,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 = functoolsKit.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;
     }
@@ -32975,7 +33263,12 @@ 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 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
  */
@@ -33046,14 +33339,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) {
@@ -33072,7 +33369,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);
                     }
                 }
             }
@@ -33080,17 +33377,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);
@@ -33213,8 +33518,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,9 +33566,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) {
@@ -33273,8 +33580,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
@@ -33285,9 +33592,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`);
                 }
@@ -33297,23 +33605,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
@@ -33323,6 +33632,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;
@@ -33341,23 +33651,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);
@@ -35018,6 +35337,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;