backtest-kit 1.0.2 → 1.0.3

package/README.md

@@ -21,12 +21,12 @@ npm install
 
 ## Quick Start
 
-### 1. Add Data Source (Candles)
+### 1. Add Data Source (Exchange)
 
 ```typescript
-import { addCandle } from "./src/function/add";
+import { addExchange } from "./src/function/add";
 
-addCandle({
+addExchange({
   getCandles: async (symbol, interval, since, limit) => {
     // Fetch candle data from your source (exchange API, database, etc.)
     return [
@@ -164,16 +164,17 @@ console.log(result.accumulator);
 ```
 src/
 ├── function/          # High-level API functions
-│   ├── add.ts        # Add schemas (strategy, candle)
+│   ├── add.ts        # Add schemas (strategy, exchange)
 │   ├── backtest.ts   # Backtesting functions
 │   ├── reduce.ts     # Reduce pattern for accumulation
-│   └── run.ts        # Real-time execution
+│   ├── run.ts        # Real-time execution
+│   └── exchange.ts   # Exchange data functions
 ├── client/           # Client implementations
-│   ├── ClientCandle.ts    # Candle client with VWAP
+│   ├── ClientExchange.ts  # Exchange client with VWAP
 │   └── ClientStrategy.ts  # Strategy client with signal lifecycle
 ├── interfaces/       # TypeScript interfaces
 │   ├── Strategy.interface.ts
-│   └── Candle.interface.ts
+│   └── Exchange.interface.ts
 └── lib/             # Core library with DI
     ├── core/        # Dependency injection
     └── services/    # Services (schema, connection, public)
@@ -200,12 +201,18 @@ export const PERCENT_FEE = 0.1; // 0.1%
 
 ### Functions
 
-#### `addCandle(candleSchema: ICandleSchema)`
-Add candle data source.
+#### `addExchange(exchangeSchema: IExchangeSchema)`
+Add exchange data source for candles.
 
 #### `addStrategy(strategySchema: IStrategySchema)`
 Add trading strategy.
 
+#### `getCandles(symbol, interval, limit): Promise<ICandleData[]>`
+Get candle data from exchange.
+
+#### `getAveragePrice(symbol): Promise<number>`
+Get VWAP average price based on last 5 1m candles.
+
 #### `runBacktest(symbol: string, timeframes: Date[]): Promise<IBacktestResult>`
 Run backtest and return closed trades only.
 

package/build/index.cjs

@@ -40,15 +40,15 @@ const contextServices$1 = {
     executionContextService: Symbol('executionContextService'),
 };
 const connectionServices$1 = {
-    candleConnectionService: Symbol('candleConnectionService'),
+    exchangeConnectionService: Symbol('exchangeConnectionService'),
     strategyConnectionService: Symbol('strategyConnectionService'),
 };
 const schemaServices$1 = {
-    candleSchemaService: Symbol('candleSchemaService'),
+    exchangeSchemaService: Symbol('exchangeSchemaService'),
     strategySchemaService: Symbol('strategySchemaService'),
 };
 const publicServices$1 = {
-    candlePublicService: Symbol('candlePublicService'),
+    exchangePublicService: Symbol('exchangePublicService'),
     strategyPublicService: Symbol('strategyPublicService'),
 };
 const TYPES = {
@@ -71,11 +71,11 @@ 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`, {
+            this.params.logger.debug(`ClientExchange getCandles`, {
                 symbol,
                 interval,
                 limit,
@@ -83,7 +83,7 @@ class ClientCandle {
             const step = INTERVAL_MINUTES[interval];
             const adjust = step * limit;
             if (!adjust) {
-                throw new Error(`ClientCandle unknown time adjust for interval=${interval}`);
+                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);
@@ -93,12 +93,12 @@ class ClientCandle {
             return data;
         };
         this.getAveragePrice = async (symbol) => {
-            this.params.logger.debug(`ClientCandle getAveragePrice`, {
+            this.params.logger.debug(`ClientExchange 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}`);
+                throw new Error(`ClientExchange getAveragePrice: no candles data for symbol=${symbol}`);
             }
             // VWAP (Volume Weighted Average Price)
             // Используем типичную цену (typical price) = (high + low + close) / 3
@@ -115,36 +115,66 @@ class ClientCandle {
             const vwap = sumPriceVolume / totalVolume;
             return vwap;
         };
+        this.formatQuantity = async (symbol, quantity) => {
+            this.params.logger.debug("binanceService formatQuantity", {
+                symbol,
+                quantity,
+            });
+            return await this.params.formatQuantity(symbol, quantity);
+        };
+        this.formatPrice = async (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 = functoolsKit.memoize((symbol) => `${symbol}`, () => {
-            const { getCandles, callbacks } = this.candleSchemaService.getSchema();
-            return new ClientCandle({
+        this.exchangeSchemaService = inject(TYPES.exchangeSchemaService);
+        this.getExchange = functoolsKit.memoize((symbol) => `${symbol}`, () => {
+            const { getCandles, formatPrice, formatQuantity, callbacks } = this.exchangeSchemaService.getSchema();
+            return new ClientExchange({
                 execution: this.executionContextService,
                 logger: this.loggerService,
                 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.getCandle(symbol).getCandles(symbol, interval, limit);
+            return await this.getExchange(symbol).getCandles(symbol, interval, limit);
         };
         this.getAveragePrice = async (symbol) => {
-            this.loggerService.log("candleConnectionService getAveragePrice", {
+            this.loggerService.log("exchangeConnectionService getAveragePrice", {
+                symbol,
+            });
+            return await this.getExchange(symbol).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(symbol).formatPrice(symbol, price);
+        };
+        this.formatQuantity = async (symbol, quantity) => {
+            this.loggerService.log("exchangeConnectionService getAveragePrice", {
+                symbol,
+                quantity,
+            });
+            return await this.getExchange(symbol).formatQuantity(symbol, quantity);
         };
     }
 }
@@ -217,7 +247,7 @@ class ClientStrategy {
             const when = this.params.execution.context.when;
             const signal = this._pendingSignal;
             // Получаем среднюю цену
-            const averagePrice = await this.params.candle.getAveragePrice(symbol);
+            const averagePrice = await this.params.exchange.getAveragePrice(symbol);
             this.params.logger.debug("ClientStrategy tick check", {
                 symbol,
                 averagePrice,
@@ -290,14 +320,14 @@ class StrategyConnectionService {
         this.loggerService = inject(TYPES.loggerService);
         this.executionContextService = inject(TYPES.executionContextService);
         this.strategySchemaService = inject(TYPES.strategySchemaService);
-        this.candleConnectionService = inject(TYPES.candleConnectionService);
+        this.exchangeConnectionService = inject(TYPES.exchangeConnectionService);
         this.getStrategy = functoolsKit.memoize((symbol) => `${symbol}`, (symbol) => {
             const { getSignal, callbacks } = this.strategySchemaService.getSchema();
             return new ClientStrategy({
                 symbol,
                 execution: this.executionContextService,
                 logger: this.loggerService,
-                candle: this.candleConnectionService,
+                exchange: this.exchangeConnectionService,
                 getSignal,
                 callbacks,
             });
@@ -317,12 +347,12 @@ const ExecutionContextService = diScoped.scoped(class {
     }
 });
 
-class CandlePublicService {
+class ExchangePublicService {
     constructor() {
         this.loggerService = inject(TYPES.loggerService);
-        this.candleConnectionService = inject(TYPES.candleConnectionService);
+        this.exchangeConnectionService = inject(TYPES.exchangeConnectionService);
         this.getCandles = async (symbol, interval, limit, when, backtest) => {
-            this.loggerService.log("candlePublicService getCandles", {
+            this.loggerService.log("exchangePublicService getCandles", {
                 symbol,
                 interval,
                 limit,
@@ -330,20 +360,48 @@ class CandlePublicService {
                 backtest,
             });
             return await ExecutionContextService.runInContext(async () => {
-                return await this.candleConnectionService.getCandles(symbol, interval, limit);
+                return await this.exchangeConnectionService.getCandles(symbol, interval, limit);
             }, {
                 when,
                 backtest,
             });
         };
         this.getAveragePrice = async (symbol, when, backtest) => {
-            this.loggerService.log("candlePublicService getAveragePrice", {
+            this.loggerService.log("exchangePublicService getAveragePrice", {
+                symbol,
+                when,
+                backtest,
+            });
+            return await ExecutionContextService.runInContext(async () => {
+                return await this.exchangeConnectionService.getAveragePrice(symbol);
+            }, {
+                when,
+                backtest,
+            });
+        };
+        this.formatPrice = async (symbol, price, when, backtest) => {
+            this.loggerService.log("exchangePublicService formatPrice", {
                 symbol,
+                price,
                 when,
                 backtest,
             });
             return await ExecutionContextService.runInContext(async () => {
-                return await this.candleConnectionService.getAveragePrice(symbol);
+                return await this.exchangeConnectionService.formatPrice(symbol, price);
+            }, {
+                when,
+                backtest,
+            });
+        };
+        this.formatQuantity = async (symbol, quantity, when, backtest) => {
+            this.loggerService.log("exchangePublicService formatQuantity", {
+                symbol,
+                quantity,
+                when,
+                backtest,
+            });
+            return await ExecutionContextService.runInContext(async () => {
+                return await this.exchangeConnectionService.formatQuantity(symbol, quantity);
             }, {
                 when,
                 backtest,
@@ -372,19 +430,19 @@ class StrategyPublicService {
     }
 }
 
-class CandleSchemaService {
+class ExchangeSchemaService {
     constructor() {
         this.loggerService = inject(TYPES.loggerService);
         this.getSchema = () => {
-            this.loggerService.log("candleSchemaService getSchema");
-            if (!this._candleSchema) {
-                throw new Error("CandleSchemaService no candle source provided");
+            this.loggerService.log("exchangeSchemaService getSchema");
+            if (!this._exchangeSchema) {
+                throw new Error("ExchangeSchemaService no exchange source provided");
             }
-            return this._candleSchema;
+            return this._exchangeSchema;
         };
-        this.addSchema = (candleSchema) => {
-            this.loggerService.log("candleSchemaService addSchema");
-            this._candleSchema = candleSchema;
+        this.addSchema = (exchangeSchema) => {
+            this.loggerService.log("exchangeSchemaService addSchema");
+            this._exchangeSchema = exchangeSchema;
         };
     }
 }
@@ -413,15 +471,15 @@ class StrategySchemaService {
     provide(TYPES.executionContextService, () => new ExecutionContextService());
 }
 {
-    provide(TYPES.candleConnectionService, () => new CandleConnectionService());
+    provide(TYPES.exchangeConnectionService, () => new ExchangeConnectionService());
     provide(TYPES.strategyConnectionService, () => new StrategyConnectionService());
 }
 {
-    provide(TYPES.candleSchemaService, () => new CandleSchemaService());
+    provide(TYPES.exchangeSchemaService, () => new ExchangeSchemaService());
     provide(TYPES.strategySchemaService, () => new StrategySchemaService());
 }
 {
-    provide(TYPES.candlePublicService, () => new CandlePublicService());
+    provide(TYPES.exchangePublicService, () => new ExchangePublicService());
     provide(TYPES.strategyPublicService, () => new StrategyPublicService());
 }
 
@@ -432,15 +490,15 @@ const contextServices = {
     executionContextService: inject(TYPES.executionContextService),
 };
 const connectionServices = {
-    candleConnectionService: inject(TYPES.candleConnectionService),
+    exchangeConnectionService: inject(TYPES.exchangeConnectionService),
     strategyConnectionService: inject(TYPES.strategyConnectionService),
 };
 const schemaServices = {
-    candleSchemaService: inject(TYPES.candleSchemaService),
+    exchangeSchemaService: inject(TYPES.exchangeSchemaService),
     strategySchemaService: inject(TYPES.strategySchemaService),
 };
 const publicServices = {
-    candlePublicService: inject(TYPES.candlePublicService),
+    exchangePublicService: inject(TYPES.exchangePublicService),
     strategyPublicService: inject(TYPES.strategyPublicService),
 };
 const backtest = {
@@ -455,8 +513,8 @@ init();
 function addStrategy(strategySchema) {
     backtest.strategySchemaService.addSchema(strategySchema);
 }
-function addCandle(candleSchema) {
-    backtest.candleSchemaService.addSchema(candleSchema);
+function addExchange(exchangeSchema) {
+    backtest.exchangeSchemaService.addSchema(exchangeSchema);
 }
 
 async function runBacktest(symbol, timeframes) {
@@ -573,16 +631,24 @@ function stopAll() {
 }
 
 async function getCandles(symbol, interval, limit) {
-    return await backtest.candleConnectionService.getCandles(symbol, interval, limit);
+    return await backtest.exchangeConnectionService.getCandles(symbol, interval, limit);
 }
 async function getAveragePrice(symbol) {
-    return await backtest.candleConnectionService.getAveragePrice(symbol);
+    return await backtest.exchangeConnectionService.getAveragePrice(symbol);
+}
+async function formatPrice(symbol, price) {
+    return await backtest.exchangeConnectionService.formatPrice(symbol, price);
+}
+async function formatQuantity(symbol, quantity) {
+    return await backtest.exchangeConnectionService.formatQuantity(symbol, quantity);
 }
 
 exports.ExecutionContextService = ExecutionContextService;
-exports.addCandle = addCandle;
+exports.addExchange = addExchange;
 exports.addStrategy = addStrategy;
 exports.backtest = backtest;
+exports.formatPrice = formatPrice;
+exports.formatQuantity = formatQuantity;
 exports.getAveragePrice = getAveragePrice;
 exports.getCandles = getCandles;
 exports.reduce = reduce;

package/build/index.mjs

@@ -38,15 +38,15 @@ const contextServices$1 = {
     executionContextService: Symbol('executionContextService'),
 };
 const connectionServices$1 = {
-    candleConnectionService: Symbol('candleConnectionService'),
+    exchangeConnectionService: Symbol('exchangeConnectionService'),
     strategyConnectionService: Symbol('strategyConnectionService'),
 };
 const schemaServices$1 = {
-    candleSchemaService: Symbol('candleSchemaService'),
+    exchangeSchemaService: Symbol('exchangeSchemaService'),
     strategySchemaService: Symbol('strategySchemaService'),
 };
 const publicServices$1 = {
-    candlePublicService: Symbol('candlePublicService'),
+    exchangePublicService: Symbol('exchangePublicService'),
     strategyPublicService: Symbol('strategyPublicService'),
 };
 const TYPES = {
@@ -69,11 +69,11 @@ 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`, {
+            this.params.logger.debug(`ClientExchange getCandles`, {
                 symbol,
                 interval,
                 limit,
@@ -81,7 +81,7 @@ class ClientCandle {
             const step = INTERVAL_MINUTES[interval];
             const adjust = step * limit;
             if (!adjust) {
-                throw new Error(`ClientCandle unknown time adjust for interval=${interval}`);
+                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);
@@ -91,12 +91,12 @@ class ClientCandle {
             return data;
         };
         this.getAveragePrice = async (symbol) => {
-            this.params.logger.debug(`ClientCandle getAveragePrice`, {
+            this.params.logger.debug(`ClientExchange 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}`);
+                throw new Error(`ClientExchange getAveragePrice: no candles data for symbol=${symbol}`);
             }
             // VWAP (Volume Weighted Average Price)
             // Используем типичную цену (typical price) = (high + low + close) / 3
@@ -113,36 +113,66 @@ class ClientCandle {
             const vwap = sumPriceVolume / totalVolume;
             return vwap;
         };
+        this.formatQuantity = async (symbol, quantity) => {
+            this.params.logger.debug("binanceService formatQuantity", {
+                symbol,
+                quantity,
+            });
+            return await this.params.formatQuantity(symbol, quantity);
+        };
+        this.formatPrice = async (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.getExchange = memoize((symbol) => `${symbol}`, () => {
+            const { getCandles, formatPrice, formatQuantity, callbacks } = this.exchangeSchemaService.getSchema();
+            return new ClientExchange({
                 execution: this.executionContextService,
                 logger: this.loggerService,
                 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.getCandle(symbol).getCandles(symbol, interval, limit);
+            return await this.getExchange(symbol).getCandles(symbol, interval, limit);
         };
         this.getAveragePrice = async (symbol) => {
-            this.loggerService.log("candleConnectionService getAveragePrice", {
+            this.loggerService.log("exchangeConnectionService getAveragePrice", {
+                symbol,
+            });
+            return await this.getExchange(symbol).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(symbol).formatPrice(symbol, price);
+        };
+        this.formatQuantity = async (symbol, quantity) => {
+            this.loggerService.log("exchangeConnectionService getAveragePrice", {
+                symbol,
+                quantity,
+            });
+            return await this.getExchange(symbol).formatQuantity(symbol, quantity);
         };
     }
 }
@@ -215,7 +245,7 @@ class ClientStrategy {
             const when = this.params.execution.context.when;
             const signal = this._pendingSignal;
             // Получаем среднюю цену
-            const averagePrice = await this.params.candle.getAveragePrice(symbol);
+            const averagePrice = await this.params.exchange.getAveragePrice(symbol);
             this.params.logger.debug("ClientStrategy tick check", {
                 symbol,
                 averagePrice,
@@ -288,14 +318,14 @@ class StrategyConnectionService {
         this.loggerService = inject(TYPES.loggerService);
         this.executionContextService = inject(TYPES.executionContextService);
         this.strategySchemaService = inject(TYPES.strategySchemaService);
-        this.candleConnectionService = inject(TYPES.candleConnectionService);
+        this.exchangeConnectionService = inject(TYPES.exchangeConnectionService);
         this.getStrategy = memoize((symbol) => `${symbol}`, (symbol) => {
             const { getSignal, callbacks } = this.strategySchemaService.getSchema();
             return new ClientStrategy({
                 symbol,
                 execution: this.executionContextService,
                 logger: this.loggerService,
-                candle: this.candleConnectionService,
+                exchange: this.exchangeConnectionService,
                 getSignal,
                 callbacks,
             });
@@ -315,12 +345,12 @@ const ExecutionContextService = scoped(class {
     }
 });
 
-class CandlePublicService {
+class ExchangePublicService {
     constructor() {
         this.loggerService = inject(TYPES.loggerService);
-        this.candleConnectionService = inject(TYPES.candleConnectionService);
+        this.exchangeConnectionService = inject(TYPES.exchangeConnectionService);
         this.getCandles = async (symbol, interval, limit, when, backtest) => {
-            this.loggerService.log("candlePublicService getCandles", {
+            this.loggerService.log("exchangePublicService getCandles", {
                 symbol,
                 interval,
                 limit,
@@ -328,20 +358,48 @@ class CandlePublicService {
                 backtest,
             });
             return await ExecutionContextService.runInContext(async () => {
-                return await this.candleConnectionService.getCandles(symbol, interval, limit);
+                return await this.exchangeConnectionService.getCandles(symbol, interval, limit);
             }, {
                 when,
                 backtest,
             });
         };
         this.getAveragePrice = async (symbol, when, backtest) => {
-            this.loggerService.log("candlePublicService getAveragePrice", {
+            this.loggerService.log("exchangePublicService getAveragePrice", {
+                symbol,
+                when,
+                backtest,
+            });
+            return await ExecutionContextService.runInContext(async () => {
+                return await this.exchangeConnectionService.getAveragePrice(symbol);
+            }, {
+                when,
+                backtest,
+            });
+        };
+        this.formatPrice = async (symbol, price, when, backtest) => {
+            this.loggerService.log("exchangePublicService formatPrice", {
                 symbol,
+                price,
                 when,
                 backtest,
             });
             return await ExecutionContextService.runInContext(async () => {
-                return await this.candleConnectionService.getAveragePrice(symbol);
+                return await this.exchangeConnectionService.formatPrice(symbol, price);
+            }, {
+                when,
+                backtest,
+            });
+        };
+        this.formatQuantity = async (symbol, quantity, when, backtest) => {
+            this.loggerService.log("exchangePublicService formatQuantity", {
+                symbol,
+                quantity,
+                when,
+                backtest,
+            });
+            return await ExecutionContextService.runInContext(async () => {
+                return await this.exchangeConnectionService.formatQuantity(symbol, quantity);
             }, {
                 when,
                 backtest,
@@ -370,19 +428,19 @@ class StrategyPublicService {
     }
 }
 
-class CandleSchemaService {
+class ExchangeSchemaService {
     constructor() {
         this.loggerService = inject(TYPES.loggerService);
         this.getSchema = () => {
-            this.loggerService.log("candleSchemaService getSchema");
-            if (!this._candleSchema) {
-                throw new Error("CandleSchemaService no candle source provided");
+            this.loggerService.log("exchangeSchemaService getSchema");
+            if (!this._exchangeSchema) {
+                throw new Error("ExchangeSchemaService no exchange source provided");
             }
-            return this._candleSchema;
+            return this._exchangeSchema;
         };
-        this.addSchema = (candleSchema) => {
-            this.loggerService.log("candleSchemaService addSchema");
-            this._candleSchema = candleSchema;
+        this.addSchema = (exchangeSchema) => {
+            this.loggerService.log("exchangeSchemaService addSchema");
+            this._exchangeSchema = exchangeSchema;
         };
     }
 }
@@ -411,15 +469,15 @@ class StrategySchemaService {
     provide(TYPES.executionContextService, () => new ExecutionContextService());
 }
 {
-    provide(TYPES.candleConnectionService, () => new CandleConnectionService());
+    provide(TYPES.exchangeConnectionService, () => new ExchangeConnectionService());
     provide(TYPES.strategyConnectionService, () => new StrategyConnectionService());
 }
 {
-    provide(TYPES.candleSchemaService, () => new CandleSchemaService());
+    provide(TYPES.exchangeSchemaService, () => new ExchangeSchemaService());
     provide(TYPES.strategySchemaService, () => new StrategySchemaService());
 }
 {
-    provide(TYPES.candlePublicService, () => new CandlePublicService());
+    provide(TYPES.exchangePublicService, () => new ExchangePublicService());
     provide(TYPES.strategyPublicService, () => new StrategyPublicService());
 }
 
@@ -430,15 +488,15 @@ const contextServices = {
     executionContextService: inject(TYPES.executionContextService),
 };
 const connectionServices = {
-    candleConnectionService: inject(TYPES.candleConnectionService),
+    exchangeConnectionService: inject(TYPES.exchangeConnectionService),
     strategyConnectionService: inject(TYPES.strategyConnectionService),
 };
 const schemaServices = {
-    candleSchemaService: inject(TYPES.candleSchemaService),
+    exchangeSchemaService: inject(TYPES.exchangeSchemaService),
     strategySchemaService: inject(TYPES.strategySchemaService),
 };
 const publicServices = {
-    candlePublicService: inject(TYPES.candlePublicService),
+    exchangePublicService: inject(TYPES.exchangePublicService),
     strategyPublicService: inject(TYPES.strategyPublicService),
 };
 const backtest = {
@@ -453,8 +511,8 @@ init();
 function addStrategy(strategySchema) {
     backtest.strategySchemaService.addSchema(strategySchema);
 }
-function addCandle(candleSchema) {
-    backtest.candleSchemaService.addSchema(candleSchema);
+function addExchange(exchangeSchema) {
+    backtest.exchangeSchemaService.addSchema(exchangeSchema);
 }
 
 async function runBacktest(symbol, timeframes) {
@@ -571,10 +629,16 @@ function stopAll() {
 }
 
 async function getCandles(symbol, interval, limit) {
-    return await backtest.candleConnectionService.getCandles(symbol, interval, limit);
+    return await backtest.exchangeConnectionService.getCandles(symbol, interval, limit);
 }
 async function getAveragePrice(symbol) {
-    return await backtest.candleConnectionService.getAveragePrice(symbol);
+    return await backtest.exchangeConnectionService.getAveragePrice(symbol);
+}
+async function formatPrice(symbol, price) {
+    return await backtest.exchangeConnectionService.formatPrice(symbol, price);
+}
+async function formatQuantity(symbol, quantity) {
+    return await backtest.exchangeConnectionService.formatQuantity(symbol, quantity);
 }
 
-export { ExecutionContextService, addCandle, addStrategy, backtest, getAveragePrice, getCandles, reduce, runBacktest, runBacktestGUI, startRun, stopAll, stopRun };
+export { ExecutionContextService, addExchange, addStrategy, backtest, formatPrice, formatQuantity, getAveragePrice, getCandles, reduce, runBacktest, runBacktestGUI, startRun, stopAll, stopRun };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "backtest-kit",
-  "version": "1.0.2",
+  "version": "1.0.3",
   "description": "A TypeScript library for trading system backtest",
   "author": {
     "name": "Petr Tripolsky",

package/types.d.ts

@@ -46,19 +46,23 @@ interface ICandleData {
     close: number;
     volume: number;
 }
-interface ICandleParams extends ICandleSchema {
+interface IExchangeParams extends IExchangeSchema {
     logger: ILogger;
     execution: TExecutionContextService;
 }
-interface ICandleCallbacks {
+interface IExchangeCallbacks {
     onCandleData: (symbol: string, interval: CandleInterval, since: Date, limit: number, data: ICandleData[]) => void;
 }
-interface ICandleSchema {
+interface IExchangeSchema {
     getCandles: (symbol: string, interval: CandleInterval, since: Date, limit: number) => Promise<ICandleData[]>;
-    callbacks?: Partial<ICandleCallbacks>;
+    formatQuantity: (symbol: string, quantity: number) => Promise<string>;
+    formatPrice: (symbol: string, price: number) => Promise<string>;
+    callbacks?: Partial<IExchangeCallbacks>;
 }
-interface ICandle {
+interface IExchange {
     getCandles: (symbol: string, interval: CandleInterval, limit: number) => Promise<ICandleData[]>;
+    formatQuantity: (symbol: string, quantity: number) => Promise<string>;
+    formatPrice: (symbol: string, price: number) => Promise<string>;
     getAveragePrice: (symbol: string) => Promise<number>;
 }
 
@@ -112,7 +116,7 @@ interface IStrategy {
 }
 
 declare function addStrategy(strategySchema: IStrategySchema): void;
-declare function addCandle(candleSchema: ICandleSchema): void;
+declare function addExchange(exchangeSchema: IExchangeSchema): void;
 
 interface IBacktestResult {
     symbol: string;
@@ -139,6 +143,8 @@ declare function stopAll(): void;
 
 declare function getCandles(symbol: string, interval: CandleInterval, limit: number): Promise<ICandleData[]>;
 declare function getAveragePrice(symbol: string): Promise<number>;
+declare function formatPrice(symbol: string, price: number): Promise<string>;
+declare function formatQuantity(symbol: string, quantity: number): Promise<string>;
 
 declare class LoggerService implements ILogger {
     private _commonLogger;
@@ -148,27 +154,31 @@ declare class LoggerService implements ILogger {
     setLogger: (logger: ILogger) => void;
 }
 
-declare class ClientCandle implements ICandle {
-    readonly params: ICandleParams;
-    constructor(params: ICandleParams);
+declare class ClientExchange implements IExchange {
+    readonly params: IExchangeParams;
+    constructor(params: IExchangeParams);
     getCandles: (symbol: string, interval: CandleInterval, limit: number) => Promise<ICandleData[]>;
     getAveragePrice: (symbol: string) => Promise<number>;
+    formatQuantity: (symbol: string, quantity: number) => Promise<string>;
+    formatPrice: (symbol: string, price: number) => Promise<string>;
 }
 
-declare class CandleConnectionService implements ICandle {
+declare class ExchangeConnectionService implements IExchange {
     private readonly loggerService;
     private readonly executionContextService;
-    private readonly candleSchemaService;
-    getCandle: ((symbol: string) => ClientCandle) & functools_kit.IClearableMemoize<string> & functools_kit.IControlMemoize<string, ClientCandle>;
+    private readonly exchangeSchemaService;
+    getExchange: ((symbol: string) => ClientExchange) & functools_kit.IClearableMemoize<string> & functools_kit.IControlMemoize<string, ClientExchange>;
     getCandles: (symbol: string, interval: CandleInterval, limit: number) => Promise<ICandleData[]>;
     getAveragePrice: (symbol: string) => Promise<number>;
+    formatPrice: (symbol: string, price: number) => Promise<string>;
+    formatQuantity: (symbol: string, quantity: number) => Promise<string>;
 }
 
-declare class CandleSchemaService {
+declare class ExchangeSchemaService {
     private readonly loggerService;
-    private _candleSchema;
-    getSchema: () => ICandleSchema;
-    addSchema: (candleSchema: ICandleSchema) => void;
+    private _exchangeSchema;
+    getSchema: () => IExchangeSchema;
+    addSchema: (exchangeSchema: IExchangeSchema) => void;
 }
 
 declare class StrategySchemaService {
@@ -182,16 +192,18 @@ declare class StrategyConnectionService implements IStrategy {
     private readonly loggerService;
     private readonly executionContextService;
     private readonly strategySchemaService;
-    private readonly candleConnectionService;
+    private readonly exchangeConnectionService;
     private getStrategy;
     tick: (symbol: string) => Promise<IStrategyTickResult>;
 }
 
-declare class CandlePublicService {
+declare class ExchangePublicService {
     private readonly loggerService;
-    private readonly candleConnectionService;
+    private readonly exchangeConnectionService;
     getCandles: (symbol: string, interval: CandleInterval, limit: number, when: Date, backtest: boolean) => Promise<ICandleData[]>;
     getAveragePrice: (symbol: string, when: Date, backtest: boolean) => Promise<number>;
+    formatPrice: (symbol: string, price: number, when: Date, backtest: boolean) => Promise<string>;
+    formatQuantity: (symbol: string, quantity: number, when: Date, backtest: boolean) => Promise<string>;
 }
 
 declare class StrategyPublicService {
@@ -201,11 +213,11 @@ declare class StrategyPublicService {
 }
 
 declare const backtest: {
-    candlePublicService: CandlePublicService;
+    exchangePublicService: ExchangePublicService;
     strategyPublicService: StrategyPublicService;
-    candleSchemaService: CandleSchemaService;
+    exchangeSchemaService: ExchangeSchemaService;
     strategySchemaService: StrategySchemaService;
-    candleConnectionService: CandleConnectionService;
+    exchangeConnectionService: ExchangeConnectionService;
     strategyConnectionService: StrategyConnectionService;
     executionContextService: {
         readonly context: IExecutionContext;
@@ -213,4 +225,4 @@ declare const backtest: {
     loggerService: LoggerService;
 };
 
-export { type CandleInterval, ExecutionContextService, type ICandleData, type ICandleSchema, type ISignalData, type IStrategyPnL, type IStrategySchema, type IStrategyTickResult, type IStrategyTickResultActive, type IStrategyTickResultClosed, type IStrategyTickResultIdle, type IStrategyTickResultOpened, addCandle, addStrategy, backtest, getAveragePrice, getCandles, reduce, runBacktest, runBacktestGUI, startRun, stopAll, stopRun };
+export { type CandleInterval, ExecutionContextService, type ICandleData, type IExchangeSchema, type ISignalData, type IStrategyPnL, type IStrategySchema, type IStrategyTickResult, type IStrategyTickResultActive, type IStrategyTickResultClosed, type IStrategyTickResultIdle, type IStrategyTickResultOpened, addExchange, addStrategy, backtest, formatPrice, formatQuantity, getAveragePrice, getCandles, reduce, runBacktest, runBacktestGUI, startRun, stopAll, stopRun };