@quantform/core 0.7.21 → 0.7.24

package/src/component/ohlc-operator.ts

@@ -1,122 +0,0 @@
-import {
-  concat,
-  filter,
-  last,
-  map,
-  mergeMap,
-  Observable,
-  OperatorFunction,
-  share,
-  skipLast,
-  switchMap
-} from 'rxjs';
-
-import { Ohlc, tf } from '@lib/component';
-import { decimal } from '@lib/shared';
-
-function aggregate(
-  candle: Ohlc | undefined,
-  timeframe: number,
-  value: decimal,
-  timestamp: number
-) {
-  const frame = tf(timestamp, timeframe);
-
-  if (!candle) {
-    return new Ohlc(frame, value, value, value, value);
-  }
-
-  if (candle.timestamp === frame) {
-    candle.apply(value);
-    return undefined;
-  } else {
-    return new Ohlc(frame, candle.close, value, value, value);
-  }
-}
-
-export function ohlc<T extends { timestamp: number }>(
-  timeframe: number,
-  fn: (x: T) => decimal,
-  candleToStartWith?: Ohlc
-) {
-  return function (source: Observable<T>): Observable<Ohlc> {
-    let candle = candleToStartWith;
-
-    return source.pipe(
-      map(it => {
-        const newCandle = aggregate(candle, timeframe, fn(it), it.timestamp);
-        if (newCandle) {
-          const prevCandle = candle;
-          candle = newCandle;
-
-          if (candleToStartWith && candleToStartWith.timestamp < newCandle.timestamp) {
-            candleToStartWith = undefined;
-
-            if (prevCandle) {
-              return [prevCandle, candle];
-            }
-
-            return [candle];
-          }
-        }
-
-        if (candleToStartWith) {
-          candleToStartWith = undefined;
-        }
-
-        if (candle) {
-          return [candle];
-        }
-
-        return [];
-      }),
-      mergeMap(it => it),
-      share()
-    );
-  };
-}
-
-export function mergeOhlc<T extends { timestamp: number }>(
-  timeframe: number,
-  fn: (x: T) => decimal,
-  history$: Observable<Ohlc>
-) {
-  return function (source$: Observable<T>): Observable<Ohlc> {
-    return concat(
-      history$.pipe(skipLast(1)),
-      history$.pipe(
-        last(),
-        switchMap(lastHistoricalCandle =>
-          source$.pipe(ohlc(timeframe, fn, lastHistoricalCandle))
-        ),
-        share()
-      )
-    );
-  };
-}
-
-export function ohlcCompleted(): (source: Observable<Ohlc>) => Observable<Ohlc> {
-  let currCandle: Ohlc;
-
-  return (source: Observable<Ohlc>) =>
-    source.pipe(
-      map(it => {
-        if (!currCandle) {
-          currCandle = it;
-
-          return undefined;
-        } else {
-          if (currCandle.timestamp !== it.timestamp) {
-            const prevCandle = currCandle;
-            currCandle = it;
-
-            return prevCandle;
-          }
-
-          return undefined;
-        }
-      }),
-      filter(it => it !== undefined) as OperatorFunction<Ohlc | undefined, Ohlc>,
-      share()
-    );
-}

package/src/component/ohlc.spec.ts

@@ -1,30 +0,0 @@
-import { Ohlc } from '@lib/component';
-import { d, now } from '@lib/shared';
-
-describe('Ohlc', () => {
-  test('should construct a ohlc', () => {
-    const timestamp = now();
-
-    const sut = new Ohlc(timestamp, d(2), d(4), d(1), d(3));
-
-    expect(sut.timestamp).toEqual(timestamp);
-    expect(sut.open).toEqual(d(2));
-    expect(sut.high).toEqual(d(4));
-    expect(sut.low).toEqual(d(1));
-    expect(sut.close).toEqual(d(3));
-  });
-
-  test('should modify a ohlc', () => {
-    const timestamp = now();
-
-    const sut = new Ohlc(timestamp, d(2), d(4), d(1), d(3));
-
-    sut.apply(d(10));
-
-    expect(sut.timestamp).toEqual(timestamp);
-    expect(sut.open).toEqual(d(2));
-    expect(sut.high).toEqual(d(10));
-    expect(sut.low).toEqual(d(1));
-    expect(sut.close).toEqual(d(10));
-  });
-});

package/src/component/ohlc.ts

@@ -1,18 +0,0 @@
-import { decimal, timestamp } from '@lib/shared';
-
-export class Ohlc {
-  constructor(
-    public timestamp: timestamp,
-    public open: decimal,
-    public high: decimal,
-    public low: decimal,
-    public close: decimal,
-    public volume?: decimal
-  ) {}
-
-  apply(value: decimal) {
-    this.high = decimal.max(this.high, value);
-    this.low = decimal.min(this.low, value);
-    this.close = value;
-  }
-}

package/src/component/timeframe.ts

@@ -1,17 +0,0 @@
-export class Timeframe {
-  static S1 = 1000;
-  static M1 = Timeframe.S1 * 60;
-  static M5 = Timeframe.M1 * 5;
-  static M15 = Timeframe.M5 * 3;
-  static M30 = Timeframe.M15 * 2;
-  static H1 = Timeframe.M30 * 2;
-  static H4 = Timeframe.H1 * 4;
-  static H6 = Timeframe.H1 * 6;
-  static H12 = Timeframe.H6 * 2;
-  static D1 = Timeframe.H12 * 2;
-  static W1 = Timeframe.D1 * 7;
-}
-
-export function tf(timestamp: number, timeframe: number): number {
-  return timestamp - (timestamp % timeframe);
-}

package/src/core.ts

@@ -1,16 +0,0 @@
-import { Dependency } from '@lib/module';
-import { useMemo } from '@lib/use-memo';
-
-import { InMemoryStorageFactory } from './storage';
-import { useStorageFactory } from './storage/use-storage-factory';
-import { useExecutionMode } from './use-execution-mode';
-import { ConsoleLoggerFactory, logger } from './use-logger';
-
-export function core(): Dependency[] {
-  return [
-    useMemo.options(),
-    logger(new ConsoleLoggerFactory()),
-    useExecutionMode.paperOptions({ recording: false }),
-    useStorageFactory.options(new InMemoryStorageFactory())
-  ];
-}

package/src/instrument/commission/commission.spec.ts

@@ -1,35 +0,0 @@
-import { d } from '@lib/shared';
-
-import { Commission, commissionPercentOf } from './commission';
-
-describe(Commission.name, () => {
-  test('should construct a Commission', () => {
-    const sut = commissionPercentOf({
-      maker: d(0.1),
-      taker: d(0.2)
-    });
-
-    expect(sut.makerRate).toEqual(d(0.001));
-    expect(sut.takerRate).toEqual(d(0.002));
-  });
-
-  test('should calculate a maker fee', () => {
-    const sut = commissionPercentOf({
-      maker: d(0.1),
-      taker: d(0.2)
-    });
-
-    expect(sut.calculateMakerFee(d(2000))).toEqual(d(2));
-    expect(sut.applyMakerFee(d(2000))).toEqual(d(1998));
-  });
-
-  test('should calculate a taker fee', () => {
-    const sut = commissionPercentOf({
-      maker: d(0.1),
-      taker: d(0.2)
-    });
-
-    expect(sut.calculateTakerFee(d(2000))).toEqual(d(4));
-    expect(sut.applyTakerFee(d(2000))).toEqual(d(1996));
-  });
-});

package/src/instrument/commission/commission.ts

@@ -1,27 +0,0 @@
-import { d, decimal } from '@lib/shared';
-
-export class Commission {
-  static readonly Zero = commissionPercentOf({ maker: d.Zero, taker: d.Zero });
-
-  constructor(readonly makerRate: decimal, readonly takerRate: decimal) {}
-
-  calculateMakerFee(value: decimal) {
-    return value.mul(this.makerRate);
-  }
-
-  calculateTakerFee(value: decimal) {
-    return value.mul(this.takerRate);
-  }
-
-  applyMakerFee(value: decimal): decimal {
-    return value.minus(this.calculateMakerFee(value));
-  }
-
-  applyTakerFee(value: decimal): decimal {
-    return value.minus(this.calculateTakerFee(value));
-  }
-}
-
-export function commissionPercentOf(fees: { maker: decimal; taker: decimal }) {
-  return new Commission(fees.maker.div(100.0), fees.taker.div(100.0));
-}

package/src/instrument/index.ts

@@ -1,2 +0,0 @@
-export * from '@lib/instrument/instrument';
-export * from '@lib/instrument/commission/commission';

package/src/instrument/instrument.spec.ts

@@ -1,76 +0,0 @@
-import {
-  Asset,
-  assetOf,
-  commissionPercentOf,
-  Instrument,
-  instrumentOf,
-  InstrumentSelector
-} from '@lib/component';
-import { d } from '@lib/shared';
-
-describe(Instrument.name, () => {
-  test('should construct a instrument', () => {
-    const sut = new Instrument(
-      0,
-      new Asset('abc', 'xyz', 4),
-      new Asset('def', 'xyz', 4),
-      'abc-def',
-      commissionPercentOf({
-        maker: d.Zero,
-        taker: d.Zero
-      })
-    );
-
-    expect(sut.base.name).toEqual('abc');
-    expect(sut.base.adapterName).toEqual('xyz');
-    expect(sut.quote.name).toEqual('def');
-    expect(sut.quote.adapterName).toEqual('xyz');
-    expect(sut.id).toEqual('xyz:abc-def');
-  });
-});
-
-describe(InstrumentSelector.name, () => {
-  test('should construct a instrument selector', () => {
-    const sut = instrumentOf('xyz:abc-def');
-
-    expect(sut.base.name).toEqual('abc');
-    expect(sut.base.adapterName).toEqual('xyz');
-    expect(sut.quote.name).toEqual('def');
-    expect(sut.quote.adapterName).toEqual('xyz');
-    expect(sut.id).toEqual('xyz:abc-def');
-  });
-
-  test('should construct a instrument selector capital case', () => {
-    const sut = instrumentOf('XYZ:ABC-DEF');
-
-    expect(sut.base.name).toEqual('abc');
-    expect(sut.base.adapterName).toEqual('xyz');
-    expect(sut.quote.name).toEqual('def');
-    expect(sut.quote.adapterName).toEqual('xyz');
-    expect(sut.id).toEqual('xyz:abc-def');
-  });
-
-  test('should throw invalid format message for missing separator', () => {
-    const fn = () => instrumentOf('xyzabc-def');
-
-    expect(fn).toThrowError();
-  });
-
-  test('should throw invalid format message for multiple separators', () => {
-    const fn = () => instrumentOf('xyz:abc:-def');
-
-    expect(fn).toThrowError();
-  });
-
-  test('should throw invalid format message for missing pair name', () => {
-    const fn = () => instrumentOf('xyz:');
-
-    expect(fn).toThrowError();
-  });
-
-  test('should throw invalid format message for missing adapter name', () => {
-    const fn = () => assetOf(':abc-def');
-
-    expect(fn).toThrowError();
-  });
-});

package/src/instrument/instrument.ts

@@ -1,65 +0,0 @@
-import { Asset, AssetSelector, AssetSelectorSeparator } from '@lib/asset';
-import { AdapterMismatchError, InvalidInstrumentSelectorError } from '@lib/component';
-
-import { Commission } from './commission/commission';
-
-export const InstrumentSelectorSeparator = '-';
-
-export class MissingInstrumentError extends Error {
-  constructor(instrument: InstrumentSelector) {
-    super(`Missing instrument: ${instrument}`);
-  }
-}
-
-export class InstrumentSelector {
-  readonly id: string;
-  readonly base: AssetSelector;
-  readonly quote: AssetSelector;
-
-  constructor(base: string, quote: string, adapter: string) {
-    this.base = new AssetSelector(base.toLowerCase(), adapter.toLowerCase());
-    this.quote = new AssetSelector(quote.toLowerCase(), adapter.toLowerCase());
-
-    this.id = `${this.base.id}${InstrumentSelectorSeparator}${this.quote.name}`;
-  }
-
-  toString() {
-    return this.id;
-  }
-}
-
-/**
- * Represents trading market which is made up by two trading assets (base and quoted).
- */
-export class Instrument extends InstrumentSelector {
-  readonly cross: Instrument | undefined;
-  leverage: number | undefined = undefined;
-
-  constructor(
-    public timestamp: number,
-    override readonly base: Asset,
-    override readonly quote: Asset,
-    readonly raw: string,
-    public commission: Commission
-  ) {
-    super(base.name, quote.name, base.adapterName);
-
-    if (base.adapterName != quote.adapterName) {
-      throw new AdapterMismatchError();
-    }
-  }
-}
-
-export function instrumentOf(selector: string): InstrumentSelector {
-  const [adapterName, asset, ...rest] = selector.split(AssetSelectorSeparator);
-  if (!adapterName || !asset || rest.length) {
-    throw new InvalidInstrumentSelectorError(selector);
-  }
-
-  const [baseAssetName, quoteAssetName] = asset.split(InstrumentSelectorSeparator);
-  if (!baseAssetName || !quoteAssetName) {
-    throw new InvalidInstrumentSelectorError(selector);
-  }
-
-  return new InstrumentSelector(baseAssetName, quoteAssetName, adapterName);
-}

package/src/operators.ts

@@ -1,18 +0,0 @@
-import { filter, map, Observable } from 'rxjs';
-
-export function asReadonly<T>() {
-  return (input: Observable<T>) => input.pipe(map(it => it as Readonly<T>));
-}
-
-export function defined<T>() {
-  return (observable: Observable<T | undefined | null>) =>
-    observable.pipe(filter(it => it !== undefined && it !== null));
-}
-
-export function exclude<T, S extends symbol>(s: S) {
-  return (observable: Observable<T | S>) =>
-    observable.pipe(
-      filter(it => it !== s),
-      map(it => it as Exclude<T, typeof s>)
-    );
-}

package/src/shared/datetime.ts

@@ -1,5 +0,0 @@
-export type timestamp = number;
-
-export function now(): timestamp {
-  return new Date().getTime();
-}

package/src/strategy.spec.ts

@@ -1,42 +0,0 @@
-import { of } from 'rxjs';
-
-import { Dependency } from './module';
-import { after, before, behavior, strategy } from './strategy';
-
-describe(strategy.name, () => {
-  let fixtures: ReturnType<typeof getFixtures>;
-
-  beforeEach(() => {
-    fixtures = getFixtures();
-  });
-
-  test('happy path', () => {
-    const sut = strategy(() => {
-      before(() => of('before'));
-      behavior(() => of('behavior 1'));
-      behavior(() => of('behavior 2'));
-      after(() => of('after'));
-
-      return fixtures.given.dependencies();
-    });
-
-    expect(sut.dependencies).toEqual(
-      expect.arrayContaining(fixtures.given.dependencies())
-    );
-    expect(sut.description).toEqual({
-      before: [expect.any(Function)],
-      behavior: [expect.any(Function), expect.any(Function)],
-      after: [expect.any(Function)]
-    });
-  });
-});
-
-function getFixtures() {
-  return {
-    given: {
-      dependencies(): Dependency[] {
-        return [];
-      }
-    }
-  };
-}

package/src/strategy.ts

@@ -1,36 +0,0 @@
-import { Observable, of } from 'rxjs';
-
-import { Dependency } from './module';
-
-export type Descriptor = () => Observable<unknown>;
-
-export let before: (descriptor: Descriptor) => void;
-export let behavior: (descriptor: Descriptor) => void;
-export let after: (descriptor: Descriptor) => void;
-
-export function strategy(descriptor: () => Dependency[]) {
-  const description = {
-    before: Array.of<Descriptor>(),
-    behavior: Array.of<Descriptor>(),
-    after: Array.of<Descriptor>()
-  };
-
-  before = descriptor => description.before.push(descriptor);
-  behavior = descriptor => description.behavior.push(descriptor);
-  after = descriptor => description.after.push(descriptor);
-
-  const dependencies = descriptor();
-
-  if (!description.before.length) {
-    description.before.push(() => of(true));
-  }
-
-  if (!description.after.length) {
-    description.after.push(() => of(true));
-  }
-
-  return {
-    dependencies,
-    description
-  };
-}

package/src/when-socket.ts

@@ -1,61 +0,0 @@
-import { Observable } from 'rxjs';
-import { WebSocket } from 'ws';
-
-import { useLogger } from './use-logger';
-import { useTimestamp } from './use-timestamp';
-
-export function whenSocket(
-  url: string,
-  options: { pingInterval?: number } = { pingInterval: 5000 }
-): [Observable<{ timestamp: number; payload: unknown }>, (message: unknown) => void] {
-  const { debug } = useLogger('whenSocket');
-
-  const message = new Observable<{ timestamp: number; payload: unknown }>(stream => {
-    const socket = new WebSocket(url);
-    let isAlive = false;
-    let interval: NodeJS.Timeout | undefined;
-
-    socket.onmessage = it =>
-      stream.next({ timestamp: useTimestamp(), payload: JSON.parse(it.data as string) });
-    socket.onerror = it => {
-      clearInterval(interval);
-      debug('errored', url);
-      stream.error(it);
-    };
-    socket.onclose = () => {
-      debug('closed', url);
-      clearInterval(interval);
-      stream.error();
-    };
-    socket.onopen = () => {
-      debug('opened', url);
-      isAlive = true;
-      interval = setInterval(() => {
-        if (isAlive) {
-          isAlive = false;
-
-          socket.ping();
-        } else {
-          socket.terminate();
-          clearInterval(interval);
-        }
-      }, options.pingInterval);
-
-      socket.on('pong', () => {
-        isAlive = true;
-      });
-
-      socket.on('ping', () => {
-        isAlive = true;
-        socket.pong();
-      });
-    };
-
-    return () => {
-      socket.terminate();
-      clearInterval(interval);
-    };
-  });
-
-  return [message, (message: unknown) => JSON.stringify(message)];
-}

package/src/with-memo.spec.ts

@@ -1,46 +0,0 @@
-import { makeTestModule } from '@lib/make-test-module';
-
-import { instrumentOf, InstrumentSelector } from './instrument';
-import { withMemo } from './with-memo';
-
-describe(withMemo.name, () => {
-  let fixtures: Awaited<ReturnType<typeof getFixtures>>;
-
-  beforeEach(async () => {
-    fixtures = await getFixtures();
-  });
-
-  test('memorize same values for same arguments', () => {
-    const { act, getValue } = fixtures;
-
-    act(() => {
-      const value1 = getValue(instrumentOf('binance:btc-usdt'));
-      const value2 = getValue(instrumentOf('binance:btc-usdt'));
-
-      expect(Object.is(value1, value2)).toBeTruthy();
-    });
-  });
-
-  test('memorize different values for different arguments', () => {
-    const { act, getValue } = fixtures;
-
-    act(() => {
-      const value1 = getValue(instrumentOf('binance:btc-usdt'));
-      const value2 = getValue(instrumentOf('binance:btc-busd'));
-
-      expect(value1).toEqual('binance:btc-usdt');
-      expect(value2).toEqual('binance:btc-busd');
-    });
-  });
-});
-
-async function getFixtures() {
-  const { act } = await makeTestModule([]);
-
-  const getValue = withMemo((instrument: InstrumentSelector) => instrument.id);
-
-  return {
-    act,
-    getValue: act(() => (instrument: InstrumentSelector) => getValue(instrument))
-  };
-}

package/src/with-memo.ts

@@ -1,33 +0,0 @@
-import { isObservable, Observable, shareReplay } from 'rxjs';
-import { v4 } from 'uuid';
-
-import { throwWithContext } from './module';
-import { asReadonly } from './operators';
-import { dependency } from './use-hash';
-import { useMemo } from './use-memo';
-
-export function withMemo<T extends Array<dependency>, U>(
-  fn: (...args: T) => U
-): (...args: T) => U;
-export function withMemo<T extends Array<dependency>, U>(
-  fn: (...args: T) => Observable<U>
-): (...args: T) => Observable<U>;
-
-export function withMemo<T extends Array<dependency>, U>(
-  fn: (...args: T) => U | Observable<U>
-): (...args: T) => U | Observable<U> {
-  throwWithContext();
-
-  const uniqueId = v4();
-
-  return (...args: T): U | Observable<U> =>
-    useMemo(() => {
-      const value = fn(...args);
-
-      if (isObservable(value)) {
-        return value.pipe(asReadonly(), shareReplay(1));
-      }
-
-      return value;
-    }, [uniqueId, ...args]);
-}