backtest-kit 2.1.1 → 2.1.3

package/build/index.cjs

@@ -586,1119 +586,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.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.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.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.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.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: functoolsKit.errorData(err),
-                message: functoolsKit.getErrorMessage(err),
-            };
-            self.params.logger.warn(message, payload);
-            console.warn(message, payload);
-            lastError = err;
-            await functoolsKit.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 functoolsKit.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;
 };
+const BASE_WAIT_FOR_INIT_UNLINK_FN = async (filePath) => functoolsKit.trycatch(functoolsKit.retry(async () => {
+    try {
+        await fs.unlink(filePath);
+        return true;
+    }
+    catch (error) {
+        console.error(`backtest-kit PersistBase unlink failed for filePath=${filePath} error=${functoolsKit.getErrorMessage(error)}`);
+        throw error;
+    }
+}, BASE_UNLINK_RETRY_COUNT, BASE_UNLINK_RETRY_DELAY), {
+    defaultValue: false,
+});
 /**
- * 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 = functoolsKit.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: functoolsKit.errorData(error),
-            message: functoolsKit.getErrorMessage(error),
-        };
-        bt.loggerService.warn(message, payload);
-        console.warn(message, payload);
-        errorEmitter.next(error);
-    },
-});
-/**
- * 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 = path.join(process.cwd(), "logs/data")) {
+        this.entityName = entityName;
+        this.baseDir = baseDir;
+        this[_a$2] = functoolsKit.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 = path.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 path.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.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}: ${functoolsKit.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.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}: ${functoolsKit.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}: ${functoolsKit.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);
+        try {
+            const files = await fs.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}: ${functoolsKit.getErrorMessage(error)}`);
+        }
     }
+}
+_a$2 = BASE_WAIT_FOR_INIT_SYMBOL;
+// @ts-ignore
+PersistBase = functoolsKit.makeExtendable(PersistBase);
+/**
+ * Dummy persist adapter that discards all writes.
+ * Used for disabling persistence.
+ */
+class PersistDummy {
     /**
-     * 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
+     * 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 = functoolsKit.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,
-            });
-        });
-        /**
-         * 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.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.PersistSignalFactory = PersistBase;
+        this.getSignalStorage = functoolsKit.memoize(([symbol, strategyName, exchangeName]) => `${symbol}:${strategyName}:${exchangeName}`, (symbol, strategyName, exchangeName) => Reflect.construct(this.PersistSignalFactory, [
+            `${symbol}_${strategyName}_${exchangeName}`,
+            `./dump/data/signal/`,
+        ]));
         /**
-         * Fetches next batch of candles relative to executionContext.when.
+         * Reads persisted signal data for a symbol and strategy.
          *
-         * Returns candles that come after the current execution timestamp.
-         * Used for backtest progression and live trading updates.
+         * 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.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.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;
         };
         /**
-         * Retrieves current average price for symbol.
+         * Writes signal data to disk with atomic file writes.
          *
-         * In live mode: fetches real-time average price from exchange API.
-         * In backtest mode: calculates VWAP from candles in current timeframe.
+         * Called by ClientStrategy.setPendingSignal() to persist state.
+         * Uses atomic writes to prevent corruption on crashes.
          *
-         * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
-         * @returns Promise resolving to average price
+         * @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.getAveragePrice = async (symbol) => {
-            this.loggerService.log("exchangeConnectionService getAveragePrice", {
-                symbol,
-            });
-            return await this.getExchange(this.methodContextService.context.exchangeName).getAveragePrice(symbol);
-        };
-        /**
-         * Formats price according to exchange-specific precision rules.
-         *
-         * Ensures price meets exchange requirements for decimal places and tick size.
-         *
-         * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
-         * @param price - Raw price value to format
-         * @returns Promise resolving to formatted price string
-         */
-        this.formatPrice = async (symbol, price) => {
-            this.loggerService.log("exchangeConnectionService getAveragePrice", {
-                symbol,
-                price,
-            });
-            return await this.getExchange(this.methodContextService.context.exchangeName).formatPrice(symbol, price);
+        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 = functoolsKit.memoize(([riskName, exchangeName]) => `${riskName}:${exchangeName}`, (riskName, exchangeName) => Reflect.construct(this.PersistRiskFactory, [
+            `${riskName}_${exchangeName}`,
+            `./dump/data/risk/`,
+        ]));
         /**
-         * Formats quantity according to exchange-specific precision rules.
+         * Reads persisted active positions for a risk profile.
          *
-         * Ensures quantity meets exchange requirements for decimal places and lot size.
+         * Called by ClientRisk.waitForInit() to restore state.
+         * Returns empty Map if no positions exist.
          *
-         * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
-         * @param quantity - Raw quantity value to format
-         * @returns Promise resolving to formatted quantity string
+         * @param riskName - Risk profile identifier
+         * @param exchangeName - Exchange identifier
+         * @returns Promise resolving to Map of active positions
          */
-        this.formatQuantity = async (symbol, quantity) => {
-            this.loggerService.log("exchangeConnectionService getAveragePrice", {
-                symbol,
-                quantity,
-            });
-            return await this.getExchange(this.methodContextService.context.exchangeName).formatQuantity(symbol, quantity);
+        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 [];
         };
         /**
-         * Fetches order book for a trading pair using configured exchange.
+         * Writes active positions 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 ClientRisk after addSignal/removeSignal 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 positions - Map of active positions
+         * @param riskName - Risk profile 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.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);
+    }
 }
-
 /**
- * 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
+ * Global singleton instance of PersistRiskUtils.
+ * Used by ClientRisk for active positions persistence.
  *
  * @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)
+ * // Custom adapter
+ * PersistRiskAdapter.usePersistRiskAdapter(RedisPersist);
  *
- * // 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)
+ * // Read positions
+ * const positions = await PersistRiskAdapter.readPositionData("my-risk");
+ *
+ * // Write positions
+ * await PersistRiskAdapter.writePositionData(positionsMap, "my-risk");
  * ```
  */
-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,
-    };
-};
-
-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
- *
- * @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 };
-    }
-    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.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.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.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.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.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 functoolsKit.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) => functoolsKit.trycatch(functoolsKit.retry(async () => {
-    try {
-        await fs.unlink(filePath);
-        return true;
-    }
-    catch (error) {
-        console.error(`backtest-kit PersistBase unlink failed for filePath=${filePath} error=${functoolsKit.getErrorMessage(error)}`);
-        throw error;
-    }
-}, BASE_UNLINK_RETRY_COUNT, BASE_UNLINK_RETRY_DELAY), {
-    defaultValue: false,
-});
+const PersistRiskAdapter = new PersistRiskUtils();
 /**
- * Base class for file-based persistence with atomic writes.
+ * Utility class for managing scheduled signal 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 strategy
+ * - Custom adapter support
+ * - Atomic read/write operations for scheduled signals
+ * - Crash-safe scheduled signal 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 ClientStrategy for live mode persistence of scheduled signals (_scheduledSignal).
  */
-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 = path.join(process.cwd(), "logs/data")) {
-        this.entityName = entityName;
-        this.baseDir = baseDir;
-        this[_a$2] = functoolsKit.singleshot(async () => await BASE_WAIT_FOR_INIT_FN(this));
-        bt.loggerService.debug(PERSIST_BASE_METHOD_NAME_CTOR, {
-            entityName: this.entityName,
-            baseDir,
-        });
-        this._directory = path.join(this.baseDir, this.entityName);
+class PersistScheduleUtils {
+    constructor() {
+        this.PersistScheduleFactory = PersistBase;
+        this.getScheduleStorage = functoolsKit.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);
+            }
+            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);
+        };
     }
     /**
-     * Computes file path for entity ID.
+     * Registers a custom persistence adapter.
      *
-     * @param entityId - Entity identifier
-     * @returns Full file path to entity JSON file
+     * @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);
+     * ```
      */
-    _getFilePath(entityId) {
-        return path.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.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}: ${functoolsKit.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.access(filePath);
-            return true;
-        }
-        catch (error) {
-            if (error?.code === "ENOENT") {
-                return false;
-            }
-            throw new Error(`Failed to check existence of entity ${this.entityName}:${entityId}: ${functoolsKit.getErrorMessage(error)}`);
-        }
+    usePersistScheduleAdapter(Ctor) {
+        bt.loggerService.info(PERSIST_SCHEDULE_UTILS_METHOD_NAME_USE_PERSIST_SCHEDULE_ADAPTER);
+        this.PersistScheduleFactory = Ctor;
     }
-    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}: ${functoolsKit.getErrorMessage(error)}`);
-        }
+    /**
+     * 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);
     }
     /**
-     * Async generator yielding all entity IDs.
-     * Sorted alphanumerically.
-     * Used internally by waitForInit for validation.
-     *
-     * @returns AsyncGenerator yielding entity IDs
-     * @throws Error if reading fails
+     * Switches to a dummy persist adapter that discards all writes.
+     * All future persistence writes will be no-ops.
      */
-    async *keys() {
-        bt.loggerService.debug(PERSIST_BASE_METHOD_NAME_KEYS, {
-            entityName: this.entityName,
-        });
-        try {
-            const files = await fs.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}: ${functoolsKit.getErrorMessage(error)}`);
-        }
+    useDummy() {
+        bt.loggerService.log(PERSIST_SCHEDULE_UTILS_METHOD_NAME_USE_DUMMY);
+        this.usePersistScheduleAdapter(PersistDummy);
     }
 }
-_a$2 = BASE_WAIT_FOR_INIT_SYMBOL;
-// @ts-ignore
-PersistBase = functoolsKit.makeExtendable(PersistBase);
 /**
- * Dummy persist adapter that discards all writes.
- * Used for disabling persistence.
+ * 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");
+ * ```
  */
-class PersistDummy {
-    /**
-     * No-op initialization function.
-     * @returns Promise that resolves immediately
-     */
-    async waitForInit() {
+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 = functoolsKit.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);
+        };
     }
     /**
-     * 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 = functoolsKit.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 = functoolsKit.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);
         };
     }
     /**
@@ -1712,538 +1492,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_BREAKEVEN_UTILS_METHOD_NAME_USE_DUMMY);
+        this.usePersistBreakevenAdapter(PersistDummy);
+    }
+}
+/**
+ * Global singleton instance of PersistBreakevenUtils.
+ * Used by ClientBreakeven for breakeven state persistence.
+ *
+ * @example
+ * ```typescript
+ * // Custom adapter
+ * PersistBreakevenAdapter.usePersistBreakevenAdapter(RedisPersist);
+ *
+ * // Read breakeven data
+ * const breakevenData = await PersistBreakevenAdapter.readBreakevenData("BTCUSDT", "my-strategy");
+ *
+ * // Write breakeven data
+ * await PersistBreakevenAdapter.writeBreakevenData(breakevenData, "BTCUSDT", "my-strategy");
+ * ```
+ */
+const PersistBreakevenAdapter = new PersistBreakevenUtils();
+/**
+ * Utility class for managing candles cache persistence.
+ *
+ * Features:
+ * - 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 ClientExchange for candle data caching.
+ */
+class PersistCandleUtils {
+    constructor() {
+        this.PersistCandlesFactory = PersistBase;
+        this.getCandlesStorage = functoolsKit.memoize(([symbol, interval, exchangeName]) => `${symbol}:${interval}:${exchangeName}`, (symbol, interval, exchangeName) => Reflect.construct(this.PersistCandlesFactory, [
+            `${exchangeName}/${symbol}/${interval}`,
+            `./dump/data/candles/`,
+        ]));
+        /**
+         * Reads cached candles for a specific exchange, symbol, and interval.
+         * Returns candles only if cache contains exactly the requested limit.
+         *
+         * @param symbol - Trading pair symbol
+         * @param interval - Candle interval
+         * @param exchangeName - Exchange identifier
+         * @param limit - Number of candles requested
+         * @param sinceTimestamp - Start timestamp (inclusive)
+         * @param untilTimestamp - End timestamp (exclusive)
+         * @returns Promise resolving to array of candles or null if cache is incomplete
+         */
+        this.readCandlesData = async (symbol, interval, exchangeName, limit, sinceTimestamp, untilTimestamp) => {
+            bt.loggerService.info("PersistCandleUtils.readCandlesData", {
+                symbol,
+                interval,
+                exchangeName,
+                limit,
+                sinceTimestamp,
+                untilTimestamp,
+            });
+            const key = `${symbol}:${interval}:${exchangeName}`;
+            const isInitial = !this.getCandlesStorage.has(key);
+            const stateStorage = this.getCandlesStorage(symbol, interval, exchangeName);
+            await stateStorage.waitForInit(isInitial);
+            // Collect all cached candles within the time range
+            const 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;
+                    }
+                }
+            }
+            // Sort by timestamp ascending
+            cachedCandles.sort((a, b) => a.timestamp - b.timestamp);
+            return cachedCandles;
+        };
+        /**
+         * Writes candles to cache with atomic file writes.
+         * Each candle is stored as a separate JSON file named by its timestamp.
+         *
+         * @param candles - Array of candle data to cache
+         * @param symbol - Trading pair symbol
+         * @param interval - Candle interval
+         * @param exchangeName - Exchange identifier
+         * @returns Promise that resolves when all writes are complete
+         */
+        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);
+            // Write each candle as a separate file
+            for (const candle of candles) {
+                if (await functoolsKit.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}`);
+        }
     }
-    /**
-     * 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);
+};
+/**
+ * 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 = functoolsKit.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: functoolsKit.errorData(error),
+            message: functoolsKit.getErrorMessage(error),
+        };
+        bt.loggerService.warn(message, payload);
+        console.warn(message, payload);
+        errorEmitter.next(error);
+    },
+    defaultValue: null,
+});
 /**
- * Global singleton instance of PersistSignalUtils.
- * Used by ClientStrategy for signal persistence.
+ * Writes candles to cache with error handling.
  *
- * @example
- * ```typescript
- * // Custom adapter
- * PersistSignalAdapter.usePersistSignalAdapter(RedisPersist);
+ * @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 = functoolsKit.trycatch(functoolsKit.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: functoolsKit.errorData(error),
+            message: functoolsKit.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.
  *
- * // Read signal
- * const signal = await PersistSignalAdapter.readSignalData("my-strategy", "BTCUSDT");
+ * 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
  *
- * // Write signal
- * await PersistSignalAdapter.writeSignalData(signal, "my-strategy", "BTCUSDT");
- * ```
+ * @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 PersistSignalAdapter = new PersistSignalUtils();
+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: functoolsKit.errorData(err),
+                message: functoolsKit.getErrorMessage(err),
+            };
+            self.params.logger.warn(message, payload);
+            console.warn(message, payload);
+            lastError = err;
+            await functoolsKit.sleep(GLOBAL_CONFIG.CC_GET_CANDLES_RETRY_DELAY_MS);
+        }
+    }
+    throw lastError;
+};
 /**
- * Utility class for managing risk active positions persistence.
+ * 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 = functoolsKit.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: functoolsKit.errorData(error),
+            message: functoolsKit.getErrorMessage(error),
+        };
+        bt.loggerService.warn(message, payload);
+        console.warn(message, payload);
+        errorEmitter.next(error);
+    },
+});
+/**
+ * Client implementation for exchange data access.
  *
  * Features:
- * - Memoized storage instances per risk profile
- * - Custom adapter support
- * - Atomic read/write operations for RiskData
- * - Crash-safe position state management
+ * - 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
  *
- * Used by ClientRisk for live mode persistence of active positions.
+ * 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 PersistRiskUtils {
-    constructor() {
-        this.PersistRiskFactory = PersistBase;
-        this.getRiskStorage = functoolsKit.memoize(([riskName, exchangeName]) => `${riskName}:${exchangeName}`, (riskName, exchangeName) => Reflect.construct(this.PersistRiskFactory, [
-            `${riskName}_${exchangeName}`,
-            `./dump/data/risk/`,
-        ]));
-        /**
-         * Reads persisted active positions for a risk profile.
-         *
-         * Called by ClientRisk.waitForInit() to restore state.
-         * Returns empty Map if no positions exist.
-         *
-         * @param riskName - Risk profile identifier
-         * @param exchangeName - Exchange identifier
-         * @returns Promise resolving to Map of active positions
-         */
-        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);
+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;
+    }
+    /**
+     * Fetches future candles forwards from execution context time.
+     * Used in backtest mode to get candles for signal duration.
+     *
+     * @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
+     */
+    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 [];
-        };
-        /**
-         * 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.
-         *
-         * @param positions - Map of active positions
-         * @param riskName - Risk profile identifier
-         * @param exchangeName - Exchange identifier
-         * @returns Promise that resolves when write is 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);
-            await stateStorage.waitForInit(isInitial);
-            const RISK_STORAGE_KEY = "positions";
-            await stateStorage.writeValue(RISK_STORAGE_KEY, riskRow);
-        };
+        }
+        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 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)); }
-     * }
-     * PersistRiskAdapter.usePersistRiskAdapter(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
      */
-    usePersistRiskAdapter(Ctor) {
-        bt.loggerService.info(PERSIST_RISK_UTILS_METHOD_NAME_USE_PERSIST_RISK_ADAPTER);
-        this.PersistRiskFactory = 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_RISK_UTILS_METHOD_NAME_USE_JSON);
-        this.usePersistRiskAdapter(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_RISK_UTILS_METHOD_NAME_USE_DUMMY);
-        this.usePersistRiskAdapter(PersistDummy);
+    async formatPrice(symbol, price) {
+        this.params.logger.debug("binanceService formatPrice", {
+            symbol,
+            price,
+        });
+        return await this.params.formatPrice(symbol, price, this.params.execution.context.backtest);
     }
-}
-/**
- * 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 = functoolsKit.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);
+    /**
+     * 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)
+     *
+     * 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
+     */
+    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);
+                }
             }
-            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: 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;
     }
     /**
-     * Registers a custom persistence adapter.
+     * Fetches order book for a trading pair.
      *
-     * @param Ctor - Custom PersistBase constructor
+     * 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.
      *
-     * @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;
-    }
-    /**
-     * 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);
-    }
-    /**
-     * Switches to a dummy persist adapter that discards all writes.
-     * All future persistence writes will be no-ops.
+     * @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_SCHEDULE_UTILS_METHOD_NAME_USE_DUMMY);
-        this.usePersistScheduleAdapter(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 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");
+ * 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.
  *
- * // Write scheduled signal
- * await PersistScheduleAdapter.writeScheduleData(scheduled, "my-strategy", "BTCUSDT");
- * ```
+ * @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 PersistScheduleAdapter = new PersistScheduleUtils();
+const DEFAULT_GET_ORDER_BOOK_FN$1 = async (_symbol, _depth, _from, _to, _backtest) => {
+    throw new Error(`getOrderBook is not implemented for this exchange`);
+};
 /**
- * Utility class for managing partial profit/loss levels persistence.
+ * Connection service routing exchange operations to correct ClientExchange instance.
  *
- * Features:
- * - Memoized storage instances per symbol:strategyName
- * - Custom adapter support
- * - Atomic read/write operations for partial data
- * - Crash-safe partial state management
+ * Routes all IExchange method calls to the appropriate exchange implementation
+ * based on methodContextService.context.exchangeName. Uses memoization to cache
+ * ClientExchange instances for performance.
  *
- * Used by ClientPartial for live mode persistence of profit/loss levels.
+ * Key features:
+ * - Automatic exchange routing via method context
+ * - Memoized ClientExchange instances by exchangeName
+ * - Implements full IExchange interface
+ * - Logging for all operations
+ *
+ * @example
+ * ```typescript
+ * // Used internally by framework
+ * const candles = await exchangeConnectionService.getCandles(
+ *   "BTCUSDT", "1h", 100
+ * );
+ * // Automatically routes to correct exchange based on methodContext
+ * ```
  */
-class PersistPartialUtils {
+class ExchangeConnectionService {
     constructor() {
-        this.PersistPartialFactory = PersistBase;
-        this.getPartialStorage = functoolsKit.memoize(([symbol, strategyName, exchangeName]) => `${symbol}:${strategyName}:${exchangeName}`, (symbol, strategyName, exchangeName) => Reflect.construct(this.PersistPartialFactory, [
-            `${symbol}_${strategyName}_${exchangeName}`,
-            `./dump/data/partial/`,
-        ]));
+        this.loggerService = inject(TYPES.loggerService);
+        this.executionContextService = inject(TYPES.executionContextService);
+        this.exchangeSchemaService = inject(TYPES.exchangeSchemaService);
+        this.methodContextService = inject(TYPES.methodContextService);
         /**
-         * Reads persisted partial data for a symbol and strategy.
+         * Retrieves memoized ClientExchange instance for given exchange name.
          *
-         * Called by ClientPartial.waitForInit() to restore state.
-         * Returns empty object if no partial data exists.
+         * Creates ClientExchange on first call, returns cached instance on subsequent calls.
+         * Cache key is exchangeName string.
          *
-         * @param symbol - Trading pair symbol
-         * @param strategyName - Strategy identifier
-         * @param signalId - Signal identifier
-         * @param exchangeName - Exchange identifier
-         * @returns Promise resolving to partial data record
+         * @param exchangeName - Name of registered exchange schema
+         * @returns Configured ClientExchange instance
          */
-        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 {};
+        this.getExchange = functoolsKit.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,
+            });
+        });
+        /**
+         * 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.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);
+        };
+        /**
+         * Fetches next batch of candles relative to executionContext.when.
+         *
+         * 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.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);
+        };
+        /**
+         * Retrieves current average price for symbol.
+         *
+         * 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 (e.g., "BTCUSDT")
+         * @returns Promise resolving to average price
+         */
+        this.getAveragePrice = async (symbol) => {
+            this.loggerService.log("exchangeConnectionService getAveragePrice", {
+                symbol,
+            });
+            return await this.getExchange(this.methodContextService.context.exchangeName).getAveragePrice(symbol);
+        };
+        /**
+         * Formats price according to exchange-specific precision rules.
+         *
+         * Ensures price meets exchange requirements for decimal places and tick size.
+         *
+         * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+         * @param price - Raw price value to format
+         * @returns Promise resolving to formatted price string
+         */
+        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);
         };
         /**
-         * Writes partial data to disk with atomic file writes.
+         * Fetches raw candles with flexible date/limit parameters.
          *
-         * Called by ClientPartial after profit/loss level changes to persist state.
-         * Uses atomic writes to prevent corruption on crashes.
+         * Routes to exchange determined by methodContextService.context.exchangeName.
          *
-         * @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
+         * @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.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);
+        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)); }
-     * }
-     * 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.
-     */
-    useJson() {
-        bt.loggerService.log(PERSIST_PARTIAL_UTILS_METHOD_NAME_USE_JSON);
-        this.usePersistPartialAdapter(PersistBase);
-    }
-    /**
-     * Switches to a dummy persist adapter that discards all writes.
-     * All future persistence writes will be no-ops.
-     */
-    useDummy() {
-        bt.loggerService.log(PERSIST_PARTIAL_UTILS_METHOD_NAME_USE_DUMMY);
-        this.usePersistPartialAdapter(PersistDummy);
-    }
 }
+
 /**
- * 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.
+ * Calculates profit/loss for a closed signal with slippage and fees.
  *
- * Handles reading and writing breakeven state to disk.
- * Uses memoized PersistBase instances per symbol-strategy pair.
+ * 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
  *
- * Features:
- * - Atomic file writes via PersistBase.writeValue()
- * - Lazy initialization on first access
- * - Singleton pattern for global access
- * - Custom adapter support via usePersistBreakevenAdapter()
+ * 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)
  *
- * File structure:
- * ```
- * ./dump/data/breakeven/
- * ├── BTCUSDT_my-strategy/
- * │   └── state.json        // { "signal-id-1": { reached: true }, ... }
- * └── ETHUSDT_other-strategy/
- *     └── state.json
- * ```
+ * @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
- * // Read breakeven data
- * const breakevenData = await PersistBreakevenAdapter.readBreakevenData("BTCUSDT", "my-strategy");
- * // Returns: { "signal-id": { reached: true }, ... }
+ * // 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)
  * ```
  */
-class PersistBreakevenUtils {
-    constructor() {
-        /**
-         * 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 = functoolsKit.memoize(([symbol, strategyName, exchangeName]) => `${symbol}:${strategyName}:${exchangeName}`, (symbol, strategyName, exchangeName) => Reflect.construct(this.PersistBreakevenFactory, [
-            `${symbol}_${strategyName}_${exchangeName}`,
-            `./dump/data/breakeven/`,
-        ]));
-        /**
-         * Reads persisted breakeven data for a symbol and strategy.
-         *
-         * 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 breakeven data record
-         */
-        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);
+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);
             }
-            return {};
-        };
-        /**
-         * Writes breakeven data to disk.
-         *
-         * Called by ClientBreakeven._persistState() after state changes.
-         * Creates directory and file if they don't exist.
-         * Uses atomic writes to prevent data corruption.
-         *
-         * @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.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);
+            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,
         };
     }
-    /**
-     * 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;
+    // 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);
     }
-    /**
-     * 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);
+    else {
+        // SHORT: продаем дешевле, покупаем дороже
+        priceOpenWithSlippage = priceOpen * (1 - GLOBAL_CONFIG.CC_PERCENT_SLIPPAGE / 100);
+        priceCloseWithSlippage = priceClose * (1 + GLOBAL_CONFIG.CC_PERCENT_SLIPPAGE / 100);
     }
-    /**
-     * 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);
+    // Применяем комиссию дважды (при открытии и закрытии)
+    const totalFee = GLOBAL_CONFIG.CC_PERCENT_FEE * 2;
+    let pnlPercentage;
+    if (signal.position === "long") {
+        // LONG: прибыль при росте цены
+        pnlPercentage =
+            ((priceCloseWithSlippage - priceOpenWithSlippage) /
+                priceOpenWithSlippage) *
+                100;
     }
-}
-/**
- * Global singleton instance of PersistBreakevenUtils.
- * Used by ClientBreakeven for breakeven state persistence.
- *
- * @example
- * ```typescript
- * // Custom adapter
- * PersistBreakevenAdapter.usePersistBreakevenAdapter(RedisPersist);
- *
- * // Read breakeven data
- * const breakevenData = await PersistBreakevenAdapter.readBreakevenData("BTCUSDT", "my-strategy");
- *
- * // Write breakeven data
- * await PersistBreakevenAdapter.writeBreakevenData(breakevenData, "BTCUSDT", "my-strategy");
- * ```
- */
-const PersistBreakevenAdapter = new PersistBreakevenUtils();
+    else {
+        // SHORT: прибыль при падении цены
+        pnlPercentage =
+            ((priceOpenWithSlippage - priceCloseWithSlippage) /
+                priceOpenWithSlippage) *
+                100;
+    }
+    // Вычитаем комиссии
+    pnlPercentage -= totalFee;
+    return {
+        pnlPercentage,
+        priceOpen,
+        priceClose,
+    };
+};
 
 /**
  * Converts markdown content to plain text with minimal formatting
@@ -9625,6 +9998,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,
+            });
+        };
     }
 }
 
@@ -24928,6 +25335,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).
  *
@@ -25185,6 +25593,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";
@@ -31456,6 +31911,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).
@@ -31531,6 +31988,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 = functoolsKit.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: functoolsKit.errorData(error),
+            message: functoolsKit.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 = functoolsKit.trycatch(functoolsKit.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: functoolsKit.errorData(error),
+            message: functoolsKit.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.
  *
@@ -31588,6 +32100,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) {
@@ -31610,7 +32129,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);
@@ -31622,6 +32140,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;
         };
         /**
@@ -31746,6 +32266,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);
     }
@@ -31850,6 +32515,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);
+        };
     }
 }
 /**
@@ -33000,6 +33683,7 @@ exports.Partial = Partial;
 exports.Performance = Performance;
 exports.PersistBase = PersistBase;
 exports.PersistBreakevenAdapter = PersistBreakevenAdapter;
+exports.PersistCandleAdapter = PersistCandleAdapter;
 exports.PersistPartialAdapter = PersistPartialAdapter;
 exports.PersistRiskAdapter = PersistRiskAdapter;
 exports.PersistScheduleAdapter = PersistScheduleAdapter;
@@ -33046,6 +33730,7 @@ exports.getFrameSchema = getFrameSchema;
 exports.getMode = getMode;
 exports.getOptimizerSchema = getOptimizerSchema;
 exports.getOrderBook = getOrderBook;
+exports.getRawCandles = getRawCandles;
 exports.getRiskSchema = getRiskSchema;
 exports.getSizingSchema = getSizingSchema;
 exports.getStrategySchema = getStrategySchema;