backtest-kit 3.0.10 → 3.0.12

package/build/index.mjs

@@ -2,7 +2,7 @@ import { createActivator } from 'di-kit';
 import { scoped } from 'di-scoped';
 import { Subject, makeExtendable, singleshot, getErrorMessage, memoize, not, errorData, trycatch, retry, queued, sleep, randomString, str, isObject, ToolRegistry, typo, and, resolveDocuments, timeout, TIMEOUT_SYMBOL as TIMEOUT_SYMBOL$1, compose, singlerun } from 'functools-kit';
 import * as fs from 'fs/promises';
-import fs__default from 'fs/promises';
+import fs__default, { stat, opendir, readFile } from 'fs/promises';
 import path, { join, dirname } from 'path';
 import crypto from 'crypto';
 import os from 'os';
@@ -695,7 +695,7 @@ async function writeFileAtomic(file, data, options = {}) {
 var _a$2;
 const BASE_WAIT_FOR_INIT_SYMBOL = Symbol("wait-for-init");
 // Calculate step in milliseconds for candle close time validation
-const INTERVAL_MINUTES$5 = {
+const INTERVAL_MINUTES$6 = {
     "1m": 1,
     "3m": 3,
     "5m": 5,
@@ -707,7 +707,7 @@ const INTERVAL_MINUTES$5 = {
     "6h": 360,
     "8h": 480,
 };
-const MS_PER_MINUTE$3 = 60000;
+const MS_PER_MINUTE$4 = 60000;
 const PERSIST_SIGNAL_UTILS_METHOD_NAME_USE_PERSIST_SIGNAL_ADAPTER = "PersistSignalUtils.usePersistSignalAdapter";
 const PERSIST_SIGNAL_UTILS_METHOD_NAME_READ_DATA = "PersistSignalUtils.readSignalData";
 const PERSIST_SIGNAL_UTILS_METHOD_NAME_WRITE_DATA = "PersistSignalUtils.writeSignalData";
@@ -1605,7 +1605,7 @@ class PersistCandleUtils {
             const isInitial = !this.getCandlesStorage.has(key);
             const stateStorage = this.getCandlesStorage(symbol, interval, exchangeName);
             await stateStorage.waitForInit(isInitial);
-            const stepMs = INTERVAL_MINUTES$5[interval] * MS_PER_MINUTE$3;
+            const stepMs = INTERVAL_MINUTES$6[interval] * MS_PER_MINUTE$4;
             // Calculate expected timestamps and fetch each candle directly
             const cachedCandles = [];
             for (let i = 0; i < limit; i++) {
@@ -1661,7 +1661,7 @@ class PersistCandleUtils {
             const stateStorage = this.getCandlesStorage(symbol, interval, exchangeName);
             await stateStorage.waitForInit(isInitial);
             // Calculate step in milliseconds to determine candle close time
-            const stepMs = INTERVAL_MINUTES$5[interval] * MS_PER_MINUTE$3;
+            const stepMs = INTERVAL_MINUTES$6[interval] * MS_PER_MINUTE$4;
             const now = Date.now();
             // Write each candle as a separate file, skipping incomplete candles
             for (const candle of candles) {
@@ -1918,8 +1918,8 @@ class PersistNotificationUtils {
  */
 const PersistNotificationAdapter = new PersistNotificationUtils();
 
-const MS_PER_MINUTE$2 = 60000;
-const INTERVAL_MINUTES$4 = {
+const MS_PER_MINUTE$3 = 60000;
+const INTERVAL_MINUTES$5 = {
     "1m": 1,
     "3m": 3,
     "5m": 5,
@@ -1948,8 +1948,8 @@ const INTERVAL_MINUTES$4 = {
  * @param intervalMinutes - Interval in minutes
  * @returns Aligned timestamp rounded down to interval boundary
  */
-const ALIGN_TO_INTERVAL_FN$1 = (timestamp, intervalMinutes) => {
-    const intervalMs = intervalMinutes * MS_PER_MINUTE$2;
+const ALIGN_TO_INTERVAL_FN$2 = (timestamp, intervalMinutes) => {
+    const intervalMs = intervalMinutes * MS_PER_MINUTE$3;
     return Math.floor(timestamp / intervalMs) * intervalMs;
 };
 /**
@@ -2094,9 +2094,9 @@ const WRITE_CANDLES_CACHE_FN$1 = trycatch(queued(async (candles, dto, self) => {
  * @returns Promise resolving to array of candle data
  */
 const GET_CANDLES_FN = async (dto, since, self) => {
-    const step = INTERVAL_MINUTES$4[dto.interval];
+    const step = INTERVAL_MINUTES$5[dto.interval];
     const sinceTimestamp = since.getTime();
-    const untilTimestamp = sinceTimestamp + dto.limit * step * MS_PER_MINUTE$2;
+    const untilTimestamp = sinceTimestamp + dto.limit * step * MS_PER_MINUTE$3;
     // Try to read from cache first
     const cachedCandles = await READ_CANDLES_CACHE_FN$1(dto, sinceTimestamp, untilTimestamp, self);
     if (cachedCandles !== null) {
@@ -2204,14 +2204,14 @@ class ClientExchange {
             interval,
             limit,
         });
-        const step = INTERVAL_MINUTES$4[interval];
+        const step = INTERVAL_MINUTES$5[interval];
         if (!step) {
             throw new Error(`ClientExchange unknown interval=${interval}`);
         }
-        const stepMs = step * MS_PER_MINUTE$2;
+        const stepMs = step * MS_PER_MINUTE$3;
         // Align when down to interval boundary
         const whenTimestamp = this.params.execution.context.when.getTime();
-        const alignedWhen = ALIGN_TO_INTERVAL_FN$1(whenTimestamp, step);
+        const alignedWhen = ALIGN_TO_INTERVAL_FN$2(whenTimestamp, step);
         // Calculate since: go back limit candles from aligned when
         const sinceTimestamp = alignedWhen - limit * stepMs;
         const since = new Date(sinceTimestamp);
@@ -2285,15 +2285,15 @@ class ClientExchange {
         if (!this.params.execution.context.backtest) {
             throw new Error(`ClientExchange getNextCandles: cannot fetch future candles in live mode`);
         }
-        const step = INTERVAL_MINUTES$4[interval];
+        const step = INTERVAL_MINUTES$5[interval];
         if (!step) {
             throw new Error(`ClientExchange getNextCandles: unknown interval=${interval}`);
         }
-        const stepMs = step * MS_PER_MINUTE$2;
+        const stepMs = step * MS_PER_MINUTE$3;
         const now = Date.now();
         // Align when down to interval boundary
         const whenTimestamp = this.params.execution.context.when.getTime();
-        const alignedWhen = ALIGN_TO_INTERVAL_FN$1(whenTimestamp, step);
+        const alignedWhen = ALIGN_TO_INTERVAL_FN$2(whenTimestamp, step);
         // since = alignedWhen (start from aligned when, going forward)
         const sinceTimestamp = alignedWhen;
         const since = new Date(sinceTimestamp);
@@ -2453,13 +2453,13 @@ class ClientExchange {
             sDate,
             eDate,
         });
-        const step = INTERVAL_MINUTES$4[interval];
+        const step = INTERVAL_MINUTES$5[interval];
         if (!step) {
             throw new Error(`ClientExchange getRawCandles: unknown interval=${interval}`);
         }
-        const stepMs = step * MS_PER_MINUTE$2;
+        const stepMs = step * MS_PER_MINUTE$3;
         const whenTimestamp = this.params.execution.context.when.getTime();
-        const alignedWhen = ALIGN_TO_INTERVAL_FN$1(whenTimestamp, step);
+        const alignedWhen = ALIGN_TO_INTERVAL_FN$2(whenTimestamp, step);
         let sinceTimestamp;
         let calculatedLimit;
         // Case 1: all three parameters provided
@@ -2471,7 +2471,7 @@ class ClientExchange {
                 throw new Error(`ClientExchange getRawCandles: eDate (${eDate}) exceeds execution context when (${whenTimestamp}). Look-ahead bias protection.`);
             }
             // Align sDate down to interval boundary
-            sinceTimestamp = ALIGN_TO_INTERVAL_FN$1(sDate, step);
+            sinceTimestamp = ALIGN_TO_INTERVAL_FN$2(sDate, step);
             calculatedLimit = limit;
         }
         // Case 2: sDate + eDate (no limit) - calculate limit from date range
@@ -2483,8 +2483,8 @@ class ClientExchange {
                 throw new Error(`ClientExchange getRawCandles: eDate (${eDate}) exceeds execution context when (${whenTimestamp}). Look-ahead bias protection.`);
             }
             // Align sDate down to interval boundary
-            sinceTimestamp = ALIGN_TO_INTERVAL_FN$1(sDate, step);
-            const alignedEDate = ALIGN_TO_INTERVAL_FN$1(eDate, step);
+            sinceTimestamp = ALIGN_TO_INTERVAL_FN$2(sDate, step);
+            const alignedEDate = ALIGN_TO_INTERVAL_FN$2(eDate, step);
             calculatedLimit = Math.ceil((alignedEDate - sinceTimestamp) / stepMs);
             if (calculatedLimit <= 0) {
                 throw new Error(`ClientExchange getRawCandles: calculated limit is ${calculatedLimit}, must be > 0`);
@@ -2496,14 +2496,14 @@ class ClientExchange {
                 throw new Error(`ClientExchange getRawCandles: eDate (${eDate}) exceeds execution context when (${whenTimestamp}). Look-ahead bias protection.`);
             }
             // Align eDate down and calculate sinceTimestamp
-            const alignedEDate = ALIGN_TO_INTERVAL_FN$1(eDate, step);
+            const alignedEDate = ALIGN_TO_INTERVAL_FN$2(eDate, step);
             sinceTimestamp = alignedEDate - limit * stepMs;
             calculatedLimit = limit;
         }
         // Case 4: sDate + limit (no eDate) - calculate eDate forward from sDate
         else if (sDate !== undefined && eDate === undefined && limit !== undefined) {
             // Align sDate down to interval boundary
-            sinceTimestamp = ALIGN_TO_INTERVAL_FN$1(sDate, step);
+            sinceTimestamp = ALIGN_TO_INTERVAL_FN$2(sDate, step);
             const endTimestamp = sinceTimestamp + limit * stepMs;
             if (endTimestamp > whenTimestamp) {
                 throw new Error(`ClientExchange getRawCandles: calculated endTimestamp (${endTimestamp}) exceeds execution context when (${whenTimestamp}). Look-ahead bias protection.`);
@@ -2583,10 +2583,10 @@ class ClientExchange {
             depth,
         });
         const whenTimestamp = this.params.execution.context.when.getTime();
-        const alignedTo = ALIGN_TO_INTERVAL_FN$1(whenTimestamp, GLOBAL_CONFIG.CC_ORDER_BOOK_TIME_OFFSET_MINUTES);
+        const alignedTo = ALIGN_TO_INTERVAL_FN$2(whenTimestamp, GLOBAL_CONFIG.CC_ORDER_BOOK_TIME_OFFSET_MINUTES);
         const to = new Date(alignedTo);
         const from = new Date(alignedTo -
-            GLOBAL_CONFIG.CC_ORDER_BOOK_TIME_OFFSET_MINUTES * MS_PER_MINUTE$2);
+            GLOBAL_CONFIG.CC_ORDER_BOOK_TIME_OFFSET_MINUTES * MS_PER_MINUTE$3);
         return await this.params.getOrderBook(symbol, depth, from, to, this.params.execution.context.backtest);
     }
 }
@@ -3051,7 +3051,7 @@ const beginTime = (run) => (...args) => {
     return fn();
 };
 
-const INTERVAL_MINUTES$3 = {
+const INTERVAL_MINUTES$4 = {
     "1m": 1,
     "3m": 3,
     "5m": 5,
@@ -3564,7 +3564,7 @@ const GET_SIGNAL_FN = trycatch(async (self) => {
     }
     const currentTime = self.params.execution.context.when.getTime();
     {
-        const intervalMinutes = INTERVAL_MINUTES$3[self.params.interval];
+        const intervalMinutes = INTERVAL_MINUTES$4[self.params.interval];
         const intervalMs = intervalMinutes * 60 * 1000;
         // Проверяем что прошел нужный интервал с последнего getSignal
         if (self._lastSignalTimestamp !== null &&
@@ -8175,7 +8175,7 @@ class StrategyConnectionService {
  * Maps FrameInterval to minutes for timestamp calculation.
  * Used to generate timeframe arrays with proper spacing.
  */
-const INTERVAL_MINUTES$2 = {
+const INTERVAL_MINUTES$3 = {
     "1m": 1,
     "3m": 3,
     "5m": 5,
@@ -8230,7 +8230,7 @@ const GET_TIMEFRAME_FN = async (symbol, self) => {
         symbol,
     });
     const { interval, startDate, endDate } = self.params;
-    const intervalMinutes = INTERVAL_MINUTES$2[interval];
+    const intervalMinutes = INTERVAL_MINUTES$3[interval];
     if (!intervalMinutes) {
         throw new Error(`ClientFrame unknown interval: ${interval}`);
     }
@@ -26020,402 +26020,1262 @@ async function getBacktestTimeframe(symbol) {
     return await bt.frameCoreService.getTimeframe(symbol, bt.methodContextService.context.frameName);
 }
 
-const METHOD_NAME = "validate.validate";
+const EXCHANGE_METHOD_NAME_GET_CANDLES = "ExchangeUtils.getCandles";
+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$2 = 60000;
 /**
- * Retrieves all registered exchanges as a map
- * @private
- * @returns Map of exchange names
+ * Gets current timestamp from execution context if available.
+ * Returns current Date() if no execution context exists (non-trading GUI).
  */
-const getExchangeMap = async () => {
-    const exchangeMap = {};
-    for (const { exchangeName } of await bt.exchangeValidationService.list()) {
-        Object.assign(exchangeMap, { [exchangeName]: exchangeName });
+const GET_TIMESTAMP_FN = async () => {
+    if (ExecutionContextService.hasContext()) {
+        return new Date(bt.executionContextService.context.when);
     }
-    return exchangeMap;
+    return new Date();
 };
 /**
- * Retrieves all registered frames as a map
- * @private
- * @returns Map of frame names
+ * Gets backtest mode flag from execution context if available.
+ * Returns false if no execution context exists (live mode).
  */
-const getFrameMap = async () => {
-    const frameMap = {};
-    for (const { frameName } of await bt.frameValidationService.list()) {
-        Object.assign(frameMap, { [frameName]: frameName });
+const GET_BACKTEST_FN = async () => {
+    if (ExecutionContextService.hasContext()) {
+        return bt.executionContextService.context.backtest;
     }
-    return frameMap;
+    return false;
 };
 /**
- * Retrieves all registered strategies as a map
- * @private
- * @returns Map of strategy names
+ * Default implementation for getCandles.
+ * Throws an error indicating the method is not implemented.
  */
-const getStrategyMap = async () => {
-    const strategyMap = {};
-    for (const { strategyName } of await bt.strategyValidationService.list()) {
-        Object.assign(strategyMap, { [strategyName]: strategyName });
-    }
-    return strategyMap;
+const DEFAULT_GET_CANDLES_FN = async (_symbol, _interval, _since, _limit, _backtest) => {
+    throw new Error(`getCandles is not implemented for this exchange`);
 };
 /**
- * Retrieves all registered risk profiles as a map
- * @private
- * @returns Map of risk names
+ * Default implementation for formatQuantity.
+ * Returns Bitcoin precision on Binance (8 decimal places).
  */
-const getRiskMap = async () => {
-    const riskMap = {};
-    for (const { riskName } of await bt.riskValidationService.list()) {
-        Object.assign(riskMap, { [riskName]: riskName });
-    }
-    return riskMap;
+const DEFAULT_FORMAT_QUANTITY_FN = async (_symbol, quantity, _backtest) => {
+    return quantity.toFixed(8);
 };
 /**
- * Retrieves all registered action handlers as a map
- * @private
- * @returns Map of action names
+ * Default implementation for formatPrice.
+ * Returns Bitcoin precision on Binance (2 decimal places).
  */
-const getActionMap = async () => {
-    const actionMap = {};
-    for (const { actionName } of await bt.actionValidationService.list()) {
-        Object.assign(actionMap, { [actionName]: actionName });
-    }
-    return actionMap;
+const DEFAULT_FORMAT_PRICE_FN = async (_symbol, price, _backtest) => {
+    return price.toFixed(2);
 };
 /**
- * Retrieves all registered sizing strategies as a map
- * @private
- * @returns Map of sizing names
+ * 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 getSizingMap = async () => {
-    const sizingMap = {};
-    for (const { sizingName } of await bt.sizingValidationService.list()) {
-        Object.assign(sizingMap, { [sizingName]: sizingName });
-    }
-    return sizingMap;
+const DEFAULT_GET_ORDER_BOOK_FN = async (_symbol, _depth, _from, _to, _backtest) => {
+    throw new Error(`getOrderBook is not implemented for this exchange`);
 };
-/**
- * Retrieves all registered walkers as a map
- * @private
- * @returns Map of walker names
- */
-const getWalkerMap = async () => {
-    const walkerMap = {};
-    for (const { walkerName } of await bt.walkerValidationService.list()) {
-        Object.assign(walkerMap, { [walkerName]: walkerName });
-    }
-    return walkerMap;
+const INTERVAL_MINUTES$2 = {
+    "1m": 1,
+    "3m": 3,
+    "5m": 5,
+    "15m": 15,
+    "30m": 30,
+    "1h": 60,
+    "2h": 120,
+    "4h": 240,
+    "6h": 360,
+    "8h": 480,
 };
 /**
- * Internal validation function that processes all provided entity enums.
+ * Aligns timestamp down to the nearest interval boundary.
+ * For example, for 15m interval: 00:17 -> 00:15, 00:44 -> 00:30
  *
- * Iterates through each enum's values and validates them against their
- * respective validation services. Uses memoized validation for performance.
+ * Candle timestamp convention:
+ * - Candle timestamp = openTime (when candle opens)
+ * - Candle with timestamp 00:00 covers period [00:00, 00:15) for 15m interval
  *
- * If entity enums are not provided, fetches all registered entities from
- * their respective validation services and validates them.
+ * Adapter contract:
+ * - Adapter must return candles with timestamp = openTime
+ * - First returned candle.timestamp must equal aligned since
+ * - Adapter must return exactly `limit` candles
  *
- * @private
- * @param args - Validation arguments containing entity name enums
- * @throws {Error} If any entity name is not found in its registry
+ * @param timestamp - Timestamp in milliseconds
+ * @param intervalMinutes - Interval in minutes
+ * @returns Aligned timestamp rounded down to interval boundary
  */
-const validateInternal = async (args) => {
-    const { ExchangeName = await getExchangeMap(), FrameName = await getFrameMap(), StrategyName = await getStrategyMap(), RiskName = await getRiskMap(), ActionName = await getActionMap(), SizingName = await getSizingMap(), WalkerName = await getWalkerMap(), } = args;
-    for (const exchangeName of Object.values(ExchangeName)) {
-        bt.exchangeValidationService.validate(exchangeName, METHOD_NAME);
-    }
-    for (const frameName of Object.values(FrameName)) {
-        bt.frameValidationService.validate(frameName, METHOD_NAME);
-    }
-    for (const strategyName of Object.values(StrategyName)) {
-        bt.strategyValidationService.validate(strategyName, METHOD_NAME);
-    }
-    for (const riskName of Object.values(RiskName)) {
-        bt.riskValidationService.validate(riskName, METHOD_NAME);
-    }
-    for (const actionName of Object.values(ActionName)) {
-        bt.actionValidationService.validate(actionName, METHOD_NAME);
-    }
-    for (const sizingName of Object.values(SizingName)) {
-        bt.sizingValidationService.validate(sizingName, METHOD_NAME);
-    }
-    for (const walkerName of Object.values(WalkerName)) {
-        bt.walkerValidationService.validate(walkerName, METHOD_NAME);
-    }
+const ALIGN_TO_INTERVAL_FN$1 = (timestamp, intervalMinutes) => {
+    const intervalMs = intervalMinutes * MS_PER_MINUTE$2;
+    return Math.floor(timestamp / intervalMs) * intervalMs;
 };
 /**
- * Validates the existence of all provided entity names across validation services.
- *
- * This function accepts enum objects for various entity types (exchanges, frames,
- * strategies, risks, sizings, walkers) and validates that each entity
- * name exists in its respective registry. Validation results are memoized for performance.
- *
- * If no arguments are provided (or specific entity types are omitted), the function
- * automatically fetches and validates ALL registered entities from their respective
- * validation services. This is useful for comprehensive validation of the entire setup.
- *
- * Use this before running backtests or optimizations to ensure all referenced
- * entities are properly registered and configured.
- *
- * @public
- * @param args - Partial validation arguments containing entity name enums to validate.
- *                If empty or omitted, validates all registered entities.
- * @throws {Error} If any entity name is not found in its validation service
- *
- * @example
- * ```typescript
- * // Validate ALL registered entities (exchanges, frames, strategies, etc.)
- * await validate({});
- * ```
- *
- * @example
- * ```typescript
- * // Define your entity name enums
- * enum ExchangeName {
- *   BINANCE = "binance",
- *   BYBIT = "bybit"
- * }
- *
- * enum StrategyName {
- *   MOMENTUM_BTC = "momentum-btc"
- * }
- *
- * // Validate specific entities before running backtest
- * await validate({
- *   ExchangeName,
- *   StrategyName,
- * });
- * ```
- *
- * @example
- * ```typescript
- * // Validate specific entity types
- * await validate({
- *   RiskName: { CONSERVATIVE: "conservative" },
- *   SizingName: { FIXED_1000: "fixed-1000" },
- * });
- * ```
- */
-async function validate(args = {}) {
-    bt.loggerService.log(METHOD_NAME);
-    return await validateInternal(args);
-}
-
-const GET_STRATEGY_METHOD_NAME = "get.getStrategySchema";
-const GET_EXCHANGE_METHOD_NAME = "get.getExchangeSchema";
-const GET_FRAME_METHOD_NAME = "get.getFrameSchema";
-const GET_WALKER_METHOD_NAME = "get.getWalkerSchema";
-const GET_SIZING_METHOD_NAME = "get.getSizingSchema";
-const GET_RISK_METHOD_NAME = "get.getRiskSchema";
-const GET_ACTION_METHOD_NAME = "get.getActionSchema";
-/**
- * Retrieves a registered strategy schema by name.
- *
- * @param strategyName - Unique strategy identifier
- * @returns The strategy schema configuration object
- * @throws Error if strategy is not registered
- *
- * @example
- * ```typescript
- * const strategy = getStrategy("my-strategy");
- * console.log(strategy.interval); // "5m"
- * console.log(strategy.getSignal); // async function
- * ```
- */
-function getStrategySchema(strategyName) {
-    bt.loggerService.log(GET_STRATEGY_METHOD_NAME, {
-        strategyName,
-    });
-    bt.strategyValidationService.validate(strategyName, GET_STRATEGY_METHOD_NAME);
-    return bt.strategySchemaService.get(strategyName);
-}
-/**
- * Retrieves a registered exchange schema by name.
- *
- * @param exchangeName - Unique exchange identifier
- * @returns The exchange schema configuration object
- * @throws Error if exchange is not registered
- *
- * @example
- * ```typescript
- * const exchange = getExchange("binance");
- * console.log(exchange.getCandles); // async function
- * console.log(exchange.formatPrice); // async function
- * ```
- */
-function getExchangeSchema(exchangeName) {
-    bt.loggerService.log(GET_EXCHANGE_METHOD_NAME, {
-        exchangeName,
-    });
-    bt.exchangeValidationService.validate(exchangeName, GET_EXCHANGE_METHOD_NAME);
-    return bt.exchangeSchemaService.get(exchangeName);
-}
-/**
- * Retrieves a registered frame schema by name.
- *
- * @param frameName - Unique frame identifier
- * @returns The frame schema configuration object
- * @throws Error if frame is not registered
- *
- * @example
- * ```typescript
- * const frame = getFrame("1d-backtest");
- * console.log(frame.interval); // "1m"
- * console.log(frame.startDate); // Date object
- * console.log(frame.endDate); // Date object
- * ```
- */
-function getFrameSchema(frameName) {
-    bt.loggerService.log(GET_FRAME_METHOD_NAME, {
-        frameName,
-    });
-    bt.frameValidationService.validate(frameName, GET_FRAME_METHOD_NAME);
-    return bt.frameSchemaService.get(frameName);
-}
-/**
- * Retrieves a registered walker schema by name.
- *
- * @param walkerName - Unique walker identifier
- * @returns The walker schema configuration object
- * @throws Error if walker is not registered
- *
- * @example
- * ```typescript
- * const walker = getWalker("llm-prompt-optimizer");
- * console.log(walker.exchangeName); // "binance"
- * console.log(walker.frameName); // "1d-backtest"
- * console.log(walker.strategies); // ["my-strategy-v1", "my-strategy-v2"]
- * console.log(walker.metric); // "sharpeRatio"
- * ```
- */
-function getWalkerSchema(walkerName) {
-    bt.loggerService.log(GET_WALKER_METHOD_NAME, {
-        walkerName,
-    });
-    bt.walkerValidationService.validate(walkerName, GET_WALKER_METHOD_NAME);
-    return bt.walkerSchemaService.get(walkerName);
-}
-/**
- * Retrieves a registered sizing schema by name.
- *
- * @param sizingName - Unique sizing identifier
- * @returns The sizing schema configuration object
- * @throws Error if sizing is not registered
+ * Creates exchange instance with methods resolved once during construction.
+ * Applies default implementations where schema methods are not provided.
  *
- * @example
- * ```typescript
- * const sizing = getSizing("conservative");
- * console.log(sizing.method); // "fixed-percentage"
- * console.log(sizing.riskPercentage); // 1
- * console.log(sizing.maxPositionPercentage); // 10
- * ```
+ * @param schema - Exchange schema from registry
+ * @returns Object with resolved exchange methods
  */
-function getSizingSchema(sizingName) {
-    bt.loggerService.log(GET_SIZING_METHOD_NAME, {
-        sizingName,
-    });
-    bt.sizingValidationService.validate(sizingName, GET_SIZING_METHOD_NAME);
-    return bt.sizingSchemaService.get(sizingName);
-}
+const CREATE_EXCHANGE_INSTANCE_FN = (schema) => {
+    const getCandles = schema.getCandles ?? DEFAULT_GET_CANDLES_FN;
+    const formatQuantity = schema.formatQuantity ?? DEFAULT_FORMAT_QUANTITY_FN;
+    const formatPrice = schema.formatPrice ?? DEFAULT_FORMAT_PRICE_FN;
+    const getOrderBook = schema.getOrderBook ?? DEFAULT_GET_ORDER_BOOK_FN;
+    return {
+        getCandles,
+        formatQuantity,
+        formatPrice,
+        getOrderBook,
+    };
+};
 /**
- * Retrieves a registered risk schema by name.
+ * Attempts to read candles from cache.
  *
- * @param riskName - Unique risk identifier
- * @returns The risk schema configuration object
- * @throws Error if risk is not registered
+ * Cache lookup calculates expected timestamps:
+ * sinceTimestamp + i * stepMs for i = 0..limit-1
+ * Returns all candles if found, null if any missing.
  *
- * @example
- * ```typescript
- * const risk = getRisk("conservative");
- * console.log(risk.maxConcurrentPositions); // 5
- * console.log(risk.validations); // Array of validation functions
- * ```
+ * @param dto - Data transfer object containing symbol, interval, and limit
+ * @param sinceTimestamp - Aligned start timestamp (openTime of first candle)
+ * @param untilTimestamp - Unused, kept for API compatibility
+ * @param exchangeName - Exchange name
+ * @returns Cached candles array (exactly limit) or null if cache miss
  */
-function getRiskSchema(riskName) {
-    bt.loggerService.log(GET_RISK_METHOD_NAME, {
-        riskName,
-    });
-    bt.riskValidationService.validate(riskName, GET_RISK_METHOD_NAME);
-    return bt.riskSchemaService.get(riskName);
-}
+const READ_CANDLES_CACHE_FN = trycatch(async (dto, sinceTimestamp, untilTimestamp, exchangeName) => {
+    // PersistCandleAdapter.readCandlesData calculates expected timestamps:
+    // sinceTimestamp + i * stepMs for i = 0..limit-1
+    // Returns all candles if found, null if any missing
+    const cachedCandles = await PersistCandleAdapter.readCandlesData(dto.symbol, dto.interval, exchangeName, dto.limit, sinceTimestamp, untilTimestamp);
+    // Return cached data only if we have exactly the requested limit
+    if (cachedCandles?.length === dto.limit) {
+        bt.loggerService.debug(`ExchangeInstance READ_CANDLES_CACHE_FN: cache hit for exchangeName=${exchangeName}, symbol=${dto.symbol}, interval=${dto.interval}, limit=${dto.limit}`);
+        return cachedCandles;
+    }
+    bt.loggerService.warn(`ExchangeInstance READ_CANDLES_CACHE_FN: cache inconsistent (count or range mismatch) for exchangeName=${exchangeName}, symbol=${dto.symbol}, interval=${dto.interval}, limit=${dto.limit}`);
+    return null;
+}, {
+    fallback: async (error) => {
+        const message = `ExchangeInstance READ_CANDLES_CACHE_FN: cache read failed`;
+        const payload = {
+            error: errorData(error),
+            message: getErrorMessage(error),
+        };
+        bt.loggerService.warn(message, payload);
+        console.warn(message, payload);
+        errorEmitter.next(error);
+    },
+    defaultValue: null,
+});
 /**
- * Retrieves a registered action schema by name.
+ * Writes candles to cache with error handling.
  *
- * @param actionName - Unique action identifier
- * @returns The action schema configuration object
- * @throws Error if action is not registered
+ * The candles passed to this function should be validated:
+ * - First candle.timestamp equals aligned sinceTimestamp (openTime)
+ * - Exact number of candles as requested (limit)
+ * - Sequential timestamps: sinceTimestamp + i * stepMs
  *
- * @example
- * ```typescript
- * const action = getAction("telegram-notifier");
- * console.log(action.handler); // Class constructor or object
- * console.log(action.callbacks); // Optional lifecycle callbacks
- * ```
+ * @param candles - Array of validated candle data to cache
+ * @param dto - Data transfer object containing symbol, interval, and limit
+ * @param exchangeName - Exchange name
  */
-function getActionSchema(actionName) {
-    bt.loggerService.log(GET_ACTION_METHOD_NAME, {
-        actionName,
-    });
-    bt.actionValidationService.validate(actionName, GET_ACTION_METHOD_NAME);
-    return bt.actionSchemaService.get(actionName);
-}
-
-const GET_CANDLES_METHOD_NAME = "exchange.getCandles";
-const GET_AVERAGE_PRICE_METHOD_NAME = "exchange.getAveragePrice";
-const FORMAT_PRICE_METHOD_NAME = "exchange.formatPrice";
-const FORMAT_QUANTITY_METHOD_NAME = "exchange.formatQuantity";
-const GET_DATE_METHOD_NAME = "exchange.getDate";
-const GET_MODE_METHOD_NAME = "exchange.getMode";
-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";
-const GET_NEXT_CANDLES_METHOD_NAME = "exchange.getNextCandles";
+const WRITE_CANDLES_CACHE_FN = trycatch(queued(async (candles, dto, exchangeName) => {
+    await PersistCandleAdapter.writeCandlesData(candles, dto.symbol, dto.interval, exchangeName);
+    bt.loggerService.debug(`ExchangeInstance WRITE_CANDLES_CACHE_FN: cache updated for exchangeName=${exchangeName}, symbol=${dto.symbol}, interval=${dto.interval}, count=${candles.length}`);
+}), {
+    fallback: async (error) => {
+        const message = `ExchangeInstance WRITE_CANDLES_CACHE_FN: cache write failed`;
+        const payload = {
+            error: errorData(error),
+            message: getErrorMessage(error),
+        };
+        bt.loggerService.warn(message, payload);
+        console.warn(message, payload);
+        errorEmitter.next(error);
+    },
+    defaultValue: null,
+});
 /**
- * Checks if trade context is active (execution and method contexts).
- *
- * Returns true when both contexts are active, which is required for calling
- * exchange functions like getCandles, getAveragePrice, formatPrice, formatQuantity,
- * getDate, and getMode.
+ * Instance class for exchange operations on a specific exchange.
  *
- * @returns true if trade context is active, false otherwise
+ * Provides isolated exchange operations for a single exchange.
+ * Each instance maintains its own context and exposes IExchangeSchema methods.
+ * The schema is retrieved once during construction for better performance.
  *
  * @example
  * ```typescript
- * import { hasTradeContext, getCandles } from "backtest-kit";
- *
- * if (hasTradeContext()) {
- *   const candles = await getCandles("BTCUSDT", "1m", 100);
- * } else {
- *   console.log("Trade context not active");
- * }
- * ```
- */
-function hasTradeContext() {
-    bt.loggerService.info(HAS_TRADE_CONTEXT_METHOD_NAME);
-    return ExecutionContextService.hasContext() && MethodContextService.hasContext();
-}
-/**
- * Fetches historical candle data from the registered exchange.
- *
- * Candles are fetched backwards from the current execution context time.
- * Uses the exchange's getCandles implementation.
- *
- * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
- * @param interval - Candle interval ("1m" | "3m" | "5m" | "15m" | "30m" | "1h" | "2h" | "4h" | "6h" | "8h")
- * @param limit - Number of candles to fetch
- * @returns Promise resolving to array of candle data
+ * const instance = new ExchangeInstance("binance");
  *
- * @example
- * ```typescript
- * const candles = await getCandles("BTCUSDT", "1m", 100);
- * console.log(candles[0]); // { timestamp, open, high, low, close, volume }
+ * const candles = await instance.getCandles("BTCUSDT", "1m", 100);
+ * const vwap = await instance.getAveragePrice("BTCUSDT");
+ * const formattedQty = await instance.formatQuantity("BTCUSDT", 0.001);
+ * const formattedPrice = await instance.formatPrice("BTCUSDT", 50000.123);
  * ```
  */
-async function getCandles(symbol, interval, limit) {
-    bt.loggerService.info(GET_CANDLES_METHOD_NAME, {
-        symbol,
-        interval,
+class ExchangeInstance {
+    /**
+     * Creates a new ExchangeInstance for a specific exchange.
+     *
+     * @param exchangeName - Exchange name (e.g., "binance")
+     */
+    constructor(exchangeName) {
+        this.exchangeName = exchangeName;
+        /**
+         * Fetch candles from data source (API or database).
+         *
+         * Automatically calculates the start date based on Date.now() and the requested interval/limit.
+         * Uses the same logic as ClientExchange to ensure backwards compatibility.
+         *
+         * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+         * @param interval - Candle time interval (e.g., "1m", "1h")
+         * @param limit - Maximum number of candles to fetch
+         * @returns Promise resolving to array of OHLCV candle data
+         *
+         * @example
+         * ```typescript
+         * const instance = new ExchangeInstance("binance");
+         * const candles = await instance.getCandles("BTCUSDT", "1m", 100);
+         * ```
+         */
+        this.getCandles = async (symbol, interval, limit) => {
+            bt.loggerService.info(EXCHANGE_METHOD_NAME_GET_CANDLES, {
+                exchangeName: this.exchangeName,
+                symbol,
+                interval,
+                limit,
+            });
+            const getCandles = this._methods.getCandles;
+            const step = INTERVAL_MINUTES$2[interval];
+            if (!step) {
+                throw new Error(`ExchangeInstance unknown interval=${interval}`);
+            }
+            const stepMs = step * MS_PER_MINUTE$2;
+            // Align when down to interval boundary
+            const when = await GET_TIMESTAMP_FN();
+            const whenTimestamp = when.getTime();
+            const alignedWhen = ALIGN_TO_INTERVAL_FN$1(whenTimestamp, step);
+            // Calculate since: go back limit candles from aligned when
+            const sinceTimestamp = alignedWhen - limit * stepMs;
+            const since = new Date(sinceTimestamp);
+            const untilTimestamp = alignedWhen;
+            // Try to read from cache first
+            const cachedCandles = await READ_CANDLES_CACHE_FN({ symbol, interval, limit }, sinceTimestamp, untilTimestamp, this.exchangeName);
+            if (cachedCandles !== null) {
+                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) {
+                let remaining = limit;
+                let currentSince = new Date(since.getTime());
+                const isBacktest = await GET_BACKTEST_FN();
+                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) {
+                        // Move currentSince forward by the number of candles fetched
+                        currentSince = new Date(currentSince.getTime() + chunkLimit * stepMs);
+                    }
+                }
+            }
+            else {
+                const isBacktest = await GET_BACKTEST_FN();
+                allData = await getCandles(symbol, interval, since, limit, isBacktest);
+            }
+            // Apply distinct by timestamp to remove duplicates
+            const uniqueData = Array.from(new Map(allData.map((candle) => [candle.timestamp, candle])).values());
+            if (allData.length !== uniqueData.length) {
+                bt.loggerService.warn(`ExchangeInstance getCandles: Removed ${allData.length - uniqueData.length} duplicate candles by timestamp`);
+            }
+            // Validate adapter returned data
+            if (uniqueData.length === 0) {
+                throw new Error(`ExchangeInstance getCandles: adapter returned empty array. ` +
+                    `Expected ${limit} candles starting from openTime=${sinceTimestamp}.`);
+            }
+            if (uniqueData[0].timestamp !== sinceTimestamp) {
+                throw new Error(`ExchangeInstance getCandles: first candle timestamp mismatch. ` +
+                    `Expected openTime=${sinceTimestamp}, got=${uniqueData[0].timestamp}. ` +
+                    `Adapter must return candles with timestamp=openTime, starting from aligned since.`);
+            }
+            if (uniqueData.length !== limit) {
+                throw new Error(`ExchangeInstance getCandles: candle count mismatch. ` +
+                    `Expected ${limit} candles, got ${uniqueData.length}. ` +
+                    `Adapter must return exact number of candles requested.`);
+            }
+            // Write to cache after successful fetch
+            await WRITE_CANDLES_CACHE_FN(uniqueData, { symbol, interval, limit }, this.exchangeName);
+            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
+         *
+         * @example
+         * ```typescript
+         * const instance = new ExchangeInstance("binance");
+         * const vwap = await instance.getAveragePrice("BTCUSDT");
+         * console.log(vwap); // 50125.43
+         * ```
+         */
+        this.getAveragePrice = async (symbol) => {
+            bt.loggerService.debug(`ExchangeInstance getAveragePrice`, {
+                exchangeName: this.exchangeName,
+                symbol,
+            });
+            const candles = await this.getCandles(symbol, "1m", GLOBAL_CONFIG.CC_AVG_PRICE_CANDLES_COUNT);
+            if (candles.length === 0) {
+                throw new Error(`ExchangeInstance 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;
+        };
+        /**
+         * Format quantity according to exchange precision rules.
+         *
+         * @param symbol - Trading pair symbol
+         * @param quantity - Raw quantity value
+         * @returns Promise resolving to formatted quantity string
+         *
+         * @example
+         * ```typescript
+         * const instance = new ExchangeInstance("binance");
+         * const formatted = await instance.formatQuantity("BTCUSDT", 0.001);
+         * console.log(formatted); // "0.00100000"
+         * ```
+         */
+        this.formatQuantity = async (symbol, quantity) => {
+            bt.loggerService.info(EXCHANGE_METHOD_NAME_FORMAT_QUANTITY, {
+                exchangeName: this.exchangeName,
+                symbol,
+                quantity,
+            });
+            const isBacktest = await GET_BACKTEST_FN();
+            return await this._methods.formatQuantity(symbol, quantity, isBacktest);
+        };
+        /**
+         * Format price according to exchange precision rules.
+         *
+         * @param symbol - Trading pair symbol
+         * @param price - Raw price value
+         * @returns Promise resolving to formatted price string
+         *
+         * @example
+         * ```typescript
+         * const instance = new ExchangeInstance("binance");
+         * const formatted = await instance.formatPrice("BTCUSDT", 50000.123);
+         * console.log(formatted); // "50000.12"
+         * ```
+         */
+        this.formatPrice = async (symbol, price) => {
+            bt.loggerService.info(EXCHANGE_METHOD_NAME_FORMAT_PRICE, {
+                exchangeName: this.exchangeName,
+                symbol,
+                price,
+            });
+            const isBacktest = await GET_BACKTEST_FN();
+            return await this._methods.formatPrice(symbol, price, isBacktest);
+        };
+        /**
+         * Fetch order book for a trading pair.
+         *
+         * Calculates time range using CC_ORDER_BOOK_TIME_OFFSET_MINUTES (default 10 minutes)
+         * and passes it to the exchange schema implementation. The implementation may use
+         * the time range (backtest) or ignore it (live trading).
+         *
+         * @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
+         *
+         * @example
+         * ```typescript
+         * const instance = new ExchangeInstance("binance");
+         * const orderBook = await instance.getOrderBook("BTCUSDT");
+         * console.log(orderBook.bids); // [{ price: "50000.00", quantity: "0.5" }, ...]
+         * const deepOrderBook = await instance.getOrderBook("BTCUSDT", 100);
+         * ```
+         */
+        this.getOrderBook = async (symbol, depth = GLOBAL_CONFIG.CC_ORDER_BOOK_MAX_DEPTH_LEVELS) => {
+            bt.loggerService.info(EXCHANGE_METHOD_NAME_GET_ORDER_BOOK, {
+                exchangeName: this.exchangeName,
+                symbol,
+                depth,
+            });
+            const when = await GET_TIMESTAMP_FN();
+            const alignedTo = ALIGN_TO_INTERVAL_FN$1(when.getTime(), GLOBAL_CONFIG.CC_ORDER_BOOK_TIME_OFFSET_MINUTES);
+            const to = new Date(alignedTo);
+            const from = new Date(alignedTo - GLOBAL_CONFIG.CC_ORDER_BOOK_TIME_OFFSET_MINUTES * MS_PER_MINUTE$2);
+            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$2[interval];
+            if (!step) {
+                throw new Error(`ExchangeInstance getRawCandles: unknown interval=${interval}`);
+            }
+            const stepMs = step * MS_PER_MINUTE$2;
+            const when = await GET_TIMESTAMP_FN();
+            const nowTimestamp = when.getTime();
+            const alignedNow = ALIGN_TO_INTERVAL_FN$1(nowTimestamp, step);
+            let sinceTimestamp;
+            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.`);
+                }
+                // Align sDate down to interval boundary
+                sinceTimestamp = ALIGN_TO_INTERVAL_FN$1(sDate, step);
+                calculatedLimit = limit;
+            }
+            // Case 2: sDate + eDate (no limit) - calculate limit from date range
+            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.`);
+                }
+                // Align sDate down to interval boundary
+                sinceTimestamp = ALIGN_TO_INTERVAL_FN$1(sDate, step);
+                const alignedEDate = ALIGN_TO_INTERVAL_FN$1(eDate, step);
+                calculatedLimit = Math.ceil((alignedEDate - sinceTimestamp) / stepMs);
+                if (calculatedLimit <= 0) {
+                    throw new Error(`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.`);
+                }
+                // Align eDate down and calculate sinceTimestamp
+                const alignedEDate = ALIGN_TO_INTERVAL_FN$1(eDate, step);
+                sinceTimestamp = alignedEDate - limit * stepMs;
+                calculatedLimit = limit;
+            }
+            // Case 4: sDate + limit (no eDate) - calculate eDate forward from sDate
+            else if (sDate !== undefined && eDate === undefined && limit !== undefined) {
+                // Align sDate down to interval boundary
+                sinceTimestamp = ALIGN_TO_INTERVAL_FN$1(sDate, step);
+                const endTimestamp = sinceTimestamp + limit * stepMs;
+                if (endTimestamp > nowTimestamp) {
+                    throw new Error(`ExchangeInstance getRawCandles: calculated endTimestamp (${endTimestamp}) exceeds current time (${nowTimestamp}). Look-ahead bias protection.`);
+                }
+                calculatedLimit = limit;
+            }
+            // Case 5: Only limit - use Date.now() as reference (backward)
+            else if (sDate === undefined && eDate === undefined && limit !== undefined) {
+                sinceTimestamp = alignedNow - limit * stepMs;
+                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 untilTimestamp = sinceTimestamp + calculatedLimit * stepMs;
+            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 * stepMs);
+                    }
+                }
+            }
+            else {
+                allData = await getCandles(symbol, interval, since, calculatedLimit, isBacktest);
+            }
+            // Apply distinct by timestamp to remove duplicates
+            const uniqueData = Array.from(new Map(allData.map((candle) => [candle.timestamp, candle])).values());
+            if (allData.length !== uniqueData.length) {
+                bt.loggerService.warn(`ExchangeInstance getRawCandles: Removed ${allData.length - uniqueData.length} duplicate candles by timestamp`);
+            }
+            // Validate adapter returned data
+            if (uniqueData.length === 0) {
+                throw new Error(`ExchangeInstance getRawCandles: adapter returned empty array. ` +
+                    `Expected ${calculatedLimit} candles starting from openTime=${sinceTimestamp}.`);
+            }
+            if (uniqueData[0].timestamp !== sinceTimestamp) {
+                throw new Error(`ExchangeInstance getRawCandles: first candle timestamp mismatch. ` +
+                    `Expected openTime=${sinceTimestamp}, got=${uniqueData[0].timestamp}. ` +
+                    `Adapter must return candles with timestamp=openTime, starting from aligned since.`);
+            }
+            if (uniqueData.length !== calculatedLimit) {
+                throw new Error(`ExchangeInstance getRawCandles: candle count mismatch. ` +
+                    `Expected ${calculatedLimit} candles, got ${uniqueData.length}. ` +
+                    `Adapter must return exact number of candles requested.`);
+            }
+            // Write to cache after successful fetch
+            await WRITE_CANDLES_CACHE_FN(uniqueData, { symbol, interval, limit: calculatedLimit }, this.exchangeName);
+            return uniqueData;
+        };
+        const schema = bt.exchangeSchemaService.get(this.exchangeName);
+        this._methods = CREATE_EXCHANGE_INSTANCE_FN(schema);
+    }
+}
+/**
+ * Utility class for exchange operations.
+ *
+ * Provides simplified access to exchange schema methods with validation.
+ * Exported as singleton instance for convenient usage.
+ *
+ * @example
+ * ```typescript
+ * import { Exchange } from "./classes/Exchange";
+ *
+ * const candles = await Exchange.getCandles("BTCUSDT", "1m", 100, {
+ *   exchangeName: "binance"
+ * });
+ * const vwap = await Exchange.getAveragePrice("BTCUSDT", {
+ *   exchangeName: "binance"
+ * });
+ * const formatted = await Exchange.formatQuantity("BTCUSDT", 0.001, {
+ *   exchangeName: "binance"
+ * });
+ * ```
+ */
+class ExchangeUtils {
+    constructor() {
+        /**
+         * Memoized function to get or create ExchangeInstance for an exchange.
+         * Each exchange gets its own isolated instance.
+         */
+        this._getInstance = memoize(([exchangeName]) => exchangeName, (exchangeName) => new ExchangeInstance(exchangeName));
+        /**
+         * Fetch candles from data source (API or database).
+         *
+         * Automatically calculates the start date based on Date.now() and the requested interval/limit.
+         * Uses the same logic as ClientExchange to ensure backwards compatibility.
+         *
+         * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+         * @param interval - Candle time interval (e.g., "1m", "1h")
+         * @param limit - Maximum number of candles to fetch
+         * @param context - Execution context with exchange name
+         * @returns Promise resolving to array of OHLCV candle data
+         */
+        this.getCandles = async (symbol, interval, limit, context) => {
+            bt.exchangeValidationService.validate(context.exchangeName, EXCHANGE_METHOD_NAME_GET_CANDLES);
+            const instance = this._getInstance(context.exchangeName);
+            return await instance.getCandles(symbol, interval, limit);
+        };
+        /**
+         * Calculates VWAP (Volume Weighted Average Price) from last N 1m candles.
+         *
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with exchange name
+         * @returns Promise resolving to VWAP price
+         */
+        this.getAveragePrice = async (symbol, context) => {
+            bt.exchangeValidationService.validate(context.exchangeName, EXCHANGE_METHOD_NAME_GET_AVERAGE_PRICE);
+            const instance = this._getInstance(context.exchangeName);
+            return await instance.getAveragePrice(symbol);
+        };
+        /**
+         * Format quantity according to exchange precision rules.
+         *
+         * @param symbol - Trading pair symbol
+         * @param quantity - Raw quantity value
+         * @param context - Execution context with exchange name
+         * @returns Promise resolving to formatted quantity string
+         */
+        this.formatQuantity = async (symbol, quantity, context) => {
+            bt.exchangeValidationService.validate(context.exchangeName, EXCHANGE_METHOD_NAME_FORMAT_QUANTITY);
+            const instance = this._getInstance(context.exchangeName);
+            return await instance.formatQuantity(symbol, quantity);
+        };
+        /**
+         * Format price according to exchange precision rules.
+         *
+         * @param symbol - Trading pair symbol
+         * @param price - Raw price value
+         * @param context - Execution context with exchange name
+         * @returns Promise resolving to formatted price string
+         */
+        this.formatPrice = async (symbol, price, context) => {
+            bt.exchangeValidationService.validate(context.exchangeName, EXCHANGE_METHOD_NAME_FORMAT_PRICE);
+            const instance = this._getInstance(context.exchangeName);
+            return await instance.formatPrice(symbol, price);
+        };
+        /**
+         * Fetch order book for a trading pair.
+         *
+         * Delegates to ExchangeInstance which calculates time range and passes it
+         * to the exchange schema implementation. The from/to parameters may be used
+         * (backtest) or ignored (live) depending on the implementation.
+         *
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with exchange name
+         * @param depth - Maximum depth levels (default: CC_ORDER_BOOK_MAX_DEPTH_LEVELS)
+         * @returns Promise resolving to order book data
+         */
+        this.getOrderBook = async (symbol, context, depth = GLOBAL_CONFIG.CC_ORDER_BOOK_MAX_DEPTH_LEVELS) => {
+            bt.exchangeValidationService.validate(context.exchangeName, EXCHANGE_METHOD_NAME_GET_ORDER_BOOK);
+            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);
+        };
+    }
+}
+/**
+ * Singleton instance of ExchangeUtils for convenient exchange operations.
+ *
+ * @example
+ * ```typescript
+ * import { Exchange } from "./classes/Exchange";
+ *
+ * // Using static-like API with context
+ * const candles = await Exchange.getCandles("BTCUSDT", "1m", 100, {
+ *   exchangeName: "binance"
+ * });
+ * const vwap = await Exchange.getAveragePrice("BTCUSDT", {
+ *   exchangeName: "binance"
+ * });
+ * const qty = await Exchange.formatQuantity("BTCUSDT", 0.001, {
+ *   exchangeName: "binance"
+ * });
+ * const price = await Exchange.formatPrice("BTCUSDT", 50000.123, {
+ *   exchangeName: "binance"
+ * });
+ *
+ * // Using instance API (no context needed, exchange set in constructor)
+ * const binance = new ExchangeInstance("binance");
+ * const candles2 = await binance.getCandles("BTCUSDT", "1m", 100);
+ * const vwap2 = await binance.getAveragePrice("BTCUSDT");
+ * ```
+ */
+const Exchange = new ExchangeUtils();
+
+const WARM_CANDLES_METHOD_NAME = "cache.warmCandles";
+const CHECK_CANDLES_METHOD_NAME = "cache.checkCandles";
+const MS_PER_MINUTE$1 = 60000;
+const INTERVAL_MINUTES$1 = {
+    "1m": 1,
+    "3m": 3,
+    "5m": 5,
+    "15m": 15,
+    "30m": 30,
+    "1h": 60,
+    "2h": 120,
+    "4h": 240,
+    "6h": 360,
+    "8h": 480,
+};
+const ALIGN_TO_INTERVAL_FN = (timestamp, intervalMinutes) => {
+    const intervalMs = intervalMinutes * MS_PER_MINUTE$1;
+    return Math.floor(timestamp / intervalMs) * intervalMs;
+};
+const BAR_LENGTH = 30;
+const BAR_FILLED_CHAR = "\u2588";
+const BAR_EMPTY_CHAR = "\u2591";
+const PRINT_PROGRESS_FN = (fetched, total, symbol, interval) => {
+    const percent = Math.round((fetched / total) * 100);
+    const filled = Math.round((fetched / total) * BAR_LENGTH);
+    const empty = BAR_LENGTH - filled;
+    const bar = BAR_FILLED_CHAR.repeat(filled) + BAR_EMPTY_CHAR.repeat(empty);
+    process.stdout.write(`\r[${bar}] ${percent}% (${fetched}/${total}) ${symbol} ${interval}`);
+    if (fetched === total) {
+        process.stdout.write("\n");
+    }
+};
+/**
+ * Checks cached candle timestamps for correct interval alignment.
+ * Reads JSON files directly from persist storage without using abstractions.
+ *
+ * @param params - Validation parameters
+ */
+async function checkCandles(params) {
+    const { symbol, exchangeName, interval, baseDir = "./dump/data/candle" } = params;
+    bt.loggerService.info(CHECK_CANDLES_METHOD_NAME, params);
+    const step = INTERVAL_MINUTES$1[interval];
+    if (!step) {
+        throw new Error(`checkCandles: unsupported interval=${interval}`);
+    }
+    const stepMs = step * MS_PER_MINUTE$1;
+    const dir = join(baseDir, exchangeName, symbol, interval);
+    try {
+        await stat(dir);
+    }
+    catch {
+        throw new Error(`checkCandles: cache directory not found: ${dir}`);
+    }
+    // First pass: count files via async iterator (no memory allocation for file list)
+    let totalFiles = 0;
+    for await (const entry of await opendir(dir)) {
+        if (entry.isFile() && entry.name.endsWith(".json")) {
+            totalFiles++;
+        }
+    }
+    if (totalFiles === 0) {
+        throw new Error(`checkCandles: no cached candles in ${dir}`);
+    }
+    // Second pass: check each file via async iterator with progress
+    let checkd = 0;
+    let prevTimestamp = null;
+    let prevName = null;
+    PRINT_PROGRESS_FN(checkd, totalFiles, symbol, interval);
+    for await (const entry of await opendir(dir)) {
+        if (!entry.isFile() || !entry.name.endsWith(".json")) {
+            continue;
+        }
+        const filePath = join(dir, entry.name);
+        const raw = await readFile(filePath, "utf-8");
+        const candle = JSON.parse(raw);
+        const { timestamp } = candle;
+        const aligned = ALIGN_TO_INTERVAL_FN(timestamp, step);
+        if (timestamp !== aligned) {
+            throw new Error(`checkCandles: ${entry.name} timestamp=${timestamp} is not aligned to ${interval} boundary (expected=${aligned})`);
+        }
+        if (prevTimestamp !== null) {
+            const gap = timestamp - prevTimestamp;
+            if (gap !== stepMs) {
+                throw new Error(`checkCandles: gap between ${prevName} and ${entry.name} is ${gap}ms, expected ${stepMs}ms`);
+            }
+        }
+        prevTimestamp = timestamp;
+        prevName = entry.name;
+        checkd++;
+        PRINT_PROGRESS_FN(checkd, totalFiles, symbol, interval);
+    }
+    console.log(`checkCandles: OK ${totalFiles} candles ${symbol} ${interval}`);
+}
+/**
+ * Pre-caches candles for a date range into persist storage.
+ * Downloads all candles matching the interval from `from` to `to`.
+ *
+ * @param params - Cache parameters
+ */
+async function warmCandles(params) {
+    const { symbol, exchangeName, interval, from, to } = params;
+    bt.loggerService.info(WARM_CANDLES_METHOD_NAME, {
+        symbol,
+        exchangeName,
+        interval,
+        from,
+        to,
+    });
+    const step = INTERVAL_MINUTES$1[interval];
+    if (!step) {
+        throw new Error(`warmCandles: unsupported interval=${interval}`);
+    }
+    const stepMs = step * MS_PER_MINUTE$1;
+    const instance = new ExchangeInstance(exchangeName);
+    const sinceTimestamp = ALIGN_TO_INTERVAL_FN(from.getTime(), step);
+    const untilTimestamp = ALIGN_TO_INTERVAL_FN(to.getTime(), step);
+    const totalCandles = Math.ceil((untilTimestamp - sinceTimestamp) / stepMs);
+    if (totalCandles <= 0) {
+        throw new Error(`warmCandles: no candles to cache (from >= to after alignment)`);
+    }
+    let fetched = 0;
+    let currentSince = sinceTimestamp;
+    PRINT_PROGRESS_FN(fetched, totalCandles, symbol, interval);
+    while (fetched < totalCandles) {
+        const chunkLimit = Math.min(totalCandles - fetched, GLOBAL_CONFIG.CC_MAX_CANDLES_PER_REQUEST);
+        await instance.getRawCandles(symbol, interval, chunkLimit, currentSince);
+        fetched += chunkLimit;
+        currentSince += chunkLimit * stepMs;
+        PRINT_PROGRESS_FN(fetched, totalCandles, symbol, interval);
+    }
+}
+
+const METHOD_NAME = "validate.validate";
+/**
+ * Retrieves all registered exchanges as a map
+ * @private
+ * @returns Map of exchange names
+ */
+const getExchangeMap = async () => {
+    const exchangeMap = {};
+    for (const { exchangeName } of await bt.exchangeValidationService.list()) {
+        Object.assign(exchangeMap, { [exchangeName]: exchangeName });
+    }
+    return exchangeMap;
+};
+/**
+ * Retrieves all registered frames as a map
+ * @private
+ * @returns Map of frame names
+ */
+const getFrameMap = async () => {
+    const frameMap = {};
+    for (const { frameName } of await bt.frameValidationService.list()) {
+        Object.assign(frameMap, { [frameName]: frameName });
+    }
+    return frameMap;
+};
+/**
+ * Retrieves all registered strategies as a map
+ * @private
+ * @returns Map of strategy names
+ */
+const getStrategyMap = async () => {
+    const strategyMap = {};
+    for (const { strategyName } of await bt.strategyValidationService.list()) {
+        Object.assign(strategyMap, { [strategyName]: strategyName });
+    }
+    return strategyMap;
+};
+/**
+ * Retrieves all registered risk profiles as a map
+ * @private
+ * @returns Map of risk names
+ */
+const getRiskMap = async () => {
+    const riskMap = {};
+    for (const { riskName } of await bt.riskValidationService.list()) {
+        Object.assign(riskMap, { [riskName]: riskName });
+    }
+    return riskMap;
+};
+/**
+ * Retrieves all registered action handlers as a map
+ * @private
+ * @returns Map of action names
+ */
+const getActionMap = async () => {
+    const actionMap = {};
+    for (const { actionName } of await bt.actionValidationService.list()) {
+        Object.assign(actionMap, { [actionName]: actionName });
+    }
+    return actionMap;
+};
+/**
+ * Retrieves all registered sizing strategies as a map
+ * @private
+ * @returns Map of sizing names
+ */
+const getSizingMap = async () => {
+    const sizingMap = {};
+    for (const { sizingName } of await bt.sizingValidationService.list()) {
+        Object.assign(sizingMap, { [sizingName]: sizingName });
+    }
+    return sizingMap;
+};
+/**
+ * Retrieves all registered walkers as a map
+ * @private
+ * @returns Map of walker names
+ */
+const getWalkerMap = async () => {
+    const walkerMap = {};
+    for (const { walkerName } of await bt.walkerValidationService.list()) {
+        Object.assign(walkerMap, { [walkerName]: walkerName });
+    }
+    return walkerMap;
+};
+/**
+ * Internal validation function that processes all provided entity enums.
+ *
+ * Iterates through each enum's values and validates them against their
+ * respective validation services. Uses memoized validation for performance.
+ *
+ * If entity enums are not provided, fetches all registered entities from
+ * their respective validation services and validates them.
+ *
+ * @private
+ * @param args - Validation arguments containing entity name enums
+ * @throws {Error} If any entity name is not found in its registry
+ */
+const validateInternal = async (args) => {
+    const { ExchangeName = await getExchangeMap(), FrameName = await getFrameMap(), StrategyName = await getStrategyMap(), RiskName = await getRiskMap(), ActionName = await getActionMap(), SizingName = await getSizingMap(), WalkerName = await getWalkerMap(), } = args;
+    for (const exchangeName of Object.values(ExchangeName)) {
+        bt.exchangeValidationService.validate(exchangeName, METHOD_NAME);
+    }
+    for (const frameName of Object.values(FrameName)) {
+        bt.frameValidationService.validate(frameName, METHOD_NAME);
+    }
+    for (const strategyName of Object.values(StrategyName)) {
+        bt.strategyValidationService.validate(strategyName, METHOD_NAME);
+    }
+    for (const riskName of Object.values(RiskName)) {
+        bt.riskValidationService.validate(riskName, METHOD_NAME);
+    }
+    for (const actionName of Object.values(ActionName)) {
+        bt.actionValidationService.validate(actionName, METHOD_NAME);
+    }
+    for (const sizingName of Object.values(SizingName)) {
+        bt.sizingValidationService.validate(sizingName, METHOD_NAME);
+    }
+    for (const walkerName of Object.values(WalkerName)) {
+        bt.walkerValidationService.validate(walkerName, METHOD_NAME);
+    }
+};
+/**
+ * Validates the existence of all provided entity names across validation services.
+ *
+ * This function accepts enum objects for various entity types (exchanges, frames,
+ * strategies, risks, sizings, walkers) and validates that each entity
+ * name exists in its respective registry. Validation results are memoized for performance.
+ *
+ * If no arguments are provided (or specific entity types are omitted), the function
+ * automatically fetches and validates ALL registered entities from their respective
+ * validation services. This is useful for comprehensive validation of the entire setup.
+ *
+ * Use this before running backtests or optimizations to ensure all referenced
+ * entities are properly registered and configured.
+ *
+ * @public
+ * @param args - Partial validation arguments containing entity name enums to validate.
+ *                If empty or omitted, validates all registered entities.
+ * @throws {Error} If any entity name is not found in its validation service
+ *
+ * @example
+ * ```typescript
+ * // Validate ALL registered entities (exchanges, frames, strategies, etc.)
+ * await validate({});
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Define your entity name enums
+ * enum ExchangeName {
+ *   BINANCE = "binance",
+ *   BYBIT = "bybit"
+ * }
+ *
+ * enum StrategyName {
+ *   MOMENTUM_BTC = "momentum-btc"
+ * }
+ *
+ * // Validate specific entities before running backtest
+ * await validate({
+ *   ExchangeName,
+ *   StrategyName,
+ * });
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Validate specific entity types
+ * await validate({
+ *   RiskName: { CONSERVATIVE: "conservative" },
+ *   SizingName: { FIXED_1000: "fixed-1000" },
+ * });
+ * ```
+ */
+async function validate(args = {}) {
+    bt.loggerService.log(METHOD_NAME);
+    return await validateInternal(args);
+}
+
+const GET_STRATEGY_METHOD_NAME = "get.getStrategySchema";
+const GET_EXCHANGE_METHOD_NAME = "get.getExchangeSchema";
+const GET_FRAME_METHOD_NAME = "get.getFrameSchema";
+const GET_WALKER_METHOD_NAME = "get.getWalkerSchema";
+const GET_SIZING_METHOD_NAME = "get.getSizingSchema";
+const GET_RISK_METHOD_NAME = "get.getRiskSchema";
+const GET_ACTION_METHOD_NAME = "get.getActionSchema";
+/**
+ * Retrieves a registered strategy schema by name.
+ *
+ * @param strategyName - Unique strategy identifier
+ * @returns The strategy schema configuration object
+ * @throws Error if strategy is not registered
+ *
+ * @example
+ * ```typescript
+ * const strategy = getStrategy("my-strategy");
+ * console.log(strategy.interval); // "5m"
+ * console.log(strategy.getSignal); // async function
+ * ```
+ */
+function getStrategySchema(strategyName) {
+    bt.loggerService.log(GET_STRATEGY_METHOD_NAME, {
+        strategyName,
+    });
+    bt.strategyValidationService.validate(strategyName, GET_STRATEGY_METHOD_NAME);
+    return bt.strategySchemaService.get(strategyName);
+}
+/**
+ * Retrieves a registered exchange schema by name.
+ *
+ * @param exchangeName - Unique exchange identifier
+ * @returns The exchange schema configuration object
+ * @throws Error if exchange is not registered
+ *
+ * @example
+ * ```typescript
+ * const exchange = getExchange("binance");
+ * console.log(exchange.getCandles); // async function
+ * console.log(exchange.formatPrice); // async function
+ * ```
+ */
+function getExchangeSchema(exchangeName) {
+    bt.loggerService.log(GET_EXCHANGE_METHOD_NAME, {
+        exchangeName,
+    });
+    bt.exchangeValidationService.validate(exchangeName, GET_EXCHANGE_METHOD_NAME);
+    return bt.exchangeSchemaService.get(exchangeName);
+}
+/**
+ * Retrieves a registered frame schema by name.
+ *
+ * @param frameName - Unique frame identifier
+ * @returns The frame schema configuration object
+ * @throws Error if frame is not registered
+ *
+ * @example
+ * ```typescript
+ * const frame = getFrame("1d-backtest");
+ * console.log(frame.interval); // "1m"
+ * console.log(frame.startDate); // Date object
+ * console.log(frame.endDate); // Date object
+ * ```
+ */
+function getFrameSchema(frameName) {
+    bt.loggerService.log(GET_FRAME_METHOD_NAME, {
+        frameName,
+    });
+    bt.frameValidationService.validate(frameName, GET_FRAME_METHOD_NAME);
+    return bt.frameSchemaService.get(frameName);
+}
+/**
+ * Retrieves a registered walker schema by name.
+ *
+ * @param walkerName - Unique walker identifier
+ * @returns The walker schema configuration object
+ * @throws Error if walker is not registered
+ *
+ * @example
+ * ```typescript
+ * const walker = getWalker("llm-prompt-optimizer");
+ * console.log(walker.exchangeName); // "binance"
+ * console.log(walker.frameName); // "1d-backtest"
+ * console.log(walker.strategies); // ["my-strategy-v1", "my-strategy-v2"]
+ * console.log(walker.metric); // "sharpeRatio"
+ * ```
+ */
+function getWalkerSchema(walkerName) {
+    bt.loggerService.log(GET_WALKER_METHOD_NAME, {
+        walkerName,
+    });
+    bt.walkerValidationService.validate(walkerName, GET_WALKER_METHOD_NAME);
+    return bt.walkerSchemaService.get(walkerName);
+}
+/**
+ * Retrieves a registered sizing schema by name.
+ *
+ * @param sizingName - Unique sizing identifier
+ * @returns The sizing schema configuration object
+ * @throws Error if sizing is not registered
+ *
+ * @example
+ * ```typescript
+ * const sizing = getSizing("conservative");
+ * console.log(sizing.method); // "fixed-percentage"
+ * console.log(sizing.riskPercentage); // 1
+ * console.log(sizing.maxPositionPercentage); // 10
+ * ```
+ */
+function getSizingSchema(sizingName) {
+    bt.loggerService.log(GET_SIZING_METHOD_NAME, {
+        sizingName,
+    });
+    bt.sizingValidationService.validate(sizingName, GET_SIZING_METHOD_NAME);
+    return bt.sizingSchemaService.get(sizingName);
+}
+/**
+ * Retrieves a registered risk schema by name.
+ *
+ * @param riskName - Unique risk identifier
+ * @returns The risk schema configuration object
+ * @throws Error if risk is not registered
+ *
+ * @example
+ * ```typescript
+ * const risk = getRisk("conservative");
+ * console.log(risk.maxConcurrentPositions); // 5
+ * console.log(risk.validations); // Array of validation functions
+ * ```
+ */
+function getRiskSchema(riskName) {
+    bt.loggerService.log(GET_RISK_METHOD_NAME, {
+        riskName,
+    });
+    bt.riskValidationService.validate(riskName, GET_RISK_METHOD_NAME);
+    return bt.riskSchemaService.get(riskName);
+}
+/**
+ * Retrieves a registered action schema by name.
+ *
+ * @param actionName - Unique action identifier
+ * @returns The action schema configuration object
+ * @throws Error if action is not registered
+ *
+ * @example
+ * ```typescript
+ * const action = getAction("telegram-notifier");
+ * console.log(action.handler); // Class constructor or object
+ * console.log(action.callbacks); // Optional lifecycle callbacks
+ * ```
+ */
+function getActionSchema(actionName) {
+    bt.loggerService.log(GET_ACTION_METHOD_NAME, {
+        actionName,
+    });
+    bt.actionValidationService.validate(actionName, GET_ACTION_METHOD_NAME);
+    return bt.actionSchemaService.get(actionName);
+}
+
+const GET_CANDLES_METHOD_NAME = "exchange.getCandles";
+const GET_AVERAGE_PRICE_METHOD_NAME = "exchange.getAveragePrice";
+const FORMAT_PRICE_METHOD_NAME = "exchange.formatPrice";
+const FORMAT_QUANTITY_METHOD_NAME = "exchange.formatQuantity";
+const GET_DATE_METHOD_NAME = "exchange.getDate";
+const GET_MODE_METHOD_NAME = "exchange.getMode";
+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";
+const GET_NEXT_CANDLES_METHOD_NAME = "exchange.getNextCandles";
+/**
+ * Checks if trade context is active (execution and method contexts).
+ *
+ * Returns true when both contexts are active, which is required for calling
+ * exchange functions like getCandles, getAveragePrice, formatPrice, formatQuantity,
+ * getDate, and getMode.
+ *
+ * @returns true if trade context is active, false otherwise
+ *
+ * @example
+ * ```typescript
+ * import { hasTradeContext, getCandles } from "backtest-kit";
+ *
+ * if (hasTradeContext()) {
+ *   const candles = await getCandles("BTCUSDT", "1m", 100);
+ * } else {
+ *   console.log("Trade context not active");
+ * }
+ * ```
+ */
+function hasTradeContext() {
+    bt.loggerService.info(HAS_TRADE_CONTEXT_METHOD_NAME);
+    return ExecutionContextService.hasContext() && MethodContextService.hasContext();
+}
+/**
+ * Fetches historical candle data from the registered exchange.
+ *
+ * Candles are fetched backwards from the current execution context time.
+ * Uses the exchange's getCandles implementation.
+ *
+ * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+ * @param interval - Candle interval ("1m" | "3m" | "5m" | "15m" | "30m" | "1h" | "2h" | "4h" | "6h" | "8h")
+ * @param limit - Number of candles to fetch
+ * @returns Promise resolving to array of candle data
+ *
+ * @example
+ * ```typescript
+ * const candles = await getCandles("BTCUSDT", "1m", 100);
+ * console.log(candles[0]); // { timestamp, open, high, low, close, volume }
+ * ```
+ */
+async function getCandles(symbol, interval, limit) {
+    bt.loggerService.info(GET_CANDLES_METHOD_NAME, {
+        symbol,
+        interval,
         limit,
     });
     if (!ExecutionContextService.hasContext()) {
@@ -35155,143 +36015,7 @@ class NotificationBacktestAdapter {
          * @param data - The risk contract data
          */
         this.handleRisk = async (data) => {
-            return await this._notificationBacktestUtils.handleRisk(data);
-        };
-        /**
-         * Handles error event.
-         * Proxies call to the underlying notification adapter.
-         * @param error - The error object
-         */
-        this.handleError = async (error) => {
-            return await this._notificationBacktestUtils.handleError(error);
-        };
-        /**
-         * Handles critical error event.
-         * Proxies call to the underlying notification adapter.
-         * @param error - The error object
-         */
-        this.handleCriticalError = async (error) => {
-            return await this._notificationBacktestUtils.handleCriticalError(error);
-        };
-        /**
-         * Handles validation error event.
-         * Proxies call to the underlying notification adapter.
-         * @param error - The error object
-         */
-        this.handleValidationError = async (error) => {
-            return await this._notificationBacktestUtils.handleValidationError(error);
-        };
-        /**
-         * Gets all stored notifications.
-         * Proxies call to the underlying notification adapter.
-         * @returns Array of all notification models
-         */
-        this.getData = async () => {
-            return await this._notificationBacktestUtils.getData();
-        };
-        /**
-         * Clears all stored notifications.
-         * Proxies call to the underlying notification adapter.
-         */
-        this.clear = async () => {
-            return await this._notificationBacktestUtils.clear();
-        };
-        /**
-         * Sets the notification adapter constructor.
-         * All future notification operations will use this adapter.
-         *
-         * @param Ctor - Constructor for notification adapter
-         */
-        this.useNotificationAdapter = (Ctor) => {
-            bt.loggerService.info(NOTIFICATION_BACKTEST_ADAPTER_METHOD_NAME_USE_ADAPTER);
-            this._notificationBacktestUtils = Reflect.construct(Ctor, []);
-        };
-        /**
-         * Switches to dummy notification adapter.
-         * All future notification writes will be no-ops.
-         */
-        this.useDummy = () => {
-            bt.loggerService.info(NOTIFICATION_BACKTEST_ADAPTER_METHOD_NAME_USE_DUMMY);
-            this._notificationBacktestUtils = new NotificationDummyBacktestUtils();
-        };
-        /**
-         * Switches to in-memory notification adapter (default).
-         * Notifications will be stored in memory only.
-         */
-        this.useMemory = () => {
-            bt.loggerService.info(NOTIFICATION_BACKTEST_ADAPTER_METHOD_NAME_USE_MEMORY);
-            this._notificationBacktestUtils = new NotificationMemoryBacktestUtils();
-        };
-        /**
-         * Switches to persistent notification adapter.
-         * Notifications will be persisted to disk.
-         */
-        this.usePersist = () => {
-            bt.loggerService.info(NOTIFICATION_BACKTEST_ADAPTER_METHOD_NAME_USE_PERSIST);
-            this._notificationBacktestUtils = new NotificationPersistBacktestUtils();
-        };
-    }
-}
-/**
- * Live trading notification adapter with pluggable notification backend.
- *
- * Features:
- * - Adapter pattern for swappable notification implementations
- * - Default adapter: NotificationMemoryLiveUtils (in-memory storage)
- * - Alternative adapters: NotificationPersistLiveUtils, NotificationDummyLiveUtils
- * - Convenience methods: usePersist(), useMemory(), useDummy()
- */
-class NotificationLiveAdapter {
-    constructor() {
-        /** Internal notification utils instance */
-        this._notificationLiveUtils = new NotificationMemoryLiveUtils();
-        /**
-         * Handles signal events.
-         * Proxies call to the underlying notification adapter.
-         * @param data - The strategy tick result data
-         */
-        this.handleSignal = async (data) => {
-            return await this._notificationLiveUtils.handleSignal(data);
-        };
-        /**
-         * Handles partial profit availability event.
-         * Proxies call to the underlying notification adapter.
-         * @param data - The partial profit contract data
-         */
-        this.handlePartialProfit = async (data) => {
-            return await this._notificationLiveUtils.handlePartialProfit(data);
-        };
-        /**
-         * Handles partial loss availability event.
-         * Proxies call to the underlying notification adapter.
-         * @param data - The partial loss contract data
-         */
-        this.handlePartialLoss = async (data) => {
-            return await this._notificationLiveUtils.handlePartialLoss(data);
-        };
-        /**
-         * Handles breakeven availability event.
-         * Proxies call to the underlying notification adapter.
-         * @param data - The breakeven contract data
-         */
-        this.handleBreakeven = async (data) => {
-            return await this._notificationLiveUtils.handleBreakeven(data);
-        };
-        /**
-         * Handles strategy commit events.
-         * Proxies call to the underlying notification adapter.
-         * @param data - The strategy commit contract data
-         */
-        this.handleStrategyCommit = async (data) => {
-            return await this._notificationLiveUtils.handleStrategyCommit(data);
-        };
-        /**
-         * Handles risk rejection event.
-         * Proxies call to the underlying notification adapter.
-         * @param data - The risk contract data
-         */
-        this.handleRisk = async (data) => {
-            return await this._notificationLiveUtils.handleRisk(data);
+            return await this._notificationBacktestUtils.handleRisk(data);
         };
         /**
          * Handles error event.
@@ -35299,7 +36023,7 @@ class NotificationLiveAdapter {
          * @param error - The error object
          */
         this.handleError = async (error) => {
-            return await this._notificationLiveUtils.handleError(error);
+            return await this._notificationBacktestUtils.handleError(error);
         };
         /**
          * Handles critical error event.
@@ -35307,7 +36031,7 @@ class NotificationLiveAdapter {
          * @param error - The error object
          */
         this.handleCriticalError = async (error) => {
-            return await this._notificationLiveUtils.handleCriticalError(error);
+            return await this._notificationBacktestUtils.handleCriticalError(error);
         };
         /**
          * Handles validation error event.
@@ -35315,7 +36039,7 @@ class NotificationLiveAdapter {
          * @param error - The error object
          */
         this.handleValidationError = async (error) => {
-            return await this._notificationLiveUtils.handleValidationError(error);
+            return await this._notificationBacktestUtils.handleValidationError(error);
         };
         /**
          * Gets all stored notifications.
@@ -35323,14 +36047,14 @@ class NotificationLiveAdapter {
          * @returns Array of all notification models
          */
         this.getData = async () => {
-            return await this._notificationLiveUtils.getData();
+            return await this._notificationBacktestUtils.getData();
         };
         /**
          * Clears all stored notifications.
          * Proxies call to the underlying notification adapter.
          */
         this.clear = async () => {
-            return await this._notificationLiveUtils.clear();
+            return await this._notificationBacktestUtils.clear();
         };
         /**
          * Sets the notification adapter constructor.
@@ -35339,897 +36063,305 @@ class NotificationLiveAdapter {
          * @param Ctor - Constructor for notification adapter
          */
         this.useNotificationAdapter = (Ctor) => {
-            bt.loggerService.info(NOTIFICATION_LIVE_ADAPTER_METHOD_NAME_USE_ADAPTER);
-            this._notificationLiveUtils = Reflect.construct(Ctor, []);
+            bt.loggerService.info(NOTIFICATION_BACKTEST_ADAPTER_METHOD_NAME_USE_ADAPTER);
+            this._notificationBacktestUtils = Reflect.construct(Ctor, []);
         };
         /**
          * Switches to dummy notification adapter.
          * All future notification writes will be no-ops.
          */
         this.useDummy = () => {
-            bt.loggerService.info(NOTIFICATION_LIVE_ADAPTER_METHOD_NAME_USE_DUMMY);
-            this._notificationLiveUtils = new NotificationDummyLiveUtils();
+            bt.loggerService.info(NOTIFICATION_BACKTEST_ADAPTER_METHOD_NAME_USE_DUMMY);
+            this._notificationBacktestUtils = new NotificationDummyBacktestUtils();
         };
         /**
          * Switches to in-memory notification adapter (default).
          * Notifications will be stored in memory only.
          */
         this.useMemory = () => {
-            bt.loggerService.info(NOTIFICATION_LIVE_ADAPTER_METHOD_NAME_USE_MEMORY);
-            this._notificationLiveUtils = new NotificationMemoryLiveUtils();
+            bt.loggerService.info(NOTIFICATION_BACKTEST_ADAPTER_METHOD_NAME_USE_MEMORY);
+            this._notificationBacktestUtils = new NotificationMemoryBacktestUtils();
         };
         /**
          * Switches to persistent notification adapter.
          * Notifications will be persisted to disk.
          */
         this.usePersist = () => {
-            bt.loggerService.info(NOTIFICATION_LIVE_ADAPTER_METHOD_NAME_USE_PERSIST);
-            this._notificationLiveUtils = new NotificationPersistLiveUtils();
+            bt.loggerService.info(NOTIFICATION_BACKTEST_ADAPTER_METHOD_NAME_USE_PERSIST);
+            this._notificationBacktestUtils = new NotificationPersistBacktestUtils();
         };
     }
 }
 /**
- * Main notification adapter that manages both backtest and live notification storage.
+ * Live trading notification adapter with pluggable notification backend.
  *
  * Features:
- * - Subscribes to signal emitters for automatic notification updates
- * - Provides unified access to both backtest and live notifications
- * - Singleshot enable pattern prevents duplicate subscriptions
- * - Cleanup function for proper unsubscription
+ * - Adapter pattern for swappable notification implementations
+ * - Default adapter: NotificationMemoryLiveUtils (in-memory storage)
+ * - Alternative adapters: NotificationPersistLiveUtils, NotificationDummyLiveUtils
+ * - Convenience methods: usePersist(), useMemory(), useDummy()
  */
-class NotificationAdapter {
+class NotificationLiveAdapter {
     constructor() {
+        /** Internal notification utils instance */
+        this._notificationLiveUtils = new NotificationMemoryLiveUtils();
         /**
-         * Enables notification storage by subscribing to signal emitters.
-         * Uses singleshot to ensure one-time subscription.
-         *
-         * @returns Cleanup function that unsubscribes from all emitters
+         * Handles signal events.
+         * Proxies call to the underlying notification adapter.
+         * @param data - The strategy tick result data
          */
-        this.enable = singleshot(() => {
-            bt.loggerService.info(NOTIFICATION_ADAPTER_METHOD_NAME_ENABLE);
-            let unLive;
-            let unBacktest;
-            {
-                const unBacktestSignal = signalBacktestEmitter.subscribe((data) => NotificationBacktest.handleSignal(data));
-                const unBacktestPartialProfit = partialProfitSubject
-                    .filter(({ backtest }) => backtest)
-                    .connect((data) => NotificationBacktest.handlePartialProfit(data));
-                const unBacktestPartialLoss = partialLossSubject
-                    .filter(({ backtest }) => backtest)
-                    .connect((data) => NotificationBacktest.handlePartialLoss(data));
-                const unBacktestBreakeven = breakevenSubject
-                    .filter(({ backtest }) => backtest)
-                    .connect((data) => NotificationBacktest.handleBreakeven(data));
-                const unBacktestStrategyCommit = strategyCommitSubject
-                    .filter(({ backtest }) => backtest)
-                    .connect((data) => NotificationBacktest.handleStrategyCommit(data));
-                const unBacktestRisk = riskSubject
-                    .filter(({ backtest }) => backtest)
-                    .connect((data) => NotificationBacktest.handleRisk(data));
-                const unBacktestError = errorEmitter.subscribe((error) => NotificationBacktest.handleError(error));
-                const unBacktestExit = exitEmitter.subscribe((error) => NotificationBacktest.handleCriticalError(error));
-                const unBacktestValidation = validationSubject.subscribe((error) => NotificationBacktest.handleValidationError(error));
-                unBacktest = compose(() => unBacktestSignal(), () => unBacktestPartialProfit(), () => unBacktestPartialLoss(), () => unBacktestBreakeven(), () => unBacktestStrategyCommit(), () => unBacktestRisk(), () => unBacktestError(), () => unBacktestExit(), () => unBacktestValidation());
-            }
-            {
-                const unLiveSignal = signalLiveEmitter.subscribe((data) => NotificationLive.handleSignal(data));
-                const unLivePartialProfit = partialProfitSubject
-                    .filter(({ backtest }) => !backtest)
-                    .connect((data) => NotificationLive.handlePartialProfit(data));
-                const unLivePartialLoss = partialLossSubject
-                    .filter(({ backtest }) => !backtest)
-                    .connect((data) => NotificationLive.handlePartialLoss(data));
-                const unLiveBreakeven = breakevenSubject
-                    .filter(({ backtest }) => !backtest)
-                    .connect((data) => NotificationLive.handleBreakeven(data));
-                const unLiveStrategyCommit = strategyCommitSubject
-                    .filter(({ backtest }) => !backtest)
-                    .connect((data) => NotificationLive.handleStrategyCommit(data));
-                const unLiveRisk = riskSubject
-                    .filter(({ backtest }) => !backtest)
-                    .connect((data) => NotificationLive.handleRisk(data));
-                const unLiveError = errorEmitter.subscribe((error) => NotificationLive.handleError(error));
-                const unLiveExit = exitEmitter.subscribe((error) => NotificationLive.handleCriticalError(error));
-                const unLiveValidation = validationSubject.subscribe((error) => NotificationLive.handleValidationError(error));
-                unLive = compose(() => unLiveSignal(), () => unLivePartialProfit(), () => unLivePartialLoss(), () => unLiveBreakeven(), () => unLiveStrategyCommit(), () => unLiveRisk(), () => unLiveError(), () => unLiveExit(), () => unLiveValidation());
-            }
-            return () => {
-                unLive();
-                unBacktest();
-                this.enable.clear();
-            };
-        });
+        this.handleSignal = async (data) => {
+            return await this._notificationLiveUtils.handleSignal(data);
+        };
         /**
-         * Disables notification storage by unsubscribing from all emitters.
-         * Safe to call multiple times.
+         * Handles partial profit availability event.
+         * Proxies call to the underlying notification adapter.
+         * @param data - The partial profit contract data
          */
-        this.disable = () => {
-            bt.loggerService.info(NOTIFICATION_ADAPTER_METHOD_NAME_DISABLE);
-            if (this.enable.hasValue()) {
-                const lastSubscription = this.enable();
-                lastSubscription();
-            }
+        this.handlePartialProfit = async (data) => {
+            return await this._notificationLiveUtils.handlePartialProfit(data);
         };
         /**
-         * Gets all backtest/live notifications from storage.
-         *
-         * @returns Array of all backtest notification models
-         * @throws Error if NotificationAdapter is not enabled
+         * Handles partial loss availability event.
+         * Proxies call to the underlying notification adapter.
+         * @param data - The partial loss contract data
          */
-        this.getData = async (isBacktest) => {
-            bt.loggerService.info(NOTIFICATION_ADAPTER_METHOD_NAME_GET_DATA_BACKTEST, {
-                backtest: isBacktest,
-            });
-            if (!this.enable.hasValue()) {
-                throw new Error("NotificationAdapter is not enabled. Call enable() first.");
-            }
-            if (isBacktest) {
-                return await NotificationBacktest.getData();
-            }
-            return await NotificationLive.getData();
+        this.handlePartialLoss = async (data) => {
+            return await this._notificationLiveUtils.handlePartialLoss(data);
         };
         /**
-         * Clears all backtest/live notifications from storage.
-         *
-         * @throws Error if NotificationAdapter is not enabled
+         * Handles breakeven availability event.
+         * Proxies call to the underlying notification adapter.
+         * @param data - The breakeven contract data
          */
-        this.clear = async (isBacktest) => {
-            bt.loggerService.info(NOTIFICATION_ADAPTER_METHOD_NAME_CLEAR_LIVE, {
-                backtest: isBacktest,
-            });
-            if (!this.enable.hasValue()) {
-                throw new Error("NotificationAdapter is not enabled. Call enable() first.");
-            }
-            if (isBacktest) {
-                return await NotificationBacktest.clear();
-            }
-            return await NotificationLive.clear();
-        };
-    }
-}
-/**
- * Global singleton instance of NotificationAdapter.
- * Provides unified notification management for backtest and live trading.
- */
-const Notification = new NotificationAdapter();
-/**
- * Global singleton instance of NotificationLiveAdapter.
- * Provides live trading notification storage with pluggable backends.
- */
-const NotificationLive = new NotificationLiveAdapter();
-/**
- * Global singleton instance of NotificationBacktestAdapter.
- * Provides backtest notification storage with pluggable backends.
- */
-const NotificationBacktest = new NotificationBacktestAdapter();
-
-const EXCHANGE_METHOD_NAME_GET_CANDLES = "ExchangeUtils.getCandles";
-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$1 = 60000;
-/**
- * Gets current timestamp from execution context if available.
- * Returns current Date() if no execution context exists (non-trading GUI).
- */
-const GET_TIMESTAMP_FN = async () => {
-    if (ExecutionContextService.hasContext()) {
-        return new Date(bt.executionContextService.context.when);
-    }
-    return new Date();
-};
-/**
- * Gets backtest mode flag from execution context if available.
- * Returns false if no execution context exists (live mode).
- */
-const GET_BACKTEST_FN = async () => {
-    if (ExecutionContextService.hasContext()) {
-        return bt.executionContextService.context.backtest;
-    }
-    return false;
-};
-/**
- * Default implementation for getCandles.
- * Throws an error indicating the method is not implemented.
- */
-const DEFAULT_GET_CANDLES_FN = 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 = 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 = 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 = async (_symbol, _depth, _from, _to, _backtest) => {
-    throw new Error(`getOrderBook is not implemented for this exchange`);
-};
-const INTERVAL_MINUTES$1 = {
-    "1m": 1,
-    "3m": 3,
-    "5m": 5,
-    "15m": 15,
-    "30m": 30,
-    "1h": 60,
-    "2h": 120,
-    "4h": 240,
-    "6h": 360,
-    "8h": 480,
-};
-/**
- * Aligns timestamp down to the nearest interval boundary.
- * For example, for 15m interval: 00:17 -> 00:15, 00:44 -> 00:30
- *
- * Candle timestamp convention:
- * - Candle timestamp = openTime (when candle opens)
- * - Candle with timestamp 00:00 covers period [00:00, 00:15) for 15m interval
- *
- * Adapter contract:
- * - Adapter must return candles with timestamp = openTime
- * - First returned candle.timestamp must equal aligned since
- * - Adapter must return exactly `limit` candles
- *
- * @param timestamp - Timestamp in milliseconds
- * @param intervalMinutes - Interval in minutes
- * @returns Aligned timestamp rounded down to interval boundary
- */
-const ALIGN_TO_INTERVAL_FN = (timestamp, intervalMinutes) => {
-    const intervalMs = intervalMinutes * MS_PER_MINUTE$1;
-    return Math.floor(timestamp / intervalMs) * intervalMs;
-};
-/**
- * Creates exchange instance with methods resolved once during construction.
- * Applies default implementations where schema methods are not provided.
- *
- * @param schema - Exchange schema from registry
- * @returns Object with resolved exchange methods
- */
-const CREATE_EXCHANGE_INSTANCE_FN = (schema) => {
-    const getCandles = schema.getCandles ?? DEFAULT_GET_CANDLES_FN;
-    const formatQuantity = schema.formatQuantity ?? DEFAULT_FORMAT_QUANTITY_FN;
-    const formatPrice = schema.formatPrice ?? DEFAULT_FORMAT_PRICE_FN;
-    const getOrderBook = schema.getOrderBook ?? DEFAULT_GET_ORDER_BOOK_FN;
-    return {
-        getCandles,
-        formatQuantity,
-        formatPrice,
-        getOrderBook,
-    };
-};
-/**
- * Attempts to read candles from cache.
- *
- * Cache lookup calculates expected timestamps:
- * sinceTimestamp + i * stepMs for i = 0..limit-1
- * Returns all candles if found, null if any missing.
- *
- * @param dto - Data transfer object containing symbol, interval, and limit
- * @param sinceTimestamp - Aligned start timestamp (openTime of first candle)
- * @param untilTimestamp - Unused, kept for API compatibility
- * @param exchangeName - Exchange name
- * @returns Cached candles array (exactly limit) or null if cache miss
- */
-const READ_CANDLES_CACHE_FN = trycatch(async (dto, sinceTimestamp, untilTimestamp, exchangeName) => {
-    // PersistCandleAdapter.readCandlesData calculates expected timestamps:
-    // sinceTimestamp + i * stepMs for i = 0..limit-1
-    // Returns all candles if found, null if any missing
-    const cachedCandles = await PersistCandleAdapter.readCandlesData(dto.symbol, dto.interval, exchangeName, dto.limit, sinceTimestamp, untilTimestamp);
-    // Return cached data only if we have exactly the requested limit
-    if (cachedCandles?.length === dto.limit) {
-        bt.loggerService.debug(`ExchangeInstance READ_CANDLES_CACHE_FN: cache hit for exchangeName=${exchangeName}, symbol=${dto.symbol}, interval=${dto.interval}, limit=${dto.limit}`);
-        return cachedCandles;
-    }
-    bt.loggerService.warn(`ExchangeInstance READ_CANDLES_CACHE_FN: cache inconsistent (count or range mismatch) for exchangeName=${exchangeName}, symbol=${dto.symbol}, interval=${dto.interval}, limit=${dto.limit}`);
-    return null;
-}, {
-    fallback: async (error) => {
-        const message = `ExchangeInstance READ_CANDLES_CACHE_FN: cache read failed`;
-        const payload = {
-            error: errorData(error),
-            message: getErrorMessage(error),
-        };
-        bt.loggerService.warn(message, payload);
-        console.warn(message, payload);
-        errorEmitter.next(error);
-    },
-    defaultValue: null,
-});
-/**
- * Writes candles to cache with error handling.
- *
- * The candles passed to this function should be validated:
- * - First candle.timestamp equals aligned sinceTimestamp (openTime)
- * - Exact number of candles as requested (limit)
- * - Sequential timestamps: sinceTimestamp + i * stepMs
- *
- * @param candles - Array of validated candle data to cache
- * @param dto - Data transfer object containing symbol, interval, and limit
- * @param exchangeName - Exchange name
- */
-const WRITE_CANDLES_CACHE_FN = trycatch(queued(async (candles, dto, exchangeName) => {
-    await PersistCandleAdapter.writeCandlesData(candles, dto.symbol, dto.interval, exchangeName);
-    bt.loggerService.debug(`ExchangeInstance WRITE_CANDLES_CACHE_FN: cache updated for exchangeName=${exchangeName}, symbol=${dto.symbol}, interval=${dto.interval}, count=${candles.length}`);
-}), {
-    fallback: async (error) => {
-        const message = `ExchangeInstance WRITE_CANDLES_CACHE_FN: cache write failed`;
-        const payload = {
-            error: errorData(error),
-            message: getErrorMessage(error),
+        this.handleBreakeven = async (data) => {
+            return await this._notificationLiveUtils.handleBreakeven(data);
         };
-        bt.loggerService.warn(message, payload);
-        console.warn(message, payload);
-        errorEmitter.next(error);
-    },
-    defaultValue: null,
-});
-/**
- * Instance class for exchange operations on a specific exchange.
- *
- * Provides isolated exchange operations for a single exchange.
- * Each instance maintains its own context and exposes IExchangeSchema methods.
- * The schema is retrieved once during construction for better performance.
- *
- * @example
- * ```typescript
- * const instance = new ExchangeInstance("binance");
- *
- * const candles = await instance.getCandles("BTCUSDT", "1m", 100);
- * const vwap = await instance.getAveragePrice("BTCUSDT");
- * const formattedQty = await instance.formatQuantity("BTCUSDT", 0.001);
- * const formattedPrice = await instance.formatPrice("BTCUSDT", 50000.123);
- * ```
- */
-class ExchangeInstance {
-    /**
-     * Creates a new ExchangeInstance for a specific exchange.
-     *
-     * @param exchangeName - Exchange name (e.g., "binance")
-     */
-    constructor(exchangeName) {
-        this.exchangeName = exchangeName;
         /**
-         * Fetch candles from data source (API or database).
-         *
-         * Automatically calculates the start date based on Date.now() and the requested interval/limit.
-         * Uses the same logic as ClientExchange to ensure backwards compatibility.
-         *
-         * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
-         * @param interval - Candle time interval (e.g., "1m", "1h")
-         * @param limit - Maximum number of candles to fetch
-         * @returns Promise resolving to array of OHLCV candle data
-         *
-         * @example
-         * ```typescript
-         * const instance = new ExchangeInstance("binance");
-         * const candles = await instance.getCandles("BTCUSDT", "1m", 100);
-         * ```
+         * Handles strategy commit events.
+         * Proxies call to the underlying notification adapter.
+         * @param data - The strategy commit contract data
          */
-        this.getCandles = async (symbol, interval, limit) => {
-            bt.loggerService.info(EXCHANGE_METHOD_NAME_GET_CANDLES, {
-                exchangeName: this.exchangeName,
-                symbol,
-                interval,
-                limit,
-            });
-            const getCandles = this._methods.getCandles;
-            const step = INTERVAL_MINUTES$1[interval];
-            if (!step) {
-                throw new Error(`ExchangeInstance unknown interval=${interval}`);
-            }
-            const stepMs = step * MS_PER_MINUTE$1;
-            // Align when down to interval boundary
-            const when = await GET_TIMESTAMP_FN();
-            const whenTimestamp = when.getTime();
-            const alignedWhen = ALIGN_TO_INTERVAL_FN(whenTimestamp, step);
-            // Calculate since: go back limit candles from aligned when
-            const sinceTimestamp = alignedWhen - limit * stepMs;
-            const since = new Date(sinceTimestamp);
-            const untilTimestamp = alignedWhen;
-            // Try to read from cache first
-            const cachedCandles = await READ_CANDLES_CACHE_FN({ symbol, interval, limit }, sinceTimestamp, untilTimestamp, this.exchangeName);
-            if (cachedCandles !== null) {
-                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) {
-                let remaining = limit;
-                let currentSince = new Date(since.getTime());
-                const isBacktest = await GET_BACKTEST_FN();
-                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) {
-                        // Move currentSince forward by the number of candles fetched
-                        currentSince = new Date(currentSince.getTime() + chunkLimit * stepMs);
-                    }
-                }
-            }
-            else {
-                const isBacktest = await GET_BACKTEST_FN();
-                allData = await getCandles(symbol, interval, since, limit, isBacktest);
-            }
-            // Apply distinct by timestamp to remove duplicates
-            const uniqueData = Array.from(new Map(allData.map((candle) => [candle.timestamp, candle])).values());
-            if (allData.length !== uniqueData.length) {
-                bt.loggerService.warn(`ExchangeInstance getCandles: Removed ${allData.length - uniqueData.length} duplicate candles by timestamp`);
-            }
-            // Validate adapter returned data
-            if (uniqueData.length === 0) {
-                throw new Error(`ExchangeInstance getCandles: adapter returned empty array. ` +
-                    `Expected ${limit} candles starting from openTime=${sinceTimestamp}.`);
-            }
-            if (uniqueData[0].timestamp !== sinceTimestamp) {
-                throw new Error(`ExchangeInstance getCandles: first candle timestamp mismatch. ` +
-                    `Expected openTime=${sinceTimestamp}, got=${uniqueData[0].timestamp}. ` +
-                    `Adapter must return candles with timestamp=openTime, starting from aligned since.`);
-            }
-            if (uniqueData.length !== limit) {
-                throw new Error(`ExchangeInstance getCandles: candle count mismatch. ` +
-                    `Expected ${limit} candles, got ${uniqueData.length}. ` +
-                    `Adapter must return exact number of candles requested.`);
-            }
-            // Write to cache after successful fetch
-            await WRITE_CANDLES_CACHE_FN(uniqueData, { symbol, interval, limit }, this.exchangeName);
-            return uniqueData;
+        this.handleStrategyCommit = async (data) => {
+            return await this._notificationLiveUtils.handleStrategyCommit(data);
         };
         /**
-         * 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
-         *
-         * @example
-         * ```typescript
-         * const instance = new ExchangeInstance("binance");
-         * const vwap = await instance.getAveragePrice("BTCUSDT");
-         * console.log(vwap); // 50125.43
-         * ```
-         */
-        this.getAveragePrice = async (symbol) => {
-            bt.loggerService.debug(`ExchangeInstance getAveragePrice`, {
-                exchangeName: this.exchangeName,
-                symbol,
-            });
-            const candles = await this.getCandles(symbol, "1m", GLOBAL_CONFIG.CC_AVG_PRICE_CANDLES_COUNT);
-            if (candles.length === 0) {
-                throw new Error(`ExchangeInstance 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;
+         * Handles risk rejection event.
+         * Proxies call to the underlying notification adapter.
+         * @param data - The risk contract data
+         */
+        this.handleRisk = async (data) => {
+            return await this._notificationLiveUtils.handleRisk(data);
         };
         /**
-         * Format quantity according to exchange precision rules.
-         *
-         * @param symbol - Trading pair symbol
-         * @param quantity - Raw quantity value
-         * @returns Promise resolving to formatted quantity string
-         *
-         * @example
-         * ```typescript
-         * const instance = new ExchangeInstance("binance");
-         * const formatted = await instance.formatQuantity("BTCUSDT", 0.001);
-         * console.log(formatted); // "0.00100000"
-         * ```
+         * Handles error event.
+         * Proxies call to the underlying notification adapter.
+         * @param error - The error object
          */
-        this.formatQuantity = async (symbol, quantity) => {
-            bt.loggerService.info(EXCHANGE_METHOD_NAME_FORMAT_QUANTITY, {
-                exchangeName: this.exchangeName,
-                symbol,
-                quantity,
-            });
-            const isBacktest = await GET_BACKTEST_FN();
-            return await this._methods.formatQuantity(symbol, quantity, isBacktest);
+        this.handleError = async (error) => {
+            return await this._notificationLiveUtils.handleError(error);
         };
         /**
-         * Format price according to exchange precision rules.
-         *
-         * @param symbol - Trading pair symbol
-         * @param price - Raw price value
-         * @returns Promise resolving to formatted price string
-         *
-         * @example
-         * ```typescript
-         * const instance = new ExchangeInstance("binance");
-         * const formatted = await instance.formatPrice("BTCUSDT", 50000.123);
-         * console.log(formatted); // "50000.12"
-         * ```
+         * Handles critical error event.
+         * Proxies call to the underlying notification adapter.
+         * @param error - The error object
          */
-        this.formatPrice = async (symbol, price) => {
-            bt.loggerService.info(EXCHANGE_METHOD_NAME_FORMAT_PRICE, {
-                exchangeName: this.exchangeName,
-                symbol,
-                price,
-            });
-            const isBacktest = await GET_BACKTEST_FN();
-            return await this._methods.formatPrice(symbol, price, isBacktest);
+        this.handleCriticalError = async (error) => {
+            return await this._notificationLiveUtils.handleCriticalError(error);
         };
         /**
-         * Fetch order book for a trading pair.
-         *
-         * Calculates time range using CC_ORDER_BOOK_TIME_OFFSET_MINUTES (default 10 minutes)
-         * and passes it to the exchange schema implementation. The implementation may use
-         * the time range (backtest) or ignore it (live trading).
-         *
-         * @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
-         *
-         * @example
-         * ```typescript
-         * const instance = new ExchangeInstance("binance");
-         * const orderBook = await instance.getOrderBook("BTCUSDT");
-         * console.log(orderBook.bids); // [{ price: "50000.00", quantity: "0.5" }, ...]
-         * const deepOrderBook = await instance.getOrderBook("BTCUSDT", 100);
-         * ```
+         * Handles validation error event.
+         * Proxies call to the underlying notification adapter.
+         * @param error - The error object
          */
-        this.getOrderBook = async (symbol, depth = GLOBAL_CONFIG.CC_ORDER_BOOK_MAX_DEPTH_LEVELS) => {
-            bt.loggerService.info(EXCHANGE_METHOD_NAME_GET_ORDER_BOOK, {
-                exchangeName: this.exchangeName,
-                symbol,
-                depth,
-            });
-            const when = await GET_TIMESTAMP_FN();
-            const alignedTo = ALIGN_TO_INTERVAL_FN(when.getTime(), GLOBAL_CONFIG.CC_ORDER_BOOK_TIME_OFFSET_MINUTES);
-            const to = new Date(alignedTo);
-            const from = new Date(alignedTo - GLOBAL_CONFIG.CC_ORDER_BOOK_TIME_OFFSET_MINUTES * MS_PER_MINUTE$1);
-            const isBacktest = await GET_BACKTEST_FN();
-            return await this._methods.getOrderBook(symbol, depth, from, to, isBacktest);
+        this.handleValidationError = async (error) => {
+            return await this._notificationLiveUtils.handleValidationError(error);
         };
         /**
-         * 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);
-         * ```
+         * Gets all stored notifications.
+         * Proxies call to the underlying notification adapter.
+         * @returns Array of all notification models
          */
-        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 stepMs = step * MS_PER_MINUTE$1;
-            const when = await GET_TIMESTAMP_FN();
-            const nowTimestamp = when.getTime();
-            const alignedNow = ALIGN_TO_INTERVAL_FN(nowTimestamp, step);
-            let sinceTimestamp;
-            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.`);
-                }
-                // Align sDate down to interval boundary
-                sinceTimestamp = ALIGN_TO_INTERVAL_FN(sDate, step);
-                calculatedLimit = limit;
-            }
-            // Case 2: sDate + eDate (no limit) - calculate limit from date range
-            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.`);
-                }
-                // Align sDate down to interval boundary
-                sinceTimestamp = ALIGN_TO_INTERVAL_FN(sDate, step);
-                const alignedEDate = ALIGN_TO_INTERVAL_FN(eDate, step);
-                calculatedLimit = Math.ceil((alignedEDate - sinceTimestamp) / stepMs);
-                if (calculatedLimit <= 0) {
-                    throw new Error(`ExchangeInstance getRawCandles: calculated limit is ${calculatedLimit}, must be > 0`);
-                }
-            }
-            // 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.`);
-                }
-                // Align eDate down and calculate sinceTimestamp
-                const alignedEDate = ALIGN_TO_INTERVAL_FN(eDate, step);
-                sinceTimestamp = alignedEDate - limit * stepMs;
-                calculatedLimit = limit;
-            }
-            // Case 4: sDate + limit (no eDate) - calculate eDate forward from sDate
-            else if (sDate !== undefined && eDate === undefined && limit !== undefined) {
-                // Align sDate down to interval boundary
-                sinceTimestamp = ALIGN_TO_INTERVAL_FN(sDate, step);
-                const endTimestamp = sinceTimestamp + limit * stepMs;
-                if (endTimestamp > nowTimestamp) {
-                    throw new Error(`ExchangeInstance getRawCandles: calculated endTimestamp (${endTimestamp}) exceeds current time (${nowTimestamp}). Look-ahead bias protection.`);
-                }
-                calculatedLimit = limit;
-            }
-            // Case 5: Only limit - use Date.now() as reference (backward)
-            else if (sDate === undefined && eDate === undefined && limit !== undefined) {
-                sinceTimestamp = alignedNow - limit * stepMs;
-                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 untilTimestamp = sinceTimestamp + calculatedLimit * stepMs;
-            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 * stepMs);
-                    }
-                }
-            }
-            else {
-                allData = await getCandles(symbol, interval, since, calculatedLimit, isBacktest);
-            }
-            // Apply distinct by timestamp to remove duplicates
-            const uniqueData = Array.from(new Map(allData.map((candle) => [candle.timestamp, candle])).values());
-            if (allData.length !== uniqueData.length) {
-                bt.loggerService.warn(`ExchangeInstance getRawCandles: Removed ${allData.length - uniqueData.length} duplicate candles by timestamp`);
-            }
-            // Validate adapter returned data
-            if (uniqueData.length === 0) {
-                throw new Error(`ExchangeInstance getRawCandles: adapter returned empty array. ` +
-                    `Expected ${calculatedLimit} candles starting from openTime=${sinceTimestamp}.`);
-            }
-            if (uniqueData[0].timestamp !== sinceTimestamp) {
-                throw new Error(`ExchangeInstance getRawCandles: first candle timestamp mismatch. ` +
-                    `Expected openTime=${sinceTimestamp}, got=${uniqueData[0].timestamp}. ` +
-                    `Adapter must return candles with timestamp=openTime, starting from aligned since.`);
-            }
-            if (uniqueData.length !== calculatedLimit) {
-                throw new Error(`ExchangeInstance getRawCandles: candle count mismatch. ` +
-                    `Expected ${calculatedLimit} candles, got ${uniqueData.length}. ` +
-                    `Adapter must return exact number of candles requested.`);
-            }
-            // Write to cache after successful fetch
-            await WRITE_CANDLES_CACHE_FN(uniqueData, { symbol, interval, limit: calculatedLimit }, this.exchangeName);
-            return uniqueData;
+        this.getData = async () => {
+            return await this._notificationLiveUtils.getData();
         };
-        const schema = bt.exchangeSchemaService.get(this.exchangeName);
-        this._methods = CREATE_EXCHANGE_INSTANCE_FN(schema);
-    }
-}
-/**
- * Utility class for exchange operations.
- *
- * Provides simplified access to exchange schema methods with validation.
- * Exported as singleton instance for convenient usage.
- *
- * @example
- * ```typescript
- * import { Exchange } from "./classes/Exchange";
- *
- * const candles = await Exchange.getCandles("BTCUSDT", "1m", 100, {
- *   exchangeName: "binance"
- * });
- * const vwap = await Exchange.getAveragePrice("BTCUSDT", {
- *   exchangeName: "binance"
- * });
- * const formatted = await Exchange.formatQuantity("BTCUSDT", 0.001, {
- *   exchangeName: "binance"
- * });
- * ```
- */
-class ExchangeUtils {
-    constructor() {
         /**
-         * Memoized function to get or create ExchangeInstance for an exchange.
-         * Each exchange gets its own isolated instance.
+         * Clears all stored notifications.
+         * Proxies call to the underlying notification adapter.
          */
-        this._getInstance = memoize(([exchangeName]) => exchangeName, (exchangeName) => new ExchangeInstance(exchangeName));
+        this.clear = async () => {
+            return await this._notificationLiveUtils.clear();
+        };
         /**
-         * Fetch candles from data source (API or database).
-         *
-         * Automatically calculates the start date based on Date.now() and the requested interval/limit.
-         * Uses the same logic as ClientExchange to ensure backwards compatibility.
+         * Sets the notification adapter constructor.
+         * All future notification operations will use this adapter.
          *
-         * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
-         * @param interval - Candle time interval (e.g., "1m", "1h")
-         * @param limit - Maximum number of candles to fetch
-         * @param context - Execution context with exchange name
-         * @returns Promise resolving to array of OHLCV candle data
+         * @param Ctor - Constructor for notification adapter
          */
-        this.getCandles = async (symbol, interval, limit, context) => {
-            bt.exchangeValidationService.validate(context.exchangeName, EXCHANGE_METHOD_NAME_GET_CANDLES);
-            const instance = this._getInstance(context.exchangeName);
-            return await instance.getCandles(symbol, interval, limit);
+        this.useNotificationAdapter = (Ctor) => {
+            bt.loggerService.info(NOTIFICATION_LIVE_ADAPTER_METHOD_NAME_USE_ADAPTER);
+            this._notificationLiveUtils = Reflect.construct(Ctor, []);
         };
         /**
-         * Calculates VWAP (Volume Weighted Average Price) from last N 1m candles.
-         *
-         * @param symbol - Trading pair symbol
-         * @param context - Execution context with exchange name
-         * @returns Promise resolving to VWAP price
+         * Switches to dummy notification adapter.
+         * All future notification writes will be no-ops.
          */
-        this.getAveragePrice = async (symbol, context) => {
-            bt.exchangeValidationService.validate(context.exchangeName, EXCHANGE_METHOD_NAME_GET_AVERAGE_PRICE);
-            const instance = this._getInstance(context.exchangeName);
-            return await instance.getAveragePrice(symbol);
+        this.useDummy = () => {
+            bt.loggerService.info(NOTIFICATION_LIVE_ADAPTER_METHOD_NAME_USE_DUMMY);
+            this._notificationLiveUtils = new NotificationDummyLiveUtils();
         };
         /**
-         * Format quantity according to exchange precision rules.
-         *
-         * @param symbol - Trading pair symbol
-         * @param quantity - Raw quantity value
-         * @param context - Execution context with exchange name
-         * @returns Promise resolving to formatted quantity string
+         * Switches to in-memory notification adapter (default).
+         * Notifications will be stored in memory only.
          */
-        this.formatQuantity = async (symbol, quantity, context) => {
-            bt.exchangeValidationService.validate(context.exchangeName, EXCHANGE_METHOD_NAME_FORMAT_QUANTITY);
-            const instance = this._getInstance(context.exchangeName);
-            return await instance.formatQuantity(symbol, quantity);
+        this.useMemory = () => {
+            bt.loggerService.info(NOTIFICATION_LIVE_ADAPTER_METHOD_NAME_USE_MEMORY);
+            this._notificationLiveUtils = new NotificationMemoryLiveUtils();
         };
         /**
-         * Format price according to exchange precision rules.
-         *
-         * @param symbol - Trading pair symbol
-         * @param price - Raw price value
-         * @param context - Execution context with exchange name
-         * @returns Promise resolving to formatted price string
+         * Switches to persistent notification adapter.
+         * Notifications will be persisted to disk.
          */
-        this.formatPrice = async (symbol, price, context) => {
-            bt.exchangeValidationService.validate(context.exchangeName, EXCHANGE_METHOD_NAME_FORMAT_PRICE);
-            const instance = this._getInstance(context.exchangeName);
-            return await instance.formatPrice(symbol, price);
+        this.usePersist = () => {
+            bt.loggerService.info(NOTIFICATION_LIVE_ADAPTER_METHOD_NAME_USE_PERSIST);
+            this._notificationLiveUtils = new NotificationPersistLiveUtils();
         };
+    }
+}
+/**
+ * Main notification adapter that manages both backtest and live notification storage.
+ *
+ * Features:
+ * - Subscribes to signal emitters for automatic notification updates
+ * - Provides unified access to both backtest and live notifications
+ * - Singleshot enable pattern prevents duplicate subscriptions
+ * - Cleanup function for proper unsubscription
+ */
+class NotificationAdapter {
+    constructor() {
         /**
-         * Fetch order book for a trading pair.
-         *
-         * Delegates to ExchangeInstance which calculates time range and passes it
-         * to the exchange schema implementation. The from/to parameters may be used
-         * (backtest) or ignored (live) depending on the implementation.
+         * Enables notification storage by subscribing to signal emitters.
+         * Uses singleshot to ensure one-time subscription.
          *
-         * @param symbol - Trading pair symbol
-         * @param context - Execution context with exchange name
-         * @param depth - Maximum depth levels (default: CC_ORDER_BOOK_MAX_DEPTH_LEVELS)
-         * @returns Promise resolving to order book data
+         * @returns Cleanup function that unsubscribes from all emitters
          */
-        this.getOrderBook = async (symbol, context, depth = GLOBAL_CONFIG.CC_ORDER_BOOK_MAX_DEPTH_LEVELS) => {
-            bt.exchangeValidationService.validate(context.exchangeName, EXCHANGE_METHOD_NAME_GET_ORDER_BOOK);
-            const instance = this._getInstance(context.exchangeName);
-            return await instance.getOrderBook(symbol, depth);
+        this.enable = singleshot(() => {
+            bt.loggerService.info(NOTIFICATION_ADAPTER_METHOD_NAME_ENABLE);
+            let unLive;
+            let unBacktest;
+            {
+                const unBacktestSignal = signalBacktestEmitter.subscribe((data) => NotificationBacktest.handleSignal(data));
+                const unBacktestPartialProfit = partialProfitSubject
+                    .filter(({ backtest }) => backtest)
+                    .connect((data) => NotificationBacktest.handlePartialProfit(data));
+                const unBacktestPartialLoss = partialLossSubject
+                    .filter(({ backtest }) => backtest)
+                    .connect((data) => NotificationBacktest.handlePartialLoss(data));
+                const unBacktestBreakeven = breakevenSubject
+                    .filter(({ backtest }) => backtest)
+                    .connect((data) => NotificationBacktest.handleBreakeven(data));
+                const unBacktestStrategyCommit = strategyCommitSubject
+                    .filter(({ backtest }) => backtest)
+                    .connect((data) => NotificationBacktest.handleStrategyCommit(data));
+                const unBacktestRisk = riskSubject
+                    .filter(({ backtest }) => backtest)
+                    .connect((data) => NotificationBacktest.handleRisk(data));
+                const unBacktestError = errorEmitter.subscribe((error) => NotificationBacktest.handleError(error));
+                const unBacktestExit = exitEmitter.subscribe((error) => NotificationBacktest.handleCriticalError(error));
+                const unBacktestValidation = validationSubject.subscribe((error) => NotificationBacktest.handleValidationError(error));
+                unBacktest = compose(() => unBacktestSignal(), () => unBacktestPartialProfit(), () => unBacktestPartialLoss(), () => unBacktestBreakeven(), () => unBacktestStrategyCommit(), () => unBacktestRisk(), () => unBacktestError(), () => unBacktestExit(), () => unBacktestValidation());
+            }
+            {
+                const unLiveSignal = signalLiveEmitter.subscribe((data) => NotificationLive.handleSignal(data));
+                const unLivePartialProfit = partialProfitSubject
+                    .filter(({ backtest }) => !backtest)
+                    .connect((data) => NotificationLive.handlePartialProfit(data));
+                const unLivePartialLoss = partialLossSubject
+                    .filter(({ backtest }) => !backtest)
+                    .connect((data) => NotificationLive.handlePartialLoss(data));
+                const unLiveBreakeven = breakevenSubject
+                    .filter(({ backtest }) => !backtest)
+                    .connect((data) => NotificationLive.handleBreakeven(data));
+                const unLiveStrategyCommit = strategyCommitSubject
+                    .filter(({ backtest }) => !backtest)
+                    .connect((data) => NotificationLive.handleStrategyCommit(data));
+                const unLiveRisk = riskSubject
+                    .filter(({ backtest }) => !backtest)
+                    .connect((data) => NotificationLive.handleRisk(data));
+                const unLiveError = errorEmitter.subscribe((error) => NotificationLive.handleError(error));
+                const unLiveExit = exitEmitter.subscribe((error) => NotificationLive.handleCriticalError(error));
+                const unLiveValidation = validationSubject.subscribe((error) => NotificationLive.handleValidationError(error));
+                unLive = compose(() => unLiveSignal(), () => unLivePartialProfit(), () => unLivePartialLoss(), () => unLiveBreakeven(), () => unLiveStrategyCommit(), () => unLiveRisk(), () => unLiveError(), () => unLiveExit(), () => unLiveValidation());
+            }
+            return () => {
+                unLive();
+                unBacktest();
+                this.enable.clear();
+            };
+        });
+        /**
+         * Disables notification storage by unsubscribing from all emitters.
+         * Safe to call multiple times.
+         */
+        this.disable = () => {
+            bt.loggerService.info(NOTIFICATION_ADAPTER_METHOD_NAME_DISABLE);
+            if (this.enable.hasValue()) {
+                const lastSubscription = this.enable();
+                lastSubscription();
+            }
         };
         /**
-         * Fetches raw candles with flexible date/limit parameters.
+         * Gets all backtest/live notifications from storage.
          *
-         * Uses Date.now() instead of execution context when for look-ahead bias protection.
+         * @returns Array of all backtest notification models
+         * @throws Error if NotificationAdapter is not enabled
+         */
+        this.getData = async (isBacktest) => {
+            bt.loggerService.info(NOTIFICATION_ADAPTER_METHOD_NAME_GET_DATA_BACKTEST, {
+                backtest: isBacktest,
+            });
+            if (!this.enable.hasValue()) {
+                throw new Error("NotificationAdapter is not enabled. Call enable() first.");
+            }
+            if (isBacktest) {
+                return await NotificationBacktest.getData();
+            }
+            return await NotificationLive.getData();
+        };
+        /**
+         * Clears all backtest/live notifications from storage.
          *
-         * @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
+         * @throws Error if NotificationAdapter is not enabled
          */
-        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);
+        this.clear = async (isBacktest) => {
+            bt.loggerService.info(NOTIFICATION_ADAPTER_METHOD_NAME_CLEAR_LIVE, {
+                backtest: isBacktest,
+            });
+            if (!this.enable.hasValue()) {
+                throw new Error("NotificationAdapter is not enabled. Call enable() first.");
+            }
+            if (isBacktest) {
+                return await NotificationBacktest.clear();
+            }
+            return await NotificationLive.clear();
         };
     }
 }
 /**
- * Singleton instance of ExchangeUtils for convenient exchange operations.
- *
- * @example
- * ```typescript
- * import { Exchange } from "./classes/Exchange";
- *
- * // Using static-like API with context
- * const candles = await Exchange.getCandles("BTCUSDT", "1m", 100, {
- *   exchangeName: "binance"
- * });
- * const vwap = await Exchange.getAveragePrice("BTCUSDT", {
- *   exchangeName: "binance"
- * });
- * const qty = await Exchange.formatQuantity("BTCUSDT", 0.001, {
- *   exchangeName: "binance"
- * });
- * const price = await Exchange.formatPrice("BTCUSDT", 50000.123, {
- *   exchangeName: "binance"
- * });
- *
- * // Using instance API (no context needed, exchange set in constructor)
- * const binance = new ExchangeInstance("binance");
- * const candles2 = await binance.getCandles("BTCUSDT", "1m", 100);
- * const vwap2 = await binance.getAveragePrice("BTCUSDT");
- * ```
+ * Global singleton instance of NotificationAdapter.
+ * Provides unified notification management for backtest and live trading.
  */
-const Exchange = new ExchangeUtils();
+const Notification = new NotificationAdapter();
+/**
+ * Global singleton instance of NotificationLiveAdapter.
+ * Provides live trading notification storage with pluggable backends.
+ */
+const NotificationLive = new NotificationLiveAdapter();
+/**
+ * Global singleton instance of NotificationBacktestAdapter.
+ * Provides backtest notification storage with pluggable backends.
+ */
+const NotificationBacktest = new NotificationBacktestAdapter();
 
 const CACHE_METHOD_NAME_FLUSH = "CacheUtils.flush";
 const CACHE_METHOD_NAME_CLEAR = "CacheInstance.clear";
@@ -37161,4 +37293,4 @@ const set = (object, path, value) => {
     }
 };
 
-export { ActionBase, Backtest, Breakeven, Cache, Constant, Exchange, ExecutionContextService, Heat, Live, Markdown, MarkdownFileBase, MarkdownFolderBase, MethodContextService, Notification, NotificationBacktest, NotificationLive, Partial, Performance, PersistBase, PersistBreakevenAdapter, PersistCandleAdapter, PersistNotificationAdapter, PersistPartialAdapter, PersistRiskAdapter, PersistScheduleAdapter, PersistSignalAdapter, PersistStorageAdapter, PositionSize, Report, ReportBase, Risk, Schedule, Storage, StorageBacktest, StorageLive, Strategy, Walker, addActionSchema, addExchangeSchema, addFrameSchema, addRiskSchema, addSizingSchema, addStrategySchema, addWalkerSchema, commitActivateScheduled, commitBreakeven, commitCancelScheduled, commitClosePending, commitPartialLoss, commitPartialProfit, commitTrailingStop, commitTrailingTake, emitters, formatPrice, formatQuantity, get, getActionSchema, getAveragePrice, getBacktestTimeframe, getCandles, getColumns, getConfig, getContext, getDate, getDefaultColumns, getDefaultConfig, getExchangeSchema, getFrameSchema, getMode, getNextCandles, getOrderBook, getRawCandles, getRiskSchema, getSizingSchema, getStrategySchema, getSymbol, getWalkerSchema, hasTradeContext, backtest as lib, listExchangeSchema, listFrameSchema, listRiskSchema, listSizingSchema, listStrategySchema, listWalkerSchema, listenActivePing, listenActivePingOnce, listenBacktestProgress, listenBreakevenAvailable, listenBreakevenAvailableOnce, listenDoneBacktest, listenDoneBacktestOnce, listenDoneLive, listenDoneLiveOnce, listenDoneWalker, listenDoneWalkerOnce, listenError, listenExit, listenPartialLossAvailable, listenPartialLossAvailableOnce, listenPartialProfitAvailable, listenPartialProfitAvailableOnce, listenPerformance, listenRisk, listenRiskOnce, listenSchedulePing, listenSchedulePingOnce, listenSignal, listenSignalBacktest, listenSignalBacktestOnce, listenSignalLive, listenSignalLiveOnce, listenSignalOnce, listenStrategyCommit, listenStrategyCommitOnce, listenValidation, listenWalker, listenWalkerComplete, listenWalkerOnce, listenWalkerProgress, overrideActionSchema, overrideExchangeSchema, overrideFrameSchema, overrideRiskSchema, overrideSizingSchema, overrideStrategySchema, overrideWalkerSchema, parseArgs, roundTicks, set, setColumns, setConfig, setLogger, stopStrategy, validate };
+export { ActionBase, Backtest, Breakeven, Cache, Constant, Exchange, ExecutionContextService, Heat, Live, Markdown, MarkdownFileBase, MarkdownFolderBase, MethodContextService, Notification, NotificationBacktest, NotificationLive, Partial, Performance, PersistBase, PersistBreakevenAdapter, PersistCandleAdapter, PersistNotificationAdapter, PersistPartialAdapter, PersistRiskAdapter, PersistScheduleAdapter, PersistSignalAdapter, PersistStorageAdapter, PositionSize, Report, ReportBase, Risk, Schedule, Storage, StorageBacktest, StorageLive, Strategy, Walker, addActionSchema, addExchangeSchema, addFrameSchema, addRiskSchema, addSizingSchema, addStrategySchema, addWalkerSchema, checkCandles, commitActivateScheduled, commitBreakeven, commitCancelScheduled, commitClosePending, commitPartialLoss, commitPartialProfit, commitTrailingStop, commitTrailingTake, emitters, formatPrice, formatQuantity, get, getActionSchema, getAveragePrice, getBacktestTimeframe, getCandles, getColumns, getConfig, getContext, getDate, getDefaultColumns, getDefaultConfig, getExchangeSchema, getFrameSchema, getMode, getNextCandles, getOrderBook, getRawCandles, getRiskSchema, getSizingSchema, getStrategySchema, getSymbol, getWalkerSchema, hasTradeContext, backtest as lib, listExchangeSchema, listFrameSchema, listRiskSchema, listSizingSchema, listStrategySchema, listWalkerSchema, listenActivePing, listenActivePingOnce, listenBacktestProgress, listenBreakevenAvailable, listenBreakevenAvailableOnce, listenDoneBacktest, listenDoneBacktestOnce, listenDoneLive, listenDoneLiveOnce, listenDoneWalker, listenDoneWalkerOnce, listenError, listenExit, listenPartialLossAvailable, listenPartialLossAvailableOnce, listenPartialProfitAvailable, listenPartialProfitAvailableOnce, listenPerformance, listenRisk, listenRiskOnce, listenSchedulePing, listenSchedulePingOnce, listenSignal, listenSignalBacktest, listenSignalBacktestOnce, listenSignalLive, listenSignalLiveOnce, listenSignalOnce, listenStrategyCommit, listenStrategyCommitOnce, listenValidation, listenWalker, listenWalkerComplete, listenWalkerOnce, listenWalkerProgress, overrideActionSchema, overrideExchangeSchema, overrideFrameSchema, overrideRiskSchema, overrideSizingSchema, overrideStrategySchema, overrideWalkerSchema, parseArgs, roundTicks, set, setColumns, setConfig, setLogger, stopStrategy, validate, warmCandles };