@quantform/core 0.6.6 → 0.7.0-beta.4

package/src/domain/balance.ts

@@ -1,123 +0,0 @@
-import { d, decimal } from '../shared';
-import { Asset } from './';
-import { Component } from './component';
-import { insufficientFundsError, invalidArgumentError } from './error';
-import { Position, PositionMode } from './position';
-
-/**
- * Represents single asset balance in your wallet.
- */
-export class Balance implements Component {
-  id: string;
-
-  private locker: Record<string, decimal> = {};
-  private available = d.Zero;
-  private unavailable = d.Zero;
-
-  /**
-   * Returns available amount to trade.
-   */
-  get free(): decimal {
-    return this.asset.floor(this.available).add(this.getEstimatedUnrealizedPnL('CROSS'));
-  }
-
-  /**
-   * Return locked amount for order.
-   */
-  get locked(): decimal {
-    return this.unavailable;
-  }
-
-  /**
-   * Return total amount of asset in wallet.
-   * Represents a sum of free, locked and opened positions.
-   */
-  get total(): decimal {
-    return this.asset
-      .floor(this.available.add(this.unavailable))
-      .add(this.getEstimatedUnrealizedPnL());
-  }
-
-  /**
-   * Collection of opened positions backed by this balance.
-   */
-  readonly position: Record<string, Position> = {};
-
-  constructor(public timestamp: number, public readonly asset: Asset) {
-    this.id = asset.id;
-  }
-
-  account(amount: decimal) {
-    if (this.available.add(amount).lessThan(0)) {
-      throw insufficientFundsError(this.id, amount, this.available);
-    }
-
-    this.available = this.available.add(amount);
-  }
-
-  set(free: decimal, locked: decimal) {
-    this.available = free;
-    this.unavailable = locked;
-    this.locker = {};
-  }
-
-  /**
-   * Lock specific amount of asset.
-   * If you place new pending order, you will lock your balance to fund order.
-   */
-  lock(id: string, amount: decimal) {
-    if (this.available.lessThan(amount)) {
-      throw insufficientFundsError(this.id, amount, this.available);
-    }
-
-    if (this.locker[id]) {
-      throw invalidArgumentError(id);
-    }
-
-    this.locker[id] = amount;
-    this.available = this.available.minus(amount);
-    this.unavailable = this.unavailable.plus(amount);
-  }
-
-  tryUnlock(id: string): boolean {
-    if (!this.locker[id]) {
-      return false;
-    }
-
-    const amount = this.locker[id];
-
-    delete this.locker[id];
-
-    if (this.unavailable < amount) {
-      throw insufficientFundsError(this.id, amount, this.unavailable);
-    }
-
-    this.available = this.available.add(amount);
-    this.unavailable = this.unavailable.minus(amount);
-
-    return true;
-  }
-
-  /**
-   * Returns unrealized profit and loss for all positions backed by this balance.
-   */
-  getEstimatedUnrealizedPnL(mode?: PositionMode): decimal {
-    return Object.values(this.position).reduce(
-      (aggregate, position) =>
-        aggregate.add(
-          mode && mode != position.mode
-            ? d.Zero
-            : position.estimatedUnrealizedPnL ?? d.Zero
-        ),
-      d.Zero
-    );
-  }
-
-  getEstimatedMargin(mode?: PositionMode): decimal {
-    return Object.values(this.position).reduce(
-      (aggregate, position) =>
-        (aggregate = aggregate.add(mode && mode != position.mode ? 0 : position.margin)),
-      d.Zero
-    );
-  }
-}

package/src/domain/component.ts

@@ -1,6 +0,0 @@
-import { timestamp } from '../shared';
-
-export interface Component {
-  id: string;
-  timestamp: timestamp;
-}

package/src/domain/error.ts

@@ -1,27 +0,0 @@
-import { decimal } from '../shared';
-
-export function insufficientFundsError(
-  assetName: string,
-  requiredAmount: decimal,
-  availableAmount: decimal
-) {
-  return new Error(
-    `insufficient funds of ${assetName} has: ${availableAmount.toString()} requires: ${requiredAmount.toString()}`
-  );
-}
-
-export function invalidArgumentError(value: any) {
-  return new Error(`invalid argument: ${value}`);
-}
-
-export function invalidAssetSelectorError(selector: string) {
-  return new Error(`invalid asset selector: ${selector}`);
-}
-
-export function invalidInstrumentSelectorError(selector: string) {
-  return new Error(`invalid instrument selector: ${selector}`);
-}
-
-export function adapterMismatchError() {
-  return new Error('adapters must be the same');
-}

package/src/domain/index.ts

@@ -1,21 +0,0 @@
-export * from './asset';
-export * from './balance';
-export * from './balance-operator';
-export * from './error';
-export * from './ohlc';
-export * from './ohlc-operator';
-export * from './commission';
-export * from './component';
-export * from './instrument';
-export * from './instrument-operator';
-export * from './order';
-export * from './order-operator';
-export * from './orderbook';
-export * from './orderbook-operator';
-export * from './position';
-export * from './position-operator';
-export * from './session';
-export * from './session-builder';
-export * from './timeframe';
-export * from './trade';
-export * from './trade-operator';

package/src/domain/instrument-operator.spec.ts

@@ -1,35 +0,0 @@
-import { Subject } from 'rxjs';
-
-import { State } from '../store';
-import { Asset } from './asset';
-import { Commission } from './commission';
-import { Component } from './component';
-import { Instrument, instrumentOf } from './instrument';
-import { instrument } from './instrument-operator';
-
-describe('instrument', () => {
-  const state = new State();
-
-  beforeEach(() => {
-    state.universe.instrument.upsert(
-      new Instrument(
-        0,
-        new Asset('abc', 'xyz', 4),
-        new Asset('def', 'xyz', 4),
-        'abc-def',
-        Commission.Zero
-      )
-    );
-  });
-
-  test('should pipe an instrument on subscription', done => {
-    new Subject<Component>()
-      .pipe(instrument(instrumentOf('xyz:abc-def'), state))
-      .subscribe({
-        next: it => {
-          expect(it.id).toEqual('xyz:abc-def');
-          done();
-        }
-      });
-  });
-});

package/src/domain/instrument-operator.ts

@@ -1,25 +0,0 @@
-import { distinctUntilChanged, filter, map, Observable, startWith } from 'rxjs';
-
-import { State } from '../store';
-import { Component } from './component';
-import { Instrument, InstrumentSelector } from './instrument';
-
-export function instrument(selector: InstrumentSelector, state: State) {
-  return (source$: Observable<Component>) =>
-    source$.pipe(
-      startWith(state.universe.instrument.get(selector.id)),
-      filter(it => it instanceof Instrument && it.id == selector.id),
-      map(it => it as Instrument)
-    );
-}
-
-export function instruments(state: State) {
-  return (source$: Observable<Component>) =>
-    source$.pipe(
-      filter(it => it instanceof Instrument),
-      map(() => state.universe.instrument.asReadonlyArray()),
-      startWith(state.universe.instrument.asReadonlyArray()),
-      filter(it => it.length > 0),
-      distinctUntilChanged((lhs, rhs) => lhs.length == rhs.length)
-    );
-}

package/src/domain/order-operator.spec.ts

@@ -1,85 +0,0 @@
-import { BehaviorSubject, map, Subject } from 'rxjs';
-
-import { d } from '../shared';
-import { InnerSet, State } from '../store';
-import { Asset } from './asset';
-import { Commission } from './commission';
-import { Component } from './component';
-import { Instrument } from './instrument';
-import { Order } from './order';
-import { order, orders } from './order-operator';
-
-const instrument = new Instrument(
-  0,
-  new Asset('abc', 'xyz', 4),
-  new Asset('def', 'xyz', 4),
-  'abc-def',
-  Commission.Zero
-);
-
-describe('order', () => {
-  test('should pipe an order', done => {
-    new BehaviorSubject<Component>(new Order(0, '1', instrument, d(-100), 0))
-      .pipe(order(instrument))
-      .subscribe({
-        next: it => {
-          expect(it.instrument).toEqual(instrument);
-          expect(it.quantity).toEqual(d(-100));
-          done();
-        }
-      });
-  });
-
-  test('should skip a pipe', done => {
-    new BehaviorSubject<Component>(instrument).pipe(order(instrument)).subscribe({
-      next: () => fail(),
-      complete: done()
-    });
-  });
-});
-
-describe('positions', () => {
-  let state: State;
-  let order1: Order, order2: Order, order3: Order;
-
-  beforeEach(() => {
-    state = new State();
-
-    order1 = new Order(0, '1', instrument, d(-100), 0);
-    order2 = new Order(0, '2', instrument, d(100), 0, d(10));
-    order3 = new Order(0, '3', instrument, d(100), 0);
-
-    state.order.upsert(new InnerSet<Order>(instrument.id, [order1, order2, order3]));
-  });
-
-  test('should pipe all orders on subscription start', done => {
-    order1.state = 'NEW';
-    order2.state = 'NEW';
-    order3.state = 'NEW';
-
-    new Subject<Component>().pipe(orders(instrument, state)).subscribe({
-      next: it => {
-        expect(it.length).toEqual(3);
-        done();
-      }
-    });
-  });
-
-  test('should pipe pending orders on subscription start', done => {
-    order1.state = 'NEW';
-    order2.state = 'PENDING';
-    order3.state = 'PENDING';
-
-    new Subject<Component>()
-      .pipe(
-        orders(instrument, state),
-        map(it => it.filter(order => order.state === 'PENDING'))
-      )
-      .subscribe({
-        next: it => {
-          expect(it.length).toEqual(2);
-          done();
-        }
-      });
-  });
-});

package/src/domain/order-operator.ts

@@ -1,23 +0,0 @@
-import { filter, map, Observable, startWith } from 'rxjs';
-
-import { State } from '../store';
-import { Component } from './component';
-import { InstrumentSelector } from './instrument';
-import { Order } from './order';
-
-export function order(selector: InstrumentSelector) {
-  return (source$: Observable<Component>) =>
-    source$.pipe(
-      filter(it => it instanceof Order && it.instrument.id == selector.id),
-      map(it => it as Order)
-    );
-}
-
-export function orders(selector: InstrumentSelector, state: State) {
-  return (source$: Observable<Component>) =>
-    source$.pipe(
-      filter(it => it instanceof Order && it.instrument.id == selector.id),
-      map(() => state.order.get(selector.id)?.asReadonlyArray() ?? []),
-      startWith(state.order.get(selector.id)?.asReadonlyArray() ?? [])
-    );
-}

package/src/domain/order.spec.ts

@@ -1,43 +0,0 @@
-import { d } from '../shared';
-import { Asset } from './asset';
-import { Commission } from './commission';
-import { Instrument } from './instrument';
-import { Order } from './order';
-
-describe('Order', () => {
-  const instrument = new Instrument(
-    0,
-    new Asset('abc', 'xyz', 4),
-    new Asset('def', 'xyz', 4),
-    'abc-def',
-    Commission.Zero
-  );
-
-  test('should construct a market buy order', () => {
-    const sut = new Order(0, '1', instrument, d(100), 0);
-
-    expect(sut.quantity).toEqual(d(100));
-    expect(sut.rate).toEqual(undefined);
-  });
-
-  test('should construct a market sell order', () => {
-    const sut = new Order(0, '1', instrument, d(-100), 0);
-
-    expect(sut.quantity).toEqual(d(-100));
-    expect(sut.rate).toEqual(undefined);
-  });
-
-  test('should construct a limit buy order', () => {
-    const sut = new Order(0, '1', instrument, d(100), 0, d(2000));
-
-    expect(sut.quantity).toEqual(d(100));
-    expect(sut.rate).toEqual(d(2000));
-  });
-
-  test('should construct a limit sell order', () => {
-    const sut = new Order(0, '1', instrument, d(-100), 0, d(2000));
-
-    expect(sut.quantity).toEqual(d(-100));
-    expect(sut.rate).toEqual(d(2000));
-  });
-});

package/src/domain/order.ts

@@ -1,68 +0,0 @@
-import { d, decimal } from '../shared';
-import { Balance } from './balance';
-import { Component } from './component';
-import { invalidArgumentError } from './error';
-import { Instrument } from './instrument';
-
-export type OrderState =
-  | 'NEW'
-  | 'PENDING'
-  | 'FILLED'
-  | 'CANCELING'
-  | 'CANCELED'
-  | 'REJECTED';
-
-export class Order implements Component {
-  state: OrderState = 'NEW';
-  quantityExecuted = d.Zero;
-  averageExecutionRate?: decimal;
-  externalId?: string;
-
-  constructor(
-    public timestamp: number,
-    readonly id: string,
-    readonly instrument: Instrument,
-    readonly quantity: decimal,
-    public createdAt: number,
-    readonly rate?: decimal,
-    readonly stopRate?: decimal
-  ) {
-    if (!quantity || Number.isNaN(quantity)) {
-      throw invalidArgumentError(quantity);
-    }
-
-    if (rate && rate.lessThanOrEqualTo(0)) {
-      throw invalidArgumentError(rate);
-    }
-  }
-
-  calculateBalanceToLock(
-    base: Balance,
-    quote: Balance
-  ): { base?: decimal; quote?: decimal } {
-    const qty = this.quantity.abs();
-
-    if (this.quantity.greaterThan(0)) {
-      if (this.rate) {
-        return {
-          base: d.Zero,
-          quote: quote.asset.ceil(this.rate.mul(qty))
-        };
-      } else {
-        return {
-          base: d.Zero,
-          quote: quote.free
-        };
-      }
-    }
-
-    if (this.quantity.lessThan(0)) {
-      return {
-        base: qty,
-        quote: d.Zero
-      };
-    }
-
-    return {};
-  }
-}

package/src/domain/orderbook-operator.spec.ts

@@ -1,40 +0,0 @@
-import { Subject } from 'rxjs';
-
-import { d } from '../shared';
-import { State } from '../store';
-import { Asset } from './asset';
-import { Commission } from './commission';
-import { Component } from './component';
-import { Instrument } from './instrument';
-import { Orderbook } from './orderbook';
-import { orderbook } from './orderbook-operator';
-
-describe('orderbook', () => {
-  const instrument = new Instrument(
-    0,
-    new Asset('abc', 'xyz', 4),
-    new Asset('def', 'xyz', 4),
-    'abc-def',
-    Commission.Zero
-  );
-
-  test('should pipe an orderbook on subscription', done => {
-    const state = new State();
-
-    state.orderbook.upsert(
-      new Orderbook(
-        0,
-        instrument,
-        { rate: d(2), quantity: d(1), next: undefined },
-        { rate: d(1), quantity: d(1), next: undefined }
-      )
-    );
-
-    new Subject<Component>().pipe(orderbook(instrument, state)).subscribe({
-      next: it => {
-        expect(it.id).toEqual(instrument.id);
-        done();
-      }
-    });
-  });
-});

package/src/domain/orderbook-operator.ts

@@ -1,15 +0,0 @@
-import { filter, map, Observable, startWith } from 'rxjs';
-
-import { State } from '../store';
-import { Component } from './component';
-import { InstrumentSelector } from './instrument';
-import { Orderbook } from './orderbook';
-
-export function orderbook(selector: InstrumentSelector, state: State) {
-  return (source$: Observable<Component>) =>
-    source$.pipe(
-      startWith(state.orderbook.get(selector.id)),
-      filter(it => it instanceof Orderbook && it.instrument.id == selector.id),
-      map(it => it as Orderbook)
-    );
-}

package/src/domain/orderbook.spec.ts

@@ -1,26 +0,0 @@
-import { d } from '../shared';
-import { Asset } from './asset';
-import { Commission } from './commission';
-import { Instrument } from './instrument';
-import { Orderbook } from './orderbook';
-
-describe('Orderbook', () => {
-  const instrument = new Instrument(
-    0,
-    new Asset('abc', 'xyz', 4),
-    new Asset('def', 'xyz', 4),
-    'abc-def',
-    Commission.Zero
-  );
-
-  test('should construct an empty orderbook', () => {
-    const sut = new Orderbook(
-      0,
-      instrument,
-      { rate: d(2), quantity: d(1), next: undefined },
-      { rate: d(1), quantity: d(1), next: undefined }
-    );
-
-    expect(sut.id).toEqual(instrument.id);
-  });
-});

package/src/domain/orderbook.ts

@@ -1,30 +0,0 @@
-import { Instrument } from '../domain';
-import { decimal } from '../shared';
-import { Component } from './component';
-
-export interface Liquidity {
-  rate: decimal;
-  quantity: decimal;
-  next: this | undefined;
-}
-
-export const LiquidityAskComparer = (lhs: { rate: decimal }, rhs: { rate: decimal }) =>
-  lhs.rate.comparedTo(rhs.rate);
-export const LiquidityBidComparer = (lhs: { rate: decimal }, rhs: { rate: decimal }) =>
-  rhs.rate.comparedTo(lhs.rate);
-
-/**
- * Provides an access to pending buy and sell orders on the specific market.
- */
-export class Orderbook implements Component {
-  readonly id: string;
-
-  constructor(
-    public timestamp: number,
-    public readonly instrument: Instrument,
-    public asks: Liquidity,
-    public bids: Liquidity
-  ) {
-    this.id = instrument.id;
-  }
-}

package/src/domain/position-operator.spec.ts

@@ -1,64 +0,0 @@
-import { BehaviorSubject, Subject } from 'rxjs';
-
-import { d } from '../shared';
-import { State } from '../store';
-import { Asset } from './asset';
-import { Balance } from './balance';
-import { Commission } from './commission';
-import { Component } from './component';
-import { Instrument } from './instrument';
-import { Position } from './position';
-import { position, positions } from './position-operator';
-
-const instrument = new Instrument(
-  0,
-  new Asset('abc', 'xyz', 4),
-  new Asset('def', 'xyz', 4),
-  'abc-def',
-  Commission.Zero
-);
-
-describe('position', () => {
-  test('should pipe a position', done => {
-    new BehaviorSubject<Component>(
-      new Position(0, '1', instrument, 'CROSS', d(10), d(2), 3)
-    )
-      .pipe(position(instrument))
-      .subscribe({
-        next: it => {
-          expect(it.id).toEqual('1');
-          done();
-        }
-      });
-  });
-
-  test('should skip a pipe', done => {
-    new BehaviorSubject<Component>(instrument).pipe(position(instrument)).subscribe({
-      next: () => fail(),
-      complete: done()
-    });
-  });
-});
-
-describe('positions', () => {
-  const state = new State();
-  const balance = new Balance(0, instrument.quote);
-  const position1 = new Position(0, '1', instrument, 'CROSS', d(10), d(2), 3);
-  const position2 = new Position(0, '2', instrument, 'CROSS', d(20), d(2), 3);
-
-  beforeEach(() => {
-    state.balance.upsert(balance);
-
-    balance.position['1'] = position1;
-    balance.position['2'] = position2;
-  });
-
-  test('should pipe an array of positions on subscription start', done => {
-    new Subject<Component>().pipe(positions(instrument, state)).subscribe({
-      next: it => {
-        expect(it.length).toEqual(2);
-        done();
-      }
-    });
-  });
-});