backtest-kit 2.1.1 → 2.1.3

package/build/index.mjs

@@ -1,6 +1,6 @@
 import { createActivator } from 'di-kit';
 import { scoped } from 'di-scoped';
-import { Subject, trycatch, errorData, getErrorMessage, sleep, memoize, makeExtendable, singleshot, not, retry, randomString, str, isObject, ToolRegistry, typo, and, resolveDocuments, timeout, TIMEOUT_SYMBOL as TIMEOUT_SYMBOL$1, compose, iterateDocuments, distinctDocuments, queued, singlerun } from 'functools-kit';
+import { Subject, makeExtendable, singleshot, getErrorMessage, memoize, not, trycatch, retry, errorData, queued, sleep, randomString, str, isObject, ToolRegistry, typo, and, resolveDocuments, timeout, TIMEOUT_SYMBOL as TIMEOUT_SYMBOL$1, compose, iterateDocuments, distinctDocuments, singlerun } from 'functools-kit';
 import * as fs from 'fs/promises';
 import fs__default, { mkdir, writeFile } from 'fs/promises';
 import path, { join, dirname } from 'path';
@@ -565,1119 +565,899 @@ var emitters = /*#__PURE__*/Object.freeze({
     walkerStopSubject: walkerStopSubject
 });
 
-const INTERVAL_MINUTES$4 = {
-    "1m": 1,
-    "3m": 3,
-    "5m": 5,
-    "15m": 15,
-    "30m": 30,
-    "1h": 60,
-    "2h": 120,
-    "4h": 240,
-    "6h": 360,
-    "8h": 480,
-};
+const IS_WINDOWS = os.platform() === "win32";
 /**
- * Validates that all candles have valid OHLCV data without anomalies.
- * Detects incomplete candles from Binance API by checking for abnormally low prices or volumes.
- * Incomplete candles often have prices like 0.1 instead of normal 100,000 or zero volume.
+ * Atomically writes data to a file, ensuring the operation either fully completes or leaves the original file unchanged.
+ * Uses a temporary file with a rename strategy on POSIX systems for atomicity, or direct writing with sync on Windows (or when POSIX rename is skipped).
  *
- * @param candles - Array of candle data to validate
- * @throws Error if any candles have anomalous OHLCV values
- */
-const VALIDATE_NO_INCOMPLETE_CANDLES_FN = (candles) => {
-    if (candles.length === 0) {
-        return;
+ *
+ * @param {string} file - The file parameter.
+ * @param {string | Buffer} data - The data to be processed or validated.
+ * @param {Options | BufferEncoding} options - The options parameter (optional).
+ * @throws {Error} Throws an error if the write, sync, or rename operation fails, after attempting cleanup of temporary files.
+ *
+ * @example
+ * // Basic usage with default options
+ * await writeFileAtomic("output.txt", "Hello, world!");
+ * // Writes "Hello, world!" to "output.txt" atomically
+ *
+ * @example
+ * // Custom options and Buffer data
+ * const buffer = Buffer.from("Binary data");
+ * await writeFileAtomic("data.bin", buffer, { encoding: "binary", mode: 0o644, tmpPrefix: "temp-" });
+ * // Writes binary data to "data.bin" with custom permissions and temp prefix
+ *
+ * @example
+ * // Using encoding shorthand
+ * await writeFileAtomic("log.txt", "Log entry", "utf16le");
+ * // Writes "Log entry" to "log.txt" in UTF-16LE encoding
+ *
+ * @remarks
+ * This function ensures atomicity to prevent partial writes:
+ * - On POSIX systems (non-Windows, unless `GLOBAL_CONFIG.CC_SKIP_POSIX_RENAME` is true):
+ *   - Writes data to a temporary file (e.g., `.tmp-<random>-filename`) in the same directory.
+ *   - Uses `crypto.randomBytes` to generate a unique temporary name, reducing collision risk.
+ *   - Syncs the data to disk and renames the temporary file to the target file atomically with `fs.rename`.
+ *   - Cleans up the temporary file on failure, swallowing cleanup errors to prioritize throwing the original error.
+ * - On Windows (or when POSIX rename is skipped):
+ *   - Writes directly to the target file, syncing data to disk to minimize corruption risk (though not fully atomic).
+ *   - Closes the file handle on failure without additional cleanup.
+ * - Accepts `options` as an object or a string (interpreted as `encoding`), defaulting to `{ encoding: "utf8", mode: 0o666, tmpPrefix: ".tmp-" }`.
+ * Useful in the agent swarm system for safely writing configuration files, logs, or state data where partial writes could cause corruption.
+ *
+ * @see {@link https://nodejs.org/api/fs.html#fspromiseswritefilefile-data-options|fs.promises.writeFile} for file writing details.
+ * @see {@link https://nodejs.org/api/crypto.html#cryptorandombytessize-callback|crypto.randomBytes} for temporary file naming.
+ * @see {@link ../config/params|GLOBAL_CONFIG} for configuration impacting POSIX behavior.
+*/
+async function writeFileAtomic(file, data, options = {}) {
+    if (typeof options === "string") {
+        options = { encoding: options };
     }
-    // Calculate reference price (median or average depending on candle count)
-    const allPrices = candles.flatMap((c) => [c.open, c.high, c.low, c.close]);
-    const validPrices = allPrices.filter(p => p > 0);
-    let referencePrice;
-    if (candles.length >= GLOBAL_CONFIG.CC_GET_CANDLES_MIN_CANDLES_FOR_MEDIAN) {
-        // Use median for reliable statistics with enough data
-        const sortedPrices = [...validPrices].sort((a, b) => a - b);
-        referencePrice = sortedPrices[Math.floor(sortedPrices.length / 2)] || 0;
+    else if (!options) {
+        options = {};
     }
-    else {
-        // Use average for small datasets (more stable than median)
-        const sum = validPrices.reduce((acc, p) => acc + p, 0);
-        referencePrice = validPrices.length > 0 ? sum / validPrices.length : 0;
+    const { encoding = "utf8", mode = 0o666, tmpPrefix = ".tmp-" } = options;
+    let fileHandle = null;
+    if (IS_WINDOWS) {
+        try {
+            // Create and write to temporary file
+            fileHandle = await fs__default.open(file, "w", mode);
+            // Write data to the temp file
+            await fileHandle.writeFile(data, { encoding });
+            // Ensure data is flushed to disk
+            await fileHandle.sync();
+            // Close the file before rename
+            await fileHandle.close();
+        }
+        catch (error) {
+            // Clean up if something went wrong
+            if (fileHandle) {
+                await fileHandle.close().catch(() => { });
+            }
+            throw error; // Re-throw the original error
+        }
+        return;
     }
-    if (referencePrice === 0) {
-        throw new Error(`VALIDATE_NO_INCOMPLETE_CANDLES_FN: cannot calculate reference price (all prices are zero)`);
+    // Create a temporary filename in the same directory
+    const dir = path.dirname(file);
+    const filename = path.basename(file);
+    const tmpFile = path.join(dir, `${tmpPrefix}${crypto.randomBytes(6).toString("hex")}-${filename}`);
+    try {
+        // Create and write to temporary file
+        fileHandle = await fs__default.open(tmpFile, "w", mode);
+        // Write data to the temp file
+        await fileHandle.writeFile(data, { encoding });
+        // Ensure data is flushed to disk
+        await fileHandle.sync();
+        // Close the file before rename
+        await fileHandle.close();
+        fileHandle = null;
+        // Atomically replace the target file with our temp file
+        await fs__default.rename(tmpFile, file);
     }
-    const minValidPrice = referencePrice / GLOBAL_CONFIG.CC_GET_CANDLES_PRICE_ANOMALY_THRESHOLD_FACTOR;
-    for (let i = 0; i < candles.length; i++) {
-        const candle = candles[i];
-        // Check for invalid numeric values
-        if (!Number.isFinite(candle.open) ||
-            !Number.isFinite(candle.high) ||
-            !Number.isFinite(candle.low) ||
-            !Number.isFinite(candle.close) ||
-            !Number.isFinite(candle.volume) ||
-            !Number.isFinite(candle.timestamp)) {
-            throw new Error(`VALIDATE_NO_INCOMPLETE_CANDLES_FN: candle[${i}] has invalid numeric values (NaN or Infinity)`);
+    catch (error) {
+        // Clean up if something went wrong
+        if (fileHandle) {
+            await fileHandle.close().catch(() => { });
         }
-        // Check for negative values
-        if (candle.open <= 0 ||
-            candle.high <= 0 ||
-            candle.low <= 0 ||
-            candle.close <= 0 ||
-            candle.volume < 0) {
-            throw new Error(`VALIDATE_NO_INCOMPLETE_CANDLES_FN: candle[${i}] has zero or negative values`);
+        // Try to remove the temporary file
+        try {
+            await fs__default.unlink(tmpFile).catch(() => { });
         }
-        // Check for anomalously low prices (incomplete candle indicator)
-        if (candle.open < minValidPrice ||
-            candle.high < minValidPrice ||
-            candle.low < minValidPrice ||
-            candle.close < minValidPrice) {
-            throw new Error(`VALIDATE_NO_INCOMPLETE_CANDLES_FN: candle[${i}] has anomalously low price. ` +
-                `OHLC: [${candle.open}, ${candle.high}, ${candle.low}, ${candle.close}], ` +
-                `reference: ${referencePrice}, threshold: ${minValidPrice}`);
+        catch (_) {
+            // Ignore errors during cleanup
         }
+        throw error;
     }
-};
-/**
- * Retries the getCandles function with specified retry count and delay.
- * @param dto - Data transfer object containing symbol, interval, and limit
- * @param since - Date object representing the start time for fetching candles
- * @param self - Instance of ClientExchange
- * @returns Promise resolving to array of candle data
- */
-const GET_CANDLES_FN = async (dto, since, self) => {
-    let lastError;
-    for (let i = 0; i !== GLOBAL_CONFIG.CC_GET_CANDLES_RETRY_COUNT; i++) {
+}
+
+var _a$2;
+const BASE_WAIT_FOR_INIT_SYMBOL = Symbol("wait-for-init");
+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";
+const PERSIST_SIGNAL_UTILS_METHOD_NAME_USE_JSON = "PersistSignalUtils.useJson";
+const PERSIST_SIGNAL_UTILS_METHOD_NAME_USE_DUMMY = "PersistSignalUtils.useDummy";
+const PERSIST_SCHEDULE_UTILS_METHOD_NAME_USE_PERSIST_SCHEDULE_ADAPTER = "PersistScheduleUtils.usePersistScheduleAdapter";
+const PERSIST_SCHEDULE_UTILS_METHOD_NAME_READ_DATA = "PersistScheduleUtils.readScheduleData";
+const PERSIST_SCHEDULE_UTILS_METHOD_NAME_WRITE_DATA = "PersistScheduleUtils.writeScheduleData";
+const PERSIST_SCHEDULE_UTILS_METHOD_NAME_USE_JSON = "PersistScheduleUtils.useJson";
+const PERSIST_SCHEDULE_UTILS_METHOD_NAME_USE_DUMMY = "PersistScheduleUtils.useDummy";
+const PERSIST_PARTIAL_UTILS_METHOD_NAME_USE_PERSIST_PARTIAL_ADAPTER = "PersistPartialUtils.usePersistPartialAdapter";
+const PERSIST_PARTIAL_UTILS_METHOD_NAME_READ_DATA = "PersistPartialUtils.readPartialData";
+const PERSIST_PARTIAL_UTILS_METHOD_NAME_WRITE_DATA = "PersistPartialUtils.writePartialData";
+const PERSIST_PARTIAL_UTILS_METHOD_NAME_USE_JSON = "PersistPartialUtils.useJson";
+const PERSIST_PARTIAL_UTILS_METHOD_NAME_USE_DUMMY = "PersistPartialUtils.useDummy";
+const PERSIST_BREAKEVEN_UTILS_METHOD_NAME_USE_PERSIST_BREAKEVEN_ADAPTER = "PersistBreakevenUtils.usePersistBreakevenAdapter";
+const PERSIST_BREAKEVEN_UTILS_METHOD_NAME_READ_DATA = "PersistBreakevenUtils.readBreakevenData";
+const PERSIST_BREAKEVEN_UTILS_METHOD_NAME_WRITE_DATA = "PersistBreakevenUtils.writeBreakevenData";
+const PERSIST_BREAKEVEN_UTILS_METHOD_NAME_USE_JSON = "PersistBreakevenUtils.useJson";
+const PERSIST_BREAKEVEN_UTILS_METHOD_NAME_USE_DUMMY = "PersistBreakevenUtils.useDummy";
+const PERSIST_RISK_UTILS_METHOD_NAME_USE_PERSIST_RISK_ADAPTER = "PersistRiskUtils.usePersistRiskAdapter";
+const PERSIST_RISK_UTILS_METHOD_NAME_READ_DATA = "PersistRiskUtils.readPositionData";
+const PERSIST_RISK_UTILS_METHOD_NAME_WRITE_DATA = "PersistRiskUtils.writePositionData";
+const PERSIST_RISK_UTILS_METHOD_NAME_USE_JSON = "PersistRiskUtils.useJson";
+const PERSIST_RISK_UTILS_METHOD_NAME_USE_DUMMY = "PersistRiskUtils.useDummy";
+const PERSIST_BASE_METHOD_NAME_CTOR = "PersistBase.CTOR";
+const PERSIST_BASE_METHOD_NAME_WAIT_FOR_INIT = "PersistBase.waitForInit";
+const PERSIST_BASE_METHOD_NAME_READ_VALUE = "PersistBase.readValue";
+const PERSIST_BASE_METHOD_NAME_WRITE_VALUE = "PersistBase.writeValue";
+const PERSIST_BASE_METHOD_NAME_HAS_VALUE = "PersistBase.hasValue";
+const PERSIST_BASE_METHOD_NAME_KEYS = "PersistBase.keys";
+const BASE_WAIT_FOR_INIT_FN_METHOD_NAME = "PersistBase.waitForInitFn";
+const BASE_UNLINK_RETRY_COUNT = 5;
+const BASE_UNLINK_RETRY_DELAY = 1000;
+const BASE_WAIT_FOR_INIT_FN = async (self) => {
+    bt.loggerService.debug(BASE_WAIT_FOR_INIT_FN_METHOD_NAME, {
+        entityName: self.entityName,
+        directory: self._directory,
+    });
+    await fs__default.mkdir(self._directory, { recursive: true });
+    for await (const key of self.keys()) {
         try {
-            const result = await self.params.getCandles(dto.symbol, dto.interval, since, dto.limit, self.params.execution.context.backtest);
-            VALIDATE_NO_INCOMPLETE_CANDLES_FN(result);
-            return result;
+            await self.readValue(key);
         }
-        catch (err) {
-            const message = `ClientExchange GET_CANDLES_FN: attempt ${i + 1} failed for symbol=${dto.symbol}, interval=${dto.interval}, since=${since.toISOString()}, limit=${dto.limit}}`;
-            const payload = {
-                error: errorData(err),
-                message: getErrorMessage(err),
-            };
-            self.params.logger.warn(message, payload);
-            console.warn(message, payload);
-            lastError = err;
-            await sleep(GLOBAL_CONFIG.CC_GET_CANDLES_RETRY_DELAY_MS);
+        catch {
+            const filePath = self._getFilePath(key);
+            console.error(`backtest-kit PersistBase found invalid document for filePath=${filePath} entityName=${self.entityName}`);
+            if (await not(BASE_WAIT_FOR_INIT_UNLINK_FN(filePath))) {
+                console.error(`backtest-kit PersistBase failed to remove invalid document for filePath=${filePath} entityName=${self.entityName}`);
+            }
         }
     }
-    throw lastError;
 };
-/**
- * Wrapper to call onCandleData callback with error handling.
- * Catches and logs any errors thrown by the user-provided callback.
- *
- * @param self - ClientExchange instance reference
- * @param symbol - Trading pair symbol
- * @param interval - Candle interval
- * @param since - Start date for candle data
- * @param limit - Number of candles
- * @param data - Array of candle data
- */
-const CALL_CANDLE_DATA_CALLBACKS_FN = trycatch(async (self, symbol, interval, since, limit, data) => {
-    if (self.params.callbacks?.onCandleData) {
-        await self.params.callbacks.onCandleData(symbol, interval, since, limit, data);
+const BASE_WAIT_FOR_INIT_UNLINK_FN = async (filePath) => trycatch(retry(async () => {
+    try {
+        await fs__default.unlink(filePath);
+        return true;
     }
-}, {
-    fallback: (error) => {
-        const message = "ClientExchange CALL_CANDLE_DATA_CALLBACKS_FN thrown";
-        const payload = {
-            error: errorData(error),
-            message: getErrorMessage(error),
-        };
-        bt.loggerService.warn(message, payload);
-        console.warn(message, payload);
-        errorEmitter.next(error);
-    },
+    catch (error) {
+        console.error(`backtest-kit PersistBase unlink failed for filePath=${filePath} error=${getErrorMessage(error)}`);
+        throw error;
+    }
+}, BASE_UNLINK_RETRY_COUNT, BASE_UNLINK_RETRY_DELAY), {
+    defaultValue: false,
 });
 /**
- * Client implementation for exchange data access.
+ * Base class for file-based persistence with atomic writes.
  *
  * Features:
- * - Historical candle fetching (backwards from execution context)
- * - Future candle fetching (forwards for backtest)
- * - VWAP calculation from last 5 1m candles
- * - Price/quantity formatting for exchange
- *
- * All methods use prototype functions for memory efficiency.
+ * - Atomic file writes using writeFileAtomic
+ * - Auto-validation and cleanup of corrupted files
+ * - Async generator support for iteration
+ * - Retry logic for file deletion
  *
  * @example
  * ```typescript
- * const exchange = new ClientExchange({
- *   exchangeName: "binance",
- *   getCandles: async (symbol, interval, since, limit) => [...],
- *   formatPrice: async (symbol, price) => price.toFixed(2),
- *   formatQuantity: async (symbol, quantity) => quantity.toFixed(8),
- *   execution: executionService,
- *   logger: loggerService,
- * });
- *
- * const candles = await exchange.getCandles("BTCUSDT", "1m", 100);
- * const vwap = await exchange.getAveragePrice("BTCUSDT");
+ * const persist = new PersistBase("my-entity", "./data");
+ * await persist.waitForInit(true);
+ * await persist.writeValue("key1", { data: "value" });
+ * const value = await persist.readValue("key1");
  * ```
  */
-class ClientExchange {
-    constructor(params) {
-        this.params = params;
-    }
+class PersistBase {
     /**
-     * Fetches historical candles backwards from execution context time.
+     * Creates new persistence instance.
      *
-     * @param symbol - Trading pair symbol
-     * @param interval - Candle interval
-     * @param limit - Number of candles to fetch
-     * @returns Promise resolving to array of candles
+     * @param entityName - Unique entity type identifier
+     * @param baseDir - Base directory for all entities (default: ./dump/data)
      */
-    async getCandles(symbol, interval, limit) {
-        this.params.logger.debug(`ClientExchange getCandles`, {
-            symbol,
-            interval,
-            limit,
+    constructor(entityName, baseDir = join(process.cwd(), "logs/data")) {
+        this.entityName = entityName;
+        this.baseDir = baseDir;
+        this[_a$2] = singleshot(async () => await BASE_WAIT_FOR_INIT_FN(this));
+        bt.loggerService.debug(PERSIST_BASE_METHOD_NAME_CTOR, {
+            entityName: this.entityName,
+            baseDir,
         });
-        const step = INTERVAL_MINUTES$4[interval];
-        const adjust = step * limit;
-        if (!adjust) {
-            throw new Error(`ClientExchange unknown time adjust for interval=${interval}`);
-        }
-        const since = new Date(this.params.execution.context.when.getTime() - adjust * 60 * 1000);
-        let allData = [];
-        // If limit exceeds CC_MAX_CANDLES_PER_REQUEST, fetch data in chunks
-        if (limit > GLOBAL_CONFIG.CC_MAX_CANDLES_PER_REQUEST) {
-            let remaining = limit;
-            let currentSince = new Date(since.getTime());
-            while (remaining > 0) {
-                const chunkLimit = Math.min(remaining, GLOBAL_CONFIG.CC_MAX_CANDLES_PER_REQUEST);
-                const chunkData = await GET_CANDLES_FN({ symbol, interval, limit: chunkLimit }, currentSince, this);
-                allData.push(...chunkData);
-                remaining -= chunkLimit;
-                if (remaining > 0) {
-                    // Move currentSince forward by the number of candles fetched
-                    currentSince = new Date(currentSince.getTime() + chunkLimit * step * 60 * 1000);
-                }
-            }
-        }
-        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 * 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) {
-            const msg = `ClientExchange Removed ${filteredData.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);
-        }
-        await CALL_CANDLE_DATA_CALLBACKS_FN(this, symbol, interval, since, limit, uniqueData);
-        return uniqueData;
+        this._directory = join(this.baseDir, this.entityName);
     }
     /**
-     * Fetches future candles forwards from execution context time.
-     * Used in backtest mode to get candles for signal duration.
+     * Computes file path for entity ID.
      *
-     * @param symbol - Trading pair symbol
-     * @param interval - Candle interval
-     * @param limit - Number of candles to fetch
-     * @returns Promise resolving to array of candles
-     * @throws Error if trying to fetch future candles in live mode
+     * @param entityId - Entity identifier
+     * @returns Full file path to entity JSON file
      */
-    async getNextCandles(symbol, interval, limit) {
-        this.params.logger.debug(`ClientExchange getNextCandles`, {
-            symbol,
-            interval,
-            limit,
+    _getFilePath(entityId) {
+        return join(this.baseDir, this.entityName, `${entityId}.json`);
+    }
+    async waitForInit(initial) {
+        bt.loggerService.debug(PERSIST_BASE_METHOD_NAME_WAIT_FOR_INIT, {
+            entityName: this.entityName,
+            initial,
         });
-        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 * 60 * 1000;
-        // Проверяем что запрошенный период не заходит за Date.now()
-        if (endTime > now) {
-            return [];
+        await this[BASE_WAIT_FOR_INIT_SYMBOL]();
+    }
+    async readValue(entityId) {
+        bt.loggerService.debug(PERSIST_BASE_METHOD_NAME_READ_VALUE, {
+            entityName: this.entityName,
+            entityId,
+        });
+        try {
+            const filePath = this._getFilePath(entityId);
+            const fileContent = await fs__default.readFile(filePath, "utf-8");
+            return JSON.parse(fileContent);
         }
-        let allData = [];
-        // If limit exceeds CC_MAX_CANDLES_PER_REQUEST, fetch data in chunks
-        if (limit > GLOBAL_CONFIG.CC_MAX_CANDLES_PER_REQUEST) {
-            let remaining = limit;
-            let currentSince = new Date(since.getTime());
-            while (remaining > 0) {
-                const chunkLimit = Math.min(remaining, GLOBAL_CONFIG.CC_MAX_CANDLES_PER_REQUEST);
-                const chunkData = await GET_CANDLES_FN({ symbol, interval, limit: chunkLimit }, currentSince, this);
-                allData.push(...chunkData);
-                remaining -= chunkLimit;
-                if (remaining > 0) {
-                    // Move currentSince forward by the number of candles fetched
-                    currentSince = new Date(currentSince.getTime() + chunkLimit * step * 60 * 1000);
-                }
+        catch (error) {
+            if (error?.code === "ENOENT") {
+                throw new Error(`Entity ${this.entityName}:${entityId} not found`);
             }
+            throw new Error(`Failed to read entity ${this.entityName}:${entityId}: ${getErrorMessage(error)}`);
         }
-        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`;
-            this.params.logger.warn(msg);
-            console.warn(msg);
+    }
+    async hasValue(entityId) {
+        bt.loggerService.debug(PERSIST_BASE_METHOD_NAME_HAS_VALUE, {
+            entityName: this.entityName,
+            entityId,
+        });
+        try {
+            const filePath = this._getFilePath(entityId);
+            await fs__default.access(filePath);
+            return true;
         }
-        if (uniqueData.length < limit) {
-            const msg = `ClientExchange getNextCandles: Expected ${limit} candles, got ${uniqueData.length}`;
-            this.params.logger.warn(msg);
-            console.warn(msg);
+        catch (error) {
+            if (error?.code === "ENOENT") {
+                return false;
+            }
+            throw new Error(`Failed to check existence of entity ${this.entityName}:${entityId}: ${getErrorMessage(error)}`);
         }
-        await CALL_CANDLE_DATA_CALLBACKS_FN(this, symbol, interval, since, limit, uniqueData);
-        return uniqueData;
     }
-    /**
-     * Calculates VWAP (Volume Weighted Average Price) from last N 1m candles.
-     * The number of candles is configurable via GLOBAL_CONFIG.CC_AVG_PRICE_CANDLES_COUNT.
-     *
-     * Formula:
-     * - Typical Price = (high + low + close) / 3
-     * - VWAP = sum(typical_price * volume) / sum(volume)
-     *
-     * If volume is zero, returns simple average of close prices.
-     *
-     * @param symbol - Trading pair symbol
-     * @returns Promise resolving to VWAP price
-     * @throws Error if no candles available
-     */
-    async getAveragePrice(symbol) {
-        this.params.logger.debug(`ClientExchange getAveragePrice`, {
-            symbol,
+    async writeValue(entityId, entity) {
+        bt.loggerService.debug(PERSIST_BASE_METHOD_NAME_WRITE_VALUE, {
+            entityName: this.entityName,
+            entityId,
         });
-        const candles = await this.getCandles(symbol, "1m", GLOBAL_CONFIG.CC_AVG_PRICE_CANDLES_COUNT);
-        if (candles.length === 0) {
-            throw new Error(`ClientExchange getAveragePrice: no candles data for symbol=${symbol}`);
+        try {
+            const filePath = this._getFilePath(entityId);
+            const serializedData = JSON.stringify(entity);
+            await writeFileAtomic(filePath, serializedData, "utf-8");
         }
-        // VWAP (Volume Weighted Average Price)
-        // Используем типичную цену (typical price) = (high + low + close) / 3
-        const sumPriceVolume = candles.reduce((acc, candle) => {
-            const typicalPrice = (candle.high + candle.low + candle.close) / 3;
-            return acc + typicalPrice * candle.volume;
-        }, 0);
-        const totalVolume = candles.reduce((acc, candle) => acc + candle.volume, 0);
-        if (totalVolume === 0) {
-            // Если объем нулевой, возвращаем простое среднее close цен
-            const sum = candles.reduce((acc, candle) => acc + candle.close, 0);
-            return sum / candles.length;
+        catch (error) {
+            throw new Error(`Failed to write entity ${this.entityName}:${entityId}: ${getErrorMessage(error)}`);
         }
-        const vwap = sumPriceVolume / totalVolume;
-        return vwap;
     }
     /**
-     * Formats quantity according to exchange-specific rules for the given symbol.
-     * Applies proper decimal precision and rounding based on symbol's lot size filters.
+     * Async generator yielding all entity IDs.
+     * Sorted alphanumerically.
+     * Used internally by waitForInit for validation.
      *
-     * @param symbol - Trading pair symbol
-     * @param quantity - Raw quantity to format
-     * @returns Promise resolving to formatted quantity as string
+     * @returns AsyncGenerator yielding entity IDs
+     * @throws Error if reading fails
      */
-    async formatQuantity(symbol, quantity) {
-        this.params.logger.debug("binanceService formatQuantity", {
-            symbol,
-            quantity,
+    async *keys() {
+        bt.loggerService.debug(PERSIST_BASE_METHOD_NAME_KEYS, {
+            entityName: this.entityName,
         });
-        return await this.params.formatQuantity(symbol, quantity, this.params.execution.context.backtest);
-    }
-    /**
-     * Formats price according to exchange-specific rules for the given symbol.
-     * Applies proper decimal precision and rounding based on symbol's price filters.
-     *
-     * @param symbol - Trading pair symbol
-     * @param price - Raw price to format
-     * @returns Promise resolving to formatted price as string
+        try {
+            const files = await fs__default.readdir(this._directory);
+            const entityIds = files
+                .filter((file) => file.endsWith(".json"))
+                .map((file) => file.slice(0, -5))
+                .sort((a, b) => a.localeCompare(b, undefined, {
+                numeric: true,
+                sensitivity: "base",
+            }));
+            for (const entityId of entityIds) {
+                yield entityId;
+            }
+        }
+        catch (error) {
+            throw new Error(`Failed to read keys for ${this.entityName}: ${getErrorMessage(error)}`);
+        }
+    }
+}
+_a$2 = BASE_WAIT_FOR_INIT_SYMBOL;
+// @ts-ignore
+PersistBase = makeExtendable(PersistBase);
+/**
+ * Dummy persist adapter that discards all writes.
+ * Used for disabling persistence.
+ */
+class PersistDummy {
+    /**
+     * No-op initialization function.
+     * @returns Promise that resolves immediately
      */
-    async formatPrice(symbol, price) {
-        this.params.logger.debug("binanceService formatPrice", {
-            symbol,
-            price,
-        });
-        return await this.params.formatPrice(symbol, price, this.params.execution.context.backtest);
+    async waitForInit() {
     }
     /**
-     * Fetches order book for a trading pair.
-     *
-     * Calculates time range based on execution context time (when) and
-     * CC_ORDER_BOOK_TIME_OFFSET_MINUTES, then delegates to the exchange
-     * schema implementation which may use or ignore the time range.
-     *
-     * @param symbol - Trading pair symbol
-     * @param depth - Maximum depth levels (default: CC_ORDER_BOOK_MAX_DEPTH_LEVELS)
-     * @returns Promise resolving to order book data
-     * @throws Error if getOrderBook is not implemented
+     * No-op read function.
+     * @returns Promise that resolves with empty object
      */
-    async getOrderBook(symbol, depth = GLOBAL_CONFIG.CC_ORDER_BOOK_MAX_DEPTH_LEVELS) {
-        this.params.logger.debug("ClientExchange getOrderBook", {
-            symbol,
-            depth,
-        });
-        const to = new Date(this.params.execution.context.when.getTime());
-        const from = new Date(to.getTime() - GLOBAL_CONFIG.CC_ORDER_BOOK_TIME_OFFSET_MINUTES * 60 * 1000);
-        return await this.params.getOrderBook(symbol, depth, from, to, this.params.execution.context.backtest);
+    async readValue() {
+        return {};
+    }
+    /**
+     * No-op has value check.
+     * @returns Promise that resolves to false
+     */
+    async hasValue() {
+        return false;
+    }
+    /**
+     * No-op write function.
+     * @returns Promise that resolves immediately
+     */
+    async writeValue() {
+    }
+    /**
+     * No-op keys generator.
+     * @returns Empty async generator
+     */
+    async *keys() {
+        // Empty generator - no keys
     }
 }
-
-/**
- * Default implementation for getCandles.
- * Throws an error indicating the method is not implemented.
- */
-const DEFAULT_GET_CANDLES_FN$1 = async (_symbol, _interval, _since, _limit, _backtest) => {
-    throw new Error(`getCandles is not implemented for this exchange`);
-};
-/**
- * Default implementation for formatQuantity.
- * Returns Bitcoin precision on Binance (8 decimal places).
- */
-const DEFAULT_FORMAT_QUANTITY_FN$1 = async (_symbol, quantity, _backtest) => {
-    return quantity.toFixed(8);
-};
-/**
- * Default implementation for formatPrice.
- * Returns Bitcoin precision on Binance (2 decimal places).
- */
-const DEFAULT_FORMAT_PRICE_FN$1 = async (_symbol, price, _backtest) => {
-    return price.toFixed(2);
-};
-/**
- * Default implementation for getOrderBook.
- * Throws an error indicating the method is not implemented.
- *
- * @param _symbol - Trading pair symbol (unused)
- * @param _depth - Maximum depth levels (unused)
- * @param _from - Start of time range (unused - can be ignored in live implementations)
- * @param _to - End of time range (unused - can be ignored in live implementations)
- * @param _backtest - Whether running in backtest mode (unused)
- */
-const DEFAULT_GET_ORDER_BOOK_FN$1 = async (_symbol, _depth, _from, _to, _backtest) => {
-    throw new Error(`getOrderBook is not implemented for this exchange`);
-};
 /**
- * Connection service routing exchange operations to correct ClientExchange instance.
- *
- * Routes all IExchange method calls to the appropriate exchange implementation
- * based on methodContextService.context.exchangeName. Uses memoization to cache
- * ClientExchange instances for performance.
+ * Utility class for managing signal persistence.
  *
- * Key features:
- * - Automatic exchange routing via method context
- * - Memoized ClientExchange instances by exchangeName
- * - Implements full IExchange interface
- * - Logging for all operations
+ * Features:
+ * - Memoized storage instances per strategy
+ * - Custom adapter support
+ * - Atomic read/write operations
+ * - Crash-safe signal state management
  *
- * @example
- * ```typescript
- * // Used internally by framework
- * const candles = await exchangeConnectionService.getCandles(
- *   "BTCUSDT", "1h", 100
- * );
- * // Automatically routes to correct exchange based on methodContext
- * ```
+ * Used by ClientStrategy for live mode persistence.
  */
-class ExchangeConnectionService {
+class PersistSignalUtils {
     constructor() {
-        this.loggerService = inject(TYPES.loggerService);
-        this.executionContextService = inject(TYPES.executionContextService);
-        this.exchangeSchemaService = inject(TYPES.exchangeSchemaService);
-        this.methodContextService = inject(TYPES.methodContextService);
-        /**
-         * Retrieves memoized ClientExchange instance for given exchange name.
-         *
-         * Creates ClientExchange on first call, returns cached instance on subsequent calls.
-         * Cache key is exchangeName string.
-         *
-         * @param exchangeName - Name of registered exchange schema
-         * @returns Configured ClientExchange instance
-         */
-        this.getExchange = memoize(([exchangeName]) => `${exchangeName}`, (exchangeName) => {
-            const { getCandles = DEFAULT_GET_CANDLES_FN$1, formatPrice = DEFAULT_FORMAT_PRICE_FN$1, formatQuantity = DEFAULT_FORMAT_QUANTITY_FN$1, getOrderBook = DEFAULT_GET_ORDER_BOOK_FN$1, callbacks } = this.exchangeSchemaService.get(exchangeName);
-            return new ClientExchange({
-                execution: this.executionContextService,
-                logger: this.loggerService,
-                exchangeName,
-                getCandles,
-                formatPrice,
-                formatQuantity,
-                getOrderBook,
-                callbacks,
-            });
-        });
+        this.PersistSignalFactory = PersistBase;
+        this.getSignalStorage = memoize(([symbol, strategyName, exchangeName]) => `${symbol}:${strategyName}:${exchangeName}`, (symbol, strategyName, exchangeName) => Reflect.construct(this.PersistSignalFactory, [
+            `${symbol}_${strategyName}_${exchangeName}`,
+            `./dump/data/signal/`,
+        ]));
         /**
-         * Fetches historical candles for symbol using configured exchange.
+         * Reads persisted signal data for a symbol and strategy.
          *
-         * Routes to exchange determined by methodContextService.context.exchangeName.
+         * Called by ClientStrategy.waitForInit() to restore state.
+         * Returns null if no signal exists.
          *
-         * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
-         * @param interval - Candle interval (e.g., "1h", "1d")
-         * @param limit - Maximum number of candles to fetch
-         * @returns Promise resolving to array of candle data
+         * @param symbol - Trading pair symbol
+         * @param strategyName - Strategy identifier
+         * @param exchangeName - Exchange identifier
+         * @returns Promise resolving to signal or null
          */
-        this.getCandles = async (symbol, interval, limit) => {
-            this.loggerService.log("exchangeConnectionService getCandles", {
-                symbol,
-                interval,
-                limit,
-            });
-            return await this.getExchange(this.methodContextService.context.exchangeName).getCandles(symbol, interval, limit);
+        this.readSignalData = async (symbol, strategyName, exchangeName) => {
+            bt.loggerService.info(PERSIST_SIGNAL_UTILS_METHOD_NAME_READ_DATA);
+            const key = `${symbol}:${strategyName}:${exchangeName}`;
+            const isInitial = !this.getSignalStorage.has(key);
+            const stateStorage = this.getSignalStorage(symbol, strategyName, exchangeName);
+            await stateStorage.waitForInit(isInitial);
+            if (await stateStorage.hasValue(symbol)) {
+                return await stateStorage.readValue(symbol);
+            }
+            return null;
         };
         /**
-         * Fetches next batch of candles relative to executionContext.when.
+         * Writes signal data to disk with atomic file writes.
          *
-         * Returns candles that come after the current execution timestamp.
-         * Used for backtest progression and live trading updates.
+         * Called by ClientStrategy.setPendingSignal() to persist state.
+         * Uses atomic writes to prevent corruption on crashes.
          *
-         * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
-         * @param interval - Candle interval (e.g., "1h", "1d")
-         * @param limit - Maximum number of candles to fetch
-         * @returns Promise resolving to array of candle data
+         * @param signalRow - Signal data (null to clear)
+         * @param symbol - Trading pair symbol
+         * @param strategyName - Strategy identifier
+         * @param exchangeName - Exchange identifier
+         * @returns Promise that resolves when write is complete
          */
-        this.getNextCandles = async (symbol, interval, limit) => {
-            this.loggerService.log("exchangeConnectionService getNextCandles", {
-                symbol,
-                interval,
-                limit,
-            });
-            return await this.getExchange(this.methodContextService.context.exchangeName).getNextCandles(symbol, interval, limit);
+        this.writeSignalData = async (signalRow, symbol, strategyName, exchangeName) => {
+            bt.loggerService.info(PERSIST_SIGNAL_UTILS_METHOD_NAME_WRITE_DATA);
+            const key = `${symbol}:${strategyName}:${exchangeName}`;
+            const isInitial = !this.getSignalStorage.has(key);
+            const stateStorage = this.getSignalStorage(symbol, strategyName, exchangeName);
+            await stateStorage.waitForInit(isInitial);
+            await stateStorage.writeValue(symbol, signalRow);
         };
+    }
+    /**
+     * Registers a custom persistence adapter.
+     *
+     * @param Ctor - Custom PersistBase constructor
+     *
+     * @example
+     * ```typescript
+     * class RedisPersist extends PersistBase {
+     *   async readValue(id) { return JSON.parse(await redis.get(id)); }
+     *   async writeValue(id, entity) { await redis.set(id, JSON.stringify(entity)); }
+     * }
+     * PersistSignalAdapter.usePersistSignalAdapter(RedisPersist);
+     * ```
+     */
+    usePersistSignalAdapter(Ctor) {
+        bt.loggerService.info(PERSIST_SIGNAL_UTILS_METHOD_NAME_USE_PERSIST_SIGNAL_ADAPTER);
+        this.PersistSignalFactory = Ctor;
+    }
+    /**
+     * Switches to the default JSON persist adapter.
+     * All future persistence writes will use JSON storage.
+     */
+    useJson() {
+        bt.loggerService.log(PERSIST_SIGNAL_UTILS_METHOD_NAME_USE_JSON);
+        this.usePersistSignalAdapter(PersistBase);
+    }
+    /**
+     * Switches to a dummy persist adapter that discards all writes.
+     * All future persistence writes will be no-ops.
+     */
+    useDummy() {
+        bt.loggerService.log(PERSIST_SIGNAL_UTILS_METHOD_NAME_USE_DUMMY);
+        this.usePersistSignalAdapter(PersistDummy);
+    }
+}
+/**
+ * Global singleton instance of PersistSignalUtils.
+ * Used by ClientStrategy for signal persistence.
+ *
+ * @example
+ * ```typescript
+ * // Custom adapter
+ * PersistSignalAdapter.usePersistSignalAdapter(RedisPersist);
+ *
+ * // Read signal
+ * const signal = await PersistSignalAdapter.readSignalData("my-strategy", "BTCUSDT");
+ *
+ * // Write signal
+ * await PersistSignalAdapter.writeSignalData(signal, "my-strategy", "BTCUSDT");
+ * ```
+ */
+const PersistSignalAdapter = new PersistSignalUtils();
+/**
+ * Utility class for managing risk active positions persistence.
+ *
+ * Features:
+ * - Memoized storage instances per risk profile
+ * - Custom adapter support
+ * - Atomic read/write operations for RiskData
+ * - Crash-safe position state management
+ *
+ * Used by ClientRisk for live mode persistence of active positions.
+ */
+class PersistRiskUtils {
+    constructor() {
+        this.PersistRiskFactory = PersistBase;
+        this.getRiskStorage = memoize(([riskName, exchangeName]) => `${riskName}:${exchangeName}`, (riskName, exchangeName) => Reflect.construct(this.PersistRiskFactory, [
+            `${riskName}_${exchangeName}`,
+            `./dump/data/risk/`,
+        ]));
         /**
-         * Retrieves current average price for symbol.
+         * Reads persisted active positions for a risk profile.
          *
-         * In live mode: fetches real-time average price from exchange API.
-         * In backtest mode: calculates VWAP from candles in current timeframe.
+         * Called by ClientRisk.waitForInit() to restore state.
+         * Returns empty Map if no positions exist.
          *
-         * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
-         * @returns Promise resolving to average price
+         * @param riskName - Risk profile identifier
+         * @param exchangeName - Exchange identifier
+         * @returns Promise resolving to Map of active positions
          */
-        this.getAveragePrice = async (symbol) => {
-            this.loggerService.log("exchangeConnectionService getAveragePrice", {
-                symbol,
-            });
-            return await this.getExchange(this.methodContextService.context.exchangeName).getAveragePrice(symbol);
+        this.readPositionData = async (riskName, exchangeName) => {
+            bt.loggerService.info(PERSIST_RISK_UTILS_METHOD_NAME_READ_DATA);
+            const key = `${riskName}:${exchangeName}`;
+            const isInitial = !this.getRiskStorage.has(key);
+            const stateStorage = this.getRiskStorage(riskName, exchangeName);
+            await stateStorage.waitForInit(isInitial);
+            const RISK_STORAGE_KEY = "positions";
+            if (await stateStorage.hasValue(RISK_STORAGE_KEY)) {
+                return await stateStorage.readValue(RISK_STORAGE_KEY);
+            }
+            return [];
         };
         /**
-         * Formats price according to exchange-specific precision rules.
+         * Writes active positions to disk with atomic file writes.
          *
-         * Ensures price meets exchange requirements for decimal places and tick size.
+         * Called by ClientRisk after addSignal/removeSignal to persist state.
+         * Uses atomic writes to prevent corruption on crashes.
          *
-         * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
-         * @param price - Raw price value to format
-         * @returns Promise resolving to formatted price string
+         * @param positions - Map of active positions
+         * @param riskName - Risk profile identifier
+         * @param exchangeName - Exchange identifier
+         * @returns Promise that resolves when write is complete
          */
-        this.formatPrice = async (symbol, price) => {
-            this.loggerService.log("exchangeConnectionService getAveragePrice", {
-                symbol,
-                price,
-            });
-            return await this.getExchange(this.methodContextService.context.exchangeName).formatPrice(symbol, price);
+        this.writePositionData = async (riskRow, riskName, exchangeName) => {
+            bt.loggerService.info(PERSIST_RISK_UTILS_METHOD_NAME_WRITE_DATA);
+            const key = `${riskName}:${exchangeName}`;
+            const isInitial = !this.getRiskStorage.has(key);
+            const stateStorage = this.getRiskStorage(riskName, exchangeName);
+            await stateStorage.waitForInit(isInitial);
+            const RISK_STORAGE_KEY = "positions";
+            await stateStorage.writeValue(RISK_STORAGE_KEY, riskRow);
         };
+    }
+    /**
+     * Registers a custom persistence adapter.
+     *
+     * @param Ctor - Custom PersistBase constructor
+     *
+     * @example
+     * ```typescript
+     * class RedisPersist extends PersistBase {
+     *   async readValue(id) { return JSON.parse(await redis.get(id)); }
+     *   async writeValue(id, entity) { await redis.set(id, JSON.stringify(entity)); }
+     * }
+     * PersistRiskAdapter.usePersistRiskAdapter(RedisPersist);
+     * ```
+     */
+    usePersistRiskAdapter(Ctor) {
+        bt.loggerService.info(PERSIST_RISK_UTILS_METHOD_NAME_USE_PERSIST_RISK_ADAPTER);
+        this.PersistRiskFactory = Ctor;
+    }
+    /**
+     * Switches to the default JSON persist adapter.
+     * All future persistence writes will use JSON storage.
+     */
+    useJson() {
+        bt.loggerService.log(PERSIST_RISK_UTILS_METHOD_NAME_USE_JSON);
+        this.usePersistRiskAdapter(PersistBase);
+    }
+    /**
+     * Switches to a dummy persist adapter that discards all writes.
+     * All future persistence writes will be no-ops.
+     */
+    useDummy() {
+        bt.loggerService.log(PERSIST_RISK_UTILS_METHOD_NAME_USE_DUMMY);
+        this.usePersistRiskAdapter(PersistDummy);
+    }
+}
+/**
+ * Global singleton instance of PersistRiskUtils.
+ * Used by ClientRisk for active positions persistence.
+ *
+ * @example
+ * ```typescript
+ * // Custom adapter
+ * PersistRiskAdapter.usePersistRiskAdapter(RedisPersist);
+ *
+ * // Read positions
+ * const positions = await PersistRiskAdapter.readPositionData("my-risk");
+ *
+ * // Write positions
+ * await PersistRiskAdapter.writePositionData(positionsMap, "my-risk");
+ * ```
+ */
+const PersistRiskAdapter = new PersistRiskUtils();
+/**
+ * Utility class for managing scheduled signal persistence.
+ *
+ * Features:
+ * - Memoized storage instances per strategy
+ * - Custom adapter support
+ * - Atomic read/write operations for scheduled signals
+ * - Crash-safe scheduled signal state management
+ *
+ * Used by ClientStrategy for live mode persistence of scheduled signals (_scheduledSignal).
+ */
+class PersistScheduleUtils {
+    constructor() {
+        this.PersistScheduleFactory = PersistBase;
+        this.getScheduleStorage = memoize(([symbol, strategyName, exchangeName]) => `${symbol}:${strategyName}:${exchangeName}`, (symbol, strategyName, exchangeName) => Reflect.construct(this.PersistScheduleFactory, [
+            `${symbol}_${strategyName}_${exchangeName}`,
+            `./dump/data/schedule/`,
+        ]));
         /**
-         * Formats quantity according to exchange-specific precision rules.
+         * Reads persisted scheduled signal data for a symbol and strategy.
          *
-         * Ensures quantity meets exchange requirements for decimal places and lot size.
+         * Called by ClientStrategy.waitForInit() to restore scheduled signal state.
+         * Returns null if no scheduled signal exists.
          *
-         * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
-         * @param quantity - Raw quantity value to format
-         * @returns Promise resolving to formatted quantity string
+         * @param symbol - Trading pair symbol
+         * @param strategyName - Strategy identifier
+         * @param exchangeName - Exchange identifier
+         * @returns Promise resolving to scheduled signal or null
          */
-        this.formatQuantity = async (symbol, quantity) => {
-            this.loggerService.log("exchangeConnectionService getAveragePrice", {
-                symbol,
-                quantity,
-            });
-            return await this.getExchange(this.methodContextService.context.exchangeName).formatQuantity(symbol, quantity);
+        this.readScheduleData = async (symbol, strategyName, exchangeName) => {
+            bt.loggerService.info(PERSIST_SCHEDULE_UTILS_METHOD_NAME_READ_DATA);
+            const key = `${symbol}:${strategyName}:${exchangeName}`;
+            const isInitial = !this.getScheduleStorage.has(key);
+            const stateStorage = this.getScheduleStorage(symbol, strategyName, exchangeName);
+            await stateStorage.waitForInit(isInitial);
+            if (await stateStorage.hasValue(symbol)) {
+                return await stateStorage.readValue(symbol);
+            }
+            return null;
         };
         /**
-         * Fetches order book for a trading pair using configured exchange.
+         * Writes scheduled signal data to disk with atomic file writes.
          *
-         * Routes to exchange determined by methodContextService.context.exchangeName.
-         * The ClientExchange will calculate time range and pass it to the schema
-         * implementation, which may use (backtest) or ignore (live) the parameters.
+         * Called by ClientStrategy.setScheduledSignal() to persist state.
+         * Uses atomic writes to prevent corruption on crashes.
          *
-         * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
-         * @param depth - Maximum depth levels (default: CC_ORDER_BOOK_MAX_DEPTH_LEVELS)
-         * @returns Promise resolving to order book data
+         * @param scheduledSignalRow - Scheduled signal data (null to clear)
+         * @param symbol - Trading pair symbol
+         * @param strategyName - Strategy identifier
+         * @param exchangeName - Exchange identifier
+         * @returns Promise that resolves when write is complete
          */
-        this.getOrderBook = async (symbol, depth) => {
-            this.loggerService.log("exchangeConnectionService getOrderBook", {
-                symbol,
-                depth,
-            });
-            return await this.getExchange(this.methodContextService.context.exchangeName).getOrderBook(symbol, depth);
+        this.writeScheduleData = async (scheduledSignalRow, symbol, strategyName, exchangeName) => {
+            bt.loggerService.info(PERSIST_SCHEDULE_UTILS_METHOD_NAME_WRITE_DATA);
+            const key = `${symbol}:${strategyName}:${exchangeName}`;
+            const isInitial = !this.getScheduleStorage.has(key);
+            const stateStorage = this.getScheduleStorage(symbol, strategyName, exchangeName);
+            await stateStorage.waitForInit(isInitial);
+            await stateStorage.writeValue(symbol, scheduledSignalRow);
         };
     }
-}
-
-/**
- * Calculates profit/loss for a closed signal with slippage and fees.
- *
- * For signals with partial closes:
- * - Calculates weighted PNL: Σ(percent_i × pnl_i) for each partial + (remaining% × final_pnl)
- * - Each partial close has its own fees and slippage
- * - Total fees = 2 × (number of partial closes + 1 final close) × CC_PERCENT_FEE
- *
- * Formula breakdown:
- * 1. Apply slippage to open/close prices (worse execution)
- *    - LONG: buy higher (+slippage), sell lower (-slippage)
- *    - SHORT: sell lower (-slippage), buy higher (+slippage)
- * 2. Calculate raw PNL percentage
- *    - LONG: ((closePrice - openPrice) / openPrice) * 100
- *    - SHORT: ((openPrice - closePrice) / openPrice) * 100
- * 3. Subtract total fees (0.1% * 2 = 0.2% per transaction)
- *
- * @param signal - Closed signal with position details and optional partial history
- * @param priceClose - Actual close price at final exit
- * @returns PNL data with percentage and prices
- *
- * @example
- * ```typescript
- * // Signal without partial closes
- * const pnl = toProfitLossDto(
- *   {
- *     position: "long",
- *     priceOpen: 100,
- *   },
- *   110 // close at +10%
- * );
- * console.log(pnl.pnlPercentage); // ~9.6% (after slippage and fees)
- *
- * // Signal with partial closes
- * const pnlPartial = toProfitLossDto(
- *   {
- *     position: "long",
- *     priceOpen: 100,
- *     _partial: [
- *       { type: "profit", percent: 30, price: 120 }, // +20% on 30%
- *       { type: "profit", percent: 40, price: 115 }, // +15% on 40%
- *     ],
- *   },
- *   105 // final close at +5% for remaining 30%
- * );
- * // Weighted PNL = 30% × 20% + 40% × 15% + 30% × 5% = 6% + 6% + 1.5% = 13.5% (before fees)
- * ```
- */
-const toProfitLossDto = (signal, priceClose) => {
-    const priceOpen = signal.priceOpen;
-    // Calculate weighted PNL with partial closes
-    if (signal._partial && signal._partial.length > 0) {
-        let totalWeightedPnl = 0;
-        let totalFees = 0;
-        // Calculate PNL for each partial close
-        for (const partial of signal._partial) {
-            const partialPercent = partial.percent;
-            const partialPrice = partial.price;
-            // Apply slippage to prices
-            let priceOpenWithSlippage;
-            let priceCloseWithSlippage;
-            if (signal.position === "long") {
-                priceOpenWithSlippage = priceOpen * (1 + GLOBAL_CONFIG.CC_PERCENT_SLIPPAGE / 100);
-                priceCloseWithSlippage = partialPrice * (1 - GLOBAL_CONFIG.CC_PERCENT_SLIPPAGE / 100);
-            }
-            else {
-                priceOpenWithSlippage = priceOpen * (1 - GLOBAL_CONFIG.CC_PERCENT_SLIPPAGE / 100);
-                priceCloseWithSlippage = partialPrice * (1 + GLOBAL_CONFIG.CC_PERCENT_SLIPPAGE / 100);
-            }
-            // Calculate PNL for this partial
-            let partialPnl;
-            if (signal.position === "long") {
-                partialPnl = ((priceCloseWithSlippage - priceOpenWithSlippage) / priceOpenWithSlippage) * 100;
-            }
-            else {
-                partialPnl = ((priceOpenWithSlippage - priceCloseWithSlippage) / priceOpenWithSlippage) * 100;
-            }
-            // Weight by percentage of position closed
-            const weightedPnl = (partialPercent / 100) * partialPnl;
-            totalWeightedPnl += weightedPnl;
-            // Each partial has fees for open + close (2 transactions)
-            totalFees += GLOBAL_CONFIG.CC_PERCENT_FEE * 2;
-        }
-        // Calculate PNL for remaining position (if any)
-        // Compute totalClosed from _partial array
-        const totalClosed = signal._partial.reduce((sum, p) => sum + p.percent, 0);
-        const remainingPercent = 100 - totalClosed;
-        if (remainingPercent > 0) {
-            // Apply slippage
-            let priceOpenWithSlippage;
-            let priceCloseWithSlippage;
-            if (signal.position === "long") {
-                priceOpenWithSlippage = priceOpen * (1 + GLOBAL_CONFIG.CC_PERCENT_SLIPPAGE / 100);
-                priceCloseWithSlippage = priceClose * (1 - GLOBAL_CONFIG.CC_PERCENT_SLIPPAGE / 100);
-            }
-            else {
-                priceOpenWithSlippage = priceOpen * (1 - GLOBAL_CONFIG.CC_PERCENT_SLIPPAGE / 100);
-                priceCloseWithSlippage = priceClose * (1 + GLOBAL_CONFIG.CC_PERCENT_SLIPPAGE / 100);
-            }
-            // Calculate PNL for remaining
-            let remainingPnl;
-            if (signal.position === "long") {
-                remainingPnl = ((priceCloseWithSlippage - priceOpenWithSlippage) / priceOpenWithSlippage) * 100;
-            }
-            else {
-                remainingPnl = ((priceOpenWithSlippage - priceCloseWithSlippage) / priceOpenWithSlippage) * 100;
-            }
-            // Weight by remaining percentage
-            const weightedRemainingPnl = (remainingPercent / 100) * remainingPnl;
-            totalWeightedPnl += weightedRemainingPnl;
-            // Final close also has fees
-            totalFees += GLOBAL_CONFIG.CC_PERCENT_FEE * 2;
-        }
-        // Subtract total fees from weighted PNL
-        const pnlPercentage = totalWeightedPnl - totalFees;
-        return {
-            pnlPercentage,
-            priceOpen,
-            priceClose,
-        };
-    }
-    // Original logic for signals without partial closes
-    let priceOpenWithSlippage;
-    let priceCloseWithSlippage;
-    if (signal.position === "long") {
-        // LONG: покупаем дороже, продаем дешевле
-        priceOpenWithSlippage = priceOpen * (1 + GLOBAL_CONFIG.CC_PERCENT_SLIPPAGE / 100);
-        priceCloseWithSlippage = priceClose * (1 - GLOBAL_CONFIG.CC_PERCENT_SLIPPAGE / 100);
-    }
-    else {
-        // SHORT: продаем дешевле, покупаем дороже
-        priceOpenWithSlippage = priceOpen * (1 - GLOBAL_CONFIG.CC_PERCENT_SLIPPAGE / 100);
-        priceCloseWithSlippage = priceClose * (1 + GLOBAL_CONFIG.CC_PERCENT_SLIPPAGE / 100);
+    /**
+     * Registers a custom persistence adapter.
+     *
+     * @param Ctor - Custom PersistBase constructor
+     *
+     * @example
+     * ```typescript
+     * class RedisPersist extends PersistBase {
+     *   async readValue(id) { return JSON.parse(await redis.get(id)); }
+     *   async writeValue(id, entity) { await redis.set(id, JSON.stringify(entity)); }
+     * }
+     * PersistScheduleAdapter.usePersistScheduleAdapter(RedisPersist);
+     * ```
+     */
+    usePersistScheduleAdapter(Ctor) {
+        bt.loggerService.info(PERSIST_SCHEDULE_UTILS_METHOD_NAME_USE_PERSIST_SCHEDULE_ADAPTER);
+        this.PersistScheduleFactory = Ctor;
     }
-    // Применяем комиссию дважды (при открытии и закрытии)
-    const totalFee = GLOBAL_CONFIG.CC_PERCENT_FEE * 2;
-    let pnlPercentage;
-    if (signal.position === "long") {
-        // LONG: прибыль при росте цены
-        pnlPercentage =
-            ((priceCloseWithSlippage - priceOpenWithSlippage) /
-                priceOpenWithSlippage) *
-                100;
+    /**
+     * Switches to the default JSON persist adapter.
+     * All future persistence writes will use JSON storage.
+     */
+    useJson() {
+        bt.loggerService.log(PERSIST_SCHEDULE_UTILS_METHOD_NAME_USE_JSON);
+        this.usePersistScheduleAdapter(PersistBase);
     }
-    else {
-        // SHORT: прибыль при падении цены
-        pnlPercentage =
-            ((priceOpenWithSlippage - priceCloseWithSlippage) /
-                priceOpenWithSlippage) *
-                100;
+    /**
+     * Switches to a dummy persist adapter that discards all writes.
+     * All future persistence writes will be no-ops.
+     */
+    useDummy() {
+        bt.loggerService.log(PERSIST_SCHEDULE_UTILS_METHOD_NAME_USE_DUMMY);
+        this.usePersistScheduleAdapter(PersistDummy);
     }
-    // Вычитаем комиссии
-    pnlPercentage -= totalFee;
-    return {
-        pnlPercentage,
-        priceOpen,
-        priceClose,
-    };
-};
-
-const IS_WINDOWS = os.platform() === "win32";
+}
 /**
- * Atomically writes data to a file, ensuring the operation either fully completes or leaves the original file unchanged.
- * Uses a temporary file with a rename strategy on POSIX systems for atomicity, or direct writing with sync on Windows (or when POSIX rename is skipped).
- *
- *
- * @param {string} file - The file parameter.
- * @param {string | Buffer} data - The data to be processed or validated.
- * @param {Options | BufferEncoding} options - The options parameter (optional).
- * @throws {Error} Throws an error if the write, sync, or rename operation fails, after attempting cleanup of temporary files.
- *
- * @example
- * // Basic usage with default options
- * await writeFileAtomic("output.txt", "Hello, world!");
- * // Writes "Hello, world!" to "output.txt" atomically
- *
- * @example
- * // Custom options and Buffer data
- * const buffer = Buffer.from("Binary data");
- * await writeFileAtomic("data.bin", buffer, { encoding: "binary", mode: 0o644, tmpPrefix: "temp-" });
- * // Writes binary data to "data.bin" with custom permissions and temp prefix
+ * Global singleton instance of PersistScheduleUtils.
+ * Used by ClientStrategy for scheduled signal persistence.
  *
  * @example
- * // Using encoding shorthand
- * await writeFileAtomic("log.txt", "Log entry", "utf16le");
- * // Writes "Log entry" to "log.txt" in UTF-16LE encoding
+ * ```typescript
+ * // Custom adapter
+ * PersistScheduleAdapter.usePersistScheduleAdapter(RedisPersist);
  *
- * @remarks
- * This function ensures atomicity to prevent partial writes:
- * - On POSIX systems (non-Windows, unless `GLOBAL_CONFIG.CC_SKIP_POSIX_RENAME` is true):
- *   - Writes data to a temporary file (e.g., `.tmp-<random>-filename`) in the same directory.
- *   - Uses `crypto.randomBytes` to generate a unique temporary name, reducing collision risk.
- *   - Syncs the data to disk and renames the temporary file to the target file atomically with `fs.rename`.
- *   - Cleans up the temporary file on failure, swallowing cleanup errors to prioritize throwing the original error.
- * - On Windows (or when POSIX rename is skipped):
- *   - Writes directly to the target file, syncing data to disk to minimize corruption risk (though not fully atomic).
- *   - Closes the file handle on failure without additional cleanup.
- * - Accepts `options` as an object or a string (interpreted as `encoding`), defaulting to `{ encoding: "utf8", mode: 0o666, tmpPrefix: ".tmp-" }`.
- * Useful in the agent swarm system for safely writing configuration files, logs, or state data where partial writes could cause corruption.
+ * // Read scheduled signal
+ * const scheduled = await PersistScheduleAdapter.readScheduleData("my-strategy", "BTCUSDT");
  *
- * @see {@link https://nodejs.org/api/fs.html#fspromiseswritefilefile-data-options|fs.promises.writeFile} for file writing details.
- * @see {@link https://nodejs.org/api/crypto.html#cryptorandombytessize-callback|crypto.randomBytes} for temporary file naming.
- * @see {@link ../config/params|GLOBAL_CONFIG} for configuration impacting POSIX behavior.
-*/
-async function writeFileAtomic(file, data, options = {}) {
-    if (typeof options === "string") {
-        options = { encoding: options };
-    }
-    else if (!options) {
-        options = {};
-    }
-    const { encoding = "utf8", mode = 0o666, tmpPrefix = ".tmp-" } = options;
-    let fileHandle = null;
-    if (IS_WINDOWS) {
-        try {
-            // Create and write to temporary file
-            fileHandle = await fs__default.open(file, "w", mode);
-            // Write data to the temp file
-            await fileHandle.writeFile(data, { encoding });
-            // Ensure data is flushed to disk
-            await fileHandle.sync();
-            // Close the file before rename
-            await fileHandle.close();
-        }
-        catch (error) {
-            // Clean up if something went wrong
-            if (fileHandle) {
-                await fileHandle.close().catch(() => { });
-            }
-            throw error; // Re-throw the original error
-        }
-        return;
-    }
-    // Create a temporary filename in the same directory
-    const dir = path.dirname(file);
-    const filename = path.basename(file);
-    const tmpFile = path.join(dir, `${tmpPrefix}${crypto.randomBytes(6).toString("hex")}-${filename}`);
-    try {
-        // Create and write to temporary file
-        fileHandle = await fs__default.open(tmpFile, "w", mode);
-        // Write data to the temp file
-        await fileHandle.writeFile(data, { encoding });
-        // Ensure data is flushed to disk
-        await fileHandle.sync();
-        // Close the file before rename
-        await fileHandle.close();
-        fileHandle = null;
-        // Atomically replace the target file with our temp file
-        await fs__default.rename(tmpFile, file);
-    }
-    catch (error) {
-        // Clean up if something went wrong
-        if (fileHandle) {
-            await fileHandle.close().catch(() => { });
-        }
-        // Try to remove the temporary file
-        try {
-            await fs__default.unlink(tmpFile).catch(() => { });
-        }
-        catch (_) {
-            // Ignore errors during cleanup
-        }
-        throw error;
-    }
-}
-
-var _a$2;
-const BASE_WAIT_FOR_INIT_SYMBOL = Symbol("wait-for-init");
-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";
-const PERSIST_SIGNAL_UTILS_METHOD_NAME_USE_JSON = "PersistSignalUtils.useJson";
-const PERSIST_SIGNAL_UTILS_METHOD_NAME_USE_DUMMY = "PersistSignalUtils.useDummy";
-const PERSIST_SCHEDULE_UTILS_METHOD_NAME_USE_PERSIST_SCHEDULE_ADAPTER = "PersistScheduleUtils.usePersistScheduleAdapter";
-const PERSIST_SCHEDULE_UTILS_METHOD_NAME_READ_DATA = "PersistScheduleUtils.readScheduleData";
-const PERSIST_SCHEDULE_UTILS_METHOD_NAME_WRITE_DATA = "PersistScheduleUtils.writeScheduleData";
-const PERSIST_SCHEDULE_UTILS_METHOD_NAME_USE_JSON = "PersistScheduleUtils.useJson";
-const PERSIST_SCHEDULE_UTILS_METHOD_NAME_USE_DUMMY = "PersistScheduleUtils.useDummy";
-const PERSIST_PARTIAL_UTILS_METHOD_NAME_USE_PERSIST_PARTIAL_ADAPTER = "PersistPartialUtils.usePersistPartialAdapter";
-const PERSIST_PARTIAL_UTILS_METHOD_NAME_READ_DATA = "PersistPartialUtils.readPartialData";
-const PERSIST_PARTIAL_UTILS_METHOD_NAME_WRITE_DATA = "PersistPartialUtils.writePartialData";
-const PERSIST_PARTIAL_UTILS_METHOD_NAME_USE_JSON = "PersistPartialUtils.useJson";
-const PERSIST_PARTIAL_UTILS_METHOD_NAME_USE_DUMMY = "PersistPartialUtils.useDummy";
-const PERSIST_BREAKEVEN_UTILS_METHOD_NAME_USE_PERSIST_BREAKEVEN_ADAPTER = "PersistBreakevenUtils.usePersistBreakevenAdapter";
-const PERSIST_BREAKEVEN_UTILS_METHOD_NAME_READ_DATA = "PersistBreakevenUtils.readBreakevenData";
-const PERSIST_BREAKEVEN_UTILS_METHOD_NAME_WRITE_DATA = "PersistBreakevenUtils.writeBreakevenData";
-const PERSIST_BREAKEVEN_UTILS_METHOD_NAME_USE_JSON = "PersistBreakevenUtils.useJson";
-const PERSIST_BREAKEVEN_UTILS_METHOD_NAME_USE_DUMMY = "PersistBreakevenUtils.useDummy";
-const PERSIST_RISK_UTILS_METHOD_NAME_USE_PERSIST_RISK_ADAPTER = "PersistRiskUtils.usePersistRiskAdapter";
-const PERSIST_RISK_UTILS_METHOD_NAME_READ_DATA = "PersistRiskUtils.readPositionData";
-const PERSIST_RISK_UTILS_METHOD_NAME_WRITE_DATA = "PersistRiskUtils.writePositionData";
-const PERSIST_RISK_UTILS_METHOD_NAME_USE_JSON = "PersistRiskUtils.useJson";
-const PERSIST_RISK_UTILS_METHOD_NAME_USE_DUMMY = "PersistRiskUtils.useDummy";
-const PERSIST_BASE_METHOD_NAME_CTOR = "PersistBase.CTOR";
-const PERSIST_BASE_METHOD_NAME_WAIT_FOR_INIT = "PersistBase.waitForInit";
-const PERSIST_BASE_METHOD_NAME_READ_VALUE = "PersistBase.readValue";
-const PERSIST_BASE_METHOD_NAME_WRITE_VALUE = "PersistBase.writeValue";
-const PERSIST_BASE_METHOD_NAME_HAS_VALUE = "PersistBase.hasValue";
-const PERSIST_BASE_METHOD_NAME_KEYS = "PersistBase.keys";
-const BASE_WAIT_FOR_INIT_FN_METHOD_NAME = "PersistBase.waitForInitFn";
-const BASE_UNLINK_RETRY_COUNT = 5;
-const BASE_UNLINK_RETRY_DELAY = 1000;
-const BASE_WAIT_FOR_INIT_FN = async (self) => {
-    bt.loggerService.debug(BASE_WAIT_FOR_INIT_FN_METHOD_NAME, {
-        entityName: self.entityName,
-        directory: self._directory,
-    });
-    await fs__default.mkdir(self._directory, { recursive: true });
-    for await (const key of self.keys()) {
-        try {
-            await self.readValue(key);
-        }
-        catch {
-            const filePath = self._getFilePath(key);
-            console.error(`backtest-kit PersistBase found invalid document for filePath=${filePath} entityName=${self.entityName}`);
-            if (await not(BASE_WAIT_FOR_INIT_UNLINK_FN(filePath))) {
-                console.error(`backtest-kit PersistBase failed to remove invalid document for filePath=${filePath} entityName=${self.entityName}`);
-            }
-        }
-    }
-};
-const BASE_WAIT_FOR_INIT_UNLINK_FN = async (filePath) => trycatch(retry(async () => {
-    try {
-        await fs__default.unlink(filePath);
-        return true;
-    }
-    catch (error) {
-        console.error(`backtest-kit PersistBase unlink failed for filePath=${filePath} error=${getErrorMessage(error)}`);
-        throw error;
-    }
-}, BASE_UNLINK_RETRY_COUNT, BASE_UNLINK_RETRY_DELAY), {
-    defaultValue: false,
-});
+ * // Write scheduled signal
+ * await PersistScheduleAdapter.writeScheduleData(scheduled, "my-strategy", "BTCUSDT");
+ * ```
+ */
+const PersistScheduleAdapter = new PersistScheduleUtils();
 /**
- * Base class for file-based persistence with atomic writes.
+ * Utility class for managing partial profit/loss levels persistence.
  *
  * Features:
- * - Atomic file writes using writeFileAtomic
- * - Auto-validation and cleanup of corrupted files
- * - Async generator support for iteration
- * - Retry logic for file deletion
+ * - Memoized storage instances per symbol:strategyName
+ * - Custom adapter support
+ * - Atomic read/write operations for partial data
+ * - Crash-safe partial state management
  *
- * @example
- * ```typescript
- * const persist = new PersistBase("my-entity", "./data");
- * await persist.waitForInit(true);
- * await persist.writeValue("key1", { data: "value" });
- * const value = await persist.readValue("key1");
- * ```
+ * Used by ClientPartial for live mode persistence of profit/loss levels.
  */
-class PersistBase {
-    /**
-     * Creates new persistence instance.
-     *
-     * @param entityName - Unique entity type identifier
-     * @param baseDir - Base directory for all entities (default: ./dump/data)
-     */
-    constructor(entityName, baseDir = join(process.cwd(), "logs/data")) {
-        this.entityName = entityName;
-        this.baseDir = baseDir;
-        this[_a$2] = singleshot(async () => await BASE_WAIT_FOR_INIT_FN(this));
-        bt.loggerService.debug(PERSIST_BASE_METHOD_NAME_CTOR, {
-            entityName: this.entityName,
-            baseDir,
-        });
-        this._directory = join(this.baseDir, this.entityName);
-    }
-    /**
-     * Computes file path for entity ID.
-     *
-     * @param entityId - Entity identifier
-     * @returns Full file path to entity JSON file
-     */
-    _getFilePath(entityId) {
-        return join(this.baseDir, this.entityName, `${entityId}.json`);
-    }
-    async waitForInit(initial) {
-        bt.loggerService.debug(PERSIST_BASE_METHOD_NAME_WAIT_FOR_INIT, {
-            entityName: this.entityName,
-            initial,
-        });
-        await this[BASE_WAIT_FOR_INIT_SYMBOL]();
-    }
-    async readValue(entityId) {
-        bt.loggerService.debug(PERSIST_BASE_METHOD_NAME_READ_VALUE, {
-            entityName: this.entityName,
-            entityId,
-        });
-        try {
-            const filePath = this._getFilePath(entityId);
-            const fileContent = await fs__default.readFile(filePath, "utf-8");
-            return JSON.parse(fileContent);
-        }
-        catch (error) {
-            if (error?.code === "ENOENT") {
-                throw new Error(`Entity ${this.entityName}:${entityId} not found`);
-            }
-            throw new Error(`Failed to read entity ${this.entityName}:${entityId}: ${getErrorMessage(error)}`);
-        }
-    }
-    async hasValue(entityId) {
-        bt.loggerService.debug(PERSIST_BASE_METHOD_NAME_HAS_VALUE, {
-            entityName: this.entityName,
-            entityId,
-        });
-        try {
-            const filePath = this._getFilePath(entityId);
-            await fs__default.access(filePath);
-            return true;
-        }
-        catch (error) {
-            if (error?.code === "ENOENT") {
-                return false;
-            }
-            throw new Error(`Failed to check existence of entity ${this.entityName}:${entityId}: ${getErrorMessage(error)}`);
-        }
-    }
-    async writeValue(entityId, entity) {
-        bt.loggerService.debug(PERSIST_BASE_METHOD_NAME_WRITE_VALUE, {
-            entityName: this.entityName,
-            entityId,
-        });
-        try {
-            const filePath = this._getFilePath(entityId);
-            const serializedData = JSON.stringify(entity);
-            await writeFileAtomic(filePath, serializedData, "utf-8");
-        }
-        catch (error) {
-            throw new Error(`Failed to write entity ${this.entityName}:${entityId}: ${getErrorMessage(error)}`);
-        }
-    }
-    /**
-     * Async generator yielding all entity IDs.
-     * Sorted alphanumerically.
-     * Used internally by waitForInit for validation.
-     *
-     * @returns AsyncGenerator yielding entity IDs
-     * @throws Error if reading fails
-     */
-    async *keys() {
-        bt.loggerService.debug(PERSIST_BASE_METHOD_NAME_KEYS, {
-            entityName: this.entityName,
-        });
-        try {
-            const files = await fs__default.readdir(this._directory);
-            const entityIds = files
-                .filter((file) => file.endsWith(".json"))
-                .map((file) => file.slice(0, -5))
-                .sort((a, b) => a.localeCompare(b, undefined, {
-                numeric: true,
-                sensitivity: "base",
-            }));
-            for (const entityId of entityIds) {
-                yield entityId;
+class PersistPartialUtils {
+    constructor() {
+        this.PersistPartialFactory = PersistBase;
+        this.getPartialStorage = memoize(([symbol, strategyName, exchangeName]) => `${symbol}:${strategyName}:${exchangeName}`, (symbol, strategyName, exchangeName) => Reflect.construct(this.PersistPartialFactory, [
+            `${symbol}_${strategyName}_${exchangeName}`,
+            `./dump/data/partial/`,
+        ]));
+        /**
+         * Reads persisted partial data for a symbol and strategy.
+         *
+         * Called by ClientPartial.waitForInit() to restore state.
+         * Returns empty object if no partial data exists.
+         *
+         * @param symbol - Trading pair symbol
+         * @param strategyName - Strategy identifier
+         * @param signalId - Signal identifier
+         * @param exchangeName - Exchange identifier
+         * @returns Promise resolving to partial data record
+         */
+        this.readPartialData = async (symbol, strategyName, signalId, exchangeName) => {
+            bt.loggerService.info(PERSIST_PARTIAL_UTILS_METHOD_NAME_READ_DATA);
+            const key = `${symbol}:${strategyName}:${exchangeName}`;
+            const isInitial = !this.getPartialStorage.has(key);
+            const stateStorage = this.getPartialStorage(symbol, strategyName, exchangeName);
+            await stateStorage.waitForInit(isInitial);
+            if (await stateStorage.hasValue(signalId)) {
+                return await stateStorage.readValue(signalId);
             }
-        }
-        catch (error) {
-            throw new Error(`Failed to read keys for ${this.entityName}: ${getErrorMessage(error)}`);
-        }
-    }
-}
-_a$2 = BASE_WAIT_FOR_INIT_SYMBOL;
-// @ts-ignore
-PersistBase = makeExtendable(PersistBase);
-/**
- * Dummy persist adapter that discards all writes.
- * Used for disabling persistence.
- */
-class PersistDummy {
-    /**
-     * No-op initialization function.
-     * @returns Promise that resolves immediately
-     */
-    async waitForInit() {
+            return {};
+        };
+        /**
+         * Writes partial data to disk with atomic file writes.
+         *
+         * Called by ClientPartial after profit/loss level changes to persist state.
+         * Uses atomic writes to prevent corruption on crashes.
+         *
+         * @param partialData - Record of signal IDs to partial data
+         * @param symbol - Trading pair symbol
+         * @param strategyName - Strategy identifier
+         * @param signalId - Signal identifier
+         * @param exchangeName - Exchange identifier
+         * @returns Promise that resolves when write is complete
+         */
+        this.writePartialData = async (partialData, symbol, strategyName, signalId, exchangeName) => {
+            bt.loggerService.info(PERSIST_PARTIAL_UTILS_METHOD_NAME_WRITE_DATA);
+            const key = `${symbol}:${strategyName}:${exchangeName}`;
+            const isInitial = !this.getPartialStorage.has(key);
+            const stateStorage = this.getPartialStorage(symbol, strategyName, exchangeName);
+            await stateStorage.waitForInit(isInitial);
+            await stateStorage.writeValue(signalId, partialData);
+        };
     }
     /**
-     * No-op read function.
-     * @returns Promise that resolves with empty object
+     * Registers a custom persistence adapter.
+     *
+     * @param Ctor - Custom PersistBase constructor
+     *
+     * @example
+     * ```typescript
+     * class RedisPersist extends PersistBase {
+     *   async readValue(id) { return JSON.parse(await redis.get(id)); }
+     *   async writeValue(id, entity) { await redis.set(id, JSON.stringify(entity)); }
+     * }
+     * PersistPartialAdapter.usePersistPartialAdapter(RedisPersist);
+     * ```
      */
-    async readValue() {
-        return {};
+    usePersistPartialAdapter(Ctor) {
+        bt.loggerService.info(PERSIST_PARTIAL_UTILS_METHOD_NAME_USE_PERSIST_PARTIAL_ADAPTER);
+        this.PersistPartialFactory = Ctor;
     }
     /**
-     * No-op has value check.
-     * @returns Promise that resolves to false
+     * Switches to the default JSON persist adapter.
+     * All future persistence writes will use JSON storage.
      */
-    async hasValue() {
-        return false;
+    useJson() {
+        bt.loggerService.log(PERSIST_PARTIAL_UTILS_METHOD_NAME_USE_JSON);
+        this.usePersistPartialAdapter(PersistBase);
     }
     /**
-     * No-op write function.
-     * @returns Promise that resolves immediately
+     * Switches to a dummy persist adapter that discards all writes.
+     * All future persistence writes will be no-ops.
      */
-    async writeValue() {
+    useDummy() {
+        bt.loggerService.log(PERSIST_PARTIAL_UTILS_METHOD_NAME_USE_DUMMY);
+        this.usePersistPartialAdapter(PersistDummy);
     }
 }
 /**
- * Utility class for managing signal persistence.
+ * Global singleton instance of PersistPartialUtils.
+ * Used by ClientPartial for partial profit/loss levels persistence.
+ *
+ * @example
+ * ```typescript
+ * // Custom adapter
+ * PersistPartialAdapter.usePersistPartialAdapter(RedisPersist);
+ *
+ * // Read partial data
+ * const partialData = await PersistPartialAdapter.readPartialData("BTCUSDT", "my-strategy");
+ *
+ * // Write partial data
+ * await PersistPartialAdapter.writePartialData(partialData, "BTCUSDT", "my-strategy");
+ * ```
+ */
+const PersistPartialAdapter = new PersistPartialUtils();
+/**
+ * Persistence utility class for breakeven state management.
+ *
+ * Handles reading and writing breakeven state to disk.
+ * Uses memoized PersistBase instances per symbol-strategy pair.
  *
  * Features:
- * - Memoized storage instances per strategy
- * - Custom adapter support
- * - Atomic read/write operations
- * - Crash-safe signal state management
+ * - Atomic file writes via PersistBase.writeValue()
+ * - Lazy initialization on first access
+ * - Singleton pattern for global access
+ * - Custom adapter support via usePersistBreakevenAdapter()
  *
- * Used by ClientStrategy for live mode persistence.
+ * File structure:
+ * ```
+ * ./dump/data/breakeven/
+ * ├── BTCUSDT_my-strategy/
+ * │   └── state.json        // { "signal-id-1": { reached: true }, ... }
+ * └── ETHUSDT_other-strategy/
+ *     └── state.json
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Read breakeven data
+ * const breakevenData = await PersistBreakevenAdapter.readBreakevenData("BTCUSDT", "my-strategy");
+ * // Returns: { "signal-id": { reached: true }, ... }
+ *
+ * // Write breakeven data
+ * await PersistBreakevenAdapter.writeBreakevenData(breakevenData, "BTCUSDT", "my-strategy");
+ * ```
  */
-class PersistSignalUtils {
+class PersistBreakevenUtils {
     constructor() {
-        this.PersistSignalFactory = PersistBase;
-        this.getSignalStorage = memoize(([symbol, strategyName, exchangeName]) => `${symbol}:${strategyName}:${exchangeName}`, (symbol, strategyName, exchangeName) => Reflect.construct(this.PersistSignalFactory, [
+        /**
+         * Factory for creating PersistBase instances.
+         * Can be replaced via usePersistBreakevenAdapter().
+         */
+        this.PersistBreakevenFactory = PersistBase;
+        /**
+         * Memoized storage factory for breakeven data.
+         * Creates one PersistBase instance per symbol-strategy-exchange combination.
+         * Key format: "symbol:strategyName:exchangeName"
+         *
+         * @param symbol - Trading pair symbol
+         * @param strategyName - Strategy identifier
+         * @param exchangeName - Exchange identifier
+         * @returns PersistBase instance for this symbol-strategy-exchange combination
+         */
+        this.getBreakevenStorage = memoize(([symbol, strategyName, exchangeName]) => `${symbol}:${strategyName}:${exchangeName}`, (symbol, strategyName, exchangeName) => Reflect.construct(this.PersistBreakevenFactory, [
             `${symbol}_${strategyName}_${exchangeName}`,
-            `./dump/data/signal/`,
+            `./dump/data/breakeven/`,
         ]));
         /**
-         * Reads persisted signal data for a symbol and strategy.
+         * Reads persisted breakeven data for a symbol and strategy.
          *
-         * Called by ClientStrategy.waitForInit() to restore state.
-         * Returns null if no signal exists.
+         * Called by ClientBreakeven.waitForInit() to restore state.
+         * Returns empty object if no breakeven data exists.
          *
          * @param symbol - Trading pair symbol
          * @param strategyName - Strategy identifier
+         * @param signalId - Signal identifier
          * @param exchangeName - Exchange identifier
-         * @returns Promise resolving to signal or null
+         * @returns Promise resolving to breakeven data record
          */
-        this.readSignalData = async (symbol, strategyName, exchangeName) => {
-            bt.loggerService.info(PERSIST_SIGNAL_UTILS_METHOD_NAME_READ_DATA);
+        this.readBreakevenData = async (symbol, strategyName, signalId, exchangeName) => {
+            bt.loggerService.info(PERSIST_BREAKEVEN_UTILS_METHOD_NAME_READ_DATA);
             const key = `${symbol}:${strategyName}:${exchangeName}`;
-            const isInitial = !this.getSignalStorage.has(key);
-            const stateStorage = this.getSignalStorage(symbol, strategyName, exchangeName);
+            const isInitial = !this.getBreakevenStorage.has(key);
+            const stateStorage = this.getBreakevenStorage(symbol, strategyName, exchangeName);
             await stateStorage.waitForInit(isInitial);
-            if (await stateStorage.hasValue(symbol)) {
-                return await stateStorage.readValue(symbol);
+            if (await stateStorage.hasValue(signalId)) {
+                return await stateStorage.readValue(signalId);
             }
-            return null;
+            return {};
         };
         /**
-         * Writes signal data to disk with atomic file writes.
+         * Writes breakeven data to disk.
          *
-         * Called by ClientStrategy.setPendingSignal() to persist state.
-         * Uses atomic writes to prevent corruption on crashes.
+         * Called by ClientBreakeven._persistState() after state changes.
+         * Creates directory and file if they don't exist.
+         * Uses atomic writes to prevent data corruption.
          *
-         * @param signalRow - Signal data (null to clear)
+         * @param breakevenData - Breakeven data record to persist
          * @param symbol - Trading pair symbol
          * @param strategyName - Strategy identifier
+         * @param signalId - Signal identifier
          * @param exchangeName - Exchange identifier
          * @returns Promise that resolves when write is complete
          */
-        this.writeSignalData = async (signalRow, symbol, strategyName, exchangeName) => {
-            bt.loggerService.info(PERSIST_SIGNAL_UTILS_METHOD_NAME_WRITE_DATA);
+        this.writeBreakevenData = async (breakevenData, symbol, strategyName, signalId, exchangeName) => {
+            bt.loggerService.info(PERSIST_BREAKEVEN_UTILS_METHOD_NAME_WRITE_DATA);
             const key = `${symbol}:${strategyName}:${exchangeName}`;
-            const isInitial = !this.getSignalStorage.has(key);
-            const stateStorage = this.getSignalStorage(symbol, strategyName, exchangeName);
+            const isInitial = !this.getBreakevenStorage.has(key);
+            const stateStorage = this.getBreakevenStorage(symbol, strategyName, exchangeName);
             await stateStorage.waitForInit(isInitial);
-            await stateStorage.writeValue(symbol, signalRow);
+            await stateStorage.writeValue(signalId, breakevenData);
         };
     }
     /**
@@ -1691,538 +1471,1131 @@ class PersistSignalUtils {
      *   async readValue(id) { return JSON.parse(await redis.get(id)); }
      *   async writeValue(id, entity) { await redis.set(id, JSON.stringify(entity)); }
      * }
-     * PersistSignalAdapter.usePersistSignalAdapter(RedisPersist);
+     * PersistBreakevenAdapter.usePersistBreakevenAdapter(RedisPersist);
      * ```
      */
-    usePersistSignalAdapter(Ctor) {
-        bt.loggerService.info(PERSIST_SIGNAL_UTILS_METHOD_NAME_USE_PERSIST_SIGNAL_ADAPTER);
-        this.PersistSignalFactory = Ctor;
+    usePersistBreakevenAdapter(Ctor) {
+        bt.loggerService.info(PERSIST_BREAKEVEN_UTILS_METHOD_NAME_USE_PERSIST_BREAKEVEN_ADAPTER);
+        this.PersistBreakevenFactory = Ctor;
     }
     /**
      * Switches to the default JSON persist adapter.
      * All future persistence writes will use JSON storage.
      */
     useJson() {
-        bt.loggerService.log(PERSIST_SIGNAL_UTILS_METHOD_NAME_USE_JSON);
-        this.usePersistSignalAdapter(PersistBase);
+        bt.loggerService.log(PERSIST_BREAKEVEN_UTILS_METHOD_NAME_USE_JSON);
+        this.usePersistBreakevenAdapter(PersistBase);
     }
     /**
      * Switches to a dummy persist adapter that discards all writes.
      * All future persistence writes will be no-ops.
      */
     useDummy() {
-        bt.loggerService.log(PERSIST_SIGNAL_UTILS_METHOD_NAME_USE_DUMMY);
-        this.usePersistSignalAdapter(PersistDummy);
+        bt.loggerService.log(PERSIST_BREAKEVEN_UTILS_METHOD_NAME_USE_DUMMY);
+        this.usePersistBreakevenAdapter(PersistDummy);
     }
 }
 /**
- * Global singleton instance of PersistSignalUtils.
- * Used by ClientStrategy for signal persistence.
+ * Global singleton instance of PersistBreakevenUtils.
+ * Used by ClientBreakeven for breakeven state persistence.
  *
  * @example
  * ```typescript
  * // Custom adapter
- * PersistSignalAdapter.usePersistSignalAdapter(RedisPersist);
+ * PersistBreakevenAdapter.usePersistBreakevenAdapter(RedisPersist);
  *
- * // Read signal
- * const signal = await PersistSignalAdapter.readSignalData("my-strategy", "BTCUSDT");
+ * // Read breakeven data
+ * const breakevenData = await PersistBreakevenAdapter.readBreakevenData("BTCUSDT", "my-strategy");
  *
- * // Write signal
- * await PersistSignalAdapter.writeSignalData(signal, "my-strategy", "BTCUSDT");
+ * // Write breakeven data
+ * await PersistBreakevenAdapter.writeBreakevenData(breakevenData, "BTCUSDT", "my-strategy");
  * ```
  */
-const PersistSignalAdapter = new PersistSignalUtils();
+const PersistBreakevenAdapter = new PersistBreakevenUtils();
 /**
- * Utility class for managing risk active positions persistence.
+ * Utility class for managing candles cache persistence.
  *
  * Features:
- * - Memoized storage instances per risk profile
- * - Custom adapter support
- * - Atomic read/write operations for RiskData
- * - Crash-safe position state management
+ * - Each candle stored as separate JSON file: ${exchangeName}/${symbol}/${interval}/${timestamp}.json
+ * - Cache validation: returns cached data if file count matches requested limit
+ * - Automatic cache invalidation and refresh when data is incomplete
+ * - Atomic read/write operations
  *
- * Used by ClientRisk for live mode persistence of active positions.
+ * Used by ClientExchange for candle data caching.
  */
-class PersistRiskUtils {
+class PersistCandleUtils {
     constructor() {
-        this.PersistRiskFactory = PersistBase;
-        this.getRiskStorage = memoize(([riskName, exchangeName]) => `${riskName}:${exchangeName}`, (riskName, exchangeName) => Reflect.construct(this.PersistRiskFactory, [
-            `${riskName}_${exchangeName}`,
-            `./dump/data/risk/`,
+        this.PersistCandlesFactory = PersistBase;
+        this.getCandlesStorage = memoize(([symbol, interval, exchangeName]) => `${symbol}:${interval}:${exchangeName}`, (symbol, interval, exchangeName) => Reflect.construct(this.PersistCandlesFactory, [
+            `${exchangeName}/${symbol}/${interval}`,
+            `./dump/data/candles/`,
         ]));
         /**
-         * Reads persisted active positions for a risk profile.
-         *
-         * Called by ClientRisk.waitForInit() to restore state.
-         * Returns empty Map if no positions exist.
+         * Reads cached candles for a specific exchange, symbol, and interval.
+         * Returns candles only if cache contains exactly the requested limit.
          *
-         * @param riskName - Risk profile identifier
+         * @param symbol - Trading pair symbol
+         * @param interval - Candle interval
          * @param exchangeName - Exchange identifier
-         * @returns Promise resolving to Map of active positions
+         * @param limit - Number of candles requested
+         * @param sinceTimestamp - Start timestamp (inclusive)
+         * @param untilTimestamp - End timestamp (exclusive)
+         * @returns Promise resolving to array of candles or null if cache is incomplete
          */
-        this.readPositionData = async (riskName, exchangeName) => {
-            bt.loggerService.info(PERSIST_RISK_UTILS_METHOD_NAME_READ_DATA);
-            const key = `${riskName}:${exchangeName}`;
-            const isInitial = !this.getRiskStorage.has(key);
-            const stateStorage = this.getRiskStorage(riskName, exchangeName);
+        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 RISK_STORAGE_KEY = "positions";
-            if (await stateStorage.hasValue(RISK_STORAGE_KEY)) {
-                return await stateStorage.readValue(RISK_STORAGE_KEY);
+            // Collect all cached candles within the time range
+            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 {
+                        // Skip invalid candles
+                        continue;
+                    }
+                }
             }
-            return [];
+            // Sort by timestamp ascending
+            cachedCandles.sort((a, b) => a.timestamp - b.timestamp);
+            return cachedCandles;
         };
         /**
-         * Writes active positions to disk with atomic file writes.
-         *
-         * Called by ClientRisk after addSignal/removeSignal to persist state.
-         * Uses atomic writes to prevent corruption on crashes.
+         * Writes candles to cache with atomic file writes.
+         * Each candle is stored as a separate JSON file named by its timestamp.
          *
-         * @param positions - Map of active positions
-         * @param riskName - Risk profile identifier
+         * @param candles - Array of candle data to cache
+         * @param symbol - Trading pair symbol
+         * @param interval - Candle interval
          * @param exchangeName - Exchange identifier
-         * @returns Promise that resolves when write is complete
+         * @returns Promise that resolves when all writes are complete
          */
-        this.writePositionData = async (riskRow, riskName, exchangeName) => {
-            bt.loggerService.info(PERSIST_RISK_UTILS_METHOD_NAME_WRITE_DATA);
-            const key = `${riskName}:${exchangeName}`;
-            const isInitial = !this.getRiskStorage.has(key);
-            const stateStorage = this.getRiskStorage(riskName, exchangeName);
+        this.writeCandlesData = async (candles, symbol, interval, exchangeName) => {
+            bt.loggerService.info("PersistCandleUtils.writeCandlesData", {
+                symbol,
+                interval,
+                exchangeName,
+                candleCount: candles.length,
+            });
+            const key = `${symbol}:${interval}:${exchangeName}`;
+            const isInitial = !this.getCandlesStorage.has(key);
+            const stateStorage = this.getCandlesStorage(symbol, interval, exchangeName);
             await stateStorage.waitForInit(isInitial);
-            const RISK_STORAGE_KEY = "positions";
-            await stateStorage.writeValue(RISK_STORAGE_KEY, riskRow);
+            // Write each candle as a separate file
+            for (const candle of candles) {
+                if (await not(stateStorage.hasValue(String(candle.timestamp)))) {
+                    await stateStorage.writeValue(String(candle.timestamp), candle);
+                }
+            }
+        };
+    }
+    /**
+     * Registers a custom persistence adapter.
+     *
+     * @param Ctor - Custom PersistBase constructor
+     */
+    usePersistCandleAdapter(Ctor) {
+        bt.loggerService.info("PersistCandleUtils.usePersistCandleAdapter");
+        this.PersistCandlesFactory = Ctor;
+    }
+    /**
+     * Switches to the default JSON persist adapter.
+     * All future persistence writes will use JSON storage.
+     */
+    useJson() {
+        bt.loggerService.log("PersistCandleUtils.useJson");
+        this.usePersistCandleAdapter(PersistBase);
+    }
+    /**
+     * Switches to a dummy persist adapter that discards all writes.
+     * All future persistence writes will be no-ops.
+     */
+    useDummy() {
+        bt.loggerService.log("PersistCandleUtils.useDummy");
+        this.usePersistCandleAdapter(PersistDummy);
+    }
+}
+/**
+ * Global singleton instance of PersistCandleUtils.
+ * Used by ClientExchange for candle data caching.
+ *
+ * @example
+ * ```typescript
+ * // Read cached candles
+ * const candles = await PersistCandleAdapter.readCandlesData(
+ *   "BTCUSDT", "1m", "binance", 100, since.getTime(), until.getTime()
+ * );
+ *
+ * // Write candles to cache
+ * await PersistCandleAdapter.writeCandlesData(candles, "BTCUSDT", "1m", "binance");
+ * ```
+ */
+const PersistCandleAdapter = new PersistCandleUtils();
+
+const MS_PER_MINUTE$1 = 60000;
+const INTERVAL_MINUTES$4 = {
+    "1m": 1,
+    "3m": 3,
+    "5m": 5,
+    "15m": 15,
+    "30m": 30,
+    "1h": 60,
+    "2h": 120,
+    "4h": 240,
+    "6h": 360,
+    "8h": 480,
+};
+/**
+ * Validates that all candles have valid OHLCV data without anomalies.
+ * Detects incomplete candles from Binance API by checking for abnormally low prices or volumes.
+ * Incomplete candles often have prices like 0.1 instead of normal 100,000 or zero volume.
+ *
+ * @param candles - Array of candle data to validate
+ * @throws Error if any candles have anomalous OHLCV values
+ */
+const VALIDATE_NO_INCOMPLETE_CANDLES_FN = (candles) => {
+    if (candles.length === 0) {
+        return;
+    }
+    // Calculate reference price (median or average depending on candle count)
+    const allPrices = candles.flatMap((c) => [c.open, c.high, c.low, c.close]);
+    const validPrices = allPrices.filter((p) => p > 0);
+    let referencePrice;
+    if (candles.length >= GLOBAL_CONFIG.CC_GET_CANDLES_MIN_CANDLES_FOR_MEDIAN) {
+        // Use median for reliable statistics with enough data
+        const sortedPrices = [...validPrices].sort((a, b) => a - b);
+        referencePrice = sortedPrices[Math.floor(sortedPrices.length / 2)] || 0;
+    }
+    else {
+        // Use average for small datasets (more stable than median)
+        const sum = validPrices.reduce((acc, p) => acc + p, 0);
+        referencePrice = validPrices.length > 0 ? sum / validPrices.length : 0;
+    }
+    if (referencePrice === 0) {
+        throw new Error(`VALIDATE_NO_INCOMPLETE_CANDLES_FN: cannot calculate reference price (all prices are zero)`);
+    }
+    const minValidPrice = referencePrice /
+        GLOBAL_CONFIG.CC_GET_CANDLES_PRICE_ANOMALY_THRESHOLD_FACTOR;
+    for (let i = 0; i < candles.length; i++) {
+        const candle = candles[i];
+        // Check for invalid numeric values
+        if (!Number.isFinite(candle.open) ||
+            !Number.isFinite(candle.high) ||
+            !Number.isFinite(candle.low) ||
+            !Number.isFinite(candle.close) ||
+            !Number.isFinite(candle.volume) ||
+            !Number.isFinite(candle.timestamp)) {
+            throw new Error(`VALIDATE_NO_INCOMPLETE_CANDLES_FN: candle[${i}] has invalid numeric values (NaN or Infinity)`);
+        }
+        // Check for negative values
+        if (candle.open <= 0 ||
+            candle.high <= 0 ||
+            candle.low <= 0 ||
+            candle.close <= 0 ||
+            candle.volume < 0) {
+            throw new Error(`VALIDATE_NO_INCOMPLETE_CANDLES_FN: candle[${i}] has zero or negative values`);
+        }
+        // Check for anomalously low prices (incomplete candle indicator)
+        if (candle.open < minValidPrice ||
+            candle.high < minValidPrice ||
+            candle.low < minValidPrice ||
+            candle.close < minValidPrice) {
+            throw new Error(`VALIDATE_NO_INCOMPLETE_CANDLES_FN: candle[${i}] has anomalously low price. ` +
+                `OHLC: [${candle.open}, ${candle.high}, ${candle.low}, ${candle.close}], ` +
+                `reference: ${referencePrice}, threshold: ${minValidPrice}`);
+        }
+    }
+};
+/**
+ * Attempts to read candles from cache.
+ * Validates cache consistency (no gaps in timestamps) before returning.
+ *
+ * @param dto - Data transfer object containing symbol, interval, and limit
+ * @param sinceTimestamp - Start timestamp in milliseconds
+ * @param untilTimestamp - End timestamp in milliseconds
+ * @param self - Instance of ClientExchange
+ * @returns Cached candles array or null if cache miss or inconsistent
+ */
+const READ_CANDLES_CACHE_FN$1 = trycatch(async (dto, sinceTimestamp, untilTimestamp, self) => {
+    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) {
+        self.params.logger.debug(`ClientExchange READ_CANDLES_CACHE_FN: cache hit for symbol=${dto.symbol}, interval=${dto.interval}, limit=${dto.limit}`);
+        return cachedCandles;
+    }
+    self.params.logger.warn(`ClientExchange READ_CANDLES_CACHE_FN: cache inconsistent (count or range mismatch) for symbol=${dto.symbol}, interval=${dto.interval}, limit=${dto.limit}`);
+    return null;
+}, {
+    fallback: async (error) => {
+        const message = `ClientExchange READ_CANDLES_CACHE_FN: cache read failed`;
+        const payload = {
+            error: errorData(error),
+            message: getErrorMessage(error),
+        };
+        bt.loggerService.warn(message, payload);
+        console.warn(message, payload);
+        errorEmitter.next(error);
+    },
+    defaultValue: null,
+});
+/**
+ * Writes candles to cache with error handling.
+ *
+ * @param candles - Array of candle data to cache
+ * @param dto - Data transfer object containing symbol, interval, and limit
+ * @param self - Instance of ClientExchange
+ */
+const WRITE_CANDLES_CACHE_FN$1 = trycatch(queued(async (candles, dto, self) => {
+    await PersistCandleAdapter.writeCandlesData(candles, dto.symbol, dto.interval, self.params.exchangeName);
+    self.params.logger.debug(`ClientExchange WRITE_CANDLES_CACHE_FN: cache updated for symbol=${dto.symbol}, interval=${dto.interval}, count=${candles.length}`);
+}), {
+    fallback: async (error) => {
+        const message = `ClientExchange WRITE_CANDLES_CACHE_FN: cache write failed`;
+        const payload = {
+            error: errorData(error),
+            message: getErrorMessage(error),
+        };
+        bt.loggerService.warn(message, payload);
+        console.warn(message, payload);
+        errorEmitter.next(error);
+    },
+    defaultValue: null,
+});
+/**
+ * Retries the getCandles function with specified retry count and delay.
+ * Uses cache to avoid redundant API calls.
+ *
+ * Cache logic:
+ * - Checks if cached candles exist for the time range
+ * - If cache has exactly dto.limit candles, returns cached data
+ * - Otherwise, fetches from API and updates cache
+ *
+ * @param dto - Data transfer object containing symbol, interval, and limit
+ * @param since - Date object representing the start time for fetching candles
+ * @param self - Instance of ClientExchange
+ * @returns Promise resolving to array of candle data
+ */
+const GET_CANDLES_FN = async (dto, since, self) => {
+    const step = INTERVAL_MINUTES$4[dto.interval];
+    const sinceTimestamp = since.getTime();
+    const untilTimestamp = sinceTimestamp + dto.limit * step * MS_PER_MINUTE$1;
+    // Try to read from cache first
+    const cachedCandles = await READ_CANDLES_CACHE_FN$1(dto, sinceTimestamp, untilTimestamp, self);
+    if (cachedCandles !== null) {
+        return cachedCandles;
+    }
+    // Cache miss or error - fetch from API
+    let lastError;
+    for (let i = 0; i !== GLOBAL_CONFIG.CC_GET_CANDLES_RETRY_COUNT; i++) {
+        try {
+            const result = await self.params.getCandles(dto.symbol, dto.interval, since, dto.limit, self.params.execution.context.backtest);
+            VALIDATE_NO_INCOMPLETE_CANDLES_FN(result);
+            // Write to cache after successful fetch
+            await WRITE_CANDLES_CACHE_FN$1(result, dto, self);
+            return result;
+        }
+        catch (err) {
+            const message = `ClientExchange GET_CANDLES_FN: attempt ${i + 1} failed for symbol=${dto.symbol}, interval=${dto.interval}, since=${since.toISOString()}, limit=${dto.limit}}`;
+            const payload = {
+                error: errorData(err),
+                message: getErrorMessage(err),
+            };
+            self.params.logger.warn(message, payload);
+            console.warn(message, payload);
+            lastError = err;
+            await sleep(GLOBAL_CONFIG.CC_GET_CANDLES_RETRY_DELAY_MS);
+        }
+    }
+    throw lastError;
+};
+/**
+ * Wrapper to call onCandleData callback with error handling.
+ * Catches and logs any errors thrown by the user-provided callback.
+ *
+ * @param self - ClientExchange instance reference
+ * @param symbol - Trading pair symbol
+ * @param interval - Candle interval
+ * @param since - Start date for candle data
+ * @param limit - Number of candles
+ * @param data - Array of candle data
+ */
+const CALL_CANDLE_DATA_CALLBACKS_FN = trycatch(async (self, symbol, interval, since, limit, data) => {
+    if (self.params.callbacks?.onCandleData) {
+        await self.params.callbacks.onCandleData(symbol, interval, since, limit, data);
+    }
+}, {
+    fallback: (error) => {
+        const message = "ClientExchange CALL_CANDLE_DATA_CALLBACKS_FN thrown";
+        const payload = {
+            error: errorData(error),
+            message: getErrorMessage(error),
         };
+        bt.loggerService.warn(message, payload);
+        console.warn(message, payload);
+        errorEmitter.next(error);
+    },
+});
+/**
+ * Client implementation for exchange data access.
+ *
+ * Features:
+ * - Historical candle fetching (backwards from execution context)
+ * - Future candle fetching (forwards for backtest)
+ * - VWAP calculation from last 5 1m candles
+ * - Price/quantity formatting for exchange
+ *
+ * All methods use prototype functions for memory efficiency.
+ *
+ * @example
+ * ```typescript
+ * const exchange = new ClientExchange({
+ *   exchangeName: "binance",
+ *   getCandles: async (symbol, interval, since, limit) => [...],
+ *   formatPrice: async (symbol, price) => price.toFixed(2),
+ *   formatQuantity: async (symbol, quantity) => quantity.toFixed(8),
+ *   execution: executionService,
+ *   logger: loggerService,
+ * });
+ *
+ * const candles = await exchange.getCandles("BTCUSDT", "1m", 100);
+ * const vwap = await exchange.getAveragePrice("BTCUSDT");
+ * ```
+ */
+class ClientExchange {
+    constructor(params) {
+        this.params = params;
+    }
+    /**
+     * Fetches historical candles backwards from execution context time.
+     *
+     * @param symbol - Trading pair symbol
+     * @param interval - Candle interval
+     * @param limit - Number of candles to fetch
+     * @returns Promise resolving to array of candles
+     */
+    async getCandles(symbol, interval, limit) {
+        this.params.logger.debug(`ClientExchange getCandles`, {
+            symbol,
+            interval,
+            limit,
+        });
+        const step = INTERVAL_MINUTES$4[interval];
+        const adjust = step * limit;
+        if (!adjust) {
+            throw new Error(`ClientExchange unknown time adjust for interval=${interval}`);
+        }
+        const since = new Date(this.params.execution.context.when.getTime() - adjust * MS_PER_MINUTE$1);
+        let allData = [];
+        // If limit exceeds CC_MAX_CANDLES_PER_REQUEST, fetch data in chunks
+        if (limit > GLOBAL_CONFIG.CC_MAX_CANDLES_PER_REQUEST) {
+            let remaining = limit;
+            let currentSince = new Date(since.getTime());
+            while (remaining > 0) {
+                const chunkLimit = Math.min(remaining, GLOBAL_CONFIG.CC_MAX_CANDLES_PER_REQUEST);
+                const chunkData = await GET_CANDLES_FN({ symbol, interval, limit: chunkLimit }, currentSince, this);
+                allData.push(...chunkData);
+                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);
+                }
+            }
+        }
+        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`;
+            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);
+        }
+        await CALL_CANDLE_DATA_CALLBACKS_FN(this, symbol, interval, since, limit, uniqueData);
+        return uniqueData;
     }
     /**
-     * Registers a custom persistence adapter.
-     *
-     * @param Ctor - Custom PersistBase constructor
+     * Fetches future candles forwards from execution context time.
+     * Used in backtest mode to get candles for signal duration.
      *
-     * @example
-     * ```typescript
-     * class RedisPersist extends PersistBase {
-     *   async readValue(id) { return JSON.parse(await redis.get(id)); }
-     *   async writeValue(id, entity) { await redis.set(id, JSON.stringify(entity)); }
-     * }
-     * PersistRiskAdapter.usePersistRiskAdapter(RedisPersist);
-     * ```
-     */
-    usePersistRiskAdapter(Ctor) {
-        bt.loggerService.info(PERSIST_RISK_UTILS_METHOD_NAME_USE_PERSIST_RISK_ADAPTER);
-        this.PersistRiskFactory = Ctor;
-    }
-    /**
-     * Switches to the default JSON persist adapter.
-     * All future persistence writes will use JSON storage.
-     */
-    useJson() {
-        bt.loggerService.log(PERSIST_RISK_UTILS_METHOD_NAME_USE_JSON);
-        this.usePersistRiskAdapter(PersistBase);
-    }
-    /**
-     * Switches to a dummy persist adapter that discards all writes.
-     * All future persistence writes will be no-ops.
+     * @param symbol - Trading pair symbol
+     * @param interval - Candle interval
+     * @param limit - Number of candles to fetch
+     * @returns Promise resolving to array of candles
+     * @throws Error if trying to fetch future candles in live mode
      */
-    useDummy() {
-        bt.loggerService.log(PERSIST_RISK_UTILS_METHOD_NAME_USE_DUMMY);
-        this.usePersistRiskAdapter(PersistDummy);
-    }
-}
-/**
- * Global singleton instance of PersistRiskUtils.
- * Used by ClientRisk for active positions persistence.
- *
- * @example
- * ```typescript
- * // Custom adapter
- * PersistRiskAdapter.usePersistRiskAdapter(RedisPersist);
- *
- * // Read positions
- * const positions = await PersistRiskAdapter.readPositionData("my-risk");
- *
- * // Write positions
- * await PersistRiskAdapter.writePositionData(positionsMap, "my-risk");
- * ```
- */
-const PersistRiskAdapter = new PersistRiskUtils();
-/**
- * Utility class for managing scheduled signal persistence.
- *
- * Features:
- * - Memoized storage instances per strategy
- * - Custom adapter support
- * - Atomic read/write operations for scheduled signals
- * - Crash-safe scheduled signal state management
- *
- * Used by ClientStrategy for live mode persistence of scheduled signals (_scheduledSignal).
- */
-class PersistScheduleUtils {
-    constructor() {
-        this.PersistScheduleFactory = PersistBase;
-        this.getScheduleStorage = memoize(([symbol, strategyName, exchangeName]) => `${symbol}:${strategyName}:${exchangeName}`, (symbol, strategyName, exchangeName) => Reflect.construct(this.PersistScheduleFactory, [
-            `${symbol}_${strategyName}_${exchangeName}`,
-            `./dump/data/schedule/`,
-        ]));
-        /**
-         * Reads persisted scheduled signal data for a symbol and strategy.
-         *
-         * Called by ClientStrategy.waitForInit() to restore scheduled signal state.
-         * Returns null if no scheduled signal exists.
-         *
-         * @param symbol - Trading pair symbol
-         * @param strategyName - Strategy identifier
-         * @param exchangeName - Exchange identifier
-         * @returns Promise resolving to scheduled signal or null
-         */
-        this.readScheduleData = async (symbol, strategyName, exchangeName) => {
-            bt.loggerService.info(PERSIST_SCHEDULE_UTILS_METHOD_NAME_READ_DATA);
-            const key = `${symbol}:${strategyName}:${exchangeName}`;
-            const isInitial = !this.getScheduleStorage.has(key);
-            const stateStorage = this.getScheduleStorage(symbol, strategyName, exchangeName);
-            await stateStorage.waitForInit(isInitial);
-            if (await stateStorage.hasValue(symbol)) {
-                return await stateStorage.readValue(symbol);
+    async getNextCandles(symbol, interval, limit) {
+        this.params.logger.debug(`ClientExchange getNextCandles`, {
+            symbol,
+            interval,
+            limit,
+        });
+        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 (endTime > now) {
+            return [];
+        }
+        let allData = [];
+        // If limit exceeds CC_MAX_CANDLES_PER_REQUEST, fetch data in chunks
+        if (limit > GLOBAL_CONFIG.CC_MAX_CANDLES_PER_REQUEST) {
+            let remaining = limit;
+            let currentSince = new Date(since.getTime());
+            while (remaining > 0) {
+                const chunkLimit = Math.min(remaining, GLOBAL_CONFIG.CC_MAX_CANDLES_PER_REQUEST);
+                const chunkData = await GET_CANDLES_FN({ symbol, interval, limit: chunkLimit }, currentSince, this);
+                allData.push(...chunkData);
+                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);
+                }
             }
-            return null;
-        };
-        /**
-         * Writes scheduled signal data to disk with atomic file writes.
-         *
-         * Called by ClientStrategy.setScheduledSignal() to persist state.
-         * Uses atomic writes to prevent corruption on crashes.
-         *
-         * @param scheduledSignalRow - Scheduled signal data (null to clear)
-         * @param symbol - Trading pair symbol
-         * @param strategyName - Strategy identifier
-         * @param exchangeName - Exchange identifier
-         * @returns Promise that resolves when write is complete
-         */
-        this.writeScheduleData = async (scheduledSignalRow, symbol, strategyName, exchangeName) => {
-            bt.loggerService.info(PERSIST_SCHEDULE_UTILS_METHOD_NAME_WRITE_DATA);
-            const key = `${symbol}:${strategyName}:${exchangeName}`;
-            const isInitial = !this.getScheduleStorage.has(key);
-            const stateStorage = this.getScheduleStorage(symbol, strategyName, exchangeName);
-            await stateStorage.waitForInit(isInitial);
-            await stateStorage.writeValue(symbol, scheduledSignalRow);
-        };
+        }
+        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`;
+            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);
+        }
+        await CALL_CANDLE_DATA_CALLBACKS_FN(this, symbol, interval, since, limit, uniqueData);
+        return uniqueData;
     }
     /**
-     * Registers a custom persistence adapter.
+     * Calculates VWAP (Volume Weighted Average Price) from last N 1m candles.
+     * The number of candles is configurable via GLOBAL_CONFIG.CC_AVG_PRICE_CANDLES_COUNT.
      *
-     * @param Ctor - Custom PersistBase constructor
+     * Formula:
+     * - Typical Price = (high + low + close) / 3
+     * - VWAP = sum(typical_price * volume) / sum(volume)
      *
-     * @example
-     * ```typescript
-     * class RedisPersist extends PersistBase {
-     *   async readValue(id) { return JSON.parse(await redis.get(id)); }
-     *   async writeValue(id, entity) { await redis.set(id, JSON.stringify(entity)); }
-     * }
-     * PersistScheduleAdapter.usePersistScheduleAdapter(RedisPersist);
-     * ```
+     * If volume is zero, returns simple average of close prices.
+     *
+     * @param symbol - Trading pair symbol
+     * @returns Promise resolving to VWAP price
+     * @throws Error if no candles available
      */
-    usePersistScheduleAdapter(Ctor) {
-        bt.loggerService.info(PERSIST_SCHEDULE_UTILS_METHOD_NAME_USE_PERSIST_SCHEDULE_ADAPTER);
-        this.PersistScheduleFactory = Ctor;
+    async getAveragePrice(symbol) {
+        this.params.logger.debug(`ClientExchange getAveragePrice`, {
+            symbol,
+        });
+        const candles = await this.getCandles(symbol, "1m", GLOBAL_CONFIG.CC_AVG_PRICE_CANDLES_COUNT);
+        if (candles.length === 0) {
+            throw new Error(`ClientExchange getAveragePrice: no candles data for symbol=${symbol}`);
+        }
+        // VWAP (Volume Weighted Average Price)
+        // Используем типичную цену (typical price) = (high + low + close) / 3
+        const sumPriceVolume = candles.reduce((acc, candle) => {
+            const typicalPrice = (candle.high + candle.low + candle.close) / 3;
+            return acc + typicalPrice * candle.volume;
+        }, 0);
+        const totalVolume = candles.reduce((acc, candle) => acc + candle.volume, 0);
+        if (totalVolume === 0) {
+            // Если объем нулевой, возвращаем простое среднее close цен
+            const sum = candles.reduce((acc, candle) => acc + candle.close, 0);
+            return sum / candles.length;
+        }
+        const vwap = sumPriceVolume / totalVolume;
+        return vwap;
     }
     /**
-     * Switches to the default JSON persist adapter.
-     * All future persistence writes will use JSON storage.
+     * Formats quantity according to exchange-specific rules for the given symbol.
+     * Applies proper decimal precision and rounding based on symbol's lot size filters.
+     *
+     * @param symbol - Trading pair symbol
+     * @param quantity - Raw quantity to format
+     * @returns Promise resolving to formatted quantity as string
      */
-    useJson() {
-        bt.loggerService.log(PERSIST_SCHEDULE_UTILS_METHOD_NAME_USE_JSON);
-        this.usePersistScheduleAdapter(PersistBase);
+    async formatQuantity(symbol, quantity) {
+        this.params.logger.debug("binanceService formatQuantity", {
+            symbol,
+            quantity,
+        });
+        return await this.params.formatQuantity(symbol, quantity, this.params.execution.context.backtest);
     }
     /**
-     * Switches to a dummy persist adapter that discards all writes.
-     * All future persistence writes will be no-ops.
+     * Formats price according to exchange-specific rules for the given symbol.
+     * Applies proper decimal precision and rounding based on symbol's price filters.
+     *
+     * @param symbol - Trading pair symbol
+     * @param price - Raw price to format
+     * @returns Promise resolving to formatted price as string
      */
-    useDummy() {
-        bt.loggerService.log(PERSIST_SCHEDULE_UTILS_METHOD_NAME_USE_DUMMY);
-        this.usePersistScheduleAdapter(PersistDummy);
-    }
-}
-/**
- * Global singleton instance of PersistScheduleUtils.
- * Used by ClientStrategy for scheduled signal persistence.
- *
- * @example
- * ```typescript
- * // Custom adapter
- * PersistScheduleAdapter.usePersistScheduleAdapter(RedisPersist);
- *
- * // Read scheduled signal
- * const scheduled = await PersistScheduleAdapter.readScheduleData("my-strategy", "BTCUSDT");
- *
- * // Write scheduled signal
- * await PersistScheduleAdapter.writeScheduleData(scheduled, "my-strategy", "BTCUSDT");
- * ```
- */
-const PersistScheduleAdapter = new PersistScheduleUtils();
-/**
- * Utility class for managing partial profit/loss levels persistence.
- *
- * Features:
- * - Memoized storage instances per symbol:strategyName
- * - Custom adapter support
- * - Atomic read/write operations for partial data
- * - Crash-safe partial state management
- *
- * Used by ClientPartial for live mode persistence of profit/loss levels.
- */
-class PersistPartialUtils {
-    constructor() {
-        this.PersistPartialFactory = PersistBase;
-        this.getPartialStorage = memoize(([symbol, strategyName, exchangeName]) => `${symbol}:${strategyName}:${exchangeName}`, (symbol, strategyName, exchangeName) => Reflect.construct(this.PersistPartialFactory, [
-            `${symbol}_${strategyName}_${exchangeName}`,
-            `./dump/data/partial/`,
-        ]));
-        /**
-         * Reads persisted partial data for a symbol and strategy.
-         *
-         * Called by ClientPartial.waitForInit() to restore state.
-         * Returns empty object if no partial data exists.
-         *
-         * @param symbol - Trading pair symbol
-         * @param strategyName - Strategy identifier
-         * @param signalId - Signal identifier
-         * @param exchangeName - Exchange identifier
-         * @returns Promise resolving to partial data record
-         */
-        this.readPartialData = async (symbol, strategyName, signalId, exchangeName) => {
-            bt.loggerService.info(PERSIST_PARTIAL_UTILS_METHOD_NAME_READ_DATA);
-            const key = `${symbol}:${strategyName}:${exchangeName}`;
-            const isInitial = !this.getPartialStorage.has(key);
-            const stateStorage = this.getPartialStorage(symbol, strategyName, exchangeName);
-            await stateStorage.waitForInit(isInitial);
-            if (await stateStorage.hasValue(signalId)) {
-                return await stateStorage.readValue(signalId);
-            }
-            return {};
-        };
-        /**
-         * Writes partial data to disk with atomic file writes.
-         *
-         * Called by ClientPartial after profit/loss level changes to persist state.
-         * Uses atomic writes to prevent corruption on crashes.
-         *
-         * @param partialData - Record of signal IDs to partial data
-         * @param symbol - Trading pair symbol
-         * @param strategyName - Strategy identifier
-         * @param signalId - Signal identifier
-         * @param exchangeName - Exchange identifier
-         * @returns Promise that resolves when write is complete
-         */
-        this.writePartialData = async (partialData, symbol, strategyName, signalId, exchangeName) => {
-            bt.loggerService.info(PERSIST_PARTIAL_UTILS_METHOD_NAME_WRITE_DATA);
-            const key = `${symbol}:${strategyName}:${exchangeName}`;
-            const isInitial = !this.getPartialStorage.has(key);
-            const stateStorage = this.getPartialStorage(symbol, strategyName, exchangeName);
-            await stateStorage.waitForInit(isInitial);
-            await stateStorage.writeValue(signalId, partialData);
-        };
+    async formatPrice(symbol, price) {
+        this.params.logger.debug("binanceService formatPrice", {
+            symbol,
+            price,
+        });
+        return await this.params.formatPrice(symbol, price, this.params.execution.context.backtest);
     }
     /**
-     * Registers a custom persistence adapter.
+     * Fetches raw candles with flexible date/limit parameters.
      *
-     * @param Ctor - Custom PersistBase constructor
+     * All modes respect execution context and prevent look-ahead bias.
      *
-     * @example
-     * ```typescript
-     * class RedisPersist extends PersistBase {
-     *   async readValue(id) { return JSON.parse(await redis.get(id)); }
-     *   async writeValue(id, entity) { await redis.set(id, JSON.stringify(entity)); }
-     * }
-     * PersistPartialAdapter.usePersistPartialAdapter(RedisPersist);
-     * ```
-     */
-    usePersistPartialAdapter(Ctor) {
-        bt.loggerService.info(PERSIST_PARTIAL_UTILS_METHOD_NAME_USE_PERSIST_PARTIAL_ADAPTER);
-        this.PersistPartialFactory = Ctor;
-    }
-    /**
-     * Switches to the default JSON persist adapter.
-     * All future persistence writes will use JSON storage.
+     * Parameter combinations:
+     * 1. sDate + eDate + limit: fetches with explicit parameters, validates eDate <= when
+     * 2. sDate + eDate: calculates limit from date range, validates eDate <= when
+     * 3. eDate + limit: calculates sDate backward, validates eDate <= when
+     * 4. sDate + limit: fetches forward, validates calculated endTimestamp <= when
+     * 5. Only limit: uses execution.context.when as reference (backward)
+     *
+     * Edge cases:
+     * - If calculated limit is 0 or negative: throws error
+     * - If sDate >= eDate: throws error
+     * - If eDate > when: throws error to prevent look-ahead bias
+     *
+     * @param symbol - Trading pair symbol
+     * @param interval - Candle interval
+     * @param limit - Optional number of candles to fetch
+     * @param sDate - Optional start date in milliseconds
+     * @param eDate - Optional end date in milliseconds
+     * @returns Promise resolving to array of candles
+     * @throws Error if parameters are invalid or conflicting
      */
-    useJson() {
-        bt.loggerService.log(PERSIST_PARTIAL_UTILS_METHOD_NAME_USE_JSON);
-        this.usePersistPartialAdapter(PersistBase);
+    async getRawCandles(symbol, interval, limit, sDate, eDate) {
+        this.params.logger.debug(`ClientExchange getRawCandles`, {
+            symbol,
+            interval,
+            limit,
+            sDate,
+            eDate,
+        });
+        const step = INTERVAL_MINUTES$4[interval];
+        if (!step) {
+            throw new Error(`ClientExchange getRawCandles: unknown interval=${interval}`);
+        }
+        const whenTimestamp = this.params.execution.context.when.getTime();
+        let sinceTimestamp;
+        let untilTimestamp;
+        let calculatedLimit;
+        // Case 1: all three parameters provided
+        if (sDate !== undefined && eDate !== undefined && limit !== undefined) {
+            if (sDate >= eDate) {
+                throw new Error(`ClientExchange getRawCandles: sDate (${sDate}) must be < eDate (${eDate})`);
+            }
+            if (eDate > whenTimestamp) {
+                throw new Error(`ClientExchange getRawCandles: eDate (${eDate}) exceeds execution context when (${whenTimestamp}). Look-ahead bias protection.`);
+            }
+            sinceTimestamp = sDate;
+            untilTimestamp = eDate;
+            calculatedLimit = limit;
+        }
+        // Case 2: sDate + eDate (no limit) - calculate limit from date range
+        else if (sDate !== undefined && eDate !== undefined && limit === undefined) {
+            if (sDate >= eDate) {
+                throw new Error(`ClientExchange getRawCandles: sDate (${sDate}) must be < eDate (${eDate})`);
+            }
+            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));
+            if (calculatedLimit <= 0) {
+                throw new Error(`ClientExchange getRawCandles: calculated limit is ${calculatedLimit}, must be > 0`);
+            }
+        }
+        // Case 3: eDate + limit (no sDate) - calculate sDate backward from eDate
+        else if (sDate === undefined && eDate !== undefined && limit !== undefined) {
+            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;
+            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.`);
+            }
+            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;
+            calculatedLimit = limit;
+        }
+        // Invalid: no parameters or only sDate or only eDate
+        else {
+            throw new Error(`ClientExchange getRawCandles: invalid parameter combination. ` +
+                `Provide one of: (sDate+eDate+limit), (sDate+eDate), (eDate+limit), (sDate+limit), or (limit only). ` +
+                `Got: sDate=${sDate}, eDate=${eDate}, limit=${limit}`);
+        }
+        // Fetch candles using existing logic
+        const since = new Date(sinceTimestamp);
+        let allData = [];
+        if (calculatedLimit > GLOBAL_CONFIG.CC_MAX_CANDLES_PER_REQUEST) {
+            let remaining = calculatedLimit;
+            let currentSince = new Date(since.getTime());
+            while (remaining > 0) {
+                const chunkLimit = Math.min(remaining, GLOBAL_CONFIG.CC_MAX_CANDLES_PER_REQUEST);
+                const chunkData = await GET_CANDLES_FN({ symbol, interval, limit: chunkLimit }, currentSince, this);
+                allData.push(...chunkData);
+                remaining -= chunkLimit;
+                if (remaining > 0) {
+                    currentSince = new Date(currentSince.getTime() + chunkLimit * step * MS_PER_MINUTE$1);
+                }
+            }
+        }
+        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`;
+            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);
+        }
+        await CALL_CANDLE_DATA_CALLBACKS_FN(this, symbol, interval, since, calculatedLimit, uniqueData);
+        return uniqueData;
     }
     /**
-     * Switches to a dummy persist adapter that discards all writes.
-     * All future persistence writes will be no-ops.
+     * Fetches order book for a trading pair.
+     *
+     * Calculates time range based on execution context time (when) and
+     * CC_ORDER_BOOK_TIME_OFFSET_MINUTES, then delegates to the exchange
+     * schema implementation which may use or ignore the time range.
+     *
+     * @param symbol - Trading pair symbol
+     * @param depth - Maximum depth levels (default: CC_ORDER_BOOK_MAX_DEPTH_LEVELS)
+     * @returns Promise resolving to order book data
+     * @throws Error if getOrderBook is not implemented
      */
-    useDummy() {
-        bt.loggerService.log(PERSIST_PARTIAL_UTILS_METHOD_NAME_USE_DUMMY);
-        this.usePersistPartialAdapter(PersistDummy);
+    async getOrderBook(symbol, depth = GLOBAL_CONFIG.CC_ORDER_BOOK_MAX_DEPTH_LEVELS) {
+        this.params.logger.debug("ClientExchange getOrderBook", {
+            symbol,
+            depth,
+        });
+        const to = new Date(this.params.execution.context.when.getTime());
+        const from = new Date(to.getTime() -
+            GLOBAL_CONFIG.CC_ORDER_BOOK_TIME_OFFSET_MINUTES * MS_PER_MINUTE$1);
+        return await this.params.getOrderBook(symbol, depth, from, to, this.params.execution.context.backtest);
     }
 }
+
 /**
- * Global singleton instance of PersistPartialUtils.
- * Used by ClientPartial for partial profit/loss levels persistence.
- *
- * @example
- * ```typescript
- * // Custom adapter
- * PersistPartialAdapter.usePersistPartialAdapter(RedisPersist);
- *
- * // Read partial data
- * const partialData = await PersistPartialAdapter.readPartialData("BTCUSDT", "my-strategy");
- *
- * // Write partial data
- * await PersistPartialAdapter.writePartialData(partialData, "BTCUSDT", "my-strategy");
- * ```
+ * Default implementation for getCandles.
+ * Throws an error indicating the method is not implemented.
  */
-const PersistPartialAdapter = new PersistPartialUtils();
+const DEFAULT_GET_CANDLES_FN$1 = async (_symbol, _interval, _since, _limit, _backtest) => {
+    throw new Error(`getCandles is not implemented for this exchange`);
+};
 /**
- * Persistence utility class for breakeven state management.
+ * Default implementation for formatQuantity.
+ * Returns Bitcoin precision on Binance (8 decimal places).
+ */
+const DEFAULT_FORMAT_QUANTITY_FN$1 = async (_symbol, quantity, _backtest) => {
+    return quantity.toFixed(8);
+};
+/**
+ * Default implementation for formatPrice.
+ * Returns Bitcoin precision on Binance (2 decimal places).
+ */
+const DEFAULT_FORMAT_PRICE_FN$1 = async (_symbol, price, _backtest) => {
+    return price.toFixed(2);
+};
+/**
+ * Default implementation for getOrderBook.
+ * Throws an error indicating the method is not implemented.
  *
- * Handles reading and writing breakeven state to disk.
- * Uses memoized PersistBase instances per symbol-strategy pair.
+ * @param _symbol - Trading pair symbol (unused)
+ * @param _depth - Maximum depth levels (unused)
+ * @param _from - Start of time range (unused - can be ignored in live implementations)
+ * @param _to - End of time range (unused - can be ignored in live implementations)
+ * @param _backtest - Whether running in backtest mode (unused)
+ */
+const DEFAULT_GET_ORDER_BOOK_FN$1 = async (_symbol, _depth, _from, _to, _backtest) => {
+    throw new Error(`getOrderBook is not implemented for this exchange`);
+};
+/**
+ * Connection service routing exchange operations to correct ClientExchange instance.
  *
- * Features:
- * - Atomic file writes via PersistBase.writeValue()
- * - Lazy initialization on first access
- * - Singleton pattern for global access
- * - Custom adapter support via usePersistBreakevenAdapter()
+ * Routes all IExchange method calls to the appropriate exchange implementation
+ * based on methodContextService.context.exchangeName. Uses memoization to cache
+ * ClientExchange instances for performance.
  *
- * File structure:
- * ```
- * ./dump/data/breakeven/
- * ├── BTCUSDT_my-strategy/
- * │   └── state.json        // { "signal-id-1": { reached: true }, ... }
- * └── ETHUSDT_other-strategy/
- *     └── state.json
- * ```
+ * Key features:
+ * - Automatic exchange routing via method context
+ * - Memoized ClientExchange instances by exchangeName
+ * - Implements full IExchange interface
+ * - Logging for all operations
  *
  * @example
  * ```typescript
- * // Read breakeven data
- * const breakevenData = await PersistBreakevenAdapter.readBreakevenData("BTCUSDT", "my-strategy");
- * // Returns: { "signal-id": { reached: true }, ... }
- *
- * // Write breakeven data
- * await PersistBreakevenAdapter.writeBreakevenData(breakevenData, "BTCUSDT", "my-strategy");
+ * // Used internally by framework
+ * const candles = await exchangeConnectionService.getCandles(
+ *   "BTCUSDT", "1h", 100
+ * );
+ * // Automatically routes to correct exchange based on methodContext
  * ```
  */
-class PersistBreakevenUtils {
+class ExchangeConnectionService {
     constructor() {
+        this.loggerService = inject(TYPES.loggerService);
+        this.executionContextService = inject(TYPES.executionContextService);
+        this.exchangeSchemaService = inject(TYPES.exchangeSchemaService);
+        this.methodContextService = inject(TYPES.methodContextService);
+        /**
+         * Retrieves memoized ClientExchange instance for given exchange name.
+         *
+         * Creates ClientExchange on first call, returns cached instance on subsequent calls.
+         * Cache key is exchangeName string.
+         *
+         * @param exchangeName - Name of registered exchange schema
+         * @returns Configured ClientExchange instance
+         */
+        this.getExchange = memoize(([exchangeName]) => `${exchangeName}`, (exchangeName) => {
+            const { getCandles = DEFAULT_GET_CANDLES_FN$1, formatPrice = DEFAULT_FORMAT_PRICE_FN$1, formatQuantity = DEFAULT_FORMAT_QUANTITY_FN$1, getOrderBook = DEFAULT_GET_ORDER_BOOK_FN$1, callbacks } = this.exchangeSchemaService.get(exchangeName);
+            return new ClientExchange({
+                execution: this.executionContextService,
+                logger: this.loggerService,
+                exchangeName,
+                getCandles,
+                formatPrice,
+                formatQuantity,
+                getOrderBook,
+                callbacks,
+            });
+        });
         /**
-         * Factory for creating PersistBase instances.
-         * Can be replaced via usePersistBreakevenAdapter().
+         * Fetches historical candles for symbol using configured exchange.
+         *
+         * Routes to exchange determined by methodContextService.context.exchangeName.
+         *
+         * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+         * @param interval - Candle interval (e.g., "1h", "1d")
+         * @param limit - Maximum number of candles to fetch
+         * @returns Promise resolving to array of candle data
          */
-        this.PersistBreakevenFactory = PersistBase;
+        this.getCandles = async (symbol, interval, limit) => {
+            this.loggerService.log("exchangeConnectionService getCandles", {
+                symbol,
+                interval,
+                limit,
+            });
+            return await this.getExchange(this.methodContextService.context.exchangeName).getCandles(symbol, interval, limit);
+        };
         /**
-         * Memoized storage factory for breakeven data.
-         * Creates one PersistBase instance per symbol-strategy-exchange combination.
-         * Key format: "symbol:strategyName:exchangeName"
+         * Fetches next batch of candles relative to executionContext.when.
          *
-         * @param symbol - Trading pair symbol
-         * @param strategyName - Strategy identifier
-         * @param exchangeName - Exchange identifier
-         * @returns PersistBase instance for this symbol-strategy-exchange combination
+         * Returns candles that come after the current execution timestamp.
+         * Used for backtest progression and live trading updates.
+         *
+         * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+         * @param interval - Candle interval (e.g., "1h", "1d")
+         * @param limit - Maximum number of candles to fetch
+         * @returns Promise resolving to array of candle data
          */
-        this.getBreakevenStorage = memoize(([symbol, strategyName, exchangeName]) => `${symbol}:${strategyName}:${exchangeName}`, (symbol, strategyName, exchangeName) => Reflect.construct(this.PersistBreakevenFactory, [
-            `${symbol}_${strategyName}_${exchangeName}`,
-            `./dump/data/breakeven/`,
-        ]));
+        this.getNextCandles = async (symbol, interval, limit) => {
+            this.loggerService.log("exchangeConnectionService getNextCandles", {
+                symbol,
+                interval,
+                limit,
+            });
+            return await this.getExchange(this.methodContextService.context.exchangeName).getNextCandles(symbol, interval, limit);
+        };
         /**
-         * Reads persisted breakeven data for a symbol and strategy.
+         * Retrieves current average price for symbol.
          *
-         * Called by ClientBreakeven.waitForInit() to restore state.
-         * Returns empty object if no breakeven data exists.
+         * In live mode: fetches real-time average price from exchange API.
+         * In backtest mode: calculates VWAP from candles in current timeframe.
          *
-         * @param symbol - Trading pair symbol
-         * @param strategyName - Strategy identifier
-         * @param signalId - Signal identifier
-         * @param exchangeName - Exchange identifier
-         * @returns Promise resolving to breakeven data record
+         * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+         * @returns Promise resolving to average price
          */
-        this.readBreakevenData = async (symbol, strategyName, signalId, exchangeName) => {
-            bt.loggerService.info(PERSIST_BREAKEVEN_UTILS_METHOD_NAME_READ_DATA);
-            const key = `${symbol}:${strategyName}:${exchangeName}`;
-            const isInitial = !this.getBreakevenStorage.has(key);
-            const stateStorage = this.getBreakevenStorage(symbol, strategyName, exchangeName);
-            await stateStorage.waitForInit(isInitial);
-            if (await stateStorage.hasValue(signalId)) {
-                return await stateStorage.readValue(signalId);
-            }
-            return {};
+        this.getAveragePrice = async (symbol) => {
+            this.loggerService.log("exchangeConnectionService getAveragePrice", {
+                symbol,
+            });
+            return await this.getExchange(this.methodContextService.context.exchangeName).getAveragePrice(symbol);
         };
         /**
-         * Writes breakeven data to disk.
+         * Formats price according to exchange-specific precision rules.
          *
-         * Called by ClientBreakeven._persistState() after state changes.
-         * Creates directory and file if they don't exist.
-         * Uses atomic writes to prevent data corruption.
+         * Ensures price meets exchange requirements for decimal places and tick size.
          *
-         * @param breakevenData - Breakeven data record to persist
-         * @param symbol - Trading pair symbol
-         * @param strategyName - Strategy identifier
-         * @param signalId - Signal identifier
-         * @param exchangeName - Exchange identifier
-         * @returns Promise that resolves when write is complete
+         * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+         * @param price - Raw price value to format
+         * @returns Promise resolving to formatted price string
          */
-        this.writeBreakevenData = async (breakevenData, symbol, strategyName, signalId, exchangeName) => {
-            bt.loggerService.info(PERSIST_BREAKEVEN_UTILS_METHOD_NAME_WRITE_DATA);
-            const key = `${symbol}:${strategyName}:${exchangeName}`;
-            const isInitial = !this.getBreakevenStorage.has(key);
-            const stateStorage = this.getBreakevenStorage(symbol, strategyName, exchangeName);
-            await stateStorage.waitForInit(isInitial);
-            await stateStorage.writeValue(signalId, breakevenData);
+        this.formatPrice = async (symbol, price) => {
+            this.loggerService.log("exchangeConnectionService getAveragePrice", {
+                symbol,
+                price,
+            });
+            return await this.getExchange(this.methodContextService.context.exchangeName).formatPrice(symbol, price);
+        };
+        /**
+         * Formats quantity according to exchange-specific precision rules.
+         *
+         * Ensures quantity meets exchange requirements for decimal places and lot size.
+         *
+         * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+         * @param quantity - Raw quantity value to format
+         * @returns Promise resolving to formatted quantity string
+         */
+        this.formatQuantity = async (symbol, quantity) => {
+            this.loggerService.log("exchangeConnectionService getAveragePrice", {
+                symbol,
+                quantity,
+            });
+            return await this.getExchange(this.methodContextService.context.exchangeName).formatQuantity(symbol, quantity);
+        };
+        /**
+         * Fetches order book for a trading pair using configured exchange.
+         *
+         * Routes to exchange determined by methodContextService.context.exchangeName.
+         * The ClientExchange will calculate time range and pass it to the schema
+         * implementation, which may use (backtest) or ignore (live) the parameters.
+         *
+         * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+         * @param depth - Maximum depth levels (default: CC_ORDER_BOOK_MAX_DEPTH_LEVELS)
+         * @returns Promise resolving to order book data
+         */
+        this.getOrderBook = async (symbol, depth) => {
+            this.loggerService.log("exchangeConnectionService getOrderBook", {
+                symbol,
+                depth,
+            });
+            return await this.getExchange(this.methodContextService.context.exchangeName).getOrderBook(symbol, depth);
+        };
+        /**
+         * Fetches raw candles with flexible date/limit parameters.
+         *
+         * Routes to exchange determined by methodContextService.context.exchangeName.
+         *
+         * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+         * @param interval - Candle interval (e.g., "1h", "1d")
+         * @param limit - Optional number of candles to fetch
+         * @param sDate - Optional start date in milliseconds
+         * @param eDate - Optional end date in milliseconds
+         * @returns Promise resolving to array of candle data
+         */
+        this.getRawCandles = async (symbol, interval, limit, sDate, eDate) => {
+            this.loggerService.log("exchangeConnectionService getRawCandles", {
+                symbol,
+                interval,
+                limit,
+                sDate,
+                eDate,
+            });
+            return await this.getExchange(this.methodContextService.context.exchangeName).getRawCandles(symbol, interval, limit, sDate, eDate);
         };
-    }
-    /**
-     * Registers a custom persistence adapter.
-     *
-     * @param Ctor - Custom PersistBase constructor
-     *
-     * @example
-     * ```typescript
-     * class RedisPersist extends PersistBase {
-     *   async readValue(id) { return JSON.parse(await redis.get(id)); }
-     *   async writeValue(id, entity) { await redis.set(id, JSON.stringify(entity)); }
-     * }
-     * PersistBreakevenAdapter.usePersistBreakevenAdapter(RedisPersist);
-     * ```
-     */
-    usePersistBreakevenAdapter(Ctor) {
-        bt.loggerService.info(PERSIST_BREAKEVEN_UTILS_METHOD_NAME_USE_PERSIST_BREAKEVEN_ADAPTER);
-        this.PersistBreakevenFactory = Ctor;
-    }
-    /**
-     * Switches to the default JSON persist adapter.
-     * All future persistence writes will use JSON storage.
-     */
-    useJson() {
-        bt.loggerService.log(PERSIST_BREAKEVEN_UTILS_METHOD_NAME_USE_JSON);
-        this.usePersistBreakevenAdapter(PersistBase);
-    }
-    /**
-     * Switches to a dummy persist adapter that discards all writes.
-     * All future persistence writes will be no-ops.
-     */
-    useDummy() {
-        bt.loggerService.log(PERSIST_BREAKEVEN_UTILS_METHOD_NAME_USE_DUMMY);
-        this.usePersistBreakevenAdapter(PersistDummy);
     }
 }
+
 /**
- * Global singleton instance of PersistBreakevenUtils.
- * Used by ClientBreakeven for breakeven state persistence.
+ * Calculates profit/loss for a closed signal with slippage and fees.
+ *
+ * For signals with partial closes:
+ * - Calculates weighted PNL: Σ(percent_i × pnl_i) for each partial + (remaining% × final_pnl)
+ * - Each partial close has its own fees and slippage
+ * - Total fees = 2 × (number of partial closes + 1 final close) × CC_PERCENT_FEE
+ *
+ * Formula breakdown:
+ * 1. Apply slippage to open/close prices (worse execution)
+ *    - LONG: buy higher (+slippage), sell lower (-slippage)
+ *    - SHORT: sell lower (-slippage), buy higher (+slippage)
+ * 2. Calculate raw PNL percentage
+ *    - LONG: ((closePrice - openPrice) / openPrice) * 100
+ *    - SHORT: ((openPrice - closePrice) / openPrice) * 100
+ * 3. Subtract total fees (0.1% * 2 = 0.2% per transaction)
+ *
+ * @param signal - Closed signal with position details and optional partial history
+ * @param priceClose - Actual close price at final exit
+ * @returns PNL data with percentage and prices
  *
  * @example
  * ```typescript
- * // Custom adapter
- * PersistBreakevenAdapter.usePersistBreakevenAdapter(RedisPersist);
- *
- * // Read breakeven data
- * const breakevenData = await PersistBreakevenAdapter.readBreakevenData("BTCUSDT", "my-strategy");
+ * // Signal without partial closes
+ * const pnl = toProfitLossDto(
+ *   {
+ *     position: "long",
+ *     priceOpen: 100,
+ *   },
+ *   110 // close at +10%
+ * );
+ * console.log(pnl.pnlPercentage); // ~9.6% (after slippage and fees)
  *
- * // Write breakeven data
- * await PersistBreakevenAdapter.writeBreakevenData(breakevenData, "BTCUSDT", "my-strategy");
+ * // Signal with partial closes
+ * const pnlPartial = toProfitLossDto(
+ *   {
+ *     position: "long",
+ *     priceOpen: 100,
+ *     _partial: [
+ *       { type: "profit", percent: 30, price: 120 }, // +20% on 30%
+ *       { type: "profit", percent: 40, price: 115 }, // +15% on 40%
+ *     ],
+ *   },
+ *   105 // final close at +5% for remaining 30%
+ * );
+ * // Weighted PNL = 30% × 20% + 40% × 15% + 30% × 5% = 6% + 6% + 1.5% = 13.5% (before fees)
  * ```
  */
-const PersistBreakevenAdapter = new PersistBreakevenUtils();
+const toProfitLossDto = (signal, priceClose) => {
+    const priceOpen = signal.priceOpen;
+    // Calculate weighted PNL with partial closes
+    if (signal._partial && signal._partial.length > 0) {
+        let totalWeightedPnl = 0;
+        let totalFees = 0;
+        // Calculate PNL for each partial close
+        for (const partial of signal._partial) {
+            const partialPercent = partial.percent;
+            const partialPrice = partial.price;
+            // Apply slippage to prices
+            let priceOpenWithSlippage;
+            let priceCloseWithSlippage;
+            if (signal.position === "long") {
+                priceOpenWithSlippage = priceOpen * (1 + GLOBAL_CONFIG.CC_PERCENT_SLIPPAGE / 100);
+                priceCloseWithSlippage = partialPrice * (1 - GLOBAL_CONFIG.CC_PERCENT_SLIPPAGE / 100);
+            }
+            else {
+                priceOpenWithSlippage = priceOpen * (1 - GLOBAL_CONFIG.CC_PERCENT_SLIPPAGE / 100);
+                priceCloseWithSlippage = partialPrice * (1 + GLOBAL_CONFIG.CC_PERCENT_SLIPPAGE / 100);
+            }
+            // Calculate PNL for this partial
+            let partialPnl;
+            if (signal.position === "long") {
+                partialPnl = ((priceCloseWithSlippage - priceOpenWithSlippage) / priceOpenWithSlippage) * 100;
+            }
+            else {
+                partialPnl = ((priceOpenWithSlippage - priceCloseWithSlippage) / priceOpenWithSlippage) * 100;
+            }
+            // Weight by percentage of position closed
+            const weightedPnl = (partialPercent / 100) * partialPnl;
+            totalWeightedPnl += weightedPnl;
+            // Each partial has fees for open + close (2 transactions)
+            totalFees += GLOBAL_CONFIG.CC_PERCENT_FEE * 2;
+        }
+        // Calculate PNL for remaining position (if any)
+        // Compute totalClosed from _partial array
+        const totalClosed = signal._partial.reduce((sum, p) => sum + p.percent, 0);
+        const remainingPercent = 100 - totalClosed;
+        if (remainingPercent > 0) {
+            // Apply slippage
+            let priceOpenWithSlippage;
+            let priceCloseWithSlippage;
+            if (signal.position === "long") {
+                priceOpenWithSlippage = priceOpen * (1 + GLOBAL_CONFIG.CC_PERCENT_SLIPPAGE / 100);
+                priceCloseWithSlippage = priceClose * (1 - GLOBAL_CONFIG.CC_PERCENT_SLIPPAGE / 100);
+            }
+            else {
+                priceOpenWithSlippage = priceOpen * (1 - GLOBAL_CONFIG.CC_PERCENT_SLIPPAGE / 100);
+                priceCloseWithSlippage = priceClose * (1 + GLOBAL_CONFIG.CC_PERCENT_SLIPPAGE / 100);
+            }
+            // Calculate PNL for remaining
+            let remainingPnl;
+            if (signal.position === "long") {
+                remainingPnl = ((priceCloseWithSlippage - priceOpenWithSlippage) / priceOpenWithSlippage) * 100;
+            }
+            else {
+                remainingPnl = ((priceOpenWithSlippage - priceCloseWithSlippage) / priceOpenWithSlippage) * 100;
+            }
+            // Weight by remaining percentage
+            const weightedRemainingPnl = (remainingPercent / 100) * remainingPnl;
+            totalWeightedPnl += weightedRemainingPnl;
+            // Final close also has fees
+            totalFees += GLOBAL_CONFIG.CC_PERCENT_FEE * 2;
+        }
+        // Subtract total fees from weighted PNL
+        const pnlPercentage = totalWeightedPnl - totalFees;
+        return {
+            pnlPercentage,
+            priceOpen,
+            priceClose,
+        };
+    }
+    // Original logic for signals without partial closes
+    let priceOpenWithSlippage;
+    let priceCloseWithSlippage;
+    if (signal.position === "long") {
+        // LONG: покупаем дороже, продаем дешевле
+        priceOpenWithSlippage = priceOpen * (1 + GLOBAL_CONFIG.CC_PERCENT_SLIPPAGE / 100);
+        priceCloseWithSlippage = priceClose * (1 - GLOBAL_CONFIG.CC_PERCENT_SLIPPAGE / 100);
+    }
+    else {
+        // SHORT: продаем дешевле, покупаем дороже
+        priceOpenWithSlippage = priceOpen * (1 - GLOBAL_CONFIG.CC_PERCENT_SLIPPAGE / 100);
+        priceCloseWithSlippage = priceClose * (1 + GLOBAL_CONFIG.CC_PERCENT_SLIPPAGE / 100);
+    }
+    // Применяем комиссию дважды (при открытии и закрытии)
+    const totalFee = GLOBAL_CONFIG.CC_PERCENT_FEE * 2;
+    let pnlPercentage;
+    if (signal.position === "long") {
+        // LONG: прибыль при росте цены
+        pnlPercentage =
+            ((priceCloseWithSlippage - priceOpenWithSlippage) /
+                priceOpenWithSlippage) *
+                100;
+    }
+    else {
+        // SHORT: прибыль при падении цены
+        pnlPercentage =
+            ((priceOpenWithSlippage - priceCloseWithSlippage) /
+                priceOpenWithSlippage) *
+                100;
+    }
+    // Вычитаем комиссии
+    pnlPercentage -= totalFee;
+    return {
+        pnlPercentage,
+        priceOpen,
+        priceClose,
+    };
+};
 
 /**
  * Converts markdown content to plain text with minimal formatting
@@ -9604,6 +9977,40 @@ class ExchangeCoreService {
                 backtest,
             });
         };
+        /**
+         * Fetches raw candles with flexible date/limit parameters and execution context.
+         *
+         * @param symbol - Trading pair symbol
+         * @param interval - Candle interval (e.g., "1m", "1h")
+         * @param when - Timestamp for context (used in backtest mode)
+         * @param backtest - Whether running in backtest mode
+         * @param limit - Optional number of candles to fetch
+         * @param sDate - Optional start date in milliseconds
+         * @param eDate - Optional end date in milliseconds
+         * @returns Promise resolving to array of candles
+         */
+        this.getRawCandles = async (symbol, interval, when, backtest, limit, sDate, eDate) => {
+            this.loggerService.log("exchangeCoreService getRawCandles", {
+                symbol,
+                interval,
+                when,
+                backtest,
+                limit,
+                sDate,
+                eDate,
+            });
+            if (!MethodContextService.hasContext()) {
+                throw new Error("exchangeCoreService getRawCandles requires a method context");
+            }
+            await this.validate(this.methodContextService.context.exchangeName);
+            return await ExecutionContextService.runInContext(async () => {
+                return await this.exchangeConnectionService.getRawCandles(symbol, interval, limit, sDate, eDate);
+            }, {
+                symbol,
+                when,
+                backtest,
+            });
+        };
     }
 }
 
@@ -24907,6 +25314,7 @@ const GET_SYMBOL_METHOD_NAME = "exchange.getSymbol";
 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";
 /**
  * Checks if trade context is active (execution and method contexts).
  *
@@ -25164,6 +25572,53 @@ async function getOrderBook(symbol, depth) {
     }
     return await bt.exchangeConnectionService.getOrderBook(symbol, depth);
 }
+/**
+ * Fetches raw candles with flexible date/limit parameters.
+ *
+ * All modes respect execution context and prevent look-ahead bias.
+ *
+ * Parameter combinations:
+ * 1. sDate + eDate + limit: fetches with explicit parameters, validates eDate <= when
+ * 2. sDate + eDate: calculates limit from date range, validates eDate <= when
+ * 3. eDate + limit: calculates sDate backward, validates eDate <= when
+ * 4. sDate + limit: fetches forward, validates calculated endTimestamp <= when
+ * 5. Only limit: uses execution.context.when as reference (backward)
+ *
+ * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+ * @param interval - Candle interval ("1m" | "3m" | "5m" | "15m" | "30m" | "1h" | "2h" | "4h" | "6h" | "8h")
+ * @param limit - Optional number of candles to fetch
+ * @param sDate - Optional start date in milliseconds
+ * @param eDate - Optional end date in milliseconds
+ * @returns Promise resolving to array of candle data
+ *
+ * @example
+ * ```typescript
+ * // Fetch 100 candles backward from current context time
+ * const candles = await getRawCandles("BTCUSDT", "1m", 100);
+ *
+ * // Fetch candles for specific date range
+ * const rangeCandles = await getRawCandles("BTCUSDT", "1h", undefined, startMs, endMs);
+ *
+ * // Fetch with all parameters specified
+ * const exactCandles = await getRawCandles("BTCUSDT", "1m", 100, startMs, endMs);
+ * ```
+ */
+async function getRawCandles(symbol, interval, limit, sDate, eDate) {
+    bt.loggerService.info(GET_RAW_CANDLES_METHOD_NAME, {
+        symbol,
+        interval,
+        limit,
+        sDate,
+        eDate,
+    });
+    if (!ExecutionContextService.hasContext()) {
+        throw new Error("getRawCandles requires an execution context");
+    }
+    if (!MethodContextService.hasContext()) {
+        throw new Error("getRawCandles requires a method context");
+    }
+    return await bt.exchangeConnectionService.getRawCandles(symbol, interval, limit, sDate, eDate);
+}
 
 const CANCEL_SCHEDULED_METHOD_NAME = "strategy.commitCancelScheduled";
 const CLOSE_PENDING_METHOD_NAME = "strategy.commitClosePending";
@@ -31435,6 +31890,8 @@ const EXCHANGE_METHOD_NAME_GET_AVERAGE_PRICE = "ExchangeUtils.getAveragePrice";
 const EXCHANGE_METHOD_NAME_FORMAT_QUANTITY = "ExchangeUtils.formatQuantity";
 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 backtest mode flag from execution context if available.
  * Returns false if no execution context exists (live mode).
@@ -31510,6 +31967,61 @@ const CREATE_EXCHANGE_INSTANCE_FN = (schema) => {
         getOrderBook,
     };
 };
+/**
+ * Attempts to read candles from cache.
+ * Validates cache consistency (no gaps in timestamps) before returning.
+ *
+ * @param dto - Data transfer object containing symbol, interval, and limit
+ * @param sinceTimestamp - Start timestamp in milliseconds
+ * @param untilTimestamp - End timestamp in milliseconds
+ * @param exchangeName - Exchange name
+ * @returns Cached candles array or null if cache miss or inconsistent
+ */
+const READ_CANDLES_CACHE_FN = trycatch(async (dto, sinceTimestamp, untilTimestamp, exchangeName) => {
+    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) {
+        bt.loggerService.debug(`ExchangeInstance READ_CANDLES_CACHE_FN: cache hit for exchangeName=${exchangeName}, symbol=${dto.symbol}, interval=${dto.interval}, limit=${dto.limit}`);
+        return cachedCandles;
+    }
+    bt.loggerService.warn(`ExchangeInstance READ_CANDLES_CACHE_FN: cache inconsistent (count or range mismatch) for exchangeName=${exchangeName}, symbol=${dto.symbol}, interval=${dto.interval}, limit=${dto.limit}`);
+    return null;
+}, {
+    fallback: async (error) => {
+        const message = `ExchangeInstance READ_CANDLES_CACHE_FN: cache read failed`;
+        const payload = {
+            error: errorData(error),
+            message: getErrorMessage(error),
+        };
+        bt.loggerService.warn(message, payload);
+        console.warn(message, payload);
+        errorEmitter.next(error);
+    },
+    defaultValue: null,
+});
+/**
+ * Writes candles to cache with error handling.
+ *
+ * @param candles - Array of candle data to cache
+ * @param dto - Data transfer object containing symbol, interval, and limit
+ * @param exchangeName - Exchange name
+ */
+const WRITE_CANDLES_CACHE_FN = trycatch(queued(async (candles, dto, exchangeName) => {
+    await PersistCandleAdapter.writeCandlesData(candles, dto.symbol, dto.interval, exchangeName);
+    bt.loggerService.debug(`ExchangeInstance WRITE_CANDLES_CACHE_FN: cache updated for exchangeName=${exchangeName}, symbol=${dto.symbol}, interval=${dto.interval}, count=${candles.length}`);
+}), {
+    fallback: async (error) => {
+        const message = `ExchangeInstance WRITE_CANDLES_CACHE_FN: cache write failed`;
+        const payload = {
+            error: errorData(error),
+            message: getErrorMessage(error),
+        };
+        bt.loggerService.warn(message, payload);
+        console.warn(message, payload);
+        errorEmitter.next(error);
+    },
+    defaultValue: null,
+});
 /**
  * Instance class for exchange operations on a specific exchange.
  *
@@ -31567,6 +32079,13 @@ class ExchangeInstance {
             }
             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;
+            // Try to read from cache first
+            const cachedCandles = await READ_CANDLES_CACHE_FN({ symbol, interval, limit }, sinceTimestamp, untilTimestamp, this.exchangeName);
+            if (cachedCandles !== null) {
+                return cachedCandles;
+            }
             let allData = [];
             // If limit exceeds CC_MAX_CANDLES_PER_REQUEST, fetch data in chunks
             if (limit > GLOBAL_CONFIG.CC_MAX_CANDLES_PER_REQUEST) {
@@ -31589,7 +32108,6 @@ class ExchangeInstance {
                 allData = await getCandles(symbol, interval, since, limit, isBacktest);
             }
             // Filter candles to strictly match the requested range
-            const sinceTimestamp = since.getTime();
             const whenTimestamp = when.getTime();
             const stepMs = step * 60 * 1000;
             const filteredData = allData.filter((candle) => candle.timestamp >= sinceTimestamp && candle.timestamp < whenTimestamp + stepMs);
@@ -31601,6 +32119,8 @@ class ExchangeInstance {
             if (uniqueData.length < limit) {
                 bt.loggerService.warn(`ExchangeInstance Expected ${limit} candles, got ${uniqueData.length}`);
             }
+            // Write to cache after successful fetch
+            await WRITE_CANDLES_CACHE_FN(uniqueData, { symbol, interval, limit }, this.exchangeName);
             return uniqueData;
         };
         /**
@@ -31725,6 +32245,151 @@ class ExchangeInstance {
             const isBacktest = await GET_BACKTEST_FN();
             return await this._methods.getOrderBook(symbol, depth, from, to, isBacktest);
         };
+        /**
+         * Fetches raw candles with flexible date/limit parameters.
+         *
+         * Uses Date.now() instead of execution context when for look-ahead bias protection.
+         *
+         * Parameter combinations:
+         * 1. sDate + eDate + limit: fetches with explicit parameters, validates eDate <= now
+         * 2. sDate + eDate: calculates limit from date range, validates eDate <= now
+         * 3. eDate + limit: calculates sDate backward, validates eDate <= now
+         * 4. sDate + limit: fetches forward, validates calculated endTimestamp <= now
+         * 5. Only limit: uses Date.now() as reference (backward)
+         *
+         * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+         * @param interval - Candle interval (e.g., "1m", "1h")
+         * @param limit - Optional number of candles to fetch
+         * @param sDate - Optional start date in milliseconds
+         * @param eDate - Optional end date in milliseconds
+         * @returns Promise resolving to array of candle data
+         *
+         * @example
+         * ```typescript
+         * const instance = new ExchangeInstance("binance");
+         *
+         * // Fetch 100 candles backward from now
+         * const candles = await instance.getRawCandles("BTCUSDT", "1m", 100);
+         *
+         * // Fetch candles for specific date range
+         * const rangeCandles = await instance.getRawCandles("BTCUSDT", "1h", undefined, startMs, endMs);
+         * ```
+         */
+        this.getRawCandles = async (symbol, interval, limit, sDate, eDate) => {
+            bt.loggerService.info(EXCHANGE_METHOD_NAME_GET_RAW_CANDLES, {
+                exchangeName: this.exchangeName,
+                symbol,
+                interval,
+                limit,
+                sDate,
+                eDate,
+            });
+            const step = INTERVAL_MINUTES$1[interval];
+            if (!step) {
+                throw new Error(`ExchangeInstance getRawCandles: unknown interval=${interval}`);
+            }
+            const nowTimestamp = Date.now();
+            let sinceTimestamp;
+            let untilTimestamp;
+            let calculatedLimit;
+            // Case 1: all three parameters provided
+            if (sDate !== undefined && eDate !== undefined && limit !== undefined) {
+                if (sDate >= eDate) {
+                    throw new Error(`ExchangeInstance getRawCandles: sDate (${sDate}) must be < eDate (${eDate})`);
+                }
+                if (eDate > nowTimestamp) {
+                    throw new Error(`ExchangeInstance getRawCandles: eDate (${eDate}) exceeds current time (${nowTimestamp}). Look-ahead bias protection.`);
+                }
+                sinceTimestamp = sDate;
+                untilTimestamp = eDate;
+                calculatedLimit = limit;
+            }
+            // Case 2: sDate + eDate (no limit) - calculate limit from date range
+            else if (sDate !== undefined && eDate !== undefined && limit === undefined) {
+                if (sDate >= eDate) {
+                    throw new Error(`ExchangeInstance getRawCandles: sDate (${sDate}) must be < eDate (${eDate})`);
+                }
+                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));
+                if (calculatedLimit <= 0) {
+                    throw new Error(`ExchangeInstance getRawCandles: calculated limit is ${calculatedLimit}, must be > 0`);
+                }
+            }
+            // Case 3: eDate + limit (no sDate) - calculate sDate backward from eDate
+            else if (sDate === undefined && eDate !== undefined && limit !== undefined) {
+                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;
+                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.`);
+                }
+                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;
+                calculatedLimit = limit;
+            }
+            // Invalid: no parameters or only sDate or only eDate
+            else {
+                throw new Error(`ExchangeInstance getRawCandles: invalid parameter combination. ` +
+                    `Provide one of: (sDate+eDate+limit), (sDate+eDate), (eDate+limit), (sDate+limit), or (limit only). ` +
+                    `Got: sDate=${sDate}, eDate=${eDate}, limit=${limit}`);
+            }
+            // Try to read from cache first
+            const cachedCandles = await READ_CANDLES_CACHE_FN({ symbol, interval, limit: calculatedLimit }, sinceTimestamp, untilTimestamp, this.exchangeName);
+            if (cachedCandles !== null) {
+                return cachedCandles;
+            }
+            // Fetch candles
+            const since = new Date(sinceTimestamp);
+            let allData = [];
+            const isBacktest = await GET_BACKTEST_FN();
+            const getCandles = this._methods.getCandles;
+            if (calculatedLimit > GLOBAL_CONFIG.CC_MAX_CANDLES_PER_REQUEST) {
+                let remaining = calculatedLimit;
+                let currentSince = new Date(since.getTime());
+                while (remaining > 0) {
+                    const chunkLimit = Math.min(remaining, GLOBAL_CONFIG.CC_MAX_CANDLES_PER_REQUEST);
+                    const chunkData = await getCandles(symbol, interval, currentSince, chunkLimit, isBacktest);
+                    allData.push(...chunkData);
+                    remaining -= chunkLimit;
+                    if (remaining > 0) {
+                        currentSince = new Date(currentSince.getTime() + chunkLimit * step * MS_PER_MINUTE);
+                    }
+                }
+            }
+            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`);
+            }
+            if (uniqueData.length < calculatedLimit) {
+                bt.loggerService.warn(`ExchangeInstance getRawCandles: Expected ${calculatedLimit} candles, got ${uniqueData.length}`);
+            }
+            // Write to cache after successful fetch
+            await WRITE_CANDLES_CACHE_FN(uniqueData, { symbol, interval, limit: calculatedLimit }, this.exchangeName);
+            return uniqueData;
+        };
         const schema = bt.exchangeSchemaService.get(this.exchangeName);
         this._methods = CREATE_EXCHANGE_INSTANCE_FN(schema);
     }
@@ -31829,6 +32494,24 @@ class ExchangeUtils {
             const instance = this._getInstance(context.exchangeName);
             return await instance.getOrderBook(symbol, depth);
         };
+        /**
+         * Fetches raw candles with flexible date/limit parameters.
+         *
+         * Uses Date.now() instead of execution context when for look-ahead bias protection.
+         *
+         * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+         * @param interval - Candle interval (e.g., "1m", "1h")
+         * @param context - Execution context with exchange name
+         * @param limit - Optional number of candles to fetch
+         * @param sDate - Optional start date in milliseconds
+         * @param eDate - Optional end date in milliseconds
+         * @returns Promise resolving to array of candle data
+         */
+        this.getRawCandles = async (symbol, interval, context, limit, sDate, eDate) => {
+            bt.exchangeValidationService.validate(context.exchangeName, EXCHANGE_METHOD_NAME_GET_RAW_CANDLES);
+            const instance = this._getInstance(context.exchangeName);
+            return await instance.getRawCandles(symbol, interval, limit, sDate, eDate);
+        };
     }
 }
 /**
@@ -32960,4 +33643,4 @@ const set = (object, path, value) => {
     }
 };
 
-export { ActionBase, Backtest, Breakeven, Cache, Constant, Exchange, ExecutionContextService, Heat, Live, Markdown, MarkdownFileBase, MarkdownFolderBase, MethodContextService, Notification, Optimizer, Partial, Performance, PersistBase, PersistBreakevenAdapter, PersistPartialAdapter, PersistRiskAdapter, PersistScheduleAdapter, PersistSignalAdapter, PositionSize, Report, ReportBase, Risk, Schedule, Walker, addActionSchema, addExchangeSchema, addFrameSchema, addOptimizerSchema, addRiskSchema, addSizingSchema, addStrategySchema, addWalkerSchema, commitBreakeven, commitCancelScheduled, commitClosePending, commitPartialLoss, commitPartialProfit, commitSignalPromptHistory, commitTrailingStop, commitTrailingTake, dumpSignalData, emitters, formatPrice, formatQuantity, get, getActionSchema, getAveragePrice, getBacktestTimeframe, getCandles, getColumns, getConfig, getContext, getDate, getDefaultColumns, getDefaultConfig, getExchangeSchema, getFrameSchema, getMode, getOptimizerSchema, getOrderBook, getRiskSchema, getSizingSchema, getStrategySchema, getSymbol, getWalkerSchema, hasTradeContext, backtest as lib, listExchangeSchema, listFrameSchema, listOptimizerSchema, listRiskSchema, listSizingSchema, listStrategySchema, listWalkerSchema, listenActivePing, listenActivePingOnce, listenBacktestProgress, listenBreakevenAvailable, listenBreakevenAvailableOnce, listenDoneBacktest, listenDoneBacktestOnce, listenDoneLive, listenDoneLiveOnce, listenDoneWalker, listenDoneWalkerOnce, listenError, listenExit, listenOptimizerProgress, listenPartialLossAvailable, listenPartialLossAvailableOnce, listenPartialProfitAvailable, listenPartialProfitAvailableOnce, listenPerformance, listenRisk, listenRiskOnce, listenSchedulePing, listenSchedulePingOnce, listenSignal, listenSignalBacktest, listenSignalBacktestOnce, listenSignalLive, listenSignalLiveOnce, listenSignalOnce, listenValidation, listenWalker, listenWalkerComplete, listenWalkerOnce, listenWalkerProgress, overrideActionSchema, overrideExchangeSchema, overrideFrameSchema, overrideOptimizerSchema, overrideRiskSchema, overrideSizingSchema, overrideStrategySchema, overrideWalkerSchema, parseArgs, roundTicks, set, setColumns, setConfig, setLogger, stopStrategy, validate };
+export { ActionBase, Backtest, Breakeven, Cache, Constant, Exchange, ExecutionContextService, Heat, Live, Markdown, MarkdownFileBase, MarkdownFolderBase, MethodContextService, Notification, Optimizer, Partial, Performance, PersistBase, PersistBreakevenAdapter, PersistCandleAdapter, PersistPartialAdapter, PersistRiskAdapter, PersistScheduleAdapter, PersistSignalAdapter, PositionSize, Report, ReportBase, Risk, Schedule, Walker, addActionSchema, addExchangeSchema, addFrameSchema, addOptimizerSchema, addRiskSchema, addSizingSchema, addStrategySchema, addWalkerSchema, commitBreakeven, commitCancelScheduled, commitClosePending, commitPartialLoss, commitPartialProfit, commitSignalPromptHistory, commitTrailingStop, commitTrailingTake, dumpSignalData, emitters, formatPrice, formatQuantity, get, getActionSchema, getAveragePrice, getBacktestTimeframe, getCandles, getColumns, getConfig, getContext, getDate, getDefaultColumns, getDefaultConfig, getExchangeSchema, getFrameSchema, getMode, getOptimizerSchema, getOrderBook, getRawCandles, getRiskSchema, getSizingSchema, getStrategySchema, getSymbol, getWalkerSchema, hasTradeContext, backtest as lib, listExchangeSchema, listFrameSchema, listOptimizerSchema, listRiskSchema, listSizingSchema, listStrategySchema, listWalkerSchema, listenActivePing, listenActivePingOnce, listenBacktestProgress, listenBreakevenAvailable, listenBreakevenAvailableOnce, listenDoneBacktest, listenDoneBacktestOnce, listenDoneLive, listenDoneLiveOnce, listenDoneWalker, listenDoneWalkerOnce, listenError, listenExit, listenOptimizerProgress, listenPartialLossAvailable, listenPartialLossAvailableOnce, listenPartialProfitAvailable, listenPartialProfitAvailableOnce, listenPerformance, listenRisk, listenRiskOnce, listenSchedulePing, listenSchedulePingOnce, listenSignal, listenSignalBacktest, listenSignalBacktestOnce, listenSignalLive, listenSignalLiveOnce, listenSignalOnce, listenValidation, listenWalker, listenWalkerComplete, listenWalkerOnce, listenWalkerProgress, overrideActionSchema, overrideExchangeSchema, overrideFrameSchema, overrideOptimizerSchema, overrideRiskSchema, overrideSizingSchema, overrideStrategySchema, overrideWalkerSchema, parseArgs, roundTicks, set, setColumns, setConfig, setLogger, stopStrategy, validate };