@quantform/core 0.5.15 → 0.5.23

package/src/adapter/adapter.ts

@@ -1,6 +1,6 @@
 import { Candle, InstrumentSelector, Order } from '../domain';
 import { now, timestamp } from '../shared';
-import { Cache, Feed } from '../storage';
+import { Cache, StorageEvent } from '../storage';
 import { Store } from '../store';
 import { PaperAdapter } from './paper';
 import { PaperEngine } from './paper/engine/paper-engine';
@@ -13,26 +13,14 @@ export const DefaultTimeProvider = {
   timestamp: () => now()
 };
 
+export type FeedAsyncCallback = (timestamp: number, chunk: StorageEvent[]) => void;
+
 export type AdapterFactory = (
   timeProvider: AdapterTimeProvider,
   store: Store,
   cache: Cache
 ) => Adapter;
 
-export type HistoryQuery = {
-  instrument: InstrumentSelector;
-  timeframe: number;
-  length: number;
-};
-
-export type FeedQuery = {
-  instrument: InstrumentSelector;
-  from: timestamp;
-  to: timestamp;
-  destination: Feed;
-  callback: (timestamp: number) => void;
-};
-
 /**
  * Base adapter class, you should derive your own adapter from this class.
  * @abstract
@@ -78,9 +66,18 @@ export abstract class Adapter {
    */
   abstract cancel(order: Order): Promise<void>;
 
-  abstract history(query: HistoryQuery): Promise<Candle[]>;
-
-  abstract feed(query: FeedQuery): Promise<void>;
+  abstract history(
+    instrument: InstrumentSelector,
+    timeframe: number,
+    length: number
+  ): Promise<Candle[]>;
+
+  abstract feed(
+    instrument: InstrumentSelector,
+    from: timestamp,
+    to: timestamp,
+    callback: FeedAsyncCallback
+  ): Promise<void>;
 
   abstract createPaperEngine(adapter: PaperAdapter): PaperEngine;
 }

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

@@ -6,14 +6,14 @@ import {
   InstrumentSelector,
   Order
 } from '../../domain';
+import { d, timestamp } from '../../shared';
 import { Cache, Feed, InMemoryStorage } from '../../storage';
-import { InstrumentPatchEvent, Store } from '../../store';
+import { InstrumentPatchEvent, Store, TradePatchEvent } from '../../store';
 import {
   Adapter,
   AdapterTimeProvider,
   DefaultTimeProvider,
-  FeedQuery,
-  HistoryQuery
+  FeedAsyncCallback
 } from '../adapter';
 import { PaperEngine } from '../paper/engine/paper-engine';
 import { PaperAdapter } from '../paper/paper-adapter';
@@ -39,10 +39,19 @@ class DefaultAdapter extends Adapter {
   cancel(order: Order): Promise<void> {
     throw new Error('Method not implemented.');
   }
-  history(query: HistoryQuery): Promise<Candle[]> {
+  history(
+    instrument: InstrumentSelector,
+    timeframe: number,
+    length: number
+  ): Promise<Candle[]> {
     throw new Error('Method not implemented.');
   }
-  feed(query: FeedQuery): Promise<void> {
+  feed(
+    instrument: InstrumentSelector,
+    from: timestamp,
+    to: timestamp,
+    callback: FeedAsyncCallback
+  ): Promise<void> {
     throw new Error('Method not implemented.');
   }
   name = 'default';
@@ -65,7 +74,7 @@ class DefaultAdapter extends Adapter {
         this.timestamp(),
         base,
         quote,
-        new Commission(0.1, 0.1),
+        new Commission(d(0.1), d(0.1)),
         'btc-usdt'
       )
     );
@@ -104,15 +113,15 @@ describe('BacktesterAdapter', () => {
       {
         onBacktestCompleted: () => {
           expect(store.snapshot.timestamp).toEqual(1);
-          expect(store.snapshot.trade.get(instrument.id).rate).toEqual(100);
-          expect(store.snapshot.trade.get(instrument.id).quantity).toEqual(10);
+          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(instrument, [new Candle(1, 100, 100, 100, 100, 10)]);
+    feed.save([new TradePatchEvent(instrument, d(100), d(10), 1)]);
 
     const sut = new BacktesterAdapter(adapter, streamer, store);
 

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

@@ -2,7 +2,7 @@ import { Candle, InstrumentSelector, Order } from '../../domain';
 import { timestamp } from '../../shared';
 import { InstrumentSubscriptionEvent, Store } from '../../store';
 import { Adapter } from '..';
-import { AdapterFactory, FeedQuery, HistoryQuery } from '../adapter';
+import { AdapterFactory, FeedAsyncCallback } from '../adapter';
 import { PaperAdapter, PaperOptions } from '../paper';
 import { PaperEngine } from '../paper/engine/paper-engine';
 import { BacktesterStreamer } from './backtester-streamer';
@@ -69,18 +69,27 @@ export class BacktesterAdapter extends Adapter {
     return this.decoratedAdapter.cancel(order);
   }
 
-  async history(query: HistoryQuery): Promise<Candle[]> {
+  async history(
+    instrument: InstrumentSelector,
+    timeframe: number,
+    length: number
+  ): Promise<Candle[]> {
     this.streamer.stop();
 
-    const response = await this.decoratedAdapter.history(query);
+    const response = await this.decoratedAdapter.history(instrument, timeframe, length);
 
     this.streamer.tryContinue();
 
     return response;
   }
 
-  feed(query: FeedQuery): Promise<void> {
-    return this.decoratedAdapter.feed(query);
+  feed(
+    instrument: InstrumentSelector,
+    from: timestamp,
+    to: timestamp,
+    callback: FeedAsyncCallback
+  ): Promise<void> {
+    return this.decoratedAdapter.feed(instrument, from, to, callback);
   }
 
   createPaperEngine(adapter: PaperAdapter): PaperEngine {

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

@@ -1,5 +1,7 @@
-import { Candle, instrumentOf } from '../../domain';
+import { instrumentOf } from '../../domain';
+import { d } from '../../shared';
 import { Feed, InMemoryStorage } from '../../storage';
+import { TradePatchEvent } from '../../store';
 import { BacktesterCursor } from './backtester-cursor';
 
 describe('BacktesterCursor', () => {
@@ -8,35 +10,35 @@ describe('BacktesterCursor', () => {
     const feed = new Feed(new InMemoryStorage());
     const cursor = new BacktesterCursor(instrument, feed);
 
-    feed.save(instrument, [
-      new Candle(1, 1, 1, 1, 1),
-      new Candle(2, 2, 2, 2, 2),
-      new Candle(3, 3, 3, 3, 3),
-      new Candle(4, 4, 4, 4, 4),
-      new Candle(5, 5, 5, 5, 5),
-      new Candle(6, 6, 6, 6, 6),
-      new Candle(7, 7, 7, 7, 7),
-      new Candle(8, 8, 8, 8, 8)
+    feed.save([
+      new TradePatchEvent(instrument, d(1), d(1), 1),
+      new TradePatchEvent(instrument, d(2), d(2), 2),
+      new TradePatchEvent(instrument, d(3), d(3), 3),
+      new TradePatchEvent(instrument, d(4), d(4), 4),
+      new TradePatchEvent(instrument, d(5), d(5), 5),
+      new TradePatchEvent(instrument, d(6), d(6), 6),
+      new TradePatchEvent(instrument, d(7), d(7), 7),
+      new TradePatchEvent(instrument, d(8), d(8), 8)
     ]);
 
     await cursor.fetchNextPage(0, 4);
 
-    expect(cursor.dequeue().open).toEqual(1);
-    expect(cursor.dequeue().open).toEqual(2);
-    expect(cursor.dequeue().open).toEqual(3);
+    expect(cursor.dequeue()).toEqual(new TradePatchEvent(instrument, d(1), d(1), 1));
+    expect(cursor.dequeue()).toEqual(new TradePatchEvent(instrument, d(2), d(2), 2));
+    expect(cursor.dequeue()).toEqual(new TradePatchEvent(instrument, d(3), d(3), 3));
     expect(cursor.peek()).toEqual(undefined);
 
     await cursor.fetchNextPage(3, 7);
 
-    expect(cursor.dequeue().open).toEqual(4);
-    expect(cursor.dequeue().open).toEqual(5);
-    expect(cursor.dequeue().open).toEqual(6);
+    expect(cursor.dequeue()).toEqual(new TradePatchEvent(instrument, d(4), d(4), 4));
+    expect(cursor.dequeue()).toEqual(new TradePatchEvent(instrument, d(5), d(5), 5));
+    expect(cursor.dequeue()).toEqual(new TradePatchEvent(instrument, d(6), d(6), 6));
     expect(cursor.peek()).toEqual(undefined);
 
     await cursor.fetchNextPage(6, 10);
 
-    expect(cursor.dequeue().open).toEqual(7);
-    expect(cursor.dequeue().open).toEqual(8);
+    expect(cursor.dequeue()).toEqual(new TradePatchEvent(instrument, d(7), d(7), 7));
+    expect(cursor.dequeue()).toEqual(new TradePatchEvent(instrument, d(8), d(8), 8));
     expect(cursor.peek()).toEqual(undefined);
   });
 });

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

@@ -1,10 +1,10 @@
-import { Candle, InstrumentSelector } from '../../domain';
+import { InstrumentSelector } from '../../domain';
 import { timestamp } from '../../shared';
-import { Feed } from '../../storage';
+import { Feed, StorageEvent } from '../../storage';
 import { backtestPageNotEmpty } from '../error';
 
 export class BacktesterCursor {
-  private page = new Array<Candle>();
+  private page = new Array<StorageEvent>();
   private pageIndex = 0;
   completed = false;
 
@@ -14,7 +14,7 @@ export class BacktesterCursor {
 
   constructor(readonly instrument: InstrumentSelector, private readonly feed: Feed) {}
 
-  peek(): Candle {
+  peek(): StorageEvent {
     if (!this.page) {
       return undefined;
     }
@@ -22,7 +22,7 @@ export class BacktesterCursor {
     return this.page[this.pageIndex];
   }
 
-  dequeue(): Candle {
+  dequeue(): StorageEvent {
     return this.page[this.pageIndex++];
   }
 

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

@@ -1,6 +1,7 @@
-import { Asset, Candle, Instrument } from '../../domain';
+import { Asset, Instrument } from '../../domain';
+import { d } from '../../shared';
 import { Feed, InMemoryStorage } from '../../storage';
-import { Store } from '../../store';
+import { Store, TradePatchEvent } from '../../store';
 import { BacktesterStreamer } from './backtester-streamer';
 
 describe('BacktesterStreamer', () => {
@@ -29,8 +30,8 @@ describe('BacktesterStreamer', () => {
           const trade = store.snapshot.trade.get(instrument.id);
 
           expect(trade.timestamp).toEqual(8);
-          expect(trade.rate).toEqual(8);
-          expect(trade.quantity).toEqual(8);
+          expect(trade.rate).toEqual(d(8));
+          expect(trade.quantity).toEqual(d(8));
           expect(store.snapshot.timestamp).toEqual(8);
 
           done();
@@ -39,15 +40,15 @@ describe('BacktesterStreamer', () => {
     );
 
     feed
-      .save(instrument, [
-        new Candle(1, 1, 1, 1, 1, 1),
-        new Candle(2, 2, 2, 2, 2, 2),
-        new Candle(3, 3, 3, 3, 3, 3),
-        new Candle(4, 4, 4, 4, 4, 4),
-        new Candle(5, 5, 5, 5, 5, 5),
-        new Candle(6, 6, 6, 6, 6, 6),
-        new Candle(7, 7, 7, 7, 7, 7),
-        new Candle(8, 8, 8, 8, 8, 8)
+      .save([
+        new TradePatchEvent(instrument, d(1), d(1), 1),
+        new TradePatchEvent(instrument, d(2), d(2), 2),
+        new TradePatchEvent(instrument, d(3), d(3), 3),
+        new TradePatchEvent(instrument, d(4), d(4), 4),
+        new TradePatchEvent(instrument, d(5), d(5), 5),
+        new TradePatchEvent(instrument, d(6), d(6), 6),
+        new TradePatchEvent(instrument, d(7), d(7), 7),
+        new TradePatchEvent(instrument, d(8), d(8), 8)
       ])
       .then(() => {
         streamer.subscribe(instrument);

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

@@ -1,7 +1,7 @@
 import { InstrumentSelector } from '../../domain';
 import { timestamp } from '../../shared';
 import { Feed } from '../../storage';
-import { OrderbookPatchEvent, Store, TradePatchEvent } from '../../store';
+import { Store } from '../../store';
 import { AdapterTimeProvider } from '../adapter';
 import { BacktesterCursor } from './backtester-cursor';
 
@@ -118,37 +118,20 @@ export class BacktesterStreamer {
       return false;
     }
 
-    const candle = cursor.peek();
-    const instrument = cursor.instrument;
-    const volume = candle.volume ?? 0;
+    const event = cursor.peek();
 
-    this.timestamp = candle.timestamp;
+    this.timestamp = event.timestamp;
     this.sequence++;
 
-    this.dispatch(candle.timestamp, instrument, candle.open, volume);
-    this.dispatch(candle.timestamp, instrument, candle.high, volume);
-    this.dispatch(candle.timestamp, instrument, candle.low, volume);
-    this.dispatch(candle.timestamp, instrument, candle.close, volume);
+    this.store.dispatch(event);
 
-    if (cursor.dequeue().timestamp != candle.timestamp) {
+    if (cursor.dequeue().timestamp != event.timestamp) {
       throw new Error('invalid event to consume');
     }
 
     return true;
   }
 
-  private dispatch(
-    timestamp: number,
-    instrument: InstrumentSelector,
-    rate: number,
-    volume: number
-  ) {
-    this.store.dispatch(
-      new TradePatchEvent(instrument, rate, volume, timestamp),
-      new OrderbookPatchEvent(instrument, rate, volume, rate, volume, timestamp)
-    );
-  }
-
   private async current(from: timestamp, to: timestamp): Promise<BacktesterCursor> {
     for (const cursor of Object.values(this.cursor)) {
       if (cursor.size == 0 && !cursor.completed) {

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

@@ -1,5 +1,5 @@
 import { Asset, commissionPercentOf, Instrument, Order } from '../../../domain';
-import { now } from '../../../shared';
+import { d, now } from '../../../shared';
 import {
   BalancePatchEvent,
   InstrumentPatchEvent,
@@ -17,57 +17,57 @@ describe('PaperEngine', () => {
   );
 
   const commission = commissionPercentOf({
-    maker: 0.1,
-    taker: 0.1
+    maker: d(0.1),
+    taker: d(0.1)
   });
 
   test('should open a new buy market order', () => {
     const store = new Store();
     const engine = new PaperEngine(store);
-    const order = Order.market(instrument, 1.0);
+    const order = Order.market(instrument, d(1.0));
 
     store.dispatch(
       new InstrumentPatchEvent(now(), instrument.base, instrument.quote, commission, ''),
-      new BalancePatchEvent(instrument.base, 1, 0, now()),
-      new BalancePatchEvent(instrument.quote, 1000, 0, now())
+      new BalancePatchEvent(instrument.base, d(1), d.Zero, now()),
+      new BalancePatchEvent(instrument.quote, d(1000), d.Zero, now())
     );
 
     engine.open(order);
 
     expect(store.snapshot.order.asReadonlyArray().length).toEqual(1);
     expect(store.snapshot.order.get(instrument.id).get(order.id)).toEqual(order);
-    expect(store.snapshot.balance.get(instrument.quote.id).free).toEqual(0);
-    expect(store.snapshot.balance.get(instrument.quote.id).locked).toEqual(1000);
+    expect(store.snapshot.balance.get(instrument.quote.id).free).toEqual(d.Zero);
+    expect(store.snapshot.balance.get(instrument.quote.id).locked).toEqual(d(1000));
   });
 
   test('should open a new sell market order', () => {
     const store = new Store();
     const engine = new PaperEngine(store);
-    const order = Order.market(instrument, -0.6);
+    const order = Order.market(instrument, d(-0.6));
 
     store.dispatch(
       new InstrumentPatchEvent(now(), instrument.base, instrument.quote, commission, ''),
-      new BalancePatchEvent(instrument.base, 1, 0, now()),
-      new BalancePatchEvent(instrument.quote, 1000, 0, now())
+      new BalancePatchEvent(instrument.base, d(1), d.Zero, now()),
+      new BalancePatchEvent(instrument.quote, d(1000), d.Zero, now())
     );
 
     engine.open(order);
 
     expect(store.snapshot.order.asReadonlyArray().length).toEqual(1);
     expect(store.snapshot.order.get(instrument.id).get(order.id)).toEqual(order);
-    expect(store.snapshot.balance.get(instrument.base.id).free).toEqual(0.4);
-    expect(store.snapshot.balance.get(instrument.base.id).locked).toEqual(0.6);
+    expect(store.snapshot.balance.get(instrument.base.id).free).toEqual(d(0.4));
+    expect(store.snapshot.balance.get(instrument.base.id).locked).toEqual(d(0.6));
   });
 
   test('should open and fill a new sell limit order', () => {
     const store = new Store();
     const engine = new PaperEngine(store);
-    const order = Order.limit(instrument, -0.6, 100);
+    const order = Order.limit(instrument, d(-0.6), d(100));
 
     store.dispatch(
       new InstrumentPatchEvent(now(), instrument.base, instrument.quote, commission, ''),
-      new BalancePatchEvent(instrument.base, 1, 0, now()),
-      new BalancePatchEvent(instrument.quote, 1000, 0, now()),
+      new BalancePatchEvent(instrument.base, d(1), d.Zero, now()),
+      new BalancePatchEvent(instrument.quote, d(1000), d.Zero, now()),
       new InstrumentSubscriptionEvent(now(), instrument, true)
     );
 
@@ -77,16 +77,23 @@ describe('PaperEngine', () => {
     expect(store.snapshot.order.get(instrument.id).get(order.id).state).toEqual(
       'PENDING'
     );
-    expect(store.snapshot.balance.get(instrument.base.id).free).toEqual(0.4);
-    expect(store.snapshot.balance.get(instrument.base.id).locked).toEqual(0.6);
+    expect(store.snapshot.balance.get(instrument.base.id).free).toEqual(d(0.4));
+    expect(store.snapshot.balance.get(instrument.base.id).locked).toEqual(d(0.6));
 
-    store.dispatch(new OrderbookPatchEvent(instrument, 102, 1, 101, 1, now()));
+    store.dispatch(
+      new OrderbookPatchEvent(
+        instrument,
+        { rate: d(102), quantity: d(1), next: undefined },
+        { rate: d(101), quantity: d(1), next: undefined },
+        now()
+      )
+    );
 
     expect(store.snapshot.order.asReadonlyArray().length).toEqual(1);
     expect(store.snapshot.order.get(instrument.id).get(order.id).state).toEqual('FILLED');
-    expect(store.snapshot.balance.get(instrument.base.id).free).toEqual(0.4);
-    expect(store.snapshot.balance.get(instrument.base.id).locked).toEqual(0);
-    expect(store.snapshot.balance.get(instrument.quote.id).free).toEqual(1060.53);
-    expect(store.snapshot.balance.get(instrument.quote.id).locked).toEqual(0);
+    expect(store.snapshot.balance.get(instrument.base.id).free).toEqual(d(0.4));
+    expect(store.snapshot.balance.get(instrument.base.id).locked).toEqual(d.Zero);
+    expect(store.snapshot.balance.get(instrument.quote.id).free).toEqual(d(1060.53));
+    expect(store.snapshot.balance.get(instrument.quote.id).locked).toEqual(d.Zero);
   });
 });

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

@@ -1,6 +1,7 @@
 import { tap } from 'rxjs';
 
 import { Order, Orderbook, Trade } from '../../../domain';
+import { d, decimal } from '../../../shared';
 import {
   BalanceLockOrderEvent,
   BalanceTransactEvent,
@@ -68,16 +69,16 @@ export class PaperEngine {
         }
 
         if (it.type == 'LIMIT') {
-          if (it.quantity > 0 && it.rate > orderbook.bestAskRate) {
-            this.completeOrder(it, orderbook.bestAskRate);
-          } else if (it.quantity < 0 && it.rate < orderbook.bestBidRate) {
-            this.completeOrder(it, orderbook.bestBidRate);
+          if (it.quantity.greaterThan(0) && it.rate.greaterThan(orderbook.asks.rate)) {
+            this.completeOrder(it, orderbook.asks.rate);
+          } else if (it.quantity.lessThan(0) && it.rate.lessThan(orderbook.bids.rate)) {
+            this.completeOrder(it, orderbook.bids.rate);
           }
         } else if (it.type == 'MARKET') {
-          if (it.quantity > 0) {
-            this.completeOrder(it, orderbook.bestAskRate);
-          } else if (it.quantity < 0) {
-            this.completeOrder(it, orderbook.bestBidRate);
+          if (it.quantity.greaterThan(0)) {
+            this.completeOrder(it, orderbook.asks.rate);
+          } else if (it.quantity.lessThan(0)) {
+            this.completeOrder(it, orderbook.bids.rate);
           }
         }
       });
@@ -93,9 +94,9 @@ export class PaperEngine {
         }
 
         if (it.type == 'LIMIT') {
-          if (it.quantity > 0 && it.rate > trade.rate) {
+          if (it.quantity.greaterThan(0) && it.rate.greaterThan(trade.rate)) {
             this.completeOrder(it, trade.rate);
-          } else if (it.quantity < 0 && it.rate < trade.rate) {
+          } else if (it.quantity.lessThan(0) && it.rate.lessThan(trade.rate)) {
             this.completeOrder(it, trade.rate);
           }
         } else if (it.type == 'MARKET') {
@@ -104,24 +105,30 @@ export class PaperEngine {
       });
   }
 
-  private completeOrder(order: Order, averageExecutionRate: number) {
+  private completeOrder(order: Order, averageExecutionRate: decimal) {
     const { timestamp } = this.store.snapshot;
 
     const instrument = this.store.snapshot.universe.instrument.get(order.instrument.id);
     const transacted = {
-      base: 0,
-      quote: 0
+      base: d.Zero,
+      quote: d.Zero
     };
 
-    const qty = Math.abs(order.quantity);
+    const qty = order.quantity.abs();
 
-    if (order.quantity > 0) {
-      transacted.base += instrument.base.floor(instrument.commission.applyMakerFee(qty));
-      transacted.quote -= instrument.quote.floor(averageExecutionRate * qty);
-    } else if (order.quantity < 0) {
-      transacted.base -= instrument.base.floor(qty);
-      transacted.quote += instrument.quote.floor(
-        instrument.commission.applyMakerFee(averageExecutionRate * qty)
+    if (order.quantity.greaterThan(0)) {
+      transacted.base = transacted.base.plus(
+        instrument.base.floor(instrument.commission.applyMakerFee(qty))
+      );
+      transacted.quote = transacted.quote.minus(
+        instrument.quote.floor(averageExecutionRate.mul(qty))
+      );
+    } else if (order.quantity.lessThan(0)) {
+      transacted.base = transacted.base.minus(instrument.base.floor(qty));
+      transacted.quote = transacted.quote.plus(
+        instrument.quote.floor(
+          instrument.commission.applyMakerFee(averageExecutionRate.mul(qty))
+        )
       );
     }
 

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

@@ -1,10 +1,10 @@
+import { d, timestamp } from '../../shared';
 import { InstrumentPatchEvent, Store } from '../../store';
 import {
   Adapter,
   AdapterTimeProvider,
   DefaultTimeProvider,
-  FeedQuery,
-  HistoryQuery
+  FeedAsyncCallback
 } from '../adapter';
 import {
   Asset,
@@ -33,10 +33,19 @@ class DefaultAdapter extends Adapter {
   cancel(order: Order): Promise<void> {
     throw new Error('Method not implemented.');
   }
-  history(query: HistoryQuery): Promise<Candle[]> {
+  history(
+    instrument: InstrumentSelector,
+    timeframe: number,
+    length: number
+  ): Promise<Candle[]> {
     throw new Error('Method not implemented.');
   }
-  feed(query: FeedQuery): Promise<void> {
+  feed(
+    instrument: InstrumentSelector,
+    from: timestamp,
+    to: timestamp,
+    callback: FeedAsyncCallback
+  ): Promise<void> {
     throw new Error('Method not implemented.');
   }
   name = 'default';
@@ -55,7 +64,7 @@ class DefaultAdapter extends Adapter {
         this.timestamp(),
         new Asset('a', this.name, 8),
         new Asset('b', this.name, 4),
-        new Commission(0.1, 0.1),
+        new Commission(d(0.1), d(0.1)),
         'a-b'
       )
     );
@@ -96,7 +105,7 @@ describe('PaperAdapter', () => {
     await sut.awake();
     await sut.account();
 
-    const order = Order.market(instrumentOf('default:a-b'), 1.0);
+    const order = Order.market(instrumentOf('default:a-b'), d(1.0));
 
     await sut.open(order);
 

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

@@ -1,7 +1,8 @@
 import { assetOf, Candle, InstrumentSelector, Order } from '../../domain';
+import { d, timestamp } from '../../shared';
 import { BalancePatchEvent, Store } from '../../store';
 import { Adapter } from '..';
-import { AdapterFactory, FeedQuery, HistoryQuery } from '../adapter';
+import { AdapterFactory, FeedAsyncCallback } from '../adapter';
 import { PaperEngine } from './engine/paper-engine';
 
 export interface PaperOptions {
@@ -56,15 +57,17 @@ export class PaperAdapter extends Adapter {
         continue;
       }
 
-      const free = this.options.balance[balance];
+      const free = d(this.options.balance[balance]);
 
       subscribed = subscribed.filter(it => it.id != asset.id);
 
-      this.store.dispatch(new BalancePatchEvent(asset, free, 0, this.timestamp()));
+      this.store.dispatch(new BalancePatchEvent(asset, free, d.Zero, this.timestamp()));
     }
 
     for (const missingAsset of subscribed) {
-      this.store.dispatch(new BalancePatchEvent(missingAsset, 0, 0, this.timestamp()));
+      this.store.dispatch(
+        new BalancePatchEvent(missingAsset, d.Zero, d.Zero, this.timestamp())
+      );
     }
   }
 
@@ -76,12 +79,21 @@ export class PaperAdapter extends Adapter {
     this.engine.cancel(order);
   }
 
-  history(query: HistoryQuery): Promise<Candle[]> {
-    return this.decoratedAdapter.history(query);
+  history(
+    instrument: InstrumentSelector,
+    timeframe: number,
+    length: number
+  ): Promise<Candle[]> {
+    return this.decoratedAdapter.history(instrument, timeframe, length);
   }
 
-  feed(query: FeedQuery): Promise<void> {
-    return this.decoratedAdapter.feed(query);
+  feed(
+    instrument: InstrumentSelector,
+    from: timestamp,
+    to: timestamp,
+    callback: FeedAsyncCallback
+  ): Promise<void> {
+    return this.decoratedAdapter.feed(instrument, from, to, callback);
   }
 
   createPaperEngine(adapter: PaperAdapter): PaperEngine {