backtest-kit 1.0.2 → 1.0.4

package/package.json

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

package/types.d.ts

@@ -1,19 +1,6 @@
 import * as di_scoped from 'di-scoped';
 import * as functools_kit from 'functools-kit';
 
-interface IExecutionContext {
-    when: Date;
-    backtest: boolean;
-}
-declare const ExecutionContextService: (new () => {
-    readonly context: IExecutionContext;
-}) & Omit<{
-    new (context: IExecutionContext): {
-        readonly context: IExecutionContext;
-    };
-}, "prototype"> & di_scoped.IScopedClassRun<[context: IExecutionContext]>;
-type TExecutionContextService = InstanceType<typeof ExecutionContextService>;
-
 /**
  * Interface representing a logging mechanism for the swarm system.
  * Provides methods to record messages at different severity levels, used across components like agents, sessions, states, storage, swarms, history, embeddings, completions, and policies.
@@ -37,6 +24,22 @@ interface ILogger {
     info(topic: string, ...args: any[]): void;
 }
 
+declare function setLogger(logger: ILogger): Promise<void>;
+
+interface IExecutionContext {
+    symbol: string;
+    when: Date;
+    backtest: boolean;
+}
+declare const ExecutionContextService: (new () => {
+    readonly context: IExecutionContext;
+}) & Omit<{
+    new (context: IExecutionContext): {
+        readonly context: IExecutionContext;
+    };
+}, "prototype"> & di_scoped.IScopedClassRun<[context: IExecutionContext]>;
+type TExecutionContextService = InstanceType<typeof ExecutionContextService>;
+
 type CandleInterval = "1m" | "3m" | "5m" | "15m" | "30m" | "1h" | "2h" | "4h" | "6h" | "8h";
 interface ICandleData {
     timestamp: number;
@@ -46,24 +49,32 @@ 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 {
+    exchangeName: ExchangeName;
     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[]>;
+    getNextCandles: (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>;
 }
+type ExchangeName = string;
 
-interface ISignalData {
-    id: string;
+type SignalInterval = "1m" | "3m" | "5m" | "15m" | "30m" | "1h";
+interface ISignalDto {
+    id?: string;
     position: "long" | "short";
     note: string;
     priceOpen: number;
@@ -72,12 +83,17 @@ interface ISignalData {
     minuteEstimatedTime: number;
     timestamp: number;
 }
+interface ISignalRow extends ISignalDto {
+    id: string;
+}
 interface IStrategyCallbacks {
-    onOpen: (backtest: boolean, symbol: string, data: ISignalData) => void;
-    onClose: (backtest: boolean, symbol: string, priceClose: number, data: ISignalData) => void;
+    onOpen: (backtest: boolean, symbol: string, data: ISignalRow) => void;
+    onClose: (backtest: boolean, symbol: string, priceClose: number, data: ISignalRow) => void;
 }
 interface IStrategySchema {
-    getSignal: (symbol: string) => Promise<ISignalData | null>;
+    strategyName: StrategyName;
+    interval: SignalInterval;
+    getSignal: (symbol: string) => Promise<ISignalDto | null>;
     callbacks?: Partial<IStrategyCallbacks>;
 }
 type StrategyCloseReason = "time_expired" | "take_profit" | "stop_loss";
@@ -92,27 +108,51 @@ interface IStrategyTickResultIdle {
 }
 interface IStrategyTickResultOpened {
     action: "opened";
-    signal: ISignalData;
+    signal: ISignalRow;
 }
 interface IStrategyTickResultActive {
     action: "active";
-    signal: ISignalData;
+    signal: ISignalRow;
     currentPrice: number;
 }
 interface IStrategyTickResultClosed {
     action: "closed";
-    signal: ISignalData;
+    signal: ISignalRow;
     currentPrice: number;
     closeReason: StrategyCloseReason;
+    closeTimestamp: number;
     pnl: IStrategyPnL;
 }
 type IStrategyTickResult = IStrategyTickResultIdle | IStrategyTickResultOpened | IStrategyTickResultActive | IStrategyTickResultClosed;
+type IStrategyBacktestResult = IStrategyTickResultClosed;
 interface IStrategy {
     tick: (symbol: string) => Promise<IStrategyTickResult>;
+    backtest: (candles: ICandleData[]) => Promise<IStrategyBacktestResult>;
+}
+type StrategyName = string;
+
+type FrameInterval = "1m" | "3m" | "5m" | "15m" | "30m" | "1h" | "2h" | "4h" | "6h" | "8h" | "12h" | "1d" | "3d";
+interface IFrameParams extends IFrameSchema {
+    logger: ILogger;
+}
+interface IFrameCallbacks {
+    onTimeframe: (timeframe: Date[], startDate: Date, endDate: Date, interval: FrameInterval) => void;
+}
+interface IFrameSchema {
+    frameName: FrameName;
+    interval: FrameInterval;
+    startDate: Date;
+    endDate: Date;
+    callbacks?: Partial<IFrameCallbacks>;
 }
+interface IFrame {
+    getTimeframe: (symbol: string) => Promise<Date[]>;
+}
+type FrameName = string;
 
 declare function addStrategy(strategySchema: IStrategySchema): void;
-declare function addCandle(candleSchema: ICandleSchema): void;
+declare function addExchange(exchangeSchema: IExchangeSchema): void;
+declare function addFrame(frameSchema: IFrameSchema): void;
 
 interface IBacktestResult {
     symbol: string;
@@ -139,78 +179,268 @@ 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 function getDate(): Promise<Date>;
+declare function getMode(): Promise<"backtest" | "live">;
+
+interface IMethodContext {
+    exchangeName: ExchangeName;
+    strategyName: StrategyName;
+    frameName: FrameName;
+}
+declare const MethodContextService: (new () => {
+    readonly context: IMethodContext;
+}) & Omit<{
+    new (context: IMethodContext): {
+        readonly context: IMethodContext;
+    };
+}, "prototype"> & di_scoped.IScopedClassRun<[context: IMethodContext]>;
+
+declare const BASE_WAIT_FOR_INIT_SYMBOL: unique symbol;
+interface ISignalData {
+    signalRow: ISignalRow | null;
+}
+type TPersistBase = InstanceType<typeof PersistBase>;
+type TPersistBaseCtor<EntityName extends string = string, Entity extends IEntity = IEntity> = new (entityName: EntityName, baseDir: string) => IPersistBase<Entity>;
+type EntityId = string | number;
+interface IEntity {
+}
+interface IPersistBase<Entity extends IEntity = IEntity> {
+    waitForInit(initial: boolean): Promise<void>;
+    readValue(entityId: EntityId): Promise<Entity>;
+    hasValue(entityId: EntityId): Promise<boolean>;
+    writeValue(entityId: EntityId, entity: Entity): Promise<void>;
+}
+declare const PersistBase: {
+    new <EntityName extends string = string>(entityName: EntityName, baseDir?: string): {
+        _directory: string;
+        readonly entityName: EntityName;
+        readonly baseDir: string;
+        _getFilePath(entityId: EntityId): string;
+        waitForInit(initial: boolean): Promise<void>;
+        getCount(): Promise<number>;
+        readValue<T extends IEntity = IEntity>(entityId: EntityId): Promise<T>;
+        hasValue(entityId: EntityId): Promise<boolean>;
+        writeValue<T extends IEntity = IEntity>(entityId: EntityId, entity: T): Promise<void>;
+        removeValue(entityId: EntityId): Promise<void>;
+        removeAll(): Promise<void>;
+        values<T extends IEntity = IEntity>(): AsyncGenerator<T>;
+        keys(): AsyncGenerator<EntityId>;
+        filter<T extends IEntity = IEntity>(predicate: (value: T) => boolean): AsyncGenerator<T>;
+        take<T extends IEntity = IEntity>(total: number, predicate?: (value: T) => boolean): AsyncGenerator<T>;
+        [BASE_WAIT_FOR_INIT_SYMBOL]: (() => Promise<void>) & functools_kit.ISingleshotClearable;
+        [Symbol.asyncIterator](): AsyncIterableIterator<any>;
+    };
+};
+declare class PersistSignalUtils {
+    private PersistSignalFactory;
+    private getSignalStorage;
+    usePersistSignalAdapter(Ctor: TPersistBaseCtor<StrategyName, ISignalData>): void;
+    readSignalData: (strategyName: StrategyName, symbol: string) => Promise<ISignalRow | null>;
+    writeSignalData: (signalRow: ISignalRow | null, strategyName: StrategyName, symbol: string) => Promise<void>;
+}
+declare const PersistSignalAdaper: PersistSignalUtils;
+
+declare class BacktestUtils {
+    run: (symbol: string, context: {
+        strategyName: string;
+        exchangeName: string;
+        frameName: string;
+    }) => AsyncGenerator<IStrategyTickResultClosed, void, unknown>;
+}
+declare const Backtest: BacktestUtils;
+
+declare class LiveUtils {
+    run: (symbol: string, context: {
+        strategyName: string;
+        exchangeName: string;
+        frameName: string;
+    }) => AsyncGenerator<IStrategyTickResultOpened | IStrategyTickResultClosed, void, unknown>;
+}
+declare const Live: LiveUtils;
 
 declare class LoggerService implements ILogger {
+    private readonly methodContextService;
+    private readonly executionContextService;
     private _commonLogger;
+    private get methodContext();
+    private get executionContext();
     log: (topic: string, ...args: any[]) => Promise<void>;
     debug: (topic: string, ...args: any[]) => Promise<void>;
     info: (topic: string, ...args: any[]) => Promise<void>;
     setLogger: (logger: ILogger) => void;
 }
 
-declare class ClientCandle implements ICandle {
-    readonly params: ICandleParams;
-    constructor(params: ICandleParams);
-    getCandles: (symbol: string, interval: CandleInterval, limit: number) => Promise<ICandleData[]>;
-    getAveragePrice: (symbol: string) => Promise<number>;
+declare class ClientExchange implements IExchange {
+    readonly params: IExchangeParams;
+    constructor(params: IExchangeParams);
+    getCandles(symbol: string, interval: CandleInterval, limit: number): Promise<ICandleData[]>;
+    getNextCandles(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;
+    private readonly methodContextService;
+    getExchange: ((exchangeName: ExchangeName) => ClientExchange) & functools_kit.IClearableMemoize<string> & functools_kit.IControlMemoize<string, ClientExchange>;
     getCandles: (symbol: string, interval: CandleInterval, limit: number) => Promise<ICandleData[]>;
+    getNextCandles: (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 StrategyConnectionService implements IStrategy {
     private readonly loggerService;
-    private _candleSchema;
-    getSchema: () => ICandleSchema;
-    addSchema: (candleSchema: ICandleSchema) => void;
+    private readonly executionContextService;
+    private readonly strategySchemaService;
+    private readonly exchangeConnectionService;
+    private readonly methodContextService;
+    private getStrategy;
+    tick: () => Promise<IStrategyTickResult>;
+    backtest: (candles: ICandleData[]) => Promise<IStrategyBacktestResult>;
 }
 
-declare class StrategySchemaService {
-    private readonly loggerService;
-    private _strategySchema;
-    getSchema: () => IStrategySchema;
-    addSchema: (strategySchema: IStrategySchema) => void;
+declare class ClientFrame implements IFrame {
+    readonly params: IFrameParams;
+    constructor(params: IFrameParams);
+    getTimeframe: ((symbol: string) => Promise<Date[]>) & functools_kit.ISingleshotClearable;
 }
 
-declare class StrategyConnectionService implements IStrategy {
+declare class FrameConnectionService implements IFrame {
     private readonly loggerService;
-    private readonly executionContextService;
-    private readonly strategySchemaService;
-    private readonly candleConnectionService;
-    private getStrategy;
-    tick: (symbol: string) => Promise<IStrategyTickResult>;
+    private readonly frameSchemaService;
+    private readonly methodContextService;
+    getFrame: ((frameName: FrameName) => ClientFrame) & functools_kit.IClearableMemoize<string> & functools_kit.IControlMemoize<string, ClientFrame>;
+    getTimeframe: (symbol: string) => Promise<Date[]>;
 }
 
-declare class CandlePublicService {
+declare class ExchangeGlobalService {
     private readonly loggerService;
-    private readonly candleConnectionService;
+    private readonly exchangeConnectionService;
     getCandles: (symbol: string, interval: CandleInterval, limit: number, when: Date, backtest: boolean) => Promise<ICandleData[]>;
+    getNextCandles: (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 {
+declare class StrategyGlobalService {
     private readonly loggerService;
     private readonly strategyConnectionService;
     tick: (symbol: string, when: Date, backtest: boolean) => Promise<IStrategyTickResult>;
+    backtest: (symbol: string, candles: ICandleData[], when: Date, backtest: boolean) => Promise<IStrategyBacktestResult>;
+}
+
+declare class FrameGlobalService {
+    private readonly loggerService;
+    private readonly frameConnectionService;
+    getTimeframe: (symbol: string) => Promise<Date[]>;
+}
+
+declare class ExchangeSchemaService {
+    readonly loggerService: LoggerService;
+    private _registry;
+    register: (key: ExchangeName, value: IExchangeSchema) => void;
+    override: (key: ExchangeName, value: Partial<IExchangeSchema>) => IExchangeSchema;
+    get: (key: ExchangeName) => IExchangeSchema;
+}
+
+declare class StrategySchemaService {
+    readonly loggerService: LoggerService;
+    private _registry;
+    register: (key: StrategyName, value: IStrategySchema) => void;
+    override: (key: StrategyName, value: Partial<IStrategySchema>) => IStrategySchema;
+    get: (key: StrategyName) => IStrategySchema;
+}
+
+declare class FrameSchemaService {
+    private _registry;
+    register(key: FrameName, value: IFrameSchema): void;
+    override(key: FrameName, value: Partial<IFrameSchema>): void;
+    get(key: FrameName): IFrameSchema;
+}
+
+declare class BacktestLogicPrivateService {
+    private readonly loggerService;
+    private readonly strategyGlobalService;
+    private readonly exchangeGlobalService;
+    private readonly frameGlobalService;
+    run(symbol: string): AsyncGenerator<IStrategyTickResultClosed, void, unknown>;
+}
+
+declare class LiveLogicPrivateService {
+    private readonly loggerService;
+    private readonly strategyGlobalService;
+    run(symbol: string): AsyncGenerator<IStrategyTickResultOpened | IStrategyTickResultClosed, void, unknown>;
+}
+
+declare class BacktestLogicPublicService {
+    private readonly loggerService;
+    private readonly backtestLogicPrivateService;
+    run: (symbol: string, context: {
+        strategyName: string;
+        exchangeName: string;
+        frameName: string;
+    }) => AsyncGenerator<IStrategyTickResultClosed, void, unknown>;
+}
+
+declare class LiveLogicPublicService {
+    private readonly loggerService;
+    private readonly liveLogicPrivateService;
+    run: (symbol: string, context: {
+        strategyName: string;
+        exchangeName: string;
+    }) => AsyncGenerator<IStrategyTickResultOpened | IStrategyTickResultClosed, void, unknown>;
+}
+
+declare class LiveGlobalService {
+    private readonly loggerService;
+    private readonly liveLogicPublicService;
+    run: (symbol: string, context: {
+        strategyName: string;
+        exchangeName: string;
+    }) => AsyncGenerator<IStrategyTickResultOpened | IStrategyTickResultClosed, void, unknown>;
+}
+
+declare class BacktestGlobalService {
+    private readonly loggerService;
+    private readonly backtestLogicPublicService;
+    run: (symbol: string, context: {
+        strategyName: string;
+        exchangeName: string;
+        frameName: string;
+    }) => AsyncGenerator<IStrategyTickResultClosed, void, unknown>;
 }
 
 declare const backtest: {
-    candlePublicService: CandlePublicService;
-    strategyPublicService: StrategyPublicService;
-    candleSchemaService: CandleSchemaService;
+    backtestLogicPublicService: BacktestLogicPublicService;
+    liveLogicPublicService: LiveLogicPublicService;
+    backtestLogicPrivateService: BacktestLogicPrivateService;
+    liveLogicPrivateService: LiveLogicPrivateService;
+    exchangeGlobalService: ExchangeGlobalService;
+    strategyGlobalService: StrategyGlobalService;
+    frameGlobalService: FrameGlobalService;
+    liveGlobalService: LiveGlobalService;
+    backtestGlobalService: BacktestGlobalService;
+    exchangeSchemaService: ExchangeSchemaService;
     strategySchemaService: StrategySchemaService;
-    candleConnectionService: CandleConnectionService;
+    frameSchemaService: FrameSchemaService;
+    exchangeConnectionService: ExchangeConnectionService;
     strategyConnectionService: StrategyConnectionService;
+    frameConnectionService: FrameConnectionService;
     executionContextService: {
         readonly context: IExecutionContext;
     };
+    methodContextService: {
+        readonly context: IMethodContext;
+    };
     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 { Backtest, type CandleInterval, ExecutionContextService, type FrameInterval, type ICandleData, type IExchangeSchema, type IFrameSchema, type IPersistBase, type ISignalDto, type ISignalRow, type IStrategyPnL, type IStrategySchema, type IStrategyTickResult, type IStrategyTickResultActive, type IStrategyTickResultClosed, type IStrategyTickResultIdle, type IStrategyTickResultOpened, Live, MethodContextService, PersistBase, PersistSignalAdaper, type SignalInterval, type TPersistBase, type TPersistBaseCtor, addExchange, addFrame, addStrategy, backtest, formatPrice, formatQuantity, getAveragePrice, getCandles, getDate, getMode, reduce, runBacktest, runBacktestGUI, setLogger, startRun, stopAll, stopRun };