@quantform/core 0.5.23 → 0.6.4

package/src/adapter/backtester/backtester-adapter.spec.ts

@@ -1,133 +0,0 @@
-import {
-  Asset,
-  Candle,
-  Commission,
-  instrumentOf,
-  InstrumentSelector,
-  Order
-} from '../../domain';
-import { d, timestamp } from '../../shared';
-import { Cache, Feed, InMemoryStorage } from '../../storage';
-import { InstrumentPatchEvent, Store, TradePatchEvent } from '../../store';
-import {
-  Adapter,
-  AdapterTimeProvider,
-  DefaultTimeProvider,
-  FeedAsyncCallback
-} from '../adapter';
-import { PaperEngine } from '../paper/engine/paper-engine';
-import { PaperAdapter } from '../paper/paper-adapter';
-import { BacktesterAdapter } from './backtester-adapter';
-import { BacktesterStreamer } from './backtester-streamer';
-
-const base = new Asset('btc', 'binance', 8);
-const quote = new Asset('usdt', 'binance', 4);
-
-class DefaultAdapter extends Adapter {
-  dispose(): Promise<void> {
-    throw new Error('Method not implemented.');
-  }
-  subscribe(instruments: InstrumentSelector[]): Promise<void> {
-    throw new Error('Method not implemented.');
-  }
-  account(): Promise<void> {
-    throw new Error('Method not implemented.');
-  }
-  open(order: Order): Promise<void> {
-    throw new Error('Method not implemented.');
-  }
-  cancel(order: Order): Promise<void> {
-    throw new Error('Method not implemented.');
-  }
-  history(
-    instrument: InstrumentSelector,
-    timeframe: number,
-    length: number
-  ): Promise<Candle[]> {
-    throw new Error('Method not implemented.');
-  }
-  feed(
-    instrument: InstrumentSelector,
-    from: timestamp,
-    to: timestamp,
-    callback: FeedAsyncCallback
-  ): Promise<void> {
-    throw new Error('Method not implemented.');
-  }
-  name = 'default';
-
-  constructor(timeProvider: AdapterTimeProvider, private readonly store: Store) {
-    super(timeProvider);
-  }
-
-  timestamp() {
-    return 123;
-  }
-
-  createPaperEngine(adapter: PaperAdapter): PaperEngine {
-    return new PaperEngine(adapter.store);
-  }
-
-  async awake(): Promise<void> {
-    this.store.dispatch(
-      new InstrumentPatchEvent(
-        this.timestamp(),
-        base,
-        quote,
-        new Commission(d(0.1), d(0.1)),
-        'btc-usdt'
-      )
-    );
-  }
-}
-
-const instrument = instrumentOf('binance:btc-usdt');
-const store = new Store();
-const adapter = new DefaultAdapter(DefaultTimeProvider, store);
-const feed = new Feed(new InMemoryStorage());
-const cache = new Cache(new InMemoryStorage());
-
-describe('BacktesterAdapter', () => {
-  test('should return proper adapter name and timestamp', () => {
-    const sut = new BacktesterAdapter(
-      adapter,
-      new BacktesterStreamer(store, feed, {
-        from: 1,
-        to: 100
-      }),
-      store
-    );
-
-    expect(sut.name).toEqual('default');
-    expect(sut.timestamp()).toEqual(1);
-  });
-
-  test('should stream data from input array', done => {
-    const streamer = new BacktesterStreamer(
-      store,
-      feed,
-      {
-        from: 0,
-        to: 100
-      },
-      {
-        onBacktestCompleted: () => {
-          expect(store.snapshot.timestamp).toEqual(1);
-          expect(store.snapshot.trade.get(instrument.id).rate).toEqual(d(100));
-          expect(store.snapshot.trade.get(instrument.id).quantity).toEqual(d(10));
-
-          done();
-        }
-      }
-    );
-
-    feed.save([new TradePatchEvent(instrument, d(100), d(10), 1)]);
-
-    const sut = new BacktesterAdapter(adapter, streamer, store);
-
-    sut.awake();
-    sut.subscribe([instrument]);
-
-    expect(sut.name).toEqual('default');
-  });
-});

package/src/adapter/paper/paper-adapter.spec.ts

@@ -1,114 +0,0 @@
-import { d, timestamp } from '../../shared';
-import { InstrumentPatchEvent, Store } from '../../store';
-import {
-  Adapter,
-  AdapterTimeProvider,
-  DefaultTimeProvider,
-  FeedAsyncCallback
-} from '../adapter';
-import {
-  Asset,
-  Candle,
-  Commission,
-  instrumentOf,
-  InstrumentSelector,
-  Order
-} from './../../domain';
-import { PaperEngine } from './engine/paper-engine';
-import { PaperAdapter } from './paper-adapter';
-
-class DefaultAdapter extends Adapter {
-  dispose(): Promise<void> {
-    throw new Error('Method not implemented.');
-  }
-  subscribe(instruments: InstrumentSelector[]): Promise<void> {
-    throw new Error('Method not implemented.');
-  }
-  account(): Promise<void> {
-    throw new Error('Method not implemented.');
-  }
-  open(order: Order): Promise<void> {
-    throw new Error('Method not implemented.');
-  }
-  cancel(order: Order): Promise<void> {
-    throw new Error('Method not implemented.');
-  }
-  history(
-    instrument: InstrumentSelector,
-    timeframe: number,
-    length: number
-  ): Promise<Candle[]> {
-    throw new Error('Method not implemented.');
-  }
-  feed(
-    instrument: InstrumentSelector,
-    from: timestamp,
-    to: timestamp,
-    callback: FeedAsyncCallback
-  ): Promise<void> {
-    throw new Error('Method not implemented.');
-  }
-  name = 'default';
-
-  timestamp() {
-    return 123;
-  }
-
-  constructor(timeProvider: AdapterTimeProvider, private readonly store: Store) {
-    super(timeProvider);
-  }
-
-  async awake(): Promise<void> {
-    this.store.dispatch(
-      new InstrumentPatchEvent(
-        this.timestamp(),
-        new Asset('a', this.name, 8),
-        new Asset('b', this.name, 4),
-        new Commission(d(0.1), d(0.1)),
-        'a-b'
-      )
-    );
-  }
-
-  createPaperEngine(adapter: PaperAdapter): PaperEngine {
-    return new PaperEngine(adapter.store);
-  }
-}
-
-describe('PaperAdapter', () => {
-  const options = {
-    balance: {
-      ['default:a']: 1000,
-      ['default:b']: 200
-    }
-  };
-
-  test('should return wrapped adapter name and timestamp', () => {
-    const store = new Store();
-
-    const sut = new PaperAdapter(
-      new DefaultAdapter(DefaultTimeProvider, store),
-      store,
-      options
-    );
-
-    expect(sut.name).toEqual('default');
-    expect(sut.timestamp()).toEqual(123);
-  });
-
-  test('', async () => {
-    const store = new Store();
-    const adapter = new DefaultAdapter(DefaultTimeProvider, store);
-
-    const sut = new PaperAdapter(adapter, store, options);
-
-    await sut.awake();
-    await sut.account();
-
-    const order = Order.market(instrumentOf('default:a-b'), d(1.0));
-
-    await sut.open(order);
-
-    expect(store.snapshot.order.get(order.instrument.id).get(order.id)).toEqual(order);
-  });
-});

package/src/bootstrap.ts

@@ -1,139 +0,0 @@
-import {
-  AdapterAggregate,
-  BacktesterListener,
-  BacktesterStreamer,
-  createBacktesterAdapterFactory,
-  createPaperAdapterFactory,
-  DefaultTimeProvider
-} from './adapter';
-import { Session, SessionDescriptor } from './domain';
-import { Cache, Feed, inMemoryStorageFactory } from './storage';
-import { Store } from './store';
-
-export class Bootstrap {
-  constructor(readonly descriptor: SessionDescriptor) {}
-
-  /**
-   * Set session id.
-   * @param id session id.
-   */
-  useSessionId(id?: number): Bootstrap {
-    if (id) {
-      this.descriptor.id = id;
-    }
-
-    return this;
-  }
-
-  /**
-   *
-   * @param from
-   * @param to
-   */
-  useBacktestPeriod(from?: number, to?: number): Bootstrap {
-    if (!this.descriptor.simulation) {
-      this.descriptor.simulation = {
-        balance: {},
-        from: undefined,
-        to: undefined
-      };
-    }
-
-    if (from) {
-      this.descriptor.simulation.from = from;
-    }
-
-    if (to) {
-      this.descriptor.simulation.to = to;
-    }
-
-    return this;
-  }
-
-  /**
-   * Starts a new backtest session.
-   * @param listener backtest event listener.
-   * @returns new session object.
-   */
-  backtest(listener?: BacktesterListener): [Session, BacktesterStreamer] {
-    const store = new Store();
-    const storage = this.descriptor.storage ?? inMemoryStorageFactory();
-    const feed = new Feed(storage('feed'));
-    const cache = new Cache(storage('cache'));
-
-    const streamer = new BacktesterStreamer(
-      store,
-      feed,
-      this.descriptor.simulation,
-      listener
-    );
-
-    const aggregate = new AdapterAggregate(
-      this.descriptor.adapter.map(it =>
-        createBacktesterAdapterFactory(
-          createPaperAdapterFactory(it, this.descriptor.simulation),
-          streamer
-        )
-      ),
-      streamer.getTimeProvider(),
-      store,
-      cache
-    );
-
-    const session = new Session(store, aggregate, this.descriptor);
-
-    return [session, streamer];
-  }
-
-  /**
-   * Starts a new paper session.
-   * @returns new session object.
-   */
-  paper(): Session {
-    if (!this.descriptor.simulation) {
-      this.descriptor.simulation = {
-        balance: {},
-        from: undefined,
-        to: undefined
-      };
-    }
-
-    if (!this.descriptor.simulation.balance) {
-      this.descriptor.simulation.balance = {};
-    }
-
-    const store = new Store();
-    const storage = this.descriptor.storage ?? inMemoryStorageFactory();
-    const cache = new Cache(storage('cache'));
-
-    const aggregate = new AdapterAggregate(
-      this.descriptor.adapter.map(it =>
-        createPaperAdapterFactory(it, this.descriptor.simulation)
-      ),
-      DefaultTimeProvider,
-      store,
-      cache
-    );
-
-    return new Session(store, aggregate, this.descriptor);
-  }
-
-  /**
-   * Starts a new live session.
-   * @returns new session object.
-   */
-  live(): Session {
-    const store = new Store();
-    const storage = this.descriptor.storage ?? inMemoryStorageFactory();
-    const cache = new Cache(storage('cache'));
-
-    const aggregate = new AdapterAggregate(
-      this.descriptor.adapter,
-      DefaultTimeProvider,
-      store,
-      cache
-    );
-
-    return new Session(store, aggregate, this.descriptor);
-  }
-}

package/src/indicator/atr.ts

@@ -1,21 +0,0 @@
-import { map, Observable, share } from 'rxjs';
-
-import { Candle } from '../domain';
-import { decimal } from '../shared';
-import { rma } from './rma';
-import { trueRange } from './true-range';
-
-export function atr<T>(length: number, fn: (it: T) => Candle) {
-  return function (source: Observable<T>): Observable<[T, decimal]> {
-    return source.pipe(
-      trueRange(fn),
-      rma(length, ([, tr]) => tr),
-      map(([[it], tr]) => {
-        const tuple: [T, decimal] = [it, tr];
-
-        return tuple;
-      }),
-      share()
-    );
-  };
-}

package/src/indicator/cross.spec.ts

@@ -1,136 +0,0 @@
-import { from, map } from 'rxjs';
-
-import { d } from '../shared';
-import { crossOver, crossUnder } from './cross';
-
-describe('crossUnder', () => {
-  test('should crossUnder uptrend once', done => {
-    from([1, 2, 3, 4, 5])
-      .pipe(
-        map(it => d(it)),
-        crossUnder(d(3), it => it)
-      )
-      .subscribe({
-        next: it => expect(it).toEqual(d(4)),
-        complete: done()
-      });
-  });
-
-  test('should crossUnder uptrend twice', done => {
-    let crosses = 0;
-
-    from([1, 2, 3, 4, 5, 4, 2, 3, 3, 3, 4, 5])
-      .pipe(
-        map(it => d(it)),
-        crossUnder(d(3), it => it)
-      )
-      .subscribe({
-        next: it => {
-          expect(it).toEqual(d(4));
-          crosses++;
-        },
-        complete: () => {
-          expect(crosses).toEqual(2);
-          done();
-        }
-      });
-  });
-
-  test('should not cross bounce', done => {
-    let crosses = 0;
-
-    from([1, 2, 3, 4, 5, 4, 3, 3, 4, 5])
-      .pipe(
-        map(it => d(it)),
-        crossUnder(d(3), it => it)
-      )
-      .subscribe({
-        next: it => {
-          expect(it).toEqual(d(4));
-          crosses++;
-        },
-        complete: () => {
-          expect(crosses).toEqual(1);
-          done();
-        }
-      });
-  });
-
-  test('should not cross downtrend', done => {
-    from([5, 4, 3, 2, 1])
-      .pipe(
-        map(it => d(it)),
-        crossUnder(d(3), it => it)
-      )
-      .subscribe({
-        next: () => fail(),
-        complete: done()
-      });
-  });
-});
-
-describe('crossover', () => {
-  test('should crossover downtrend once', done => {
-    from([5, 4, 3, 2, 1])
-      .pipe(
-        map(it => d(it)),
-        crossOver(d(3), it => it)
-      )
-      .subscribe({
-        next: it => expect(it).toEqual(d(2)),
-        complete: done()
-      });
-  });
-
-  test('should crossover downtrend twice', done => {
-    let crosses = 0;
-
-    from([5, 4, 3, 2, 1, 2, 2, 3, 4, 4, 2, 3])
-      .pipe(
-        map(it => d(it)),
-        crossOver(d(3), it => it)
-      )
-      .subscribe({
-        next: it => {
-          expect(it).toEqual(d(2));
-          crosses++;
-        },
-        complete: () => {
-          expect(crosses).toEqual(2);
-          done();
-        }
-      });
-  });
-
-  test('should not cross bounce', done => {
-    let crosses = 0;
-
-    from([5, 4, 3, 2, 1, 2, 3, 3, 4, 5])
-      .pipe(
-        map(it => d(it)),
-        crossOver(d(3), it => it)
-      )
-      .subscribe({
-        next: it => {
-          expect(it).toEqual(d(2));
-          crosses++;
-        },
-        complete: () => {
-          expect(crosses).toEqual(1);
-          done();
-        }
-      });
-  });
-
-  test('should not cross uptrend', done => {
-    from([1, 2, 3, 4, 5])
-      .pipe(
-        map(it => d(it)),
-        crossOver(d(3), it => it)
-      )
-      .subscribe({
-        next: () => fail(),
-        complete: done()
-      });
-  });
-});

package/src/indicator/cross.ts

@@ -1,59 +0,0 @@
-import { filter, Observable } from 'rxjs';
-
-import { decimal } from '../shared';
-
-export function crossUnder<T>(
-  trigger: decimal | ((it: T) => decimal),
-  value: (it: T) => decimal
-) {
-  return function (source: Observable<T>): Observable<T> {
-    let triggered = false;
-
-    return source.pipe(
-      filter(it => {
-        const limit = typeof trigger == 'function' ? trigger(it) : trigger;
-        const current = value(it);
-
-        if (current.lessThan(limit)) {
-          triggered = true;
-        }
-
-        if (triggered && current.greaterThan(limit)) {
-          triggered = false;
-
-          return true;
-        }
-
-        return false;
-      })
-    );
-  };
-}
-
-export function crossOver<T>(
-  trigger: decimal | ((it: T) => decimal),
-  value: (it: T) => decimal
-) {
-  return function (source: Observable<T>): Observable<T> {
-    let triggered = false;
-
-    return source.pipe(
-      filter(it => {
-        const limit = typeof trigger == 'function' ? trigger(it) : trigger;
-        const current = value(it);
-
-        if (current.greaterThan(limit)) {
-          triggered = true;
-        }
-
-        if (triggered && current.lessThan(limit)) {
-          triggered = false;
-
-          return true;
-        }
-
-        return false;
-      })
-    );
-  };
-}

package/src/indicator/donchian.ts

@@ -1,38 +0,0 @@
-import { map, Observable, share, withLatestFrom } from 'rxjs';
-
-import { Candle } from '../domain';
-import { decimal } from '../shared';
-import { minMax } from './min-max';
-
-export function donchian<T>(length: number, fn: (it: T) => Candle) {
-  return function (source: Observable<T>): Observable<
-    [
-      T,
-      {
-        upper: decimal;
-        lower: decimal;
-      }
-    ]
-  > {
-    source = source.pipe(share());
-
-    return source.pipe(
-      withLatestFrom(
-        source.pipe(minMax(length, it => fn(it).low)),
-        source.pipe(minMax(length, it => fn(it).high))
-      ),
-      map(([it, low, high]) => {
-        const tuple: [
-          T,
-          {
-            upper: decimal;
-            lower: decimal;
-          }
-        ] = [it, { lower: low[1].min, upper: high[1].max }];
-
-        return tuple;
-      }),
-      share()
-    );
-  };
-}

package/src/indicator/drawdown.ts

@@ -1,29 +0,0 @@
-import { map, Observable, share } from 'rxjs';
-
-import { d, decimal } from '../shared';
-
-export function drawdown<T>(fn: (it: T) => decimal) {
-  return function (source: Observable<T>): Observable<decimal> {
-    let rate: decimal;
-    let max = d.Zero;
-
-    return source.pipe(
-      map(it => {
-        const value = fn(it);
-
-        if (!rate) {
-          rate = value;
-        } else {
-          if (value > rate) {
-            rate = value;
-          } else if (value < rate) {
-            max = decimal.min(max, value.div(rate).minus(1));
-          }
-        }
-
-        return max;
-      }),
-      share()
-    );
-  };
-}

package/src/indicator/ema.spec.ts

@@ -1,39 +0,0 @@
-import { from } from 'rxjs';
-
-import { d, decimal } from '../shared';
-import { ema } from './ema';
-
-describe('ema', () => {
-  test('should return expected value', done => {
-    let value: decimal;
-
-    from([
-      212.8, 214.06, 213.89, 214.66, 213.95, 213.95, 214.55, 214.02, 214.51, 213.75,
-      214.22, 213.43, 214.21, 213.66, 215.03, 216.89, 216.66, 216.32, 214.98, 214.96,
-      215.05, 215.19
-    ])
-      .pipe(ema(20, it => d(it)))
-      .subscribe({
-        next: ([, it]) => (value = it),
-        complete: () => {
-          expect(value.toDecimalPlaces(4)).toEqual(d(214.6336));
-          done();
-        }
-      });
-  });
-  /*
-  test('should return expected value', done => {
-    let value;
-
-    //12 Dec 2020 00:00
-    from([18136.17, 18092.15, 18082.39, 18065.4, 18046.47])
-      .pipe(ema(5, it => it))
-      .subscribe({
-        next: it => (value = it.value),
-        complete: () => {
-          expect(parseFloat(value.toFixed(2))).toBe(18076.28);
-          done();
-        }
-      });
-  });*/
-});