@extasyio/strategy-dsl/dist/index.d.ts

Declarative strategy builder and event bus for extasy-trading-core-libs

import { Indicator } from '@extasyio/indicators';

type OrderSide = 'long' | 'short';
type StrategySignal = 'enter' | 'exit' | 'none';
/** Standardized tick coming from indicators/builder */
interface SignalPayload {
    side: OrderSide;
    price: number;
    ts: number;
}

type Handler<T> = (data: T) => void;
declare class EventBus<TEventMap extends object> {
    private readonly listeners;
    on<K extends keyof TEventMap>(event: K, handler: Handler<TEventMap[K]>): void;
    emit<K extends keyof TEventMap>(event: K, data: TEventMap[K]): void;
    off<K extends keyof TEventMap>(event: K, handler: Handler<TEventMap[K]>): void;
}

type State = 'idle' | 'long' | 'short';
declare class StateMachine {
    private state;
    get current(): State;
    enter(side: OrderSide): void;
    exit(): void;
    toggle(side: OrderSide): void;
    reset(): void;
}

type Rule<T> = (v: T, side: 'long' | 'short' | 'idle') => boolean;
declare const and: <T>(...rules: Rule<T>[]) => Rule<T>;
declare const or: <T>(...rules: Rule<T>[]) => Rule<T>;
declare const not: <T>(rule: Rule<T>) => Rule<T>;
declare const withinHours: (h: [number, number]) => Rule<unknown>;

interface BuilderOptions<TIn> {
    name: string;
    indicator: Indicator<TIn, number>;
    enterRule: (val: number) => OrderSide | null;
    exitRule: (val: number, side: OrderSide) => boolean;
}
declare class StrategyBuilder<TIn> {
    private readonly opts;
    private readonly bus;
    private readonly fsm;
    constructor(opts: BuilderOptions<TIn>);
    onSignal(cb: (p: SignalPayload) => void): void;
    feed(data: TIn, price: number, ts: number): void;
}

export { EventBus, type OrderSide, type Rule, type SignalPayload, type State, StateMachine, StrategyBuilder, type StrategySignal, and, not, or, withinHours };