backtest-kit 1.0.0

package/build/index.mjs

@@ -0,0 +1,573 @@
+import { createActivator } from 'di-kit';
+import { memoize, singlerun, sleep } from 'functools-kit';
+import { scoped } from 'di-scoped';
+import Table from 'cli-table3';
+
+const NOOP_LOGGER = {
+    log() {
+    },
+    debug() {
+    },
+    info() {
+    },
+};
+class LoggerService {
+    constructor() {
+        this._commonLogger = NOOP_LOGGER;
+        this.log = async (topic, ...args) => {
+            await this._commonLogger.log(topic, ...args);
+        };
+        this.debug = async (topic, ...args) => {
+            await this._commonLogger.debug(topic, ...args);
+        };
+        this.info = async (topic, ...args) => {
+            await this._commonLogger.info(topic, ...args);
+        };
+        this.setLogger = (logger) => {
+            this._commonLogger = logger;
+        };
+    }
+}
+
+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 = {
+    "1m": 1,
+    "3m": 3,
+    "5m": 5,
+    "15m": 15,
+    "30m": 30,
+    "1h": 60,
+    "2h": 120,
+    "4h": 240,
+    "6h": 360,
+    "8h": 480,
+};
+class ClientCandle {
+    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;
+        };
+    }
+}
+
+class CandleConnectionService {
+    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({
+                execution: this.executionContextService,
+                logger: this.loggerService,
+                getCandles,
+                callbacks,
+            });
+        });
+        this.getCandles = async (symbol, interval, limit) => {
+            this.loggerService.log("candleConnectionService getCandles", {
+                symbol,
+                interval,
+                limit,
+            });
+            return await this.getCandle(symbol).getCandles(symbol, interval, limit);
+        };
+        this.getAveragePrice = async (symbol) => {
+            this.loggerService.log("candleConnectionService getAveragePrice", {
+                symbol,
+            });
+            return await this.getCandle(symbol).getAveragePrice(symbol);
+        };
+    }
+}
+
+const PERCENT_SLIPPAGE = 0.1;
+const PERCENT_FEE = 0.1;
+const GET_PNL_FN = (signal, priceClose) => {
+    const priceOpen = signal.priceOpen;
+    let priceOpenWithSlippage;
+    let priceCloseWithSlippage;
+    if (signal.position === "long") {
+        // LONG: покупаем дороже, продаем дешевле
+        priceOpenWithSlippage = priceOpen * (1 + PERCENT_SLIPPAGE / 100);
+        priceCloseWithSlippage = priceClose * (1 - PERCENT_SLIPPAGE / 100);
+    }
+    else {
+        // SHORT: продаем дешевле, покупаем дороже
+        priceOpenWithSlippage = priceOpen * (1 - PERCENT_SLIPPAGE / 100);
+        priceCloseWithSlippage = priceClose * (1 + PERCENT_SLIPPAGE / 100);
+    }
+    // Применяем комиссию дважды (при открытии и закрытии)
+    const totalFee = PERCENT_FEE * 2;
+    let pnlPercentage;
+    if (signal.position === "long") {
+        // LONG: прибыль при росте цены
+        pnlPercentage =
+            ((priceCloseWithSlippage - priceOpenWithSlippage) /
+                priceOpenWithSlippage) *
+                100;
+    }
+    else {
+        // SHORT: прибыль при падении цены
+        pnlPercentage =
+            ((priceOpenWithSlippage - priceCloseWithSlippage) /
+                priceOpenWithSlippage) *
+                100;
+    }
+    // Вычитаем комиссии
+    pnlPercentage -= totalFee;
+    return {
+        pnlPercentage,
+        priceOpen,
+        priceClose,
+    };
+};
+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,
+                    };
+                }
+                return {
+                    action: "idle",
+                    signal: null,
+                };
+            }
+            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,
+                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 = GET_PNL_FN(signal, averagePrice);
+                this.params.logger.debug("ClientStrategy closing", {
+                    symbol,
+                    signalId: signal.id,
+                    reason: closeReason,
+                    priceClose: averagePrice,
+                    pnlPercentage: pnl.pnlPercentage,
+                });
+                if (this.params.callbacks?.onClose) {
+                    this.params.callbacks.onClose(this.params.execution.context.backtest, symbol, averagePrice, signal);
+                }
+                this._pendingSignal = null;
+                return {
+                    action: "closed",
+                    signal: signal,
+                    currentPrice: averagePrice,
+                    closeReason: closeReason,
+                    pnl: pnl,
+                };
+            }
+            return {
+                action: "active",
+                signal: signal,
+                currentPrice: averagePrice,
+            };
+        };
+    }
+}
+
+class StrategyConnectionService {
+    constructor() {
+        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();
+            return new ClientStrategy({
+                symbol,
+                execution: this.executionContextService,
+                logger: this.loggerService,
+                candle: this.candleConnectionService,
+                getSignal,
+                callbacks,
+            });
+        });
+        this.tick = async (symbol) => {
+            this.loggerService.log("strategyConnectionService tick", {
+                symbol,
+            });
+            return await this.getStrategy(symbol).tick(symbol);
+        };
+    }
+}
+
+const ExecutionContextService = scoped(class {
+    constructor(context) {
+        this.context = context;
+    }
+});
+
+class CandlePublicService {
+    constructor() {
+        this.loggerService = inject(TYPES.loggerService);
+        this.candleConnectionService = inject(TYPES.candleConnectionService);
+        this.getCandles = async (symbol, interval, limit, when, backtest) => {
+            this.loggerService.log("candlePublicService getCandles", {
+                symbol,
+                interval,
+                limit,
+                when,
+                backtest,
+            });
+            return await ExecutionContextService.runInContext(async () => {
+                return await this.candleConnectionService.getCandles(symbol, interval, limit);
+            }, {
+                when,
+                backtest,
+            });
+        };
+        this.getAveragePrice = async (symbol, when, backtest) => {
+            this.loggerService.log("candlePublicService getAveragePrice", {
+                symbol,
+                when,
+                backtest,
+            });
+            return await ExecutionContextService.runInContext(async () => {
+                return await this.candleConnectionService.getAveragePrice(symbol);
+            }, {
+                when,
+                backtest,
+            });
+        };
+    }
+}
+
+class StrategyPublicService {
+    constructor() {
+        this.loggerService = inject(TYPES.loggerService);
+        this.strategyConnectionService = inject(TYPES.strategyConnectionService);
+        this.tick = async (symbol, when, backtest) => {
+            this.loggerService.log("strategyPublicService tick", {
+                symbol,
+                when,
+                backtest,
+            });
+            return await ExecutionContextService.runInContext(async () => {
+                return await this.strategyConnectionService.tick(symbol);
+            }, {
+                when,
+                backtest,
+            });
+        };
+    }
+}
+
+class CandleSchemaService {
+    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.addSchema = (candleSchema) => {
+            this.loggerService.log("candleSchemaService addSchema");
+            this._candleSchema = candleSchema;
+        };
+    }
+}
+
+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");
+            }
+            return this._strategySchema;
+        };
+        this.addSchema = (strategySchema) => {
+            this.loggerService.log("strategySchemaService addSchema");
+            this._strategySchema = strategySchema;
+        };
+    }
+}
+
+{
+    provide(TYPES.loggerService, () => new LoggerService());
+}
+{
+    provide(TYPES.executionContextService, () => new ExecutionContextService());
+}
+{
+    provide(TYPES.candleConnectionService, () => new CandleConnectionService());
+    provide(TYPES.strategyConnectionService, () => new StrategyConnectionService());
+}
+{
+    provide(TYPES.candleSchemaService, () => new CandleSchemaService());
+    provide(TYPES.strategySchemaService, () => new StrategySchemaService());
+}
+{
+    provide(TYPES.candlePublicService, () => new CandlePublicService());
+    provide(TYPES.strategyPublicService, () => new StrategyPublicService());
+}
+
+const baseServices = {
+    loggerService: inject(TYPES.loggerService),
+};
+const contextServices = {
+    executionContextService: inject(TYPES.executionContextService),
+};
+const connectionServices = {
+    candleConnectionService: inject(TYPES.candleConnectionService),
+    strategyConnectionService: inject(TYPES.strategyConnectionService),
+};
+const schemaServices = {
+    candleSchemaService: inject(TYPES.candleSchemaService),
+    strategySchemaService: inject(TYPES.strategySchemaService),
+};
+const publicServices = {
+    candlePublicService: inject(TYPES.candlePublicService),
+    strategyPublicService: inject(TYPES.strategyPublicService),
+};
+const backtest = {
+    ...baseServices,
+    ...contextServices,
+    ...connectionServices,
+    ...schemaServices,
+    ...publicServices,
+};
+init();
+
+function addStrategy(strategySchema) {
+    backtest.strategySchemaService.addSchema(strategySchema);
+}
+function addCandle(candleSchema) {
+    backtest.candleSchemaService.addSchema(candleSchema);
+}
+
+async function runBacktest(symbol, timeframes) {
+    const results = [];
+    for (const when of timeframes) {
+        const result = await backtest.strategyPublicService.tick(symbol, when, true);
+        // Сохраняем только результаты closed
+        if (result.action === "closed") {
+            results.push(result);
+        }
+    }
+    return {
+        symbol,
+        results,
+    };
+}
+async function runBacktestGUI(symbol, timeframes) {
+    const backtestResult = await runBacktest(symbol, timeframes);
+    const { results } = backtestResult;
+    // Таблица для терминала
+    const table = new Table({
+        head: ["#", "Time", "Note", "Price", "Reason", "PNL %"],
+    });
+    let totalPnl = 0;
+    let winCount = 0;
+    let lossCount = 0;
+    results.forEach((result, index) => {
+        if (result.action === "closed") {
+            const pnl = result.pnl.pnlPercentage;
+            totalPnl += pnl;
+            if (pnl > 0)
+                winCount++;
+            else if (pnl < 0)
+                lossCount++;
+            const pnlFormatted = pnl > 0 ? `+${pnl.toFixed(2)}%` : `${pnl.toFixed(2)}%`;
+            const emoji = pnl > 0 ? "🟢" : pnl < 0 ? "🔴" : "⚪";
+            table.push([
+                index + 1,
+                new Date(result.signal.timestamp).toISOString(),
+                result.signal.note,
+                result.currentPrice.toFixed(2),
+                result.closeReason,
+                `${emoji} ${pnlFormatted}`,
+            ]);
+        }
+    });
+    // Добавляем статистику
+    const closedCount = results.length;
+    table.push([]);
+    table.push([
+        "TOTAL",
+        `${closedCount} trades`,
+        `Win: ${winCount}`,
+        `Loss: ${lossCount}`,
+        "-",
+        `WR: ${closedCount > 0 ? ((winCount / closedCount) * 100).toFixed(1) : 0}%`,
+        `${totalPnl > 0 ? "+" : ""}${totalPnl.toFixed(2)}%`,
+    ]);
+    console.log("\n");
+    console.log(table.toString());
+    console.log("\n");
+}
+
+async function reduce(symbol, timeframes, callback, initialValue) {
+    let accumulator = initialValue;
+    for (let i = 0; i < timeframes.length; i++) {
+        const when = timeframes[i];
+        accumulator = await callback(accumulator, i, when, symbol);
+    }
+    return {
+        symbol,
+        accumulator,
+        totalTicks: timeframes.length,
+    };
+}
+
+const instances = new Map();
+function startRun(config) {
+    const { symbol, interval } = config;
+    // Останавливаем предыдущий инстанс для этого символа
+    if (instances.has(symbol)) {
+        stopRun(symbol);
+    }
+    const doWork = singlerun(async () => {
+        const now = new Date();
+        const result = await backtest.strategyPublicService.tick(symbol, now, false);
+        const instance = instances.get(symbol);
+        if (instance) {
+            instance.tickCount++;
+        }
+        await sleep(interval);
+        return result;
+    });
+    const intervalId = setInterval(doWork, interval);
+    instances.set(symbol, {
+        config,
+        tickCount: 0,
+        intervalId,
+        doWork,
+    });
+}
+function stopRun(symbol) {
+    const instance = instances.get(symbol);
+    if (instance) {
+        clearInterval(instance.intervalId);
+        instances.delete(symbol);
+    }
+}
+function stopAll() {
+    instances.forEach((instance) => {
+        clearInterval(instance.intervalId);
+    });
+    instances.clear();
+}
+
+export { ExecutionContextService, addCandle, addStrategy, backtest, reduce, runBacktest, runBacktestGUI, startRun, stopAll, stopRun };

package/package.json

@@ -0,0 +1,86 @@
+{
+  "name": "backtest-kit",
+  "version": "1.0.0",
+  "description": "A TypeScript library for trading system backtest",
+  "author": {
+    "name": "Petr Tripolsky",
+    "email": "tripolskypetr@gmail.com",
+    "url": "https://github.com/tripolskypetr"
+  },
+  "funding": {
+    "type": "individual",
+    "url": "http://paypal.me/tripolskypetr"
+  },
+  "license": "MIT",
+  "homepage": "https://backtest-kit.github.io/modules.html",
+  "keywords": [
+    "backtesting",
+    "backtest",
+    "finance",
+    "trading",
+    "candles",
+    "indicators",
+    "multi value",
+    "multi symbol",
+    "framework"
+  ],
+  "files": [
+    "build",
+    "types.d.ts",
+    "README.md"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/tripolskypetr/backtest-kit",
+    "documentation": "https://github.com/tripolskypetr/backtest-kit/tree/master/docs"
+  },
+  "bugs": {
+    "url": "https://github.com/tripolskypetr/backtest-kit/issues"
+  },
+  "scripts": {
+    "build": "rollup -c",
+    "build:docs": "rimraf docs && mkdir docs && node ./scripts/dts-docs.cjs ./types.d.ts ./docs",
+    "docs:gpt": "npm run build && node ./scripts/gpt-docs.mjs",
+    "docs:uml": "npm run build && node ./scripts/uml.mjs",
+    "docs:www": "rimraf docs/wwwroot && typedoc",
+    "repl": "dotenv -e .env -- npm run build && node -e \"import('./scripts/repl.mjs')\" --interactive"
+  },
+  "main": "build/index.cjs",
+  "module": "build/index.mjs",
+  "source": "src/index.ts",
+  "types": "./types.d.ts",
+  "exports": {
+    "require": "./build/index.cjs",
+    "types": "./types.d.ts",
+    "import": "./build/index.mjs",
+    "default": "./build/index.cjs"
+  },
+  "devDependencies": {
+    "@rollup/plugin-typescript": "11.1.6",
+    "@types/lodash-es": "4.17.12",
+    "@types/node": "22.9.0",
+    "@types/xml2js": "0.4.14",
+    "glob": "11.0.1",
+    "ollama": "0.5.14",
+    "rimraf": "6.0.1",
+    "rollup": "3.29.5",
+    "rollup-plugin-dts": "6.1.1",
+    "rollup-plugin-peer-deps-external": "2.2.4",
+    "tslib": "2.7.0",
+    "typedoc": "0.27.9",
+    "undici": "6.21.2",
+    "worker-testbed": "1.0.10"
+  },
+  "peerDependencies": {
+    "typescript": "^5.0.0"
+  },
+  "dependencies": {
+    "cli-table3": "^0.6.5",
+    "di-kit": "^1.0.18",
+    "di-scoped": "^1.0.20",
+    "functools-kit": "^1.0.93",
+    "get-moment-stamp": "^1.1.1",
+    "lodash-es": "4.17.21",
+    "xml2js": "0.6.2"
+  }
+}