backtest-kit 2.3.1 → 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';
@@ -1558,73 +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.
          *
-         * Boundary semantics (EXCLUSIVE):
-         * - sinceTimestamp: candle.timestamp must be > sinceTimestamp
-         * - untilTimestamp: candle.timestamp + stepMs must be < untilTimestamp
-         * - Only fully closed candles within the exclusive range are returned
+         * 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 - Exclusive start timestamp in milliseconds
-         * @param untilTimestamp - Exclusive end timestamp in milliseconds
+         * @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);
             const stepMs = INTERVAL_MINUTES$5[interval] * MS_PER_MINUTE$2;
-            // Collect all cached candles within the time range using EXCLUSIVE boundaries
+            // Calculate expected timestamps and fetch each candle directly
             const cachedCandles = [];
-            for await (const timestamp of stateStorage.keys()) {
-                const ts = Number(timestamp);
-                // EXCLUSIVE boundaries:
-                // - candle.timestamp > sinceTimestamp
-                // - candle.timestamp + stepMs < untilTimestamp (fully closed before untilTimestamp)
-                if (ts > sinceTimestamp && ts + stepMs < untilTimestamp) {
-                    try {
-                        const candle = await stateStorage.readValue(timestamp);
-                        cachedCandles.push(candle);
-                    }
-                    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.
          *
-         * The candles passed to this function must already be filtered using EXCLUSIVE boundaries:
-         * - candle.timestamp > sinceTimestamp
-         * - candle.timestamp + stepMs < untilTimestamp
+         * 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 (already filtered with exclusive boundaries)
+         * @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
@@ -1641,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);
                 }
@@ -1800,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.
@@ -1863,25 +1901,24 @@ const VALIDATE_NO_INCOMPLETE_CANDLES_FN = (candles) => {
 };
 /**
  * Attempts to read candles from cache.
- * Validates cache consistency (no gaps in timestamps) before returning.
  *
- * Boundary semantics:
- * - sinceTimestamp: EXCLUSIVE lower bound (candle.timestamp > sinceTimestamp)
- * - untilTimestamp: EXCLUSIVE upper bound (candle.timestamp + stepMs < untilTimestamp)
- * - Only fully closed candles within the exclusive range are returned
+ * 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 - Exclusive start timestamp in milliseconds
- * @param untilTimestamp - Exclusive 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 uses EXCLUSIVE boundaries:
-    // Returns candles where: timestamp > sinceTimestamp AND timestamp + stepMs < untilTimestamp
+    // 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;
     }
@@ -1903,11 +1940,12 @@ const READ_CANDLES_CACHE_FN$1 = trycatch(async (dto, sinceTimestamp, untilTimest
 /**
  * Writes candles to cache with error handling.
  *
- * The candles passed to this function must already be filtered using EXCLUSIVE boundaries:
- * - candle.timestamp > sinceTimestamp
- * - candle.timestamp + stepMs < untilTimestamp
+ * 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 candle data to cache (already filtered with exclusive boundaries)
+ * @param candles - Array of validated candle data to cache
  * @param dto - Data transfer object containing symbol, interval, and limit
  * @param self - Instance of ClientExchange
  */
@@ -2034,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
@@ -2046,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) {
@@ -2063,39 +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 stepMs = step * MS_PER_MINUTE$1;
-        const filteredData = allData.filter((candle) => {
-            // EXCLUSIVE boundaries:
-            // - candle.timestamp > sinceTimestamp (exclude exact boundary)
-            // - candle.timestamp + stepMs < whenTimestamp (fully closed before "when")
-            if (candle.timestamp <= sinceTimestamp) {
-                return false;
-            }
-            // Check against current time (when)
-            // Only allow candles that have fully CLOSED before "when"
-            return candle.timestamp + stepMs < whenTimestamp;
-        });
         // Apply distinct by timestamp to remove duplicates
-        const uniqueData = Array.from(new Map(filteredData.map((candle) => [candle.timestamp, candle])).values());
-        if (filteredData.length !== uniqueData.length) {
-            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;
@@ -2104,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
@@ -2119,12 +2171,21 @@ class ClientExchange {
         if (!this.params.execution.context.backtest) {
             throw new Error(`ClientExchange getNextCandles: cannot fetch future candles in live mode`);
         }
-        const since = new Date(this.params.execution.context.when.getTime());
-        const now = Date.now();
-        // Вычисляем конечное время запроса
         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 [];
         }
@@ -2140,29 +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 stepMs = step * MS_PER_MINUTE$1;
-        const filteredData = allData.filter((candle) => candle.timestamp > sinceTimestamp &&
-            candle.timestamp + stepMs < endTime);
         // Apply distinct by timestamp to remove duplicates
-        const uniqueData = Array.from(new Map(filteredData.map((candle) => [candle.timestamp, candle])).values());
-        if (filteredData.length !== uniqueData.length) {
-            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;
@@ -2237,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:
@@ -2271,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) {
@@ -2283,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
@@ -2295,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`);
             }
@@ -2307,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
@@ -2344,29 +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
-        // Only include candles that have fully CLOSED before untilTimestamp
-        const stepMs = step * MS_PER_MINUTE$1;
-        const filteredData = allData.filter((candle) => candle.timestamp > sinceTimestamp &&
-            candle.timestamp + stepMs < untilTimestamp);
         // Apply distinct by timestamp to remove duplicates
-        const uniqueData = Array.from(new Map(filteredData.map((candle) => [candle.timestamp, candle])).values());
-        if (filteredData.length !== uniqueData.length) {
-            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;
@@ -12323,13 +12403,6 @@ class WalkerSchemaService {
     }
 }
 
-/**
- * Компенсация для exclusive boundaries при фильтрации свечей.
- * ClientExchange.getNextCandles использует фильтр:
- *   timestamp > since && timestamp + stepMs < endTime
- * который исключает первую и последнюю свечи из запрошенного диапазона.
- */
-const CANDLE_EXCLUSIVE_BOUNDARY_OFFSET = 2;
 /**
  * Private service for backtest orchestration using async generators.
  *
@@ -12595,7 +12668,7 @@ class BacktestLogicPrivateService {
                 // Запрашиваем minuteEstimatedTime + буфер свечей одним запросом
                 const bufferMinutes = GLOBAL_CONFIG.CC_AVG_PRICE_CANDLES_COUNT - 1;
                 const bufferStartTime = new Date(when.getTime() - bufferMinutes * 60 * 1000);
-                const totalCandles = signal.minuteEstimatedTime + GLOBAL_CONFIG.CC_AVG_PRICE_CANDLES_COUNT + CANDLE_EXCLUSIVE_BOUNDARY_OFFSET;
+                const totalCandles = signal.minuteEstimatedTime + GLOBAL_CONFIG.CC_AVG_PRICE_CANDLES_COUNT;
                 let candles;
                 try {
                     candles = await this.exchangeCoreService.getNextCandles(symbol, "1m", totalCandles, bufferStartTime, true);
@@ -33089,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.
@@ -33110,25 +33204,24 @@ const CREATE_EXCHANGE_INSTANCE_FN = (schema) => {
 };
 /**
  * Attempts to read candles from cache.
- * Validates cache consistency (no gaps in timestamps) before returning.
  *
- * Boundary semantics:
- * - sinceTimestamp: EXCLUSIVE lower bound (candle.timestamp > sinceTimestamp)
- * - untilTimestamp: EXCLUSIVE upper bound (candle.timestamp + stepMs < untilTimestamp)
- * - Only fully closed candles within the exclusive range are returned
+ * 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 - Exclusive start timestamp in milliseconds
- * @param untilTimestamp - Exclusive 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 uses EXCLUSIVE boundaries:
-    // Returns candles where: timestamp > sinceTimestamp AND timestamp + stepMs < untilTimestamp
+    // 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;
     }
@@ -33150,11 +33243,12 @@ const READ_CANDLES_CACHE_FN = trycatch(async (dto, sinceTimestamp, untilTimestam
 /**
  * Writes candles to cache with error handling.
  *
- * The candles passed to this function must already be filtered using EXCLUSIVE boundaries:
- * - candle.timestamp > sinceTimestamp
- * - candle.timestamp + stepMs < untilTimestamp
+ * 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 candle data to cache (already filtered with exclusive boundaries)
+ * @param candles - Array of validated candle data to cache
  * @param dto - Data transfer object containing symbol, interval, and limit
  * @param exchangeName - Exchange name
  */
@@ -33225,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}`);
+            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 since = new Date(when.getTime() - adjust * MS_PER_MINUTE);
-            const sinceTimestamp = since.getTime();
-            const untilTimestamp = sinceTimestamp + limit * step * MS_PER_MINUTE;
+            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) {
@@ -33251,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 * MS_PER_MINUTE);
+                        currentSince = new Date(currentSince.getTime() + chunkLimit * stepMs);
                     }
                 }
             }
@@ -33259,27 +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 * MS_PER_MINUTE;
-            const filteredData = allData.filter((candle) => {
-                // EXCLUSIVE boundaries:
-                // - candle.timestamp > sinceTimestamp (exclude exact boundary)
-                // - candle.timestamp + stepMs < whenTimestamp (fully closed before "when")
-                if (candle.timestamp <= sinceTimestamp) {
-                    return false;
-                }
-                // Check against current time (when)
-                // Only allow candles that have fully CLOSED before "when"
-                return candle.timestamp + stepMs < whenTimestamp;
-            });
             // Apply distinct by timestamp to remove duplicates
-            const uniqueData = Array.from(new Map(filteredData.map((candle) => [candle.timestamp, candle])).values());
-            if (filteredData.length !== uniqueData.length) {
-                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`);
+            }
+            // 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.length < limit) {
-                bt.loggerService.warn(`ExchangeInstance Expected ${limit} candles, got ${uniqueData.length}`);
+            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);
@@ -33450,10 +33546,11 @@ class ExchangeInstance {
             if (!step) {
                 throw new Error(`ExchangeInstance getRawCandles: unknown interval=${interval}`);
             }
+            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) {
@@ -33463,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
@@ -33475,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`);
                 }
@@ -33487,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
@@ -33513,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;
@@ -33531,25 +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
-            // Only include candles that have fully CLOSED before untilTimestamp
-            const stepMs = step * MS_PER_MINUTE;
-            const filteredData = allData.filter((candle) => candle.timestamp > sinceTimestamp &&
-                candle.timestamp + stepMs < untilTimestamp);
             // Apply distinct by timestamp to remove duplicates
-            const uniqueData = Array.from(new Map(filteredData.map((candle) => [candle.timestamp, candle])).values());
-            if (filteredData.length !== uniqueData.length) {
-                bt.loggerService.warn(`ExchangeInstance getRawCandles: Removed ${filteredData.length - uniqueData.length} duplicate candles by timestamp`);
-            }
-            if (uniqueData.length < calculatedLimit) {
-                bt.loggerService.warn(`ExchangeInstance getRawCandles: Expected ${calculatedLimit} candles, got ${uniqueData.length}`);
+            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) {
+                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);