@quantform/core 0.5.14 → 0.5.15

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

@@ -0,0 +1,81 @@
+import { BehaviorSubject, map, Subject } from 'rxjs';
+
+import { InnerSet, State } from '../store';
+import { Asset } from './asset';
+import { Component } from './component';
+import { Instrument } from './instrument';
+import { Order } from './order';
+import { order, orders } from './order.operator';
+
+const instrument = new Instrument(
+  new Asset('abc', 'xyz', 4),
+  new Asset('def', 'xyz', 4),
+  'abc-def'
+);
+
+describe('order', () => {
+  test('should pipe an order', done => {
+    new BehaviorSubject<Component>(Order.market(instrument, -100))
+      .pipe(order(instrument))
+      .subscribe({
+        next: it => {
+          expect(it.instrument).toEqual(instrument);
+          expect(it.quantity).toEqual(-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 = Order.market(instrument, -100);
+    order2 = Order.limit(instrument, 100, 10);
+    order3 = Order.market(instrument, 100);
+
+    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

@@ -0,0 +1,23 @@
+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

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

package/src/domain/order.ts

@@ -1,10 +1,11 @@
 import { v4 } from 'uuid';
 
 import { timestamp } from '../shared';
+import { Balance } from './balance';
 import { Component } from './component';
+import { invalidArgumentError } from './error';
 import { InstrumentSelector } from './instrument';
 
-export type OrderSide = 'SELL' | 'BUY';
 export type OrderType = 'MARKET' | 'LIMIT' | 'STOP-MARKET' | 'STOP-LIMIT';
 export type OrderState =
   | 'NEW'
@@ -24,80 +25,76 @@ export class Order implements Component {
   quantityExecuted = 0;
   averageExecutionRate: number;
   createdAt: timestamp;
-  comment: string;
 
-  static sellMarket(instrument: InstrumentSelector, quantity: number): Order {
-    return new Order(instrument, 'SELL', 'MARKET', quantity);
+  static market(instrument: InstrumentSelector, quantity: number): Order {
+    return new Order(instrument, 'MARKET', quantity);
   }
 
-  static buyMarket(instrument: InstrumentSelector, quantity: number): Order {
-    return new Order(instrument, 'BUY', 'MARKET', quantity);
+  static limit(instrument: InstrumentSelector, quantity: number, rate: number): Order {
+    return new Order(instrument, 'LIMIT', quantity, rate);
   }
 
-  static sellLimit(
-    instrument: InstrumentSelector,
-    quantity: number,
-    rate: number
-  ): Order {
-    return new Order(instrument, 'SELL', 'LIMIT', quantity, rate);
-  }
-
-  static buyLimit(instrument: InstrumentSelector, quantity: number, rate: number): Order {
-    return new Order(instrument, 'BUY', 'LIMIT', quantity, rate);
-  }
-
-  static sellStopMarket(
+  static stopMarket(
     instrument: InstrumentSelector,
     quantity: number,
     stopRate: number
   ): Order {
-    return new Order(instrument, 'SELL', 'STOP-MARKET', quantity, null, stopRate);
+    return new Order(instrument, 'STOP-MARKET', quantity, undefined, stopRate);
   }
 
-  static buyStopMarket(
-    instrument: InstrumentSelector,
-    quantity: number,
-    stopRate: number
-  ): Order {
-    return new Order(instrument, 'BUY', 'STOP-MARKET', quantity, null, stopRate);
-  }
-
-  static sellStopLimit(
+  static stopLimit(
     instrument: InstrumentSelector,
     quantity: number,
     rate: number,
     stopRate: number
   ): Order {
-    return new Order(instrument, 'SELL', 'STOP-LIMIT', quantity, rate, stopRate);
-  }
-
-  static buyStopLimit(
-    instrument: InstrumentSelector,
-    quantity: number,
-    rate: number,
-    stopRate: number
-  ): Order {
-    return new Order(instrument, 'BUY', 'STOP-LIMIT', quantity, rate, stopRate);
+    return new Order(instrument, 'STOP-LIMIT', quantity, rate, stopRate);
   }
 
   constructor(
     readonly instrument: InstrumentSelector,
-    readonly side: OrderSide,
     readonly type: OrderType,
     readonly quantity: number,
-    readonly rate: number = null,
-    readonly stopRate: number = null
+    readonly rate?: number,
+    readonly stopRate?: number
   ) {
-    if (quantity <= 0 || Number.isNaN(quantity)) {
-      throw new Error(`invalid order quantity: ${quantity}`);
+    if (!quantity || Number.isNaN(quantity)) {
+      throw invalidArgumentError(quantity);
     }
 
-    if (rate && (Number.isNaN(quantity) || rate <= 0)) {
-      throw new Error('invalid order rate');
+    if (rate && (Number.isNaN(rate) || rate <= 0)) {
+      throw invalidArgumentError(rate);
     }
   }
 
   toString() {
     return this.id;
   }
+
+  calculateBalanceToLock(base: Balance, quote: Balance): { base: number; quote: number } {
+    const qty = Math.abs(this.quantity);
+
+    if (this.quantity > 0) {
+      switch (this.type) {
+        case 'MARKET':
+          return {
+            base: 0,
+            quote: quote.free
+          };
+
+        case 'LIMIT':
+          return {
+            base: 0,
+            quote: quote.asset.ceil(this.rate * qty)
+          };
+      }
+    }
+
+    if (this.quantity < 0) {
+      return {
+        base: qty,
+        quote: 0
+      };
+    }
+  }
 }

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

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

package/src/domain/orderbook.operator.ts

@@ -0,0 +1,15 @@
+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

@@ -0,0 +1,17 @@
+import { Asset } from './asset';
+import { Instrument } from './instrument';
+import { Orderbook } from './orderbook';
+
+describe('Orderbook', () => {
+  const instrument = new Instrument(
+    new Asset('abc', 'xyz', 4),
+    new Asset('def', 'xyz', 4),
+    'abc-def'
+  );
+
+  test('should construct an empty orderbook', () => {
+    const sut = new Orderbook(instrument);
+
+    expect(sut.id).toEqual(instrument.id);
+  });
+});

package/src/domain/orderbook.ts

@@ -6,6 +6,7 @@ import { Component } from './component';
  * Provides an access to pending buy and sell orders on the specific market.
  */
 export class Orderbook implements Component {
+  id: string;
   kind = 'orderbook';
   timestamp: timestamp;
   bestAskRate: number;
@@ -17,7 +18,9 @@ export class Orderbook implements Component {
     return this.instrument.quote.fixed((this.bestAskRate + this.bestBidRate) / 2);
   }
 
-  constructor(public readonly instrument: Instrument) {}
+  constructor(public readonly instrument: Instrument) {
+    this.id = instrument.id;
+  }
 
   toString() {
     return this.instrument.toString();

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

@@ -0,0 +1,58 @@
+import { BehaviorSubject, map, Subject } from 'rxjs';
+
+import { State } from '../store';
+import { Asset } from './asset';
+import { Balance } from './balance';
+import { Component } from './component';
+import { Instrument } from './instrument';
+import { Position } from './position';
+import { position, positions } from './position.operator';
+
+const instrument = new Instrument(
+  new Asset('abc', 'xyz', 4),
+  new Asset('def', 'xyz', 4),
+  'abc-def'
+);
+
+describe('position', () => {
+  test('should pipe a position', done => {
+    new BehaviorSubject<Component>(new Position('1', instrument, 'CROSS', 10, 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(instrument.quote);
+  const position1 = new Position('1', instrument, 'CROSS', 10, 2, 3);
+  const position2 = new Position('2', instrument, 'CROSS', 20, 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();
+      }
+    });
+  });
+});

package/src/domain/position.operator.ts

@@ -0,0 +1,61 @@
+import { filter, map, Observable, share, startWith } from 'rxjs';
+
+import { weightedMean } from '../shared';
+import { State } from '../store';
+import { InstrumentSelector } from './instrument';
+import { Position } from './position';
+
+export function position(selector: InstrumentSelector) {
+  return (source: Observable<Position>) =>
+    source.pipe(
+      filter(it => it.kind == 'position' && it.instrument.id == selector.id),
+      map(it => it as Readonly<Position>)
+    );
+}
+
+export function positions(selector: InstrumentSelector, state: State) {
+  const getter = () =>
+    Object.values(state.balance.get(selector.quote.id).position).filter(
+      it => it.instrument.id == selector.id
+    );
+
+  return (source: Observable<Position>) =>
+    source.pipe(
+      position(selector),
+      map(() => getter()),
+      startWith(getter())
+    );
+}
+
+export function flatten() {
+  return function (
+    source: Observable<Position[]>
+  ): Observable<{ size: number; rate: number }> {
+    return source.pipe(
+      map(it => {
+        if (it.length > 1) {
+          return {
+            size: it.reduce((aggregate, position) => aggregate + position.size, 0),
+            rate: weightedMean(
+              it.map(x => x.averageExecutionRate),
+              it.map(x => x.size)
+            )
+          };
+        }
+
+        if (it.length == 1) {
+          return {
+            size: it[0].size,
+            rate: it[0].averageExecutionRate
+          };
+        }
+
+        return {
+          size: 0,
+          rate: 0
+        };
+      }),
+      share()
+    );
+  };
+}

package/src/domain/position.spec.ts

@@ -2,34 +2,38 @@ import { Asset } from './asset';
 import { Instrument } from './instrument';
 import { Position } from './position';
 
-const instrument = new Instrument(
-  new Asset('abc', 'xyz', 4),
-  new Asset('def', 'xyz', 4),
-  'abc-def'
-);
-
-describe('position tests', () => {
-  test('should instantiate proper position', () => {
-    const sut = new Position('123', instrument);
-
-    sut.size = 5;
-    sut.averageExecutionRate = 20;
-    sut.leverage = 20;
-
-    expect(sut.margin).toEqual(5);
-    expect(sut.estimatedUnrealizedPnL).toEqual(0);
+describe('Position', () => {
+  const instrument = new Instrument(
+    new Asset('abc', 'xyz', 4),
+    new Asset('def', 'xyz', 4),
+    'abc-def'
+  );
+
+  test('should construct a position', () => {
+    const sut = new Position('1', instrument, 'CROSS', 10, 2, 3);
+
+    expect(sut.id).toEqual('1');
+    expect(sut.mode).toEqual('CROSS');
+    expect(sut.averageExecutionRate).toEqual(10);
+    expect(sut.size).toEqual(2);
+    expect(sut.leverage).toEqual(3);
+    expect(sut.estimatedUnrealizedPnL).toEqual(undefined);
+    expect(sut.id).toEqual('1');
   });
 
-  test('should calculate unrealized pnl', () => {
-    const sut = new Position('123', instrument);
+  test('should calculate correct margin', () => {
+    const sut = new Position('1', instrument, 'CROSS', 2511.81, 10.31, 20);
 
-    sut.size = -5;
-    sut.averageExecutionRate = 20;
-    sut.leverage = 20;
+    expect(sut.margin).toEqual(0.5155);
+    expect(sut.estimatedUnrealizedPnL).toEqual(undefined);
+  });
+
+  test('should calculate correct unrealized pnl', () => {
+    const sut = new Position('1', instrument, 'CROSS', 2511.81, 10.31, 20);
 
-    sut.calculatePnL(10);
+    const pnl = sut.calculateEstimatedUnrealizedPnL(2576.44);
 
-    expect(sut.margin).toEqual(5);
-    expect(sut.estimatedUnrealizedPnL).toEqual(50);
+    expect(pnl).toEqual(0.2652);
+    expect(sut.estimatedUnrealizedPnL).toEqual(0.2652);
   });
 });

package/src/domain/position.ts

@@ -1,7 +1,5 @@
-import { map, Observable, share } from 'rxjs';
-
 import { Instrument } from '../domain';
-import { pnl, timestamp, weightedMean } from '../shared';
+import { pnl, timestamp } from '../shared';
 import { Component } from './component';
 
 export type PositionMode = 'CROSS' | 'ISOLATED';
@@ -9,22 +7,25 @@ export type PositionMode = 'CROSS' | 'ISOLATED';
 export class Position implements Component {
   kind = 'position';
   timestamp: timestamp;
-  averageExecutionRate: number;
-  size: number;
-  leverage: number;
-  mode: PositionMode = 'CROSS';
-  estimatedUnrealizedPnL = 0;
+  estimatedUnrealizedPnL?: number;
 
   get margin(): number {
-    return this.instrument.quote.ceil(
-      (Math.abs(this.size) * this.averageExecutionRate) / this.leverage
-    );
+    return this.instrument.quote.fixed(Math.abs(this.size) / this.leverage);
   }
 
-  constructor(readonly id: string, readonly instrument: Instrument) {}
-
-  calculatePnL(rate: number): number {
-    this.estimatedUnrealizedPnL = pnl(this.averageExecutionRate, rate, this.size);
+  constructor(
+    readonly id: string,
+    readonly instrument: Instrument,
+    readonly mode: PositionMode,
+    public averageExecutionRate: number,
+    public size: number,
+    public leverage: number
+  ) {}
+
+  calculateEstimatedUnrealizedPnL(rate: number): number {
+    this.estimatedUnrealizedPnL = this.instrument.quote.fixed(
+      pnl(this.averageExecutionRate, rate, this.size)
+    );
 
     return this.estimatedUnrealizedPnL;
   }
@@ -33,36 +34,3 @@ export class Position implements Component {
     return this.id;
   }
 }
-
-export function positionsFlat() {
-  return function (
-    source: Observable<Position[]>
-  ): Observable<{ size: number; rate: number }> {
-    return source.pipe(
-      map(it => {
-        if (it.length > 1) {
-          return {
-            size: it.reduce((aggregate, position) => aggregate + position.size, 0),
-            rate: weightedMean(
-              it.map(x => x.averageExecutionRate),
-              it.map(x => x.size)
-            )
-          };
-        }
-
-        if (it.length == 1) {
-          return {
-            size: it[0].size,
-            rate: it[0].averageExecutionRate
-          };
-        }
-
-        return {
-          size: 0,
-          rate: 0
-        };
-      }),
-      share()
-    );
-  };
-}

package/src/domain/session.spec.ts

@@ -4,7 +4,7 @@ import { now } from '../shared';
 import { InstrumentPatchEvent } from '../store';
 import { SessionDescriptor } from './session';
 
-describe('session tests', () => {
+describe('Session', () => {
   const descriptor: SessionDescriptor = {
     id: now(),
     adapter: []