backtest-kit 1.0.2 → 1.0.4

package/build/index.mjs

@@ -1,8 +1,68 @@
 import { createActivator } from 'di-kit';
-import { memoize, singlerun, sleep } from 'functools-kit';
 import { scoped } from 'di-scoped';
+import { memoize, makeExtendable, singleshot, getErrorMessage, not, trycatch, retry, randomString, ToolRegistry, sleep, singlerun } from 'functools-kit';
+import fs from 'fs/promises';
+import path, { join } from 'path';
+import crypto from 'crypto';
+import os from 'os';
 import Table from 'cli-table3';
 
+const { init, inject, provide } = createActivator("backtest");
+
+const MethodContextService = scoped(class {
+    constructor(context) {
+        this.context = context;
+    }
+});
+
+const baseServices$1 = {
+    loggerService: Symbol('loggerService'),
+};
+const contextServices$1 = {
+    executionContextService: Symbol('executionContextService'),
+    methodContextService: Symbol('methodContextService'),
+};
+const connectionServices$1 = {
+    exchangeConnectionService: Symbol('exchangeConnectionService'),
+    strategyConnectionService: Symbol('strategyConnectionService'),
+    frameConnectionService: Symbol('frameConnectionService'),
+};
+const schemaServices$1 = {
+    exchangeSchemaService: Symbol('exchangeSchemaService'),
+    strategySchemaService: Symbol('strategySchemaService'),
+    frameSchemaService: Symbol('frameSchemaService'),
+};
+const globalServices$1 = {
+    exchangeGlobalService: Symbol('exchangeGlobalService'),
+    strategyGlobalService: Symbol('strategyGlobalService'),
+    frameGlobalService: Symbol('frameGlobalService'),
+    liveGlobalService: Symbol('liveGlobalService'),
+    backtestGlobalService: Symbol('backtestGlobalService'),
+};
+const logicPrivateServices$1 = {
+    backtestLogicPrivateService: Symbol('backtestLogicPrivateService'),
+    liveLogicPrivateService: Symbol('liveLogicPrivateService'),
+};
+const logicPublicServices$1 = {
+    backtestLogicPublicService: Symbol('backtestLogicPublicService'),
+    liveLogicPublicService: Symbol('liveLogicPublicService'),
+};
+const TYPES = {
+    ...baseServices$1,
+    ...contextServices$1,
+    ...connectionServices$1,
+    ...schemaServices$1,
+    ...globalServices$1,
+    ...logicPrivateServices$1,
+    ...logicPublicServices$1,
+};
+
+const ExecutionContextService = scoped(class {
+    constructor(context) {
+        this.context = context;
+    }
+});
+
 const NOOP_LOGGER = {
     log() {
     },
@@ -13,51 +73,37 @@ const NOOP_LOGGER = {
 };
 class LoggerService {
     constructor() {
+        this.methodContextService = inject(TYPES.methodContextService);
+        this.executionContextService = inject(TYPES.executionContextService);
         this._commonLogger = NOOP_LOGGER;
         this.log = async (topic, ...args) => {
-            await this._commonLogger.log(topic, ...args);
+            await this._commonLogger.log(topic, ...args, this.methodContext, this.executionContext);
         };
         this.debug = async (topic, ...args) => {
-            await this._commonLogger.debug(topic, ...args);
+            await this._commonLogger.debug(topic, ...args, this.methodContext, this.executionContext);
         };
         this.info = async (topic, ...args) => {
-            await this._commonLogger.info(topic, ...args);
+            await this._commonLogger.info(topic, ...args, this.methodContext, this.executionContext);
         };
         this.setLogger = (logger) => {
             this._commonLogger = logger;
         };
     }
+    get methodContext() {
+        if (MethodContextService.hasContext()) {
+            return this.methodContextService.context;
+        }
+        return {};
+    }
+    get executionContext() {
+        if (ExecutionContextService.hasContext()) {
+            return this.executionContextService.context;
+        }
+        return {};
+    }
 }
 
-const { init, inject, provide } = createActivator("backtest");
-
-const baseServices$1 = {
-    loggerService: Symbol('loggerService'),
-};
-const contextServices$1 = {
-    executionContextService: Symbol('executionContextService'),
-};
-const connectionServices$1 = {
-    candleConnectionService: Symbol('candleConnectionService'),
-    strategyConnectionService: Symbol('strategyConnectionService'),
-};
-const schemaServices$1 = {
-    candleSchemaService: Symbol('candleSchemaService'),
-    strategySchemaService: Symbol('strategySchemaService'),
-};
-const publicServices$1 = {
-    candlePublicService: Symbol('candlePublicService'),
-    strategyPublicService: Symbol('strategyPublicService'),
-};
-const TYPES = {
-    ...baseServices$1,
-    ...contextServices$1,
-    ...connectionServices$1,
-    ...schemaServices$1,
-    ...publicServices$1,
-};
-
-const INTERVAL_MINUTES = {
+const INTERVAL_MINUTES$2 = {
     "1m": 1,
     "3m": 3,
     "5m": 5,
@@ -69,87 +115,148 @@ const INTERVAL_MINUTES = {
     "6h": 360,
     "8h": 480,
 };
-class ClientCandle {
+class ClientExchange {
     constructor(params) {
         this.params = params;
-        this.getCandles = async (symbol, interval, limit) => {
-            this.params.logger.debug(`ClientCandle getCandles`, {
-                symbol,
-                interval,
-                limit,
-            });
-            const step = INTERVAL_MINUTES[interval];
-            const adjust = step * limit;
-            if (!adjust) {
-                throw new Error(`ClientCandle unknown time adjust for interval=${interval}`);
-            }
-            const since = new Date(this.params.execution.context.when.getTime() - adjust * 60 * 1000);
-            const data = await this.params.getCandles(symbol, interval, since, limit);
-            if (this.params.callbacks?.onCandleData) {
-                this.params.callbacks.onCandleData(symbol, interval, since, limit, data);
-            }
-            return data;
-        };
-        this.getAveragePrice = async (symbol) => {
-            this.params.logger.debug(`ClientCandle getAveragePrice`, {
-                symbol,
-            });
-            const candles = await this.getCandles(symbol, "1m", 5);
-            if (candles.length === 0) {
-                throw new Error(`ClientCandle 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;
-        };
+    }
+    async getCandles(symbol, interval, limit) {
+        this.params.logger.debug(`ClientExchange getCandles`, {
+            symbol,
+            interval,
+            limit,
+        });
+        const step = INTERVAL_MINUTES$2[interval];
+        const adjust = step * limit - 1;
+        if (!adjust) {
+            throw new Error(`ClientExchange unknown time adjust for interval=${interval}`);
+        }
+        const since = new Date(this.params.execution.context.when.getTime() - adjust * 60 * 1000);
+        const data = await this.params.getCandles(symbol, interval, since, limit);
+        if (this.params.callbacks?.onCandleData) {
+            this.params.callbacks.onCandleData(symbol, interval, since, limit, data);
+        }
+        return data;
+    }
+    async getNextCandles(symbol, interval, limit) {
+        this.params.logger.debug(`ClientExchange getNextCandles`, {
+            symbol,
+            interval,
+            limit,
+        });
+        const since = new Date(this.params.execution.context.when.getTime());
+        const now = Date.now();
+        // Вычисляем конечное время запроса
+        const step = INTERVAL_MINUTES$2[interval];
+        const endTime = since.getTime() + limit * step * 60 * 1000;
+        // Проверяем что запрошенный период не заходит за Date.now()
+        if (endTime > now) {
+            return [];
+        }
+        const data = await this.params.getCandles(symbol, interval, since, limit);
+        if (this.params.callbacks?.onCandleData) {
+            this.params.callbacks.onCandleData(symbol, interval, since, limit, data);
+        }
+        return data;
+    }
+    async getAveragePrice(symbol) {
+        this.params.logger.debug(`ClientExchange getAveragePrice`, {
+            symbol,
+        });
+        const candles = await this.getCandles(symbol, "1m", 5);
+        if (candles.length === 0) {
+            throw new Error(`ClientExchange getAveragePrice: no candles data for symbol=${symbol}`);
+        }
+        // VWAP (Volume Weighted Average Price)
+        // Используем типичную цену (typical price) = (high + low + close) / 3
+        const sumPriceVolume = candles.reduce((acc, candle) => {
+            const typicalPrice = (candle.high + candle.low + candle.close) / 3;
+            return acc + typicalPrice * candle.volume;
+        }, 0);
+        const totalVolume = candles.reduce((acc, candle) => acc + candle.volume, 0);
+        if (totalVolume === 0) {
+            // Если объем нулевой, возвращаем простое среднее close цен
+            const sum = candles.reduce((acc, candle) => acc + candle.close, 0);
+            return sum / candles.length;
+        }
+        const vwap = sumPriceVolume / totalVolume;
+        return vwap;
+    }
+    async formatQuantity(symbol, quantity) {
+        this.params.logger.debug("binanceService formatQuantity", {
+            symbol,
+            quantity,
+        });
+        return await this.params.formatQuantity(symbol, quantity);
+    }
+    async formatPrice(symbol, price) {
+        this.params.logger.debug("binanceService formatPrice", {
+            symbol,
+            price,
+        });
+        return await this.params.formatPrice(symbol, price);
     }
 }
 
-class CandleConnectionService {
+class ExchangeConnectionService {
     constructor() {
         this.loggerService = inject(TYPES.loggerService);
         this.executionContextService = inject(TYPES.executionContextService);
-        this.candleSchemaService = inject(TYPES.candleSchemaService);
-        this.getCandle = memoize((symbol) => `${symbol}`, () => {
-            const { getCandles, callbacks } = this.candleSchemaService.getSchema();
-            return new ClientCandle({
+        this.exchangeSchemaService = inject(TYPES.exchangeSchemaService);
+        this.methodContextService = inject(TYPES.methodContextService);
+        this.getExchange = memoize((exchangeName) => `${exchangeName}`, (exchangeName) => {
+            const { getCandles, formatPrice, formatQuantity, callbacks } = this.exchangeSchemaService.get(exchangeName);
+            return new ClientExchange({
                 execution: this.executionContextService,
                 logger: this.loggerService,
+                exchangeName,
                 getCandles,
+                formatPrice,
+                formatQuantity,
                 callbacks,
             });
         });
         this.getCandles = async (symbol, interval, limit) => {
-            this.loggerService.log("candleConnectionService getCandles", {
+            this.loggerService.log("exchangeConnectionService getCandles", {
+                symbol,
+                interval,
+                limit,
+            });
+            return await this.getExchange(this.methodContextService.context.exchangeName).getCandles(symbol, interval, limit);
+        };
+        this.getNextCandles = async (symbol, interval, limit) => {
+            this.loggerService.log("exchangeConnectionService getNextCandles", {
                 symbol,
                 interval,
                 limit,
             });
-            return await this.getCandle(symbol).getCandles(symbol, interval, limit);
+            return await this.getExchange(this.methodContextService.context.exchangeName).getNextCandles(symbol, interval, limit);
         };
         this.getAveragePrice = async (symbol) => {
-            this.loggerService.log("candleConnectionService getAveragePrice", {
+            this.loggerService.log("exchangeConnectionService getAveragePrice", {
+                symbol,
+            });
+            return await this.getExchange(this.methodContextService.context.exchangeName).getAveragePrice(symbol);
+        };
+        this.formatPrice = async (symbol, price) => {
+            this.loggerService.log("exchangeConnectionService getAveragePrice", {
                 symbol,
+                price,
             });
-            return await this.getCandle(symbol).getAveragePrice(symbol);
+            return await this.getExchange(this.methodContextService.context.exchangeName).formatPrice(symbol, price);
+        };
+        this.formatQuantity = async (symbol, quantity) => {
+            this.loggerService.log("exchangeConnectionService getAveragePrice", {
+                symbol,
+                quantity,
+            });
+            return await this.getExchange(this.methodContextService.context.exchangeName).formatQuantity(symbol, quantity);
         };
     }
 }
 
 const PERCENT_SLIPPAGE = 0.1;
 const PERCENT_FEE = 0.1;
-const GET_PNL_FN = (signal, priceClose) => {
+const toProfitLossDto = (signal, priceClose) => {
     const priceOpen = signal.priceOpen;
     let priceOpenWithSlippage;
     let priceCloseWithSlippage;
@@ -188,48 +295,554 @@ const GET_PNL_FN = (signal, priceClose) => {
         priceClose,
     };
 };
+
+const IS_WINDOWS = os.platform() === "win32";
+/**
+ * Atomically writes data to a file, ensuring the operation either fully completes or leaves the original file unchanged.
+ * Uses a temporary file with a rename strategy on POSIX systems for atomicity, or direct writing with sync on Windows (or when POSIX rename is skipped).
+ *
+ *
+ * @param {string} file - The file parameter.
+ * @param {string | Buffer} data - The data to be processed or validated.
+ * @param {Options | BufferEncoding} options - The options parameter (optional).
+ * @throws {Error} Throws an error if the write, sync, or rename operation fails, after attempting cleanup of temporary files.
+ *
+ * @example
+ * // Basic usage with default options
+ * await writeFileAtomic("output.txt", "Hello, world!");
+ * // Writes "Hello, world!" to "output.txt" atomically
+ *
+ * @example
+ * // Custom options and Buffer data
+ * const buffer = Buffer.from("Binary data");
+ * await writeFileAtomic("data.bin", buffer, { encoding: "binary", mode: 0o644, tmpPrefix: "temp-" });
+ * // Writes binary data to "data.bin" with custom permissions and temp prefix
+ *
+ * @example
+ * // Using encoding shorthand
+ * await writeFileAtomic("log.txt", "Log entry", "utf16le");
+ * // Writes "Log entry" to "log.txt" in UTF-16LE encoding
+ *
+ * @remarks
+ * This function ensures atomicity to prevent partial writes:
+ * - On POSIX systems (non-Windows, unless `GLOBAL_CONFIG.CC_SKIP_POSIX_RENAME` is true):
+ *   - Writes data to a temporary file (e.g., `.tmp-<random>-filename`) in the same directory.
+ *   - Uses `crypto.randomBytes` to generate a unique temporary name, reducing collision risk.
+ *   - Syncs the data to disk and renames the temporary file to the target file atomically with `fs.rename`.
+ *   - Cleans up the temporary file on failure, swallowing cleanup errors to prioritize throwing the original error.
+ * - On Windows (or when POSIX rename is skipped):
+ *   - Writes directly to the target file, syncing data to disk to minimize corruption risk (though not fully atomic).
+ *   - Closes the file handle on failure without additional cleanup.
+ * - Accepts `options` as an object or a string (interpreted as `encoding`), defaulting to `{ encoding: "utf8", mode: 0o666, tmpPrefix: ".tmp-" }`.
+ * Useful in the agent swarm system for safely writing configuration files, logs, or state data where partial writes could cause corruption.
+ *
+ * @see {@link https://nodejs.org/api/fs.html#fspromiseswritefilefile-data-options|fs.promises.writeFile} for file writing details.
+ * @see {@link https://nodejs.org/api/crypto.html#cryptorandombytessize-callback|crypto.randomBytes} for temporary file naming.
+ * @see {@link ../config/params|GLOBAL_CONFIG} for configuration impacting POSIX behavior.
+*/
+async function writeFileAtomic(file, data, options = {}) {
+    if (typeof options === "string") {
+        options = { encoding: options };
+    }
+    else if (!options) {
+        options = {};
+    }
+    const { encoding = "utf8", mode = 0o666, tmpPrefix = ".tmp-" } = options;
+    let fileHandle = null;
+    if (IS_WINDOWS) {
+        try {
+            // Create and write to temporary file
+            fileHandle = await fs.open(file, "w", mode);
+            // Write data to the temp file
+            await fileHandle.writeFile(data, { encoding });
+            // Ensure data is flushed to disk
+            await fileHandle.sync();
+            // Close the file before rename
+            await fileHandle.close();
+        }
+        catch (error) {
+            // Clean up if something went wrong
+            if (fileHandle) {
+                await fileHandle.close().catch(() => { });
+            }
+            throw error; // Re-throw the original error
+        }
+        return;
+    }
+    // Create a temporary filename in the same directory
+    const dir = path.dirname(file);
+    const filename = path.basename(file);
+    const tmpFile = path.join(dir, `${tmpPrefix}${crypto.randomBytes(6).toString("hex")}-${filename}`);
+    try {
+        // Create and write to temporary file
+        fileHandle = await fs.open(tmpFile, "w", mode);
+        // Write data to the temp file
+        await fileHandle.writeFile(data, { encoding });
+        // Ensure data is flushed to disk
+        await fileHandle.sync();
+        // Close the file before rename
+        await fileHandle.close();
+        fileHandle = null;
+        // Atomically replace the target file with our temp file
+        await fs.rename(tmpFile, file);
+    }
+    catch (error) {
+        // Clean up if something went wrong
+        if (fileHandle) {
+            await fileHandle.close().catch(() => { });
+        }
+        // Try to remove the temporary file
+        try {
+            await fs.unlink(tmpFile).catch(() => { });
+        }
+        catch (_) {
+            // Ignore errors during cleanup
+        }
+        throw error;
+    }
+}
+
+var _a;
+const BASE_WAIT_FOR_INIT_SYMBOL = Symbol("wait-for-init");
+const PERSIST_SIGNAL_UTILS_METHOD_NAME_USE_PERSIST_SIGNAL_ADAPTER = "PersistSignalUtils.usePersistSignalAdapter";
+const PERSIST_SIGNAL_UTILS_METHOD_NAME_READ_DATA = "PersistSignalUtils.readSignalData";
+const PERSIST_SIGNAL_UTILS_METHOD_NAME_WRITE_DATA = "PersistSignalUtils.writeSignalData";
+const PERSIST_BASE_METHOD_NAME_CTOR = "PersistBase.CTOR";
+const PERSIST_BASE_METHOD_NAME_WAIT_FOR_INIT = "PersistBase.waitForInit";
+const PERSIST_BASE_METHOD_NAME_READ_VALUE = "PersistBase.readValue";
+const PERSIST_BASE_METHOD_NAME_WRITE_VALUE = "PersistBase.writeValue";
+const PERSIST_BASE_METHOD_NAME_HAS_VALUE = "PersistBase.hasValue";
+const PERSIST_BASE_METHOD_NAME_REMOVE_VALUE = "PersistBase.removeValue";
+const PERSIST_BASE_METHOD_NAME_REMOVE_ALL = "PersistBase.removeAll";
+const PERSIST_BASE_METHOD_NAME_VALUES = "PersistBase.values";
+const PERSIST_BASE_METHOD_NAME_KEYS = "PersistBase.keys";
+const BASE_WAIT_FOR_INIT_FN_METHOD_NAME = "PersistBase.waitForInitFn";
+const BASE_UNLINK_RETRY_COUNT = 5;
+const BASE_UNLINK_RETRY_DELAY = 1000;
+const BASE_WAIT_FOR_INIT_FN = async (self) => {
+    backtest$1.loggerService.debug(BASE_WAIT_FOR_INIT_FN_METHOD_NAME, {
+        entityName: self.entityName,
+        directory: self._directory,
+    });
+    await fs.mkdir(self._directory, { recursive: true });
+    for await (const key of self.keys()) {
+        try {
+            await self.readValue(key);
+        }
+        catch {
+            const filePath = self._getFilePath(key);
+            console.error(`agent-swarm PersistBase found invalid document for filePath=${filePath} entityName=${self.entityName}`);
+            if (await not(BASE_WAIT_FOR_INIT_UNLINK_FN(filePath))) {
+                console.error(`agent-swarm PersistBase failed to remove invalid document for filePath=${filePath} entityName=${self.entityName}`);
+            }
+        }
+    }
+};
+const BASE_WAIT_FOR_INIT_UNLINK_FN = async (filePath) => trycatch(retry(async () => {
+    try {
+        await fs.unlink(filePath);
+        return true;
+    }
+    catch (error) {
+        console.error(`agent-swarm PersistBase unlink failed for filePath=${filePath} error=${getErrorMessage(error)}`);
+        throw error;
+    }
+}, BASE_UNLINK_RETRY_COUNT, BASE_UNLINK_RETRY_DELAY), {
+    defaultValue: false,
+});
+const PersistBase = makeExtendable(class {
+    constructor(entityName, baseDir = join(process.cwd(), "logs/data")) {
+        this.entityName = entityName;
+        this.baseDir = baseDir;
+        this[_a] = singleshot(async () => await BASE_WAIT_FOR_INIT_FN(this));
+        backtest$1.loggerService.debug(PERSIST_BASE_METHOD_NAME_CTOR, {
+            entityName: this.entityName,
+            baseDir,
+        });
+        this._directory = join(this.baseDir, this.entityName);
+    }
+    _getFilePath(entityId) {
+        return join(this.baseDir, this.entityName, `${entityId}.json`);
+    }
+    async waitForInit(initial) {
+        backtest$1.loggerService.debug(PERSIST_BASE_METHOD_NAME_WAIT_FOR_INIT, {
+            entityName: this.entityName,
+            initial,
+        });
+        await this[BASE_WAIT_FOR_INIT_SYMBOL]();
+    }
+    async getCount() {
+        const files = await fs.readdir(this._directory);
+        const { length } = files.filter((file) => file.endsWith(".json"));
+        return length;
+    }
+    async readValue(entityId) {
+        backtest$1.loggerService.debug(PERSIST_BASE_METHOD_NAME_READ_VALUE, {
+            entityName: this.entityName,
+            entityId,
+        });
+        try {
+            const filePath = this._getFilePath(entityId);
+            const fileContent = await fs.readFile(filePath, "utf-8");
+            return JSON.parse(fileContent);
+        }
+        catch (error) {
+            if (error?.code === "ENOENT") {
+                throw new Error(`Entity ${this.entityName}:${entityId} not found`);
+            }
+            throw new Error(`Failed to read entity ${this.entityName}:${entityId}: ${getErrorMessage(error)}`);
+        }
+    }
+    async hasValue(entityId) {
+        backtest$1.loggerService.debug(PERSIST_BASE_METHOD_NAME_HAS_VALUE, {
+            entityName: this.entityName,
+            entityId,
+        });
+        try {
+            const filePath = this._getFilePath(entityId);
+            await fs.access(filePath);
+            return true;
+        }
+        catch (error) {
+            if (error?.code === "ENOENT") {
+                return false;
+            }
+            throw new Error(`Failed to check existence of entity ${this.entityName}:${entityId}: ${getErrorMessage(error)}`);
+        }
+    }
+    async writeValue(entityId, entity) {
+        backtest$1.loggerService.debug(PERSIST_BASE_METHOD_NAME_WRITE_VALUE, {
+            entityName: this.entityName,
+            entityId,
+        });
+        try {
+            const filePath = this._getFilePath(entityId);
+            const serializedData = JSON.stringify(entity);
+            await writeFileAtomic(filePath, serializedData, "utf-8");
+        }
+        catch (error) {
+            throw new Error(`Failed to write entity ${this.entityName}:${entityId}: ${getErrorMessage(error)}`);
+        }
+    }
+    async removeValue(entityId) {
+        backtest$1.loggerService.debug(PERSIST_BASE_METHOD_NAME_REMOVE_VALUE, {
+            entityName: this.entityName,
+            entityId,
+        });
+        try {
+            const filePath = this._getFilePath(entityId);
+            await fs.unlink(filePath);
+        }
+        catch (error) {
+            if (error?.code === "ENOENT") {
+                throw new Error(`Entity ${this.entityName}:${entityId} not found for deletion`);
+            }
+            throw new Error(`Failed to remove entity ${this.entityName}:${entityId}: ${getErrorMessage(error)}`);
+        }
+    }
+    async removeAll() {
+        backtest$1.loggerService.debug(PERSIST_BASE_METHOD_NAME_REMOVE_ALL, {
+            entityName: this.entityName,
+        });
+        try {
+            const files = await fs.readdir(this._directory);
+            const entityFiles = files.filter((file) => file.endsWith(".json"));
+            for (const file of entityFiles) {
+                await fs.unlink(join(this._directory, file));
+            }
+        }
+        catch (error) {
+            throw new Error(`Failed to remove values for ${this.entityName}: ${getErrorMessage(error)}`);
+        }
+    }
+    async *values() {
+        backtest$1.loggerService.debug(PERSIST_BASE_METHOD_NAME_VALUES, {
+            entityName: this.entityName,
+        });
+        try {
+            const files = await fs.readdir(this._directory);
+            const entityIds = files
+                .filter((file) => file.endsWith(".json"))
+                .map((file) => file.slice(0, -5))
+                .sort((a, b) => a.localeCompare(b, undefined, {
+                numeric: true,
+                sensitivity: "base",
+            }));
+            for (const entityId of entityIds) {
+                const entity = await this.readValue(entityId);
+                yield entity;
+            }
+        }
+        catch (error) {
+            throw new Error(`Failed to read values for ${this.entityName}: ${getErrorMessage(error)}`);
+        }
+    }
+    async *keys() {
+        backtest$1.loggerService.debug(PERSIST_BASE_METHOD_NAME_KEYS, {
+            entityName: this.entityName,
+        });
+        try {
+            const files = await fs.readdir(this._directory);
+            const entityIds = files
+                .filter((file) => file.endsWith(".json"))
+                .map((file) => file.slice(0, -5))
+                .sort((a, b) => a.localeCompare(b, undefined, {
+                numeric: true,
+                sensitivity: "base",
+            }));
+            for (const entityId of entityIds) {
+                yield entityId;
+            }
+        }
+        catch (error) {
+            throw new Error(`Failed to read keys for ${this.entityName}: ${getErrorMessage(error)}`);
+        }
+    }
+    async *[(_a = BASE_WAIT_FOR_INIT_SYMBOL, Symbol.asyncIterator)]() {
+        for await (const entity of this.values()) {
+            yield entity;
+        }
+    }
+    async *filter(predicate) {
+        for await (const entity of this.values()) {
+            if (predicate(entity)) {
+                yield entity;
+            }
+        }
+    }
+    async *take(total, predicate) {
+        let count = 0;
+        if (predicate) {
+            for await (const entity of this.values()) {
+                if (!predicate(entity)) {
+                    continue;
+                }
+                count += 1;
+                yield entity;
+                if (count >= total) {
+                    break;
+                }
+            }
+        }
+        else {
+            for await (const entity of this.values()) {
+                count += 1;
+                yield entity;
+                if (count >= total) {
+                    break;
+                }
+            }
+        }
+    }
+});
+class PersistSignalUtils {
+    constructor() {
+        this.PersistSignalFactory = PersistBase;
+        this.getSignalStorage = memoize(([strategyName]) => `${strategyName}`, (strategyName) => Reflect.construct(this.PersistSignalFactory, [
+            strategyName,
+            `./logs/data/signal/`,
+        ]));
+        this.readSignalData = async (strategyName, symbol) => {
+            backtest$1.loggerService.info(PERSIST_SIGNAL_UTILS_METHOD_NAME_READ_DATA);
+            const isInitial = !this.getSignalStorage.has(strategyName);
+            const stateStorage = this.getSignalStorage(strategyName);
+            await stateStorage.waitForInit(isInitial);
+            if (await stateStorage.hasValue(symbol)) {
+                const { signalRow } = await stateStorage.readValue(symbol);
+                return signalRow;
+            }
+            return null;
+        };
+        this.writeSignalData = async (signalRow, strategyName, symbol) => {
+            backtest$1.loggerService.info(PERSIST_SIGNAL_UTILS_METHOD_NAME_WRITE_DATA);
+            const isInitial = !this.getSignalStorage.has(strategyName);
+            const stateStorage = this.getSignalStorage(strategyName);
+            await stateStorage.waitForInit(isInitial);
+            await stateStorage.writeValue(symbol, { signalRow });
+        };
+    }
+    usePersistSignalAdapter(Ctor) {
+        backtest$1.loggerService.info(PERSIST_SIGNAL_UTILS_METHOD_NAME_USE_PERSIST_SIGNAL_ADAPTER);
+        this.PersistSignalFactory = Ctor;
+    }
+}
+const PersistSignalAdaper = new PersistSignalUtils();
+
+const INTERVAL_MINUTES$1 = {
+    "1m": 1,
+    "3m": 3,
+    "5m": 5,
+    "15m": 15,
+    "30m": 30,
+    "1h": 60,
+};
+const GET_SIGNAL_FN = trycatch(async (self) => {
+    const currentTime = self.params.execution.context.when.getTime();
+    {
+        const intervalMinutes = INTERVAL_MINUTES$1[self.params.interval];
+        const intervalMs = intervalMinutes * 60 * 1000;
+        // Проверяем что прошел нужный интервал с последнего getSignal
+        if (self._lastSignalTimestamp !== null &&
+            currentTime - self._lastSignalTimestamp < intervalMs) {
+            return null;
+        }
+        self._lastSignalTimestamp = currentTime;
+    }
+    const signal = await self.params.getSignal(self.params.execution.context.symbol);
+    if (!signal) {
+        return null;
+    }
+    return {
+        id: randomString(),
+        ...signal,
+    };
+}, {
+    defaultValue: null,
+});
+const GET_AVG_PRICE_FN = (candles) => {
+    const sumPriceVolume = candles.reduce((acc, c) => {
+        const typicalPrice = (c.high + c.low + c.close) / 3;
+        return acc + typicalPrice * c.volume;
+    }, 0);
+    const totalVolume = candles.reduce((acc, c) => acc + c.volume, 0);
+    return totalVolume === 0
+        ? candles.reduce((acc, c) => acc + c.close, 0) / candles.length
+        : sumPriceVolume / totalVolume;
+};
+const WAIT_FOR_INIT_FN = async (self) => {
+    self.params.logger.debug("ClientStrategy waitForInit");
+    if (self.params.execution.context.backtest) {
+        return;
+    }
+    self._pendingSignal = await PersistSignalAdaper.readSignalData(self.params.strategyName, self.params.execution.context.symbol);
+};
 class ClientStrategy {
     constructor(params) {
         this.params = params;
         this._pendingSignal = null;
-        this.tick = async (symbol) => {
-            this.params.logger.debug("ClientStrategy tick", {
-                symbol,
-            });
-            if (!this._pendingSignal) {
-                this._pendingSignal = await this.params.getSignal(this.params.symbol);
-                if (this._pendingSignal) {
-                    if (this.params.callbacks?.onOpen) {
-                        this.params.callbacks.onOpen(this.params.execution.context.backtest, symbol, this._pendingSignal);
-                    }
-                    return {
-                        action: "opened",
-                        signal: this._pendingSignal,
-                    };
+        this._lastSignalTimestamp = null;
+        this.waitForInit = singleshot(async () => await WAIT_FOR_INIT_FN(this));
+    }
+    async setPendingSignal(pendingSignal) {
+        this.params.logger.debug("ClientStrategy setPendingSignal", {
+            pendingSignal,
+        });
+        this._pendingSignal = pendingSignal;
+        if (this.params.execution.context.backtest) {
+            return;
+        }
+        await PersistSignalAdaper.writeSignalData(this._pendingSignal, this.params.strategyName, this.params.execution.context.symbol);
+    }
+    async tick() {
+        this.params.logger.debug("ClientStrategy tick");
+        if (!this._pendingSignal) {
+            const pendingSignal = await GET_SIGNAL_FN(this);
+            await this.setPendingSignal(pendingSignal);
+            if (this._pendingSignal) {
+                if (this.params.callbacks?.onOpen) {
+                    this.params.callbacks.onOpen(this.params.execution.context.backtest, this.params.execution.context.symbol, this._pendingSignal);
                 }
                 return {
-                    action: "idle",
-                    signal: null,
+                    action: "opened",
+                    signal: this._pendingSignal,
                 };
             }
-            const when = this.params.execution.context.when;
-            const signal = this._pendingSignal;
-            // Получаем среднюю цену
-            const averagePrice = await this.params.candle.getAveragePrice(symbol);
-            this.params.logger.debug("ClientStrategy tick check", {
-                symbol,
-                averagePrice,
+            return {
+                action: "idle",
+                signal: null,
+            };
+        }
+        const when = this.params.execution.context.when;
+        const signal = this._pendingSignal;
+        // Получаем среднюю цену
+        const averagePrice = await this.params.exchange.getAveragePrice(this.params.execution.context.symbol);
+        this.params.logger.debug("ClientStrategy tick check", {
+            symbol: this.params.execution.context.symbol,
+            averagePrice,
+            signalId: signal.id,
+            position: signal.position,
+        });
+        let shouldClose = false;
+        let closeReason;
+        // Проверяем истечение времени
+        const signalEndTime = signal.timestamp + signal.minuteEstimatedTime * 60 * 1000;
+        if (when.getTime() >= signalEndTime) {
+            shouldClose = true;
+            closeReason = "time_expired";
+        }
+        // Проверяем достижение TP/SL для long позиции
+        if (signal.position === "long") {
+            if (averagePrice >= signal.priceTakeProfit) {
+                shouldClose = true;
+                closeReason = "take_profit";
+            }
+            else if (averagePrice <= signal.priceStopLoss) {
+                shouldClose = true;
+                closeReason = "stop_loss";
+            }
+        }
+        // Проверяем достижение TP/SL для short позиции
+        if (signal.position === "short") {
+            if (averagePrice <= signal.priceTakeProfit) {
+                shouldClose = true;
+                closeReason = "take_profit";
+            }
+            else if (averagePrice >= signal.priceStopLoss) {
+                shouldClose = true;
+                closeReason = "stop_loss";
+            }
+        }
+        // Закрываем сигнал если выполнены условия
+        if (shouldClose) {
+            const pnl = toProfitLossDto(signal, averagePrice);
+            const closeTimestamp = this.params.execution.context.when.getTime();
+            this.params.logger.debug("ClientStrategy closing", {
+                symbol: this.params.execution.context.symbol,
                 signalId: signal.id,
-                position: signal.position,
+                reason: closeReason,
+                priceClose: averagePrice,
+                closeTimestamp,
+                pnlPercentage: pnl.pnlPercentage,
             });
+            if (this.params.callbacks?.onClose) {
+                this.params.callbacks.onClose(this.params.execution.context.backtest, this.params.execution.context.symbol, averagePrice, signal);
+            }
+            await this.setPendingSignal(null);
+            return {
+                action: "closed",
+                signal: signal,
+                currentPrice: averagePrice,
+                closeReason: closeReason,
+                closeTimestamp: closeTimestamp,
+                pnl: pnl,
+            };
+        }
+        return {
+            action: "active",
+            signal: signal,
+            currentPrice: averagePrice,
+        };
+    }
+    async backtest(candles) {
+        this.params.logger.debug("ClientStrategy backtest", {
+            symbol: this.params.execution.context.symbol,
+            candlesCount: candles.length,
+        });
+        const signal = this._pendingSignal;
+        if (!signal) {
+            throw new Error("ClientStrategy backtest: no pending signal");
+        }
+        if (!this.params.execution.context.backtest) {
+            throw new Error("ClientStrategy backtest: running in live context");
+        }
+        // Проверяем каждую свечу на достижение TP/SL
+        // Начинаем с индекса 4 (пятая свеча), чтобы было минимум 5 свечей для VWAP
+        for (let i = 4; i < candles.length; i++) {
+            // Вычисляем VWAP из последних 5 свечей для текущего момента
+            const recentCandles = candles.slice(i - 4, i + 1);
+            const averagePrice = GET_AVG_PRICE_FN(recentCandles);
             let shouldClose = false;
             let closeReason;
-            // Проверяем истечение времени
-            const signalEndTime = signal.timestamp + signal.minuteEstimatedTime * 60 * 1000;
-            if (when.getTime() >= signalEndTime) {
-                shouldClose = true;
-                closeReason = "time_expired";
-            }
             // Проверяем достижение TP/SL для long позиции
             if (signal.position === "long") {
                 if (averagePrice >= signal.priceTakeProfit) {
@@ -252,33 +865,55 @@ class ClientStrategy {
                     closeReason = "stop_loss";
                 }
             }
-            // Закрываем сигнал если выполнены условия
+            // Если достигнут TP/SL, закрываем сигнал
             if (shouldClose) {
-                const pnl = GET_PNL_FN(signal, averagePrice);
-                this.params.logger.debug("ClientStrategy closing", {
-                    symbol,
+                const pnl = toProfitLossDto(signal, averagePrice);
+                const closeTimestamp = recentCandles[recentCandles.length - 1].timestamp;
+                this.params.logger.debug("ClientStrategy backtest closing", {
+                    symbol: this.params.execution.context.symbol,
                     signalId: signal.id,
                     reason: closeReason,
                     priceClose: averagePrice,
+                    closeTimestamp,
                     pnlPercentage: pnl.pnlPercentage,
                 });
                 if (this.params.callbacks?.onClose) {
-                    this.params.callbacks.onClose(this.params.execution.context.backtest, symbol, averagePrice, signal);
+                    this.params.callbacks.onClose(this.params.execution.context.backtest, this.params.execution.context.symbol, averagePrice, signal);
                 }
-                this._pendingSignal = null;
+                await this.setPendingSignal(null);
                 return {
                     action: "closed",
                     signal: signal,
                     currentPrice: averagePrice,
                     closeReason: closeReason,
+                    closeTimestamp: closeTimestamp,
                     pnl: pnl,
                 };
             }
-            return {
-                action: "active",
-                signal: signal,
-                currentPrice: averagePrice,
-            };
+        }
+        // Если TP/SL не достигнут за период, вычисляем VWAP из последних 5 свечей
+        const lastFiveCandles = candles.slice(-5);
+        const lastPrice = GET_AVG_PRICE_FN(lastFiveCandles);
+        const closeTimestamp = lastFiveCandles[lastFiveCandles.length - 1].timestamp;
+        const pnl = toProfitLossDto(signal, lastPrice);
+        this.params.logger.debug("ClientStrategy backtest time_expired", {
+            symbol: this.params.execution.context.symbol,
+            signalId: signal.id,
+            priceClose: lastPrice,
+            closeTimestamp,
+            pnlPercentage: pnl.pnlPercentage,
+        });
+        if (this.params.callbacks?.onClose) {
+            this.params.callbacks.onClose(this.params.execution.context.backtest, this.params.execution.context.symbol, lastPrice, signal);
+        }
+        await this.setPendingSignal(null);
+        return {
+            action: "closed",
+            signal: signal,
+            currentPrice: lastPrice,
+            closeReason: "time_expired",
+            closeTimestamp: closeTimestamp,
+            pnl: pnl,
         };
     }
 }
@@ -288,39 +923,108 @@ class StrategyConnectionService {
         this.loggerService = inject(TYPES.loggerService);
         this.executionContextService = inject(TYPES.executionContextService);
         this.strategySchemaService = inject(TYPES.strategySchemaService);
-        this.candleConnectionService = inject(TYPES.candleConnectionService);
-        this.getStrategy = memoize((symbol) => `${symbol}`, (symbol) => {
-            const { getSignal, callbacks } = this.strategySchemaService.getSchema();
+        this.exchangeConnectionService = inject(TYPES.exchangeConnectionService);
+        this.methodContextService = inject(TYPES.methodContextService);
+        this.getStrategy = memoize((strategyName) => `${strategyName}`, (strategyName) => {
+            const { getSignal, interval, callbacks } = this.strategySchemaService.get(strategyName);
             return new ClientStrategy({
-                symbol,
+                interval,
                 execution: this.executionContextService,
                 logger: this.loggerService,
-                candle: this.candleConnectionService,
+                exchange: this.exchangeConnectionService,
+                strategyName,
                 getSignal,
                 callbacks,
             });
         });
-        this.tick = async (symbol) => {
-            this.loggerService.log("strategyConnectionService tick", {
-                symbol,
-            });
-            return await this.getStrategy(symbol).tick(symbol);
+        this.tick = async () => {
+            this.loggerService.log("strategyConnectionService tick");
+            const strategy = await this.getStrategy(this.methodContextService.context.strategyName);
+            await strategy.waitForInit();
+            return await strategy.tick();
+        };
+        this.backtest = async (candles) => {
+            this.loggerService.log("strategyConnectionService backtest");
+            const strategy = await this.getStrategy(this.methodContextService.context.strategyName);
+            await strategy.waitForInit();
+            return await strategy.backtest(candles);
         };
     }
 }
 
-const ExecutionContextService = scoped(class {
-    constructor(context) {
-        this.context = context;
+const INTERVAL_MINUTES = {
+    "1m": 1,
+    "3m": 3,
+    "5m": 5,
+    "15m": 15,
+    "30m": 30,
+    "1h": 60,
+    "2h": 120,
+    "4h": 240,
+    "6h": 360,
+    "8h": 480,
+    "12h": 720,
+    "1d": 1440,
+    "3d": 4320,
+};
+const GET_TIMEFRAME_FN = async (symbol, self) => {
+    self.params.logger.debug("ClientFrame getTimeframe", {
+        symbol,
+    });
+    const { interval, startDate, endDate } = self.params;
+    const intervalMinutes = INTERVAL_MINUTES[interval];
+    if (!intervalMinutes) {
+        throw new Error(`ClientFrame unknown interval: ${interval}`);
     }
-});
+    const timeframes = [];
+    let currentDate = new Date(startDate);
+    while (currentDate <= endDate) {
+        timeframes.push(new Date(currentDate));
+        currentDate = new Date(currentDate.getTime() + intervalMinutes * 60 * 1000);
+    }
+    if (self.params.callbacks?.onTimeframe) {
+        self.params.callbacks.onTimeframe(timeframes, startDate, endDate, interval);
+    }
+    return timeframes;
+};
+class ClientFrame {
+    constructor(params) {
+        this.params = params;
+        this.getTimeframe = singleshot(async (symbol) => await GET_TIMEFRAME_FN(symbol, this));
+    }
+}
 
-class CandlePublicService {
+class FrameConnectionService {
     constructor() {
         this.loggerService = inject(TYPES.loggerService);
-        this.candleConnectionService = inject(TYPES.candleConnectionService);
+        this.frameSchemaService = inject(TYPES.frameSchemaService);
+        this.methodContextService = inject(TYPES.methodContextService);
+        this.getFrame = memoize((frameName) => `${frameName}`, (frameName) => {
+            const { endDate, interval, startDate, callbacks } = this.frameSchemaService.get(frameName);
+            return new ClientFrame({
+                frameName,
+                logger: this.loggerService,
+                startDate,
+                endDate,
+                interval,
+                callbacks,
+            });
+        });
+        this.getTimeframe = async (symbol) => {
+            this.loggerService.log("frameConnectionService getTimeframe", {
+                symbol,
+            });
+            return await this.getFrame(this.methodContextService.context.frameName).getTimeframe(symbol);
+        };
+    }
+}
+
+class ExchangeGlobalService {
+    constructor() {
+        this.loggerService = inject(TYPES.loggerService);
+        this.exchangeConnectionService = inject(TYPES.exchangeConnectionService);
         this.getCandles = async (symbol, interval, limit, when, backtest) => {
-            this.loggerService.log("candlePublicService getCandles", {
+            this.loggerService.log("exchangeGlobalService getCandles", {
                 symbol,
                 interval,
                 limit,
@@ -328,21 +1032,69 @@ class CandlePublicService {
                 backtest,
             });
             return await ExecutionContextService.runInContext(async () => {
-                return await this.candleConnectionService.getCandles(symbol, interval, limit);
+                return await this.exchangeConnectionService.getCandles(symbol, interval, limit);
             }, {
+                symbol,
+                when,
+                backtest,
+            });
+        };
+        this.getNextCandles = async (symbol, interval, limit, when, backtest) => {
+            this.loggerService.log("exchangeGlobalService getNextCandles", {
+                symbol,
+                interval,
+                limit,
+                when,
+                backtest,
+            });
+            return await ExecutionContextService.runInContext(async () => {
+                return await this.exchangeConnectionService.getNextCandles(symbol, interval, limit);
+            }, {
+                symbol,
                 when,
                 backtest,
             });
         };
         this.getAveragePrice = async (symbol, when, backtest) => {
-            this.loggerService.log("candlePublicService getAveragePrice", {
+            this.loggerService.log("exchangeGlobalService getAveragePrice", {
+                symbol,
+                when,
+                backtest,
+            });
+            return await ExecutionContextService.runInContext(async () => {
+                return await this.exchangeConnectionService.getAveragePrice(symbol);
+            }, {
                 symbol,
                 when,
                 backtest,
             });
+        };
+        this.formatPrice = async (symbol, price, when, backtest) => {
+            this.loggerService.log("exchangeGlobalService formatPrice", {
+                symbol,
+                price,
+                when,
+                backtest,
+            });
             return await ExecutionContextService.runInContext(async () => {
-                return await this.candleConnectionService.getAveragePrice(symbol);
+                return await this.exchangeConnectionService.formatPrice(symbol, price);
             }, {
+                symbol,
+                when,
+                backtest,
+            });
+        };
+        this.formatQuantity = async (symbol, quantity, when, backtest) => {
+            this.loggerService.log("exchangeGlobalService formatQuantity", {
+                symbol,
+                quantity,
+                when,
+                backtest,
+            });
+            return await ExecutionContextService.runInContext(async () => {
+                return await this.exchangeConnectionService.formatQuantity(symbol, quantity);
+            }, {
+                symbol,
                 when,
                 backtest,
             });
@@ -350,19 +1102,34 @@ class CandlePublicService {
     }
 }
 
-class StrategyPublicService {
+class StrategyGlobalService {
     constructor() {
         this.loggerService = inject(TYPES.loggerService);
         this.strategyConnectionService = inject(TYPES.strategyConnectionService);
         this.tick = async (symbol, when, backtest) => {
-            this.loggerService.log("strategyPublicService tick", {
+            this.loggerService.log("strategyGlobalService tick", {
+                symbol,
+                when,
+                backtest,
+            });
+            return await ExecutionContextService.runInContext(async () => {
+                return await this.strategyConnectionService.tick();
+            }, {
+                symbol,
+                when,
+                backtest,
+            });
+        };
+        this.backtest = async (symbol, candles, when, backtest) => {
+            this.loggerService.log("strategyGlobalService backtest", {
                 symbol,
                 when,
                 backtest,
             });
             return await ExecutionContextService.runInContext(async () => {
-                return await this.strategyConnectionService.tick(symbol);
+                return await this.strategyConnectionService.backtest(candles);
             }, {
+                symbol,
                 when,
                 backtest,
             });
@@ -370,19 +1137,35 @@ class StrategyPublicService {
     }
 }
 
-class CandleSchemaService {
+class FrameGlobalService {
     constructor() {
         this.loggerService = inject(TYPES.loggerService);
-        this.getSchema = () => {
-            this.loggerService.log("candleSchemaService getSchema");
-            if (!this._candleSchema) {
-                throw new Error("CandleSchemaService no candle source provided");
-            }
-            return this._candleSchema;
+        this.frameConnectionService = inject(TYPES.frameConnectionService);
+        this.getTimeframe = async (symbol) => {
+            this.loggerService.log("frameGlobalService getTimeframe", {
+                symbol,
+            });
+            return await this.frameConnectionService.getTimeframe(symbol);
+        };
+    }
+}
+
+class ExchangeSchemaService {
+    constructor() {
+        this.loggerService = inject(TYPES.loggerService);
+        this._registry = new ToolRegistry("exchangeSchema");
+        this.register = (key, value) => {
+            this.loggerService.info(`exchangeSchemaService register`, { key });
+            this._registry = this._registry.register(key, value);
         };
-        this.addSchema = (candleSchema) => {
-            this.loggerService.log("candleSchemaService addSchema");
-            this._candleSchema = candleSchema;
+        this.override = (key, value) => {
+            this.loggerService.info(`exchangeSchemaService override`, { key });
+            this._registry = this._registry.override(key, value);
+            return this._registry.get(key);
+        };
+        this.get = (key) => {
+            this.loggerService.info(`exchangeSchemaService get`, { key });
+            return this._registry.get(key);
         };
     }
 }
@@ -390,16 +1173,183 @@ class CandleSchemaService {
 class StrategySchemaService {
     constructor() {
         this.loggerService = inject(TYPES.loggerService);
-        this.getSchema = () => {
-            this.loggerService.log("strategySchemaService getSchema");
-            if (!this._strategySchema) {
-                throw new Error("StrategySchemaService no strategy provided");
+        this._registry = new ToolRegistry("strategySchema");
+        this.register = (key, value) => {
+            this.loggerService.info(`strategySchemaService register`, { key });
+            this._registry = this._registry.register(key, value);
+        };
+        this.override = (key, value) => {
+            this.loggerService.info(`strategySchemaService override`, { key });
+            this._registry = this._registry.override(key, value);
+            return this._registry.get(key);
+        };
+        this.get = (key) => {
+            this.loggerService.info(`strategySchemaService get`, { key });
+            return this._registry.get(key);
+        };
+    }
+}
+
+class FrameSchemaService {
+    constructor() {
+        this._registry = new ToolRegistry("frameSchema");
+    }
+    register(key, value) {
+        this._registry.register(key, value);
+    }
+    override(key, value) {
+        this._registry.override(key, value);
+    }
+    get(key) {
+        return this._registry.get(key);
+    }
+}
+
+class BacktestLogicPrivateService {
+    constructor() {
+        this.loggerService = inject(TYPES.loggerService);
+        this.strategyGlobalService = inject(TYPES.strategyGlobalService);
+        this.exchangeGlobalService = inject(TYPES.exchangeGlobalService);
+        this.frameGlobalService = inject(TYPES.frameGlobalService);
+    }
+    async *run(symbol) {
+        this.loggerService.log("backtestLogicPrivateService run", {
+            symbol,
+        });
+        const timeframes = await this.frameGlobalService.getTimeframe(symbol);
+        let i = 0;
+        while (i < timeframes.length) {
+            const when = timeframes[i];
+            const result = await this.strategyGlobalService.tick(symbol, when, true);
+            // Если сигнал открыт, вызываем backtest
+            if (result.action === "opened") {
+                const signal = result.signal;
+                this.loggerService.info("backtestLogicPrivateService signal opened", {
+                    symbol,
+                    signalId: signal.id,
+                    minuteEstimatedTime: signal.minuteEstimatedTime,
+                });
+                // Получаем свечи для бектеста
+                const candles = await this.exchangeGlobalService.getNextCandles(symbol, "1m", signal.minuteEstimatedTime, when, true);
+                if (!candles.length) {
+                    return;
+                }
+                this.loggerService.info("backtestLogicPrivateService candles fetched", {
+                    symbol,
+                    signalId: signal.id,
+                    candlesCount: candles.length,
+                });
+                // Вызываем backtest - всегда возвращает closed
+                const backtestResult = await this.strategyGlobalService.backtest(symbol, candles, when, true);
+                this.loggerService.info("backtestLogicPrivateService signal closed", {
+                    symbol,
+                    signalId: backtestResult.signal.id,
+                    closeTimestamp: backtestResult.closeTimestamp,
+                    closeReason: backtestResult.closeReason,
+                });
+                // Пропускаем timeframes до closeTimestamp
+                while (i < timeframes.length &&
+                    timeframes[i].getTime() < backtestResult.closeTimestamp) {
+                    i++;
+                }
+                yield backtestResult;
+            }
+            i++;
+        }
+    }
+}
+
+const TICK_TTL = 1 * 60 * 1000 + 1;
+class LiveLogicPrivateService {
+    constructor() {
+        this.loggerService = inject(TYPES.loggerService);
+        this.strategyGlobalService = inject(TYPES.strategyGlobalService);
+    }
+    async *run(symbol) {
+        this.loggerService.log("liveLogicPrivateService run", {
+            symbol,
+        });
+        while (true) {
+            const when = new Date();
+            const result = await this.strategyGlobalService.tick(symbol, when, false);
+            this.loggerService.info("liveLogicPrivateService tick result", {
+                symbol,
+                action: result.action,
+            });
+            if (result.action === "active") {
+                await sleep(TICK_TTL);
+                continue;
+            }
+            if (result.action === "idle") {
+                await sleep(TICK_TTL);
+                continue;
             }
-            return this._strategySchema;
+            yield result;
+            await sleep(TICK_TTL);
+        }
+    }
+}
+
+class BacktestLogicPublicService {
+    constructor() {
+        this.loggerService = inject(TYPES.loggerService);
+        this.backtestLogicPrivateService = inject(TYPES.backtestLogicPrivateService);
+        this.run = (symbol, context) => {
+            this.loggerService.log("backtestLogicPublicService run", {
+                symbol,
+                context,
+            });
+            return MethodContextService.runAsyncIterator(this.backtestLogicPrivateService.run(symbol), {
+                exchangeName: context.exchangeName,
+                strategyName: context.strategyName,
+                frameName: context.frameName,
+            });
         };
-        this.addSchema = (strategySchema) => {
-            this.loggerService.log("strategySchemaService addSchema");
-            this._strategySchema = strategySchema;
+    }
+}
+
+class LiveLogicPublicService {
+    constructor() {
+        this.loggerService = inject(TYPES.loggerService);
+        this.liveLogicPrivateService = inject(TYPES.liveLogicPrivateService);
+        this.run = (symbol, context) => {
+            this.loggerService.log("liveLogicPublicService run", {
+                symbol,
+                context,
+            });
+            return MethodContextService.runAsyncIterator(this.liveLogicPrivateService.run(symbol), {
+                exchangeName: context.exchangeName,
+                strategyName: context.strategyName,
+                frameName: "",
+            });
+        };
+    }
+}
+
+class LiveGlobalService {
+    constructor() {
+        this.loggerService = inject(TYPES.loggerService);
+        this.liveLogicPublicService = inject(TYPES.liveLogicPublicService);
+        this.run = (symbol, context) => {
+            this.loggerService.log("liveGlobalService run", {
+                symbol,
+                context,
+            });
+            return this.liveLogicPublicService.run(symbol, context);
+        };
+    }
+}
+
+class BacktestGlobalService {
+    constructor() {
+        this.loggerService = inject(TYPES.loggerService);
+        this.backtestLogicPublicService = inject(TYPES.backtestLogicPublicService);
+        this.run = (symbol, context) => {
+            this.loggerService.log("backtestGlobalService run", {
+                symbol,
+                context,
+            });
+            return this.backtestLogicPublicService.run(symbol, context);
         };
     }
 }
@@ -409,18 +1359,32 @@ class StrategySchemaService {
 }
 {
     provide(TYPES.executionContextService, () => new ExecutionContextService());
+    provide(TYPES.methodContextService, () => new MethodContextService());
 }
 {
-    provide(TYPES.candleConnectionService, () => new CandleConnectionService());
+    provide(TYPES.exchangeConnectionService, () => new ExchangeConnectionService());
     provide(TYPES.strategyConnectionService, () => new StrategyConnectionService());
+    provide(TYPES.frameConnectionService, () => new FrameConnectionService());
 }
 {
-    provide(TYPES.candleSchemaService, () => new CandleSchemaService());
+    provide(TYPES.exchangeSchemaService, () => new ExchangeSchemaService());
     provide(TYPES.strategySchemaService, () => new StrategySchemaService());
+    provide(TYPES.frameSchemaService, () => new FrameSchemaService());
+}
+{
+    provide(TYPES.exchangeGlobalService, () => new ExchangeGlobalService());
+    provide(TYPES.strategyGlobalService, () => new StrategyGlobalService());
+    provide(TYPES.frameGlobalService, () => new FrameGlobalService());
+    provide(TYPES.liveGlobalService, () => new LiveGlobalService());
+    provide(TYPES.backtestGlobalService, () => new BacktestGlobalService());
+}
+{
+    provide(TYPES.backtestLogicPrivateService, () => new BacktestLogicPrivateService());
+    provide(TYPES.liveLogicPrivateService, () => new LiveLogicPrivateService());
 }
 {
-    provide(TYPES.candlePublicService, () => new CandlePublicService());
-    provide(TYPES.strategyPublicService, () => new StrategyPublicService());
+    provide(TYPES.backtestLogicPublicService, () => new BacktestLogicPublicService());
+    provide(TYPES.liveLogicPublicService, () => new LiveLogicPublicService());
 }
 
 const baseServices = {
@@ -428,39 +1392,75 @@ const baseServices = {
 };
 const contextServices = {
     executionContextService: inject(TYPES.executionContextService),
+    methodContextService: inject(TYPES.methodContextService),
 };
 const connectionServices = {
-    candleConnectionService: inject(TYPES.candleConnectionService),
+    exchangeConnectionService: inject(TYPES.exchangeConnectionService),
     strategyConnectionService: inject(TYPES.strategyConnectionService),
+    frameConnectionService: inject(TYPES.frameConnectionService),
 };
 const schemaServices = {
-    candleSchemaService: inject(TYPES.candleSchemaService),
+    exchangeSchemaService: inject(TYPES.exchangeSchemaService),
     strategySchemaService: inject(TYPES.strategySchemaService),
+    frameSchemaService: inject(TYPES.frameSchemaService),
+};
+const globalServices = {
+    exchangeGlobalService: inject(TYPES.exchangeGlobalService),
+    strategyGlobalService: inject(TYPES.strategyGlobalService),
+    frameGlobalService: inject(TYPES.frameGlobalService),
+    liveGlobalService: inject(TYPES.liveGlobalService),
+    backtestGlobalService: inject(TYPES.backtestGlobalService),
 };
-const publicServices = {
-    candlePublicService: inject(TYPES.candlePublicService),
-    strategyPublicService: inject(TYPES.strategyPublicService),
+const logicPrivateServices = {
+    backtestLogicPrivateService: inject(TYPES.backtestLogicPrivateService),
+    liveLogicPrivateService: inject(TYPES.liveLogicPrivateService),
+};
+const logicPublicServices = {
+    backtestLogicPublicService: inject(TYPES.backtestLogicPublicService),
+    liveLogicPublicService: inject(TYPES.liveLogicPublicService),
 };
 const backtest = {
     ...baseServices,
     ...contextServices,
     ...connectionServices,
     ...schemaServices,
-    ...publicServices,
+    ...globalServices,
+    ...logicPrivateServices,
+    ...logicPublicServices,
 };
 init();
+var backtest$1 = backtest;
 
+async function setLogger(logger) {
+    backtest$1.loggerService.setLogger(logger);
+}
+
+const ADD_STRATEGY_METHOD_NAME = "add.addStrategy";
+const ADD_EXCHANGE_METHOD_NAME = "add.addExchange";
+const ADD_FRAME_METHOD_NAME = "add.addFrame";
 function addStrategy(strategySchema) {
-    backtest.strategySchemaService.addSchema(strategySchema);
+    backtest$1.loggerService.info(ADD_STRATEGY_METHOD_NAME, {
+        strategySchema,
+    });
+    backtest$1.strategySchemaService.register(strategySchema.strategyName, strategySchema);
 }
-function addCandle(candleSchema) {
-    backtest.candleSchemaService.addSchema(candleSchema);
+function addExchange(exchangeSchema) {
+    backtest$1.loggerService.info(ADD_EXCHANGE_METHOD_NAME, {
+        exchangeSchema,
+    });
+    backtest$1.exchangeSchemaService.register(exchangeSchema.exchangeName, exchangeSchema);
+}
+function addFrame(frameSchema) {
+    backtest$1.loggerService.info(ADD_FRAME_METHOD_NAME, {
+        frameSchema,
+    });
+    backtest$1.frameSchemaService.register(frameSchema.frameName, frameSchema);
 }
 
 async function runBacktest(symbol, timeframes) {
     const results = [];
     for (const when of timeframes) {
-        const result = await backtest.strategyPublicService.tick(symbol, when, true);
+        const result = await backtest$1.strategyGlobalService.tick(symbol, when, true);
         // Сохраняем только результаты closed
         if (result.action === "closed") {
             results.push(result);
@@ -540,7 +1540,7 @@ function startRun(config) {
     }
     const doWork = singlerun(async () => {
         const now = new Date();
-        const result = await backtest.strategyPublicService.tick(symbol, now, false);
+        const result = await backtest$1.strategyGlobalService.tick(symbol, now, false);
         const instance = instances.get(symbol);
         if (instance) {
             instance.tickCount++;
@@ -570,11 +1570,77 @@ function stopAll() {
     instances.clear();
 }
 
+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";
 async function getCandles(symbol, interval, limit) {
-    return await backtest.candleConnectionService.getCandles(symbol, interval, limit);
+    backtest$1.loggerService.info(GET_CANDLES_METHOD_NAME, {
+        symbol,
+        interval,
+        limit,
+    });
+    return await backtest$1.exchangeConnectionService.getCandles(symbol, interval, limit);
 }
 async function getAveragePrice(symbol) {
-    return await backtest.candleConnectionService.getAveragePrice(symbol);
+    backtest$1.loggerService.info(GET_AVERAGE_PRICE_METHOD_NAME, {
+        symbol,
+    });
+    return await backtest$1.exchangeConnectionService.getAveragePrice(symbol);
+}
+async function formatPrice(symbol, price) {
+    backtest$1.loggerService.info(FORMAT_PRICE_METHOD_NAME, {
+        symbol,
+        price,
+    });
+    return await backtest$1.exchangeConnectionService.formatPrice(symbol, price);
+}
+async function formatQuantity(symbol, quantity) {
+    backtest$1.loggerService.info(FORMAT_QUANTITY_METHOD_NAME, {
+        symbol,
+        quantity,
+    });
+    return await backtest$1.exchangeConnectionService.formatQuantity(symbol, quantity);
+}
+async function getDate() {
+    backtest$1.loggerService.info(GET_DATE_METHOD_NAME);
+    const { when } = backtest$1.executionContextService.context;
+    return new Date(when.getTime());
+}
+async function getMode() {
+    backtest$1.loggerService.info(GET_MODE_METHOD_NAME);
+    const { backtest: bt } = backtest$1.executionContextService.context;
+    return bt ? "backtest" : "live";
+}
+
+const BACKTEST_METHOD_NAME_RUN = "BacktestUtils.run";
+class BacktestUtils {
+    constructor() {
+        this.run = (symbol, context) => {
+            backtest$1.loggerService.info(BACKTEST_METHOD_NAME_RUN, {
+                symbol,
+                context,
+            });
+            return backtest$1.backtestGlobalService.run(symbol, context);
+        };
+    }
+}
+const Backtest = new BacktestUtils();
+
+const LIVE_METHOD_NAME_RUN = "LiveUtils.run";
+class LiveUtils {
+    constructor() {
+        this.run = (symbol, context) => {
+            backtest$1.loggerService.info(LIVE_METHOD_NAME_RUN, {
+                symbol,
+                context,
+            });
+            return backtest$1.liveGlobalService.run(symbol, context);
+        };
+    }
 }
+const Live = new LiveUtils();
 
-export { ExecutionContextService, addCandle, addStrategy, backtest, getAveragePrice, getCandles, reduce, runBacktest, runBacktestGUI, startRun, stopAll, stopRun };
+export { Backtest, ExecutionContextService, Live, MethodContextService, PersistBase, PersistSignalAdaper, addExchange, addFrame, addStrategy, backtest, formatPrice, formatQuantity, getAveragePrice, getCandles, getDate, getMode, reduce, runBacktest, runBacktestGUI, setLogger, startRun, stopAll, stopRun };