backtest-kit 3.0.10 → 3.0.12

package/build/index.cjs

@@ -715,7 +715,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,
@@ -727,7 +727,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";
@@ -1625,7 +1625,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++) {
@@ -1681,7 +1681,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) {
@@ -1938,8 +1938,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,
@@ -1968,8 +1968,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;
 };
 /**
@@ -2114,9 +2114,9 @@ const WRITE_CANDLES_CACHE_FN$1 = functoolsKit.trycatch(functoolsKit.queued(async
  * @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) {
@@ -2224,14 +2224,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);
@@ -2305,15 +2305,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);
@@ -2473,13 +2473,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
@@ -2491,7 +2491,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
@@ -2503,8 +2503,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`);
@@ -2516,14 +2516,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.`);
@@ -2603,10 +2603,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);
     }
 }
@@ -3071,7 +3071,7 @@ const beginTime = (run) => (...args) => {
     return fn();
 };
 
-const INTERVAL_MINUTES$3 = {
+const INTERVAL_MINUTES$4 = {
     "1m": 1,
     "3m": 3,
     "5m": 5,
@@ -3584,7 +3584,7 @@ const GET_SIGNAL_FN = functoolsKit.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 &&
@@ -8195,7 +8195,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,
@@ -8250,7 +8250,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}`);
     }
@@ -26040,402 +26040,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 = functoolsKit.trycatch(async (dto, sinceTimestamp, untilTimestamp, exchangeName) => {
+    // PersistCandleAdapter.readCandlesData calculates expected timestamps:
+    // sinceTimestamp + i * stepMs for i = 0..limit-1
+    // Returns all candles if found, null if any missing
+    const cachedCandles = await PersistCandleAdapter.readCandlesData(dto.symbol, dto.interval, exchangeName, dto.limit, sinceTimestamp, untilTimestamp);
+    // Return cached data only if we have exactly the requested limit
+    if (cachedCandles?.length === dto.limit) {
+        bt.loggerService.debug(`ExchangeInstance READ_CANDLES_CACHE_FN: cache hit for exchangeName=${exchangeName}, symbol=${dto.symbol}, interval=${dto.interval}, limit=${dto.limit}`);
+        return cachedCandles;
+    }
+    bt.loggerService.warn(`ExchangeInstance READ_CANDLES_CACHE_FN: cache inconsistent (count or range mismatch) for exchangeName=${exchangeName}, symbol=${dto.symbol}, interval=${dto.interval}, limit=${dto.limit}`);
+    return null;
+}, {
+    fallback: async (error) => {
+        const message = `ExchangeInstance READ_CANDLES_CACHE_FN: cache read failed`;
+        const payload = {
+            error: functoolsKit.errorData(error),
+            message: functoolsKit.getErrorMessage(error),
+        };
+        bt.loggerService.warn(message, payload);
+        console.warn(message, payload);
+        errorEmitter.next(error);
+    },
+    defaultValue: null,
+});
 /**
- * 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 = functoolsKit.trycatch(functoolsKit.queued(async (candles, dto, exchangeName) => {
+    await PersistCandleAdapter.writeCandlesData(candles, dto.symbol, dto.interval, exchangeName);
+    bt.loggerService.debug(`ExchangeInstance WRITE_CANDLES_CACHE_FN: cache updated for exchangeName=${exchangeName}, symbol=${dto.symbol}, interval=${dto.interval}, count=${candles.length}`);
+}), {
+    fallback: async (error) => {
+        const message = `ExchangeInstance WRITE_CANDLES_CACHE_FN: cache write failed`;
+        const payload = {
+            error: functoolsKit.errorData(error),
+            message: functoolsKit.getErrorMessage(error),
+        };
+        bt.loggerService.warn(message, payload);
+        console.warn(message, payload);
+        errorEmitter.next(error);
+    },
+    defaultValue: null,
+});
 /**
- * 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 = functoolsKit.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 = path.join(baseDir, exchangeName, symbol, interval);
+    try {
+        await fs.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 fs.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 fs.opendir(dir)) {
+        if (!entry.isFile() || !entry.name.endsWith(".json")) {
+            continue;
+        }
+        const filePath = path.join(dir, entry.name);
+        const raw = await fs.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()) {
@@ -35175,143 +36035,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.
@@ -35319,7 +36043,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.
@@ -35327,7 +36051,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.
@@ -35335,7 +36059,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.
@@ -35343,14 +36067,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.
@@ -35359,897 +36083,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 = functoolsKit.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 = functoolsKit.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 = functoolsKit.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 = functoolsKit.trycatch(async (dto, sinceTimestamp, untilTimestamp, exchangeName) => {
-    // PersistCandleAdapter.readCandlesData calculates expected timestamps:
-    // sinceTimestamp + i * stepMs for i = 0..limit-1
-    // Returns all candles if found, null if any missing
-    const cachedCandles = await PersistCandleAdapter.readCandlesData(dto.symbol, dto.interval, exchangeName, dto.limit, sinceTimestamp, untilTimestamp);
-    // Return cached data only if we have exactly the requested limit
-    if (cachedCandles?.length === dto.limit) {
-        bt.loggerService.debug(`ExchangeInstance READ_CANDLES_CACHE_FN: cache hit for exchangeName=${exchangeName}, symbol=${dto.symbol}, interval=${dto.interval}, limit=${dto.limit}`);
-        return cachedCandles;
-    }
-    bt.loggerService.warn(`ExchangeInstance READ_CANDLES_CACHE_FN: cache inconsistent (count or range mismatch) for exchangeName=${exchangeName}, symbol=${dto.symbol}, interval=${dto.interval}, limit=${dto.limit}`);
-    return null;
-}, {
-    fallback: async (error) => {
-        const message = `ExchangeInstance READ_CANDLES_CACHE_FN: cache read failed`;
-        const payload = {
-            error: functoolsKit.errorData(error),
-            message: functoolsKit.getErrorMessage(error),
-        };
-        bt.loggerService.warn(message, payload);
-        console.warn(message, payload);
-        errorEmitter.next(error);
-    },
-    defaultValue: null,
-});
-/**
- * Writes candles to cache with error handling.
- *
- * 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 = functoolsKit.trycatch(functoolsKit.queued(async (candles, dto, exchangeName) => {
-    await PersistCandleAdapter.writeCandlesData(candles, dto.symbol, dto.interval, exchangeName);
-    bt.loggerService.debug(`ExchangeInstance WRITE_CANDLES_CACHE_FN: cache updated for exchangeName=${exchangeName}, symbol=${dto.symbol}, interval=${dto.interval}, count=${candles.length}`);
-}), {
-    fallback: async (error) => {
-        const message = `ExchangeInstance WRITE_CANDLES_CACHE_FN: cache write failed`;
-        const payload = {
-            error: functoolsKit.errorData(error),
-            message: functoolsKit.getErrorMessage(error),
+        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 = functoolsKit.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 = functoolsKit.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 = functoolsKit.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 = functoolsKit.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";
@@ -37225,6 +37357,7 @@ exports.addRiskSchema = addRiskSchema;
 exports.addSizingSchema = addSizingSchema;
 exports.addStrategySchema = addStrategySchema;
 exports.addWalkerSchema = addWalkerSchema;
+exports.checkCandles = checkCandles;
 exports.commitActivateScheduled = commitActivateScheduled;
 exports.commitBreakeven = commitBreakeven;
 exports.commitCancelScheduled = commitCancelScheduled;
@@ -37316,3 +37449,4 @@ exports.setConfig = setConfig;
 exports.setLogger = setLogger;
 exports.stopStrategy = stopStrategy;
 exports.validate = validate;
+exports.warmCandles = warmCandles;