@quantform/core 0.3.260 → 0.3.262

package/src/adapter/adapter-aggregate.ts

@@ -1,18 +1,8 @@
 import { Store } from '../store';
-import { Adapter, AdapterContext } from '.';
-import { Logger } from '../shared';
-import {
-  AdapterAccountCommand,
-  AdapterAwakeCommand,
-  AdapterDisposeCommand,
-  AdapterFeedCommand,
-  AdapterHistoryQuery,
-  AdapterOrderCancelCommand,
-  AdapterOrderOpenCommand,
-  AdapterSubscribeCommand
-} from './adapter.event';
+import { Adapter, AdapterContext, FeedQuery, HistoryQuery } from '.';
 import { InstrumentSelector, Order, Candle } from '../domain';
 import { Feed } from './../storage';
+import { Logger } from '../shared';
 
 /**
  * Manages instances of all adapters provided in session descriptor.
@@ -31,16 +21,28 @@ export class AdapterAggregate {
    * @returns
    */
   get(adapterName: string): Adapter {
-    return this.adapter[adapterName];
+    const adapter = this.adapter[adapterName];
+
+    if (!adapter) {
+      throw new Error(
+        `Unknown adapter: ${adapterName}. You should provide adapter in session descriptor.`
+      );
+    }
+
+    return adapter;
   }
 
   /**
    * Sets up all adapters.
    */
   async awake(): Promise<void> {
-    for (const adapter in this.adapter) {
-      await this.dispatch(adapter, new AdapterAwakeCommand());
-      await this.dispatch(adapter, new AdapterAccountCommand());
+    for (const adapter of Object.values(this.adapter)) {
+      try {
+        await adapter.awake(this.createContext(adapter));
+        await adapter.account();
+      } catch (e) {
+        Logger.error(e);
+      }
     }
   }
 
@@ -48,8 +50,12 @@ export class AdapterAggregate {
    * Disposes all adapters.
    */
   async dispose(): Promise<any> {
-    for (const adapter in this.adapter) {
-      await this.dispatch(adapter, new AdapterDisposeCommand());
+    for (const adapter of Object.values(this.adapter)) {
+      try {
+        await adapter.dispose();
+      } catch (e) {
+        Logger.error(e);
+      }
     }
   }
 
@@ -73,7 +79,11 @@ export class AdapterAggregate {
       }, {});
 
     for (const adapterName in grouped) {
-      await this.dispatch(adapterName, new AdapterSubscribeCommand(grouped[adapterName]));
+      try {
+        await this.get(adapterName).subscribe(grouped[adapterName]);
+      } catch (e) {
+        Logger.error(e);
+      }
     }
   }
 
@@ -82,84 +92,54 @@ export class AdapterAggregate {
    * @param order an order to open.
    */
   open(order: Order): Promise<void> {
-    return this.dispatch<AdapterOrderOpenCommand, void>(
-      order.instrument.base.adapter,
-      new AdapterOrderOpenCommand(order)
-    );
+    try {
+      return this.get(order.instrument.base.adapter).open(order);
+    } catch (e) {
+      Logger.error(e);
+    }
   }
 
   /**
    * Cancels specific order.
    */
   cancel(order: Order): Promise<void> {
-    return this.dispatch(
-      order.instrument.base.adapter,
-      new AdapterOrderCancelCommand(order)
-    );
+    try {
+      return this.get(order.instrument.base.adapter).cancel(order);
+    } catch (e) {
+      Logger.error(e);
+    }
   }
 
   /**
    *
-   * @param selector Returns collection of candles for specific history.
-   * @param timeframe
-   * @param length
    * @returns
    */
-  history(
-    selector: InstrumentSelector,
-    timeframe: number,
-    length: number
-  ): Promise<Candle[]> {
-    return this.dispatch<AdapterHistoryQuery, Candle[]>(
-      selector.base.adapter,
-      new AdapterHistoryQuery(selector, timeframe, length)
-    );
+  history(query: HistoryQuery): Promise<Candle[]> {
+    try {
+      return this.get(query.instrument.base.adapter).history(query);
+    } catch (e) {
+      Logger.error(e);
+    }
   }
 
   /**
    * Feeds a storage with historical instrument data.
-   * @param selector
-   * @param from
-   * @param to
-   * @param destination
-   * @param callback
    * @returns
    */
-  feed(
-    selector: InstrumentSelector,
-    from: number,
-    to: number,
-    destination: Feed,
-    callback: (timestamp: number) => void
-  ): Promise<void> {
-    return this.dispatch(
-      selector.base.adapter,
-      new AdapterFeedCommand(selector, from, to, destination, callback)
-    );
+  feed(query: FeedQuery): Promise<void> {
+    try {
+      return this.get(query.instrument.base.adapter).feed(query);
+    } catch (e) {
+      Logger.error(e);
+    }
   }
 
   /**
-   * Routes and executes command to a specific adapter.
-   * @param adapterName name of adapter
-   * @param command
+   *
+   * @param adapter
    * @returns
    */
-  private dispatch<TCommand extends { type: string }, TResponse>(
-    adapterName: string,
-    command: TCommand
-  ): Promise<TResponse> {
-    const adapter = this.get(adapterName);
-
-    if (!adapter) {
-      throw new Error(
-        `Unknown adapter: ${adapterName}. You should provide adapter in session descriptor.`
-      );
-    }
-
-    try {
-      return adapter.dispatch(command, new AdapterContext(adapter, this.store));
-    } catch (e) {
-      Logger.error(e);
-    }
+  private createContext(adapter: Adapter) {
+    return new AdapterContext(adapter, this.store);
   }
 }

package/src/adapter/adapter.ts

@@ -1,8 +1,10 @@
 import { now, timestamp } from '../shared';
 import { PaperExecutor } from './paper/executor/paper-executor';
 import { PaperAdapter } from './paper';
-import { Topic } from '../shared/topic';
-import { Store } from '../store';
+import { State, Store } from '../store';
+import { InstrumentSelector, Order, Candle } from '../domain';
+import { Feed } from '../storage';
+import { StoreEvent } from '../store/event';
 
 /**
  * Shared context for adapter execution. Provides access to the store.
@@ -15,18 +17,94 @@ export class AdapterContext {
     return this.adapter.timestamp();
   }
 
-  constructor(private readonly adapter: Adapter, readonly store: Store) {}
+  get snapshot(): State {
+    return this.store.snapshot;
+  }
+
+  constructor(private readonly adapter: Adapter, private readonly store: Store) {}
+
+  dispatch(...events: StoreEvent[]) {
+    return this.store.dispatch(...events);
+  }
 }
 
+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
  */
-export abstract class Adapter extends Topic<{ type: string }, AdapterContext> {
+export abstract class Adapter {
+  context: AdapterContext;
+
   abstract name: string;
-  abstract createPaperExecutor(adapter: PaperAdapter): PaperExecutor;
 
   timestamp(): timestamp {
     return now();
   }
+
+  /**
+   * Setup an adapter.
+   * @param context
+   */
+  async awake(context: AdapterContext): Promise<void> {
+    this.context = context;
+  }
+
+  /**
+   * Dispose an adapter.
+   */
+  async dispose(): Promise<void> {}
+
+  /**
+   * Subscribe to collection of instruments.
+   * @param instruments
+   */
+  subscribe(instruments: InstrumentSelector[]): Promise<void> {
+    throw new Error('method not implemented');
+  }
+
+  /**
+   *
+   */
+  account(): Promise<void> {
+    throw new Error('method not implemented');
+  }
+
+  /**
+   * Opens new order.
+   * @param order an order to open.
+   */
+  open(order: Order): Promise<void> {
+    throw new Error('method not implemented');
+  }
+
+  /**
+   * Cancels specific order.
+   */
+  cancel(order: Order): Promise<void> {
+    throw new Error('method not implemented');
+  }
+
+  history(query: HistoryQuery): Promise<Candle[]> {
+    throw new Error('method not implemented');
+  }
+
+  feed(query: FeedQuery): Promise<void> {
+    throw new Error('method not implemented');
+  }
+
+  abstract createPaperExecutor(adapter: PaperAdapter): PaperExecutor;
 }

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

@@ -1,10 +1,11 @@
 import { Adapter, AdapterContext } from '..';
 import { BacktesterStreamer } from './backtester-streamer';
 import { PaperAdapter, PaperOptions } from '../paper';
-import { handler } from '../../shared/topic';
 import { timestamp } from '../../shared';
-import { AdapterSubscribeCommand, AdapterHistoryQuery } from '../adapter.event';
 import { InstrumentSubscriptionEvent } from '../../store/event';
+import { InstrumentSelector, Order, Candle } from '../../domain';
+import { PaperExecutor } from '../paper/executor/paper-executor';
+import { FeedQuery, HistoryQuery } from '../adapter';
 
 export class BacktesterOptions extends PaperOptions {
   from: timestamp;
@@ -14,43 +15,62 @@ export class BacktesterOptions extends PaperOptions {
 export class BacktesterAdapter extends Adapter {
   readonly name = this.decoratedAdapter.name;
 
-  constructor(readonly decoratedAdapter: Adapter, readonly streamer: BacktesterStreamer) {
-    super();
-  }
-
   timestamp() {
     return this.streamer.timestamp;
   }
 
-  createPaperExecutor(adapter: PaperAdapter) {
-    return this.decoratedAdapter.createPaperExecutor(adapter);
+  constructor(readonly decoratedAdapter: Adapter, readonly streamer: BacktesterStreamer) {
+    super();
   }
 
-  onUnknownEvent(event: { type: string }, context: AdapterContext) {
-    return this.decoratedAdapter.dispatch(event, context);
+  async awake(context: AdapterContext): Promise<void> {
+    await this.awake(context);
+    await this.decoratedAdapter.awake(context);
   }
 
-  @handler(AdapterSubscribeCommand)
-  onSubscribe(command: AdapterSubscribeCommand, context: AdapterContext) {
-    command.instrument.forEach(it => {
+  dispose(): Promise<void> {
+    return this.decoratedAdapter.dispose();
+  }
+
+  async subscribe(instruments: InstrumentSelector[]): Promise<void> {
+    instruments.forEach(it => {
       this.streamer.subscribe(it);
     });
 
-    context.store.dispatch(
-      ...command.instrument.map(
-        it => new InstrumentSubscriptionEvent(context.timestamp, it, true)
+    this.context.dispatch(
+      ...instruments.map(
+        it => new InstrumentSubscriptionEvent(this.context.timestamp, it, true)
       )
     );
   }
 
-  @handler(AdapterHistoryQuery)
-  async onHistory(event: AdapterHistoryQuery, context: AdapterContext) {
+  account(): Promise<void> {
+    return this.decoratedAdapter.account();
+  }
+
+  open(order: Order): Promise<void> {
+    return this.decoratedAdapter.open(order);
+  }
+
+  cancel(order: Order): Promise<void> {
+    return this.decoratedAdapter.cancel(order);
+  }
+
+  async history(query: HistoryQuery): Promise<Candle[]> {
     this.streamer.stop();
 
-    const response = await this.decoratedAdapter.dispatch(event, context);
+    const response = await this.decoratedAdapter.history(query);
 
     this.streamer.tryContinue();
 
     return response;
   }
+
+  feed(query: FeedQuery): Promise<void> {
+    return this.decoratedAdapter.feed(query);
+  }
+
+  createPaperExecutor(adapter: PaperAdapter): PaperExecutor {
+    return this.decoratedAdapter.createPaperExecutor(adapter);
+  }
 }

package/src/adapter/index.ts

@@ -1,3 +1,2 @@
 export * from './adapter';
 export * from './adapter-aggregate';
-export * from './adapter.event';

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

@@ -1,8 +1,12 @@
 import { PaperSpotExecutor } from '.';
+import { AdapterContext } from '..';
 import { Store } from '../../store';
 import { Adapter } from '../adapter';
 import { PaperExecutor } from './executor/paper-executor';
 import { PaperAdapter } from './paper-adapter';
+import { Order, Asset, Commission, assetOf } from './../../domain';
+import { instrumentOf } from './../../domain/instrument';
+import { BalancePatchEvent, InstrumentPatchEvent } from '../../store/event';
 
 class DefaultAdapter extends Adapter {
   name = 'default';
@@ -11,24 +15,55 @@ class DefaultAdapter extends Adapter {
     return 123;
   }
 
+  async awake(context: AdapterContext): Promise<void> {
+    super.awake(context);
+
+    context.dispatch(
+      new InstrumentPatchEvent(
+        context.timestamp,
+        new Asset('a', this.name, 8),
+        new Asset('b', this.name, 4),
+        new Commission(0.1, 0.1),
+        'a-b'
+      )
+    );
+  }
+
   createPaperExecutor(adapter: PaperAdapter): PaperExecutor {
     return new PaperSpotExecutor(adapter);
   }
 }
 
 describe('paper adapter tests', () => {
+  const options = {
+    balance: {
+      ['default:a']: 1000,
+      ['default:b']: 200
+    }
+  };
+
   test('should return wrapped adapter name and timestamp', () => {
-    const adapter = new DefaultAdapter();
     const store = new Store();
-    const options = {
-      balance: {
-        ['binance:usdt']: 1000
-      }
-    };
 
-    const sut = new PaperAdapter(adapter, store, options);
+    const sut = new PaperAdapter(new DefaultAdapter(), store, options);
 
     expect(sut.name).toEqual('default');
     expect(sut.timestamp()).toEqual(123);
   });
+
+  test('', async () => {
+    const store = new Store();
+    const adapter = new DefaultAdapter();
+
+    const sut = new PaperAdapter(adapter, store, options);
+
+    await sut.awake(new AdapterContext(sut, store));
+    await sut.account();
+
+    const order = Order.buyMarket(instrumentOf('default:a-b'), 1.0);
+
+    await sut.open(order);
+
+    expect(store.snapshot.order[order.id]).toEqual(order);
+  });
 });

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

@@ -1,14 +1,10 @@
 import { Adapter, AdapterContext } from '..';
 import { Store } from '../../store';
 import { PaperExecutor } from './executor/paper-executor';
-import { handler } from '../../shared/topic';
-import { assetOf } from '../../domain';
+import { assetOf, Candle, InstrumentSelector, Order } from '../../domain';
 import { BalancePatchEvent } from '../../store/event';
-import {
-  AdapterAccountCommand,
-  AdapterOrderOpenCommand,
-  AdapterOrderCancelCommand
-} from '../adapter.event';
+import { Feed } from 'src/storage';
+import { FeedQuery, HistoryQuery } from '../adapter';
 
 export class PaperOptions {
   balance: { [key: string]: number };
@@ -32,16 +28,20 @@ export class PaperAdapter extends Adapter {
     return this.decoratedAdapter.timestamp();
   }
 
-  createPaperExecutor(adapter: PaperAdapter): PaperExecutor {
-    return this.decoratedAdapter.createPaperExecutor(adapter);
+  async awake(context: AdapterContext): Promise<void> {
+    await super.awake(context);
+    await this.decoratedAdapter.awake(context);
   }
 
-  onUnknownEvent(event: { type: string }, context: AdapterContext) {
-    return this.decoratedAdapter.dispatch(event, context);
+  dispose(): Promise<void> {
+    return this.decoratedAdapter.dispose();
   }
 
-  @handler(AdapterAccountCommand)
-  onAccount(event: AdapterAccountCommand, context: AdapterContext) {
+  subscribe(instruments: InstrumentSelector[]): Promise<void> {
+    return this.decoratedAdapter.subscribe(instruments);
+  }
+
+  async account(): Promise<void> {
     let subscribed = Object.values(this.store.snapshot.subscription.asset).filter(
       it => it.adapter == this.name
     );
@@ -57,25 +57,33 @@ export class PaperAdapter extends Adapter {
 
       subscribed = subscribed.filter(it => it.toString() != asset.toString());
 
-      this.store.dispatch(new BalancePatchEvent(asset, free, 0, context.timestamp));
+      this.store.dispatch(new BalancePatchEvent(asset, free, 0, this.context.timestamp));
     }
 
     for (const missingAsset of subscribed) {
-      this.store.dispatch(new BalancePatchEvent(missingAsset, 0, 0, context.timestamp));
+      this.store.dispatch(
+        new BalancePatchEvent(missingAsset, 0, 0, this.context.timestamp)
+      );
     }
   }
 
-  @handler(AdapterOrderOpenCommand)
-  onOrderOpen(event: AdapterOrderOpenCommand, context: AdapterContext) {
-    this.executor.open(event.order);
+  async open(order: Order): Promise<void> {
+    this.executor.open(order);
+  }
+
+  async cancel(order: Order): Promise<void> {
+    this.executor.cancel(order);
+  }
 
-    return Promise.resolve();
+  history(query: HistoryQuery): Promise<Candle[]> {
+    return this.decoratedAdapter.history(query);
   }
 
-  @handler(AdapterOrderCancelCommand)
-  onOrderCancel(event: AdapterOrderCancelCommand, context: AdapterContext) {
-    this.executor.cancel(event.order);
+  feed(query: FeedQuery): Promise<void> {
+    return this.decoratedAdapter.feed(query);
+  }
 
-    return Promise.resolve();
+  createPaperExecutor(adapter: PaperAdapter): PaperExecutor {
+    return this.decoratedAdapter.createPaperExecutor(adapter);
   }
 }

package/src/bootstrap.ts

@@ -54,7 +54,7 @@ export class Bootstrap {
 
     const aggregate = new AdapterAggregate(
       this.descriptor.adapter.map(
-        it => new PaperAdapter(new BacktesterAdapter(it, streamer), store, backtester)
+        it => new BacktesterAdapter(new PaperAdapter(it, store, backtester), streamer)
       ),
       store
     );

package/src/ipc.spec.ts

@@ -1,20 +1,10 @@
-import { Session } from './session';
-import {
-  Adapter,
-  AdapterFeedCommand,
-  AdapterAwakeCommand,
-  AdapterAccountCommand,
-  AdapterSubscribeCommand,
-  AdapterDisposeCommand
-} from './adapter';
+import { Adapter, AdapterContext } from './adapter';
 import { PaperAdapter, PaperSpotExecutor } from './adapter/paper';
 import { PaperExecutor } from './adapter/paper/executor/paper-executor';
 import { run } from './ipc';
-import { Feed, InMemoryStorage } from './storage';
-import { instrumentOf } from './domain';
-import { handler, task } from './shared';
+import { task } from './shared';
 import { EventEmitter } from 'events';
-import { from, of, take, tap } from 'rxjs';
+import { of, take, tap } from 'rxjs';
 
 class DefaultAdapter extends Adapter {
   name = 'default';
@@ -27,42 +17,14 @@ class DefaultAdapter extends Adapter {
     return new PaperSpotExecutor(adapter);
   }
 
-  @handler(AdapterAwakeCommand)
-  onAwake(command: AdapterAwakeCommand) {}
-
-  @handler(AdapterDisposeCommand)
-  onDispose(command: AdapterDisposeCommand) {}
-
-  @handler(AdapterSubscribeCommand)
-  onSubscribe(command: AdapterSubscribeCommand) {}
-
-  @handler(AdapterAccountCommand)
-  onAccount(command: AdapterAccountCommand) {}
+  awake(context: AdapterContext): Promise<void> {
+    return super.awake(context);
+  }
 
-  @handler(AdapterFeedCommand)
-  onFeed(command: AdapterFeedCommand) {}
+  async account(): Promise<void> {}
 }
 
 describe('ipc feed tests', () => {
-  test('should trigger adapter feed command', async () => {
-    const command = {
-      type: 'feed',
-      instrument: 'default:btc-usdt',
-      from: 0,
-      to: 100
-    };
-
-    const session = await run(
-      {
-        adapter: [new DefaultAdapter()],
-        feed: new Feed(new InMemoryStorage())
-      },
-      command
-    );
-
-    //expect(session.descriptor).toBeUndefined();
-  });
-
   test('should dispatch session started event', done => {
     const command = {
       type: 'paper'

package/src/ipc.ts

@@ -216,19 +216,19 @@ class IpcHandler extends Topic<{ type: string }, IpcSessionAccessor> {
 
     this.emit({ type: 'feed:started' });
 
-    await accessor.session.aggregate.feed(
+    await accessor.session.aggregate.feed({
       instrument,
-      command.from,
-      command.to,
-      feed,
-      timestamp =>
+      from: command.from,
+      to: command.to,
+      destination: feed,
+      callback: timestamp =>
         this.emit({
           type: 'feed:updated',
           timestamp,
           from: command.from,
           to: command.to
         })
-    );
+    });
 
     this.emit({ type: 'feed:completed' });