backtest-kit 1.11.7 → 1.11.9

package/build/index.cjs

@@ -414,6 +414,21 @@ const GLOBAL_CONFIG = {
      * Default: 0.2% (additional buffer above costs to ensure no loss when moving to breakeven)
      */
     CC_BREAKEVEN_THRESHOLD: 0.2,
+    /**
+     * Time offset in minutes for order book fetching.
+     * Subtracts this amount from the current time when fetching order book data.
+     * This helps get a more stable snapshot of the order book by avoiding real-time volatility.
+     *
+     * Default: 10 minutes
+     */
+    CC_ORDER_BOOK_TIME_OFFSET_MINUTES: 10,
+    /**
+     * Maximum depth levels for order book fetching.
+     * Specifies how many price levels to fetch from both bids and asks.
+     *
+     * Default: 20 levels
+     */
+    CC_ORDER_BOOK_MAX_DEPTH_LEVELS: 1000,
 };
 const DEFAULT_CONFIG = Object.freeze({ ...GLOBAL_CONFIG });
 
@@ -880,8 +895,62 @@ class ClientExchange {
         });
         return await this.params.formatPrice(symbol, price);
     }
+    /**
+     * Fetches order book for a trading pair.
+     *
+     * Calculates time range based on execution context time (when) and
+     * CC_ORDER_BOOK_TIME_OFFSET_MINUTES, then delegates to the exchange
+     * schema implementation which may use or ignore the time range.
+     *
+     * @param symbol - Trading pair symbol
+     * @param depth - Maximum depth levels (default: CC_ORDER_BOOK_MAX_DEPTH_LEVELS)
+     * @returns Promise resolving to order book data
+     * @throws Error if getOrderBook is not implemented
+     */
+    async getOrderBook(symbol, depth = GLOBAL_CONFIG.CC_ORDER_BOOK_MAX_DEPTH_LEVELS) {
+        this.params.logger.debug("ClientExchange getOrderBook", {
+            symbol,
+            depth,
+        });
+        const to = new Date(this.params.execution.context.when.getTime());
+        const from = new Date(to.getTime() - GLOBAL_CONFIG.CC_ORDER_BOOK_TIME_OFFSET_MINUTES * 60 * 1000);
+        return await this.params.getOrderBook(symbol, depth, from, to);
+    }
 }
 
+/**
+ * Default implementation for getCandles.
+ * Throws an error indicating the method is not implemented.
+ */
+const DEFAULT_GET_CANDLES_FN$1 = async (_symbol, _interval, _since, _limit) => {
+    throw new Error(`getCandles is not implemented for this exchange`);
+};
+/**
+ * Default implementation for formatQuantity.
+ * Returns Bitcoin precision on Binance (8 decimal places).
+ */
+const DEFAULT_FORMAT_QUANTITY_FN$1 = async (_symbol, quantity) => {
+    return quantity.toFixed(8);
+};
+/**
+ * Default implementation for formatPrice.
+ * Returns Bitcoin precision on Binance (2 decimal places).
+ */
+const DEFAULT_FORMAT_PRICE_FN$1 = async (_symbol, price) => {
+    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)
+ */
+const DEFAULT_GET_ORDER_BOOK_FN$1 = async (_symbol, _depth, _from, _to) => {
+    throw new Error(`getOrderBook is not implemented for this exchange`);
+};
 /**
  * Connection service routing exchange operations to correct ClientExchange instance.
  *
@@ -920,7 +989,7 @@ class ExchangeConnectionService {
          * @returns Configured ClientExchange instance
          */
         this.getExchange = functoolsKit.memoize(([exchangeName]) => `${exchangeName}`, (exchangeName) => {
-            const { getCandles, formatPrice, formatQuantity, callbacks } = this.exchangeSchemaService.get(exchangeName);
+            const { getCandles = DEFAULT_GET_CANDLES_FN$1, formatPrice = DEFAULT_FORMAT_PRICE_FN$1, formatQuantity = DEFAULT_FORMAT_QUANTITY_FN$1, getOrderBook = DEFAULT_GET_ORDER_BOOK_FN$1, callbacks } = this.exchangeSchemaService.get(exchangeName);
             return new ClientExchange({
                 execution: this.executionContextService,
                 logger: this.loggerService,
@@ -928,6 +997,7 @@ class ExchangeConnectionService {
                 getCandles,
                 formatPrice,
                 formatQuantity,
+                getOrderBook,
                 callbacks,
             });
         });
@@ -1015,6 +1085,24 @@ class ExchangeConnectionService {
             });
             return await this.getExchange(this.methodContextService.context.exchangeName).formatQuantity(symbol, quantity);
         };
+        /**
+         * Fetches order book for a trading pair using configured exchange.
+         *
+         * Routes to exchange determined by methodContextService.context.exchangeName.
+         * The ClientExchange will calculate time range and pass it to the schema
+         * implementation, which may use (backtest) or ignore (live) the parameters.
+         *
+         * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+         * @param depth - Maximum depth levels (default: CC_ORDER_BOOK_MAX_DEPTH_LEVELS)
+         * @returns Promise resolving to order book data
+         */
+        this.getOrderBook = async (symbol, depth) => {
+            this.loggerService.log("exchangeConnectionService getOrderBook", {
+                symbol,
+                depth,
+            });
+            return await this.getExchange(this.methodContextService.context.exchangeName).getOrderBook(symbol, depth);
+        };
     }
 }
 
@@ -1284,7 +1372,7 @@ async function writeFileAtomic(file, data, options = {}) {
     }
 }
 
-var _a$2;
+var _a$2, _b$2;
 const BASE_WAIT_FOR_INIT_SYMBOL = Symbol("wait-for-init");
 const PERSIST_SIGNAL_UTILS_METHOD_NAME_USE_PERSIST_SIGNAL_ADAPTER = "PersistSignalUtils.usePersistSignalAdapter";
 const PERSIST_SIGNAL_UTILS_METHOD_NAME_READ_DATA = "PersistSignalUtils.readSignalData";
@@ -1316,9 +1404,6 @@ 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;
@@ -1371,254 +1456,119 @@ const BASE_WAIT_FOR_INIT_UNLINK_FN = async (filePath) => functoolsKit.trycatch(f
  * const value = await persist.readValue("key1");
  * ```
  */
-const PersistBase = functoolsKit.makeExtendable(class {
-    /**
-     * Creates new persistence instance.
-     *
-     * @param entityName - Unique entity type identifier
-     * @param baseDir - Base directory for all entities (default: ./dump/data)
-     */
-    constructor(entityName, baseDir = path.join(process.cwd(), "logs/data")) {
-        this.entityName = entityName;
-        this.baseDir = baseDir;
-        this[_a$2] = functoolsKit.singleshot(async () => await BASE_WAIT_FOR_INIT_FN(this));
-        bt.loggerService.debug(PERSIST_BASE_METHOD_NAME_CTOR, {
-            entityName: this.entityName,
-            baseDir,
-        });
-        this._directory = path.join(this.baseDir, this.entityName);
-    }
-    /**
-     * Computes file path for entity ID.
-     *
-     * @param entityId - Entity identifier
-     * @returns Full file path to entity JSON file
-     */
-    _getFilePath(entityId) {
-        return path.join(this.baseDir, this.entityName, `${entityId}.json`);
-    }
-    async waitForInit(initial) {
-        bt.loggerService.debug(PERSIST_BASE_METHOD_NAME_WAIT_FOR_INIT, {
-            entityName: this.entityName,
-            initial,
-        });
-        await this[BASE_WAIT_FOR_INIT_SYMBOL]();
-    }
-    /**
-     * Returns count of persisted entities.
-     *
-     * @returns Promise resolving to number of .json files in directory
-     */
-    async getCount() {
-        const files = await fs.readdir(this._directory);
-        const { length } = files.filter((file) => file.endsWith(".json"));
-        return length;
-    }
-    async readValue(entityId) {
-        bt.loggerService.debug(PERSIST_BASE_METHOD_NAME_READ_VALUE, {
-            entityName: this.entityName,
-            entityId,
-        });
-        try {
-            const filePath = this._getFilePath(entityId);
-            const fileContent = await fs.readFile(filePath, "utf-8");
-            return JSON.parse(fileContent);
+const PersistBase = functoolsKit.makeExtendable((_b$2 = class {
+        /**
+         * Creates new persistence instance.
+         *
+         * @param entityName - Unique entity type identifier
+         * @param baseDir - Base directory for all entities (default: ./dump/data)
+         */
+        constructor(entityName, baseDir = path.join(process.cwd(), "logs/data")) {
+            this.entityName = entityName;
+            this.baseDir = baseDir;
+            this[_a$2] = functoolsKit.singleshot(async () => await BASE_WAIT_FOR_INIT_FN(this));
+            bt.loggerService.debug(PERSIST_BASE_METHOD_NAME_CTOR, {
+                entityName: this.entityName,
+                baseDir,
+            });
+            this._directory = path.join(this.baseDir, this.entityName);
         }
-        catch (error) {
-            if (error?.code === "ENOENT") {
-                throw new Error(`Entity ${this.entityName}:${entityId} not found`);
-            }
-            throw new Error(`Failed to read entity ${this.entityName}:${entityId}: ${functoolsKit.getErrorMessage(error)}`);
+        /**
+         * Computes file path for entity ID.
+         *
+         * @param entityId - Entity identifier
+         * @returns Full file path to entity JSON file
+         */
+        _getFilePath(entityId) {
+            return path.join(this.baseDir, this.entityName, `${entityId}.json`);
         }
-    }
-    async hasValue(entityId) {
-        bt.loggerService.debug(PERSIST_BASE_METHOD_NAME_HAS_VALUE, {
-            entityName: this.entityName,
-            entityId,
-        });
-        try {
-            const filePath = this._getFilePath(entityId);
-            await fs.access(filePath);
-            return true;
+        async waitForInit(initial) {
+            bt.loggerService.debug(PERSIST_BASE_METHOD_NAME_WAIT_FOR_INIT, {
+                entityName: this.entityName,
+                initial,
+            });
+            await this[BASE_WAIT_FOR_INIT_SYMBOL]();
         }
-        catch (error) {
-            if (error?.code === "ENOENT") {
-                return false;
+        async readValue(entityId) {
+            bt.loggerService.debug(PERSIST_BASE_METHOD_NAME_READ_VALUE, {
+                entityName: this.entityName,
+                entityId,
+            });
+            try {
+                const filePath = this._getFilePath(entityId);
+                const fileContent = await fs.readFile(filePath, "utf-8");
+                return JSON.parse(fileContent);
             }
-            throw new Error(`Failed to check existence of entity ${this.entityName}:${entityId}: ${functoolsKit.getErrorMessage(error)}`);
-        }
-    }
-    async writeValue(entityId, entity) {
-        bt.loggerService.debug(PERSIST_BASE_METHOD_NAME_WRITE_VALUE, {
-            entityName: this.entityName,
-            entityId,
-        });
-        try {
-            const filePath = this._getFilePath(entityId);
-            const serializedData = JSON.stringify(entity);
-            await writeFileAtomic(filePath, serializedData, "utf-8");
-        }
-        catch (error) {
-            throw new Error(`Failed to write entity ${this.entityName}:${entityId}: ${functoolsKit.getErrorMessage(error)}`);
-        }
-    }
-    /**
-     * Removes entity from storage.
-     *
-     * @param entityId - Entity identifier to remove
-     * @returns Promise that resolves when entity is deleted
-     * @throws Error if entity not found or deletion fails
-     */
-    async removeValue(entityId) {
-        bt.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`);
+            catch (error) {
+                if (error?.code === "ENOENT") {
+                    throw new Error(`Entity ${this.entityName}:${entityId} not found`);
+                }
+                throw new Error(`Failed to read entity ${this.entityName}:${entityId}: ${functoolsKit.getErrorMessage(error)}`);
             }
-            throw new Error(`Failed to remove entity ${this.entityName}:${entityId}: ${functoolsKit.getErrorMessage(error)}`);
         }
-    }
-    /**
-     * Removes all entities from storage.
-     *
-     * @returns Promise that resolves when all entities are deleted
-     * @throws Error if deletion fails
-     */
-    async removeAll() {
-        bt.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(path.join(this._directory, file));
+        async hasValue(entityId) {
+            bt.loggerService.debug(PERSIST_BASE_METHOD_NAME_HAS_VALUE, {
+                entityName: this.entityName,
+                entityId,
+            });
+            try {
+                const filePath = this._getFilePath(entityId);
+                await fs.access(filePath);
+                return true;
             }
-        }
-        catch (error) {
-            throw new Error(`Failed to remove values for ${this.entityName}: ${functoolsKit.getErrorMessage(error)}`);
-        }
-    }
-    /**
-     * Async generator yielding all entity values.
-     * Sorted alphanumerically by entity ID.
-     *
-     * @returns AsyncGenerator yielding entities
-     * @throws Error if reading fails
-     */
-    async *values() {
-        bt.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) {
+                if (error?.code === "ENOENT") {
+                    return false;
+                }
+                throw new Error(`Failed to check existence of entity ${this.entityName}:${entityId}: ${functoolsKit.getErrorMessage(error)}`);
             }
         }
-        catch (error) {
-            throw new Error(`Failed to read values for ${this.entityName}: ${functoolsKit.getErrorMessage(error)}`);
-        }
-    }
-    /**
-     * Async generator yielding all entity IDs.
-     * Sorted alphanumerically.
-     *
-     * @returns AsyncGenerator yielding entity IDs
-     * @throws Error if reading fails
-     */
-    async *keys() {
-        bt.loggerService.debug(PERSIST_BASE_METHOD_NAME_KEYS, {
-            entityName: this.entityName,
-        });
-        try {
-            const files = await fs.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;
+        async writeValue(entityId, entity) {
+            bt.loggerService.debug(PERSIST_BASE_METHOD_NAME_WRITE_VALUE, {
+                entityName: this.entityName,
+                entityId,
+            });
+            try {
+                const filePath = this._getFilePath(entityId);
+                const serializedData = JSON.stringify(entity);
+                await writeFileAtomic(filePath, serializedData, "utf-8");
             }
-        }
-        catch (error) {
-            throw new Error(`Failed to read keys for ${this.entityName}: ${functoolsKit.getErrorMessage(error)}`);
-        }
-    }
-    /**
-     * Async iterator implementation.
-     * Delegates to values() generator.
-     *
-     * @returns AsyncIterableIterator yielding entities
-     */
-    async *[(_a$2 = BASE_WAIT_FOR_INIT_SYMBOL, Symbol.asyncIterator)]() {
-        for await (const entity of this.values()) {
-            yield entity;
-        }
-    }
-    /**
-     * Filters entities by predicate function.
-     *
-     * @param predicate - Filter function
-     * @returns AsyncGenerator yielding filtered entities
-     */
-    async *filter(predicate) {
-        for await (const entity of this.values()) {
-            if (predicate(entity)) {
-                yield entity;
+            catch (error) {
+                throw new Error(`Failed to write entity ${this.entityName}:${entityId}: ${functoolsKit.getErrorMessage(error)}`);
             }
         }
-    }
-    /**
-     * Takes first N entities, optionally filtered.
-     *
-     * @param total - Maximum number of entities to yield
-     * @param predicate - Optional filter function
-     * @returns AsyncGenerator yielding up to total entities
-     */
-    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;
+        /**
+         * Async generator yielding all entity IDs.
+         * Sorted alphanumerically.
+         * Used internally by waitForInit for validation.
+         *
+         * @returns AsyncGenerator yielding entity IDs
+         * @throws Error if reading fails
+         */
+        async *keys() {
+            bt.loggerService.debug(PERSIST_BASE_METHOD_NAME_KEYS, {
+                entityName: this.entityName,
+            });
+            try {
+                const files = await fs.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;
                 }
             }
-        }
-        else {
-            for await (const entity of this.values()) {
-                count += 1;
-                yield entity;
-                if (count >= total) {
-                    break;
-                }
+            catch (error) {
+                throw new Error(`Failed to read keys for ${this.entityName}: ${functoolsKit.getErrorMessage(error)}`);
             }
         }
-    }
-});
+    },
+    _a$2 = BASE_WAIT_FOR_INIT_SYMBOL,
+    _b$2));
 /**
  * Dummy persist adapter that discards all writes.
  * Used for disabling persistence.
@@ -1650,12 +1600,6 @@ class PersistDummy {
      */
     async writeValue() {
     }
-    /**
-     * No-op keys generator.
-     * @returns Empty async generator
-     */
-    async *keys() {
-    }
 }
 /**
  * Utility class for managing signal persistence.
@@ -7541,6 +7485,38 @@ class ExchangeCoreService {
                 backtest,
             });
         };
+        /**
+         * Fetches order book with execution context.
+         *
+         * Sets up execution context with the provided when/backtest parameters.
+         * The exchange implementation will receive time range parameters but may
+         * choose to use them (backtest) or ignore them (live).
+         *
+         * @param symbol - Trading pair symbol
+         * @param when - Timestamp for context
+         * @param backtest - Whether running in backtest mode
+         * @param depth - Maximum depth levels (default: CC_ORDER_BOOK_MAX_DEPTH_LEVELS)
+         * @returns Promise resolving to order book data
+         */
+        this.getOrderBook = async (symbol, when, backtest, depth) => {
+            this.loggerService.log("exchangeCoreService getOrderBook", {
+                symbol,
+                when,
+                backtest,
+                depth,
+            });
+            if (!MethodContextService.hasContext()) {
+                throw new Error("exchangeCoreService getOrderBook requires a method context");
+            }
+            await this.validate(this.methodContextService.context.exchangeName);
+            return await ExecutionContextService.runInContext(async () => {
+                return await this.exchangeConnectionService.getOrderBook(symbol, depth);
+            }, {
+                symbol,
+                when,
+                backtest,
+            });
+        };
     }
 }
 
@@ -8187,12 +8163,6 @@ class ExchangeSchemaService {
             if (typeof exchangeSchema.getCandles !== "function") {
                 throw new Error(`exchange schema validation failed: missing getCandles for exchangeName=${exchangeSchema.exchangeName}`);
             }
-            if (typeof exchangeSchema.formatPrice !== "function") {
-                throw new Error(`exchange schema validation failed: missing formatPrice for exchangeName=${exchangeSchema.exchangeName}`);
-            }
-            if (typeof exchangeSchema.formatQuantity !== "function") {
-                throw new Error(`exchange schema validation failed: missing formatQuantity for exchangeName=${exchangeSchema.exchangeName}`);
-            }
         };
         /**
          * Overrides an existing exchange schema with partial updates.
@@ -10062,21 +10032,21 @@ const live_columns = [
     {
         key: "openPrice",
         label: "Open Price",
-        format: (data) => data.openPrice !== undefined ? `${data.openPrice.toFixed(8)} USD` : "N/A",
+        format: (data) => data.priceOpen !== undefined ? `${data.priceOpen.toFixed(8)} USD` : "N/A",
         isVisible: () => true,
     },
     {
         key: "takeProfit",
         label: "Take Profit",
-        format: (data) => data.takeProfit !== undefined
-            ? `${data.takeProfit.toFixed(8)} USD`
+        format: (data) => data.priceTakeProfit !== undefined
+            ? `${data.priceTakeProfit.toFixed(8)} USD`
             : "N/A",
         isVisible: () => true,
     },
     {
         key: "stopLoss",
         label: "Stop Loss",
-        format: (data) => data.stopLoss !== undefined ? `${data.stopLoss.toFixed(8)} USD` : "N/A",
+        format: (data) => data.priceStopLoss !== undefined ? `${data.priceStopLoss.toFixed(8)} USD` : "N/A",
         isVisible: () => true,
     },
     {
@@ -10760,13 +10730,13 @@ const schedule_columns = [
     {
         key: "takeProfit",
         label: "Take Profit",
-        format: (data) => `${data.takeProfit.toFixed(8)} USD`,
+        format: (data) => `${data.priceTakeProfit.toFixed(8)} USD`,
         isVisible: () => true,
     },
     {
         key: "stopLoss",
         label: "Stop Loss",
-        format: (data) => `${data.stopLoss.toFixed(8)} USD`,
+        format: (data) => `${data.priceStopLoss.toFixed(8)} USD`,
         isVisible: () => true,
     },
     {
@@ -12065,9 +12035,9 @@ let ReportStorage$5 = class ReportStorage {
             position: data.signal.position,
             note: data.signal.note,
             currentPrice: data.signal.priceOpen,
-            openPrice: data.signal.priceOpen,
-            takeProfit: data.signal.priceTakeProfit,
-            stopLoss: data.signal.priceStopLoss,
+            priceOpen: data.signal.priceOpen,
+            priceTakeProfit: data.signal.priceTakeProfit,
+            priceStopLoss: data.signal.priceStopLoss,
             originalPriceTakeProfit: data.signal.originalPriceTakeProfit,
             originalPriceStopLoss: data.signal.originalPriceStopLoss,
             totalExecuted: data.signal.totalExecuted,
@@ -12092,9 +12062,9 @@ let ReportStorage$5 = class ReportStorage {
             position: data.signal.position,
             note: data.signal.note,
             currentPrice: data.currentPrice,
-            openPrice: data.signal.priceOpen,
-            takeProfit: data.signal.priceTakeProfit,
-            stopLoss: data.signal.priceStopLoss,
+            priceOpen: data.signal.priceOpen,
+            priceTakeProfit: data.signal.priceTakeProfit,
+            priceStopLoss: data.signal.priceStopLoss,
             originalPriceTakeProfit: data.signal.originalPriceTakeProfit,
             originalPriceStopLoss: data.signal.originalPriceStopLoss,
             totalExecuted: data.signal.totalExecuted,
@@ -12132,9 +12102,9 @@ let ReportStorage$5 = class ReportStorage {
             position: data.signal.position,
             note: data.signal.note,
             currentPrice: data.currentPrice,
-            openPrice: data.signal.priceOpen,
-            takeProfit: data.signal.priceTakeProfit,
-            stopLoss: data.signal.priceStopLoss,
+            priceOpen: data.signal.priceOpen,
+            priceTakeProfit: data.signal.priceTakeProfit,
+            priceStopLoss: data.signal.priceStopLoss,
             originalPriceTakeProfit: data.signal.originalPriceTakeProfit,
             originalPriceStopLoss: data.signal.originalPriceStopLoss,
             totalExecuted: data.signal.totalExecuted,
@@ -12619,8 +12589,8 @@ let ReportStorage$4 = class ReportStorage {
             note: data.signal.note,
             currentPrice: data.currentPrice,
             priceOpen: data.signal.priceOpen,
-            takeProfit: data.signal.priceTakeProfit,
-            stopLoss: data.signal.priceStopLoss,
+            priceTakeProfit: data.signal.priceTakeProfit,
+            priceStopLoss: data.signal.priceStopLoss,
             originalPriceTakeProfit: data.signal.originalPriceTakeProfit,
             originalPriceStopLoss: data.signal.originalPriceStopLoss,
             totalExecuted: data.signal.totalExecuted,
@@ -12647,8 +12617,8 @@ let ReportStorage$4 = class ReportStorage {
             note: data.signal.note,
             currentPrice: data.currentPrice,
             priceOpen: data.signal.priceOpen,
-            takeProfit: data.signal.priceTakeProfit,
-            stopLoss: data.signal.priceStopLoss,
+            priceTakeProfit: data.signal.priceTakeProfit,
+            priceStopLoss: data.signal.priceStopLoss,
             originalPriceTakeProfit: data.signal.originalPriceTakeProfit,
             originalPriceStopLoss: data.signal.originalPriceStopLoss,
             totalExecuted: data.signal.totalExecuted,
@@ -12677,8 +12647,8 @@ let ReportStorage$4 = class ReportStorage {
             note: data.signal.note,
             currentPrice: data.currentPrice,
             priceOpen: data.signal.priceOpen,
-            takeProfit: data.signal.priceTakeProfit,
-            stopLoss: data.signal.priceStopLoss,
+            priceTakeProfit: data.signal.priceTakeProfit,
+            priceStopLoss: data.signal.priceStopLoss,
             originalPriceTakeProfit: data.signal.originalPriceTakeProfit,
             originalPriceStopLoss: data.signal.originalPriceStopLoss,
             totalExecuted: data.signal.totalExecuted,
@@ -13716,11 +13686,11 @@ let ReportStorage$3 = class ReportStorage {
         await Markdown.writeData("walker", markdown, {
             path,
             file: filename,
-            symbol: "",
+            symbol: symbol,
             signalId: "",
             strategyName: "",
-            exchangeName: "",
-            frameName: ""
+            exchangeName: context.exchangeName,
+            frameName: context.frameName
         });
     }
 };
@@ -18815,6 +18785,9 @@ class ConfigValidationService {
             if (!Number.isInteger(GLOBAL_CONFIG.CC_MAX_CANDLES_PER_REQUEST) || GLOBAL_CONFIG.CC_MAX_CANDLES_PER_REQUEST <= 0) {
                 errors.push(`CC_MAX_CANDLES_PER_REQUEST must be a positive integer, got ${GLOBAL_CONFIG.CC_MAX_CANDLES_PER_REQUEST}`);
             }
+            if (!Number.isInteger(GLOBAL_CONFIG.CC_ORDER_BOOK_TIME_OFFSET_MINUTES) || GLOBAL_CONFIG.CC_ORDER_BOOK_TIME_OFFSET_MINUTES < 0) {
+                errors.push(`CC_ORDER_BOOK_TIME_OFFSET_MINUTES must be a non-negative integer, got ${GLOBAL_CONFIG.CC_ORDER_BOOK_TIME_OFFSET_MINUTES}`);
+            }
             // Throw aggregated errors if any
             if (errors.length > 0) {
                 const errorMessage = `GLOBAL_CONFIG validation failed:\n${errors.map((e, i) => `  ${i + 1}. ${e}`).join('\n')}`;
@@ -21406,6 +21379,7 @@ const FORMAT_QUANTITY_METHOD_NAME = "exchange.formatQuantity";
 const GET_DATE_METHOD_NAME = "exchange.getDate";
 const GET_MODE_METHOD_NAME = "exchange.getMode";
 const HAS_TRADE_CONTEXT_METHOD_NAME = "exchange.hasTradeContext";
+const GET_ORDER_BOOK_METHOD_NAME = "exchange.getOrderBook";
 /**
  * Checks if trade context is active (execution and method contexts).
  *
@@ -21586,6 +21560,41 @@ async function getMode() {
     const { backtest: bt$1 } = bt.executionContextService.context;
     return bt$1 ? "backtest" : "live";
 }
+/**
+ * Fetches order book for a trading pair from the registered exchange.
+ *
+ * Uses current execution context to determine timing. The underlying exchange
+ * implementation receives time range parameters but may use them (backtest)
+ * or ignore them (live trading).
+ *
+ * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+ * @param depth - Maximum depth levels (default: CC_ORDER_BOOK_MAX_DEPTH_LEVELS)
+ * @returns Promise resolving to order book data
+ * @throws Error if execution or method context is missing
+ *
+ * @example
+ * ```typescript
+ * const orderBook = await getOrderBook("BTCUSDT");
+ * console.log(orderBook.bids); // [{ price: "50000.00", quantity: "0.5" }, ...]
+ * console.log(orderBook.asks); // [{ price: "50001.00", quantity: "0.3" }, ...]
+ *
+ * // Fetch deeper order book
+ * const deepBook = await getOrderBook("BTCUSDT", 100);
+ * ```
+ */
+async function getOrderBook(symbol, depth) {
+    bt.loggerService.info(GET_ORDER_BOOK_METHOD_NAME, {
+        symbol,
+        depth,
+    });
+    if (!ExecutionContextService.hasContext()) {
+        throw new Error("getOrderBook requires an execution context");
+    }
+    if (!MethodContextService.hasContext()) {
+        throw new Error("getOrderBook requires a method context");
+    }
+    return await bt.exchangeConnectionService.getOrderBook(symbol, depth);
+}
 
 const STOP_METHOD_NAME = "strategy.stop";
 const CANCEL_METHOD_NAME = "strategy.cancel";
@@ -27161,6 +27170,40 @@ 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";
+/**
+ * Default implementation for getCandles.
+ * Throws an error indicating the method is not implemented.
+ */
+const DEFAULT_GET_CANDLES_FN = async (_symbol, _interval, _since, _limit) => {
+    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) => {
+    return quantity.toFixed(8);
+};
+/**
+ * Default implementation for formatPrice.
+ * Returns Bitcoin precision on Binance (2 decimal places).
+ */
+const DEFAULT_FORMAT_PRICE_FN = async (_symbol, price) => {
+    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)
+ */
+const DEFAULT_GET_ORDER_BOOK_FN = async (_symbol, _depth, _from, _to) => {
+    throw new Error(`getOrderBook is not implemented for this exchange`);
+};
 const INTERVAL_MINUTES$1 = {
     "1m": 1,
     "3m": 3,
@@ -27173,6 +27216,25 @@ const INTERVAL_MINUTES$1 = {
     "6h": 360,
     "8h": 480,
 };
+/**
+ * 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,
+    };
+};
 /**
  * Instance class for exchange operations on a specific exchange.
  *
@@ -27222,6 +27284,7 @@ class ExchangeInstance {
                 interval,
                 limit,
             });
+            const getCandles = this._methods.getCandles;
             const step = INTERVAL_MINUTES$1[interval];
             const adjust = step * limit - step;
             if (!adjust) {
@@ -27236,7 +27299,7 @@ class ExchangeInstance {
                 let currentSince = new Date(since.getTime());
                 while (remaining > 0) {
                     const chunkLimit = Math.min(remaining, GLOBAL_CONFIG.CC_MAX_CANDLES_PER_REQUEST);
-                    const chunkData = await this._schema.getCandles(symbol, interval, currentSince, chunkLimit);
+                    const chunkData = await getCandles(symbol, interval, currentSince, chunkLimit);
                     allData.push(...chunkData);
                     remaining -= chunkLimit;
                     if (remaining > 0) {
@@ -27246,7 +27309,7 @@ class ExchangeInstance {
                 }
             }
             else {
-                allData = await this._schema.getCandles(symbol, interval, since, limit);
+                allData = await getCandles(symbol, interval, since, limit);
             }
             // Filter candles to strictly match the requested range
             const whenTimestamp = when.getTime();
@@ -27313,7 +27376,7 @@ class ExchangeInstance {
          * ```typescript
          * const instance = new ExchangeInstance("binance");
          * const formatted = await instance.formatQuantity("BTCUSDT", 0.001);
-         * console.log(formatted); // "0.001"
+         * console.log(formatted); // "0.00100000"
          * ```
          */
         this.formatQuantity = async (symbol, quantity) => {
@@ -27322,7 +27385,7 @@ class ExchangeInstance {
                 symbol,
                 quantity,
             });
-            return await this._schema.formatQuantity(symbol, quantity);
+            return await this._methods.formatQuantity(symbol, quantity);
         };
         /**
          * Format price according to exchange precision rules.
@@ -27344,9 +27407,40 @@ class ExchangeInstance {
                 symbol,
                 price,
             });
-            return await this._schema.formatPrice(symbol, price);
+            return await this._methods.formatPrice(symbol, price);
         };
-        this._schema = bt.exchangeSchemaService.get(this.exchangeName);
+        /**
+         * 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 to = new Date(Date.now());
+            const from = new Date(to.getTime() - GLOBAL_CONFIG.CC_ORDER_BOOK_TIME_OFFSET_MINUTES * 60 * 1000);
+            return await this._methods.getOrderBook(symbol, depth, from, to);
+        };
+        const schema = bt.exchangeSchemaService.get(this.exchangeName);
+        this._methods = CREATE_EXCHANGE_INSTANCE_FN(schema);
     }
 }
 /**
@@ -27432,6 +27526,23 @@ class ExchangeUtils {
             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);
+        };
     }
 }
 /**
@@ -28425,6 +28536,7 @@ exports.getDate = getDate;
 exports.getDefaultColumns = getDefaultColumns;
 exports.getDefaultConfig = getDefaultConfig;
 exports.getMode = getMode;
+exports.getOrderBook = getOrderBook;
 exports.hasTradeContext = hasTradeContext;
 exports.lib = backtest;
 exports.listExchanges = listExchanges;