@quantform/core 0.3.230 → 0.3.234

package/src/adapter/adapter-aggregate.ts

@@ -7,6 +7,10 @@ import {
   AdapterDisposeCommand
 } from './adapter.event';
 
+/**
+ * Manages instances of all adapters provided in session descriptor.
+ * Awakes and disposes adapters, routes and executes commands.
+ */
 export class AdapterAggregate {
   private readonly adapter: Record<string, Adapter> = {};
 
@@ -14,6 +18,10 @@ export class AdapterAggregate {
     adapters.forEach(it => (this.adapter[it.name] = it));
   }
 
+  /**
+   * Sets up all adapters.
+   * @param usePrivateScope use private api (api keys needed).
+   */
   async awake(usePrivateScope = true): Promise<void> {
     for (const exchange in this.adapter) {
       await this.dispatch(exchange, new AdapterAwakeCommand());
@@ -24,21 +32,30 @@ export class AdapterAggregate {
     }
   }
 
+  /**
+   * Disposes all adapters.
+   */
   async dispose(): Promise<any> {
     for (const exchange in this.adapter) {
       await this.dispatch(exchange, new AdapterDisposeCommand());
     }
   }
 
+  /**
+   * Routes and executes command to a specific adapter.
+   * @param adapterName name of adapter
+   * @param event
+   * @returns
+   */
   dispatch<TEvent extends { type: string }, TResponse>(
-    exchange: string,
+    adapterName: string,
     event: TEvent
   ): Promise<TResponse> {
-    const adapter = this.adapter[exchange];
+    const adapter = this.adapter[adapterName];
 
     if (!adapter) {
       throw new Error(
-        `Unknown adapter: ${exchange}. You should provide adapter in session descriptor.`
+        `Unknown adapter: ${adapterName}. You should provide adapter in session descriptor.`
       );
     }
 

package/src/adapter/adapter.event.ts

@@ -52,7 +52,7 @@ export class AdapterHistoryQuery {
 
 @event
 export class AdapterFeedCommand {
-  type = 'import';
+  type = 'feed';
 
   constructor(
     readonly instrument: InstrumentSelector,

package/src/adapter/adapter.ts

@@ -4,7 +4,13 @@ import { PaperAdapter } from './paper';
 import { Topic } from '../shared/topic';
 import { Store } from '../store';
 
+/**
+ * Shared context for adapter execution. Provides access to the store.
+ */
 export class AdapterContext {
+  /**
+   * Returns the current unix timestamp (points to historical date in case of backtest).
+   */
   get timestamp(): timestamp {
     return this.adapter.timestamp();
   }
@@ -12,6 +18,10 @@ export class AdapterContext {
   constructor(private readonly adapter: Adapter, readonly store: Store) {}
 }
 
+/**
+ * Base adapter class, you should derive your own adapter from this class.
+ * @abstract
+ */
 export abstract class Adapter extends Topic<{ type: string }, AdapterContext> {
   abstract name: string;
   abstract createPaperExecutor(adapter: PaperAdapter): PaperExecutor;

package/src/bin.ts

@@ -3,199 +3,17 @@ import {
   BacktesterOptions,
   BacktesterStreamer
 } from './adapter/backtester';
-import { AdapterAggregate, AdapterFeedCommand } from './adapter';
+import { AdapterAggregate } from './adapter';
 import { PaperAdapter, PaperOptions } from './adapter/paper';
 import { Session, SessionDescriptor } from './session';
 import { Store } from './store';
-import { instrumentOf } from './domain';
-import { Topic, event, handler } from './shared/topic';
-import minimist = require('minimist');
-import { Logger } from './shared';
-
-export interface IpcCommand {
-  type;
-}
-
-@event
-export class IpcPaperModeCommand implements IpcCommand {
-  type = 'paper';
-  id?: number;
-  balance: { [key: string]: number };
-}
-
-@event
-export class IpcBacktestModeCommand implements IpcCommand {
-  type = 'backtest';
-  from: number;
-  to: number;
-  balance: { [key: string]: number };
-}
-
-@event
-export class IpcLiveModeCommand implements IpcCommand {
-  id?: number;
-  type = 'live';
-}
-
-@event
-export class IpcUniverseQuery implements IpcCommand {
-  type = 'universe';
-  exchange: string;
-}
-
-@event
-export class IpcFeedCommand implements IpcCommand {
-  type = 'feed';
-  instrument: string;
-  from: number;
-  to: number;
-}
-
-class ExecutionAccessor {
-  session: Session;
-}
-
-class ExecutionHandler extends Topic<{ type: string }, ExecutionAccessor> {
-  constructor(private readonly descriptor: SessionDescriptor) {
-    super();
-  }
-
-  @handler(IpcLiveModeCommand)
-  async onLiveMode(command: IpcLiveModeCommand, accessor: ExecutionAccessor) {
-    if (command.id) {
-      this.descriptor.id = command.id;
-    }
-
-    accessor.session = live(this.descriptor);
-
-    await accessor.session.awake();
-  }
-
-  @handler(IpcPaperModeCommand)
-  async onPaperMode(command: IpcPaperModeCommand, accessor: ExecutionAccessor) {
-    if (command.id) {
-      this.descriptor.id = command.id;
-    }
-
-    accessor.session = paper(this.descriptor, {
-      balance: command.balance
-    });
-
-    await accessor.session.awake();
-  }
-
-  @handler(IpcBacktestModeCommand)
-  onBacktestMode(command: IpcBacktestModeCommand, accessor: ExecutionAccessor) {
-    return new Promise<void>(async resolve => {
-      const [session, streamer] = backtest(this.descriptor, {
-        from: command.from,
-        to: command.to,
-        balance: command.balance,
-        progress: timestamp =>
-          this.notify({
-            type: 'backtest:updated',
-            timestamp,
-            from: command.from,
-            to: command.to
-          }),
-        completed: async () => {
-          const statement = {};
-
-          await accessor.session.dispose();
-
-          this.notify({ type: 'backtest:completed', statement });
-
-          resolve();
-        }
-      });
-
-      accessor.session = session;
-
-      this.notify({ type: 'backtest:started' });
-
-      await accessor.session.awake();
-      await streamer.tryContinue().catch(it => Logger.error(it));
-    });
-  }
-
-  @handler(IpcUniverseQuery)
-  onUniverse(query: IpcUniverseQuery, accessor: ExecutionAccessor) {
-    accessor.session = accessor.session ?? idle(this.descriptor);
-  }
-
-  @handler(IpcFeedCommand)
-  async onFeed(command: IpcFeedCommand, accessor: ExecutionAccessor) {
-    accessor.session = accessor.session ?? idle(this.descriptor);
-    const instrument = instrumentOf(command.instrument);
-
-    await accessor.session.awake();
-
-    this.notify({ type: 'feed:started' });
-
-    await accessor.session.aggregate.dispatch(
-      instrument.base.exchange,
-      new AdapterFeedCommand(
-        instrument,
-        command.from,
-        command.to,
-        this.descriptor.feed,
-        timestamp =>
-          this.notify({
-            type: 'feed:updated',
-            timestamp,
-            from: command.from,
-            to: command.to
-          })
-      )
-    );
-
-    this.notify({ type: 'feed:completed' });
-
-    await accessor.session.dispose();
-  }
-
-  private notify(message: any) {
-    if (!process.send) {
-      return;
-    }
-
-    process.send(message);
-  }
-}
-
-export async function run(
-  descriptor: SessionDescriptor,
-  ...commands: IpcCommand[]
-): Promise<Session> {
-  const handler = new ExecutionHandler(descriptor);
-  const accessor = new ExecutionAccessor();
-  const argv = minimist(process.argv.slice(2));
-
-  if (argv.command) {
-    const json = Buffer.from(argv.command, 'base64').toString('utf-8');
-
-    commands.push(JSON.parse(json));
-  } else {
-    if (!commands.length) {
-      commands.push(new IpcPaperModeCommand());
-    }
-  }
-
-  for (const command of commands) {
-    await handler.dispatch(command, accessor);
-  }
-
-  process.on('message', async (request: any) => {
-    const response = await handler.dispatch(request, accessor);
-
-    if (response) {
-      process.send(response);
-    }
-  });
-
-  return accessor.session;
-}
 
+/**
+ * Starts a new backtest session.
+ * @param descriptor session descriptor.
+ * @param options backtest options.
+ * @returns new session object.
+ */
 export function backtest(
   descriptor: SessionDescriptor,
   options: BacktesterOptions
@@ -213,6 +31,12 @@ export function backtest(
   return [new Session(store, aggregate, descriptor), streamer];
 }
 
+/**
+ * Starts a new paper session.
+ * @param descriptor session descriptor.
+ * @param options backtest options.
+ * @returns new session object.
+ */
 export function paper(descriptor: SessionDescriptor, options: PaperOptions): Session {
   const store = new Store();
 
@@ -224,6 +48,11 @@ export function paper(descriptor: SessionDescriptor, options: PaperOptions): Ses
   return new Session(store, aggregate, descriptor);
 }
 
+/**
+ * Starts a new live session.
+ * @param descriptor session descriptor.
+ * @returns new session object.
+ */
 export function live(descriptor: SessionDescriptor): Session {
   const store = new Store();
   const aggregate = new AdapterAggregate(store, descriptor.adapter);
@@ -231,6 +60,10 @@ export function live(descriptor: SessionDescriptor): Session {
   return new Session(store, aggregate, descriptor);
 }
 
+/**
+ * Starts a new idle session.
+ * @param descriptor session descriptor.
+ */
 export function idle(descriptor: SessionDescriptor): Session {
   const store = new Store();
   const aggregate = new AdapterAggregate(store, descriptor.adapter);

package/src/domain/asset.ts

@@ -58,21 +58,21 @@ export class Asset extends AssetSelector {
   }
 
   /**
-   * Trims a number to the specified precision.
+   * Trims a number to the asset precision.
    */
   fixed(number: number): number {
     return fixed(number, this.scale);
   }
 
   /**
-   * Rounds down a number to the specified precision.
+   * Rounds down a number to the asset precision.
    */
   floor(number: number): number {
     return floor(number, this.scale);
   }
 
   /**
-   * Rounds up a number to the specified precision.
+   * Rounds up a number to the asset precision.
    */
   ceil(number: number): number {
     return ceil(number, this.scale);

package/src/domain/instrument.ts

@@ -21,6 +21,9 @@ export class InstrumentSelector {
   }
 }
 
+/**
+ * Represents trading market which is made up by two trading assets (base and quoted).
+ */
 export class Instrument extends InstrumentSelector implements Component {
   timestamp: timestamp;
   commission: Commission;

package/src/domain/orderbook.ts

@@ -2,13 +2,16 @@ import { timestamp } from '../shared';
 import { Instrument } from '../domain';
 import { Component } from './component';
 
+/**
+ * Provides an access to pending buy and sell orders on the specific market.
+ */
 export class Orderbook implements Component {
   timestamp: timestamp;
   bestAskRate: number;
   bestAskQuantity: number;
   bestBidRate: number;
   bestBidQuantity: number;
-
+  az;
   get midRate(): number {
     return this.instrument.quote.fixed((this.bestAskRate + this.bestBidRate) / 2);
   }

package/src/domain/trade.ts

@@ -2,6 +2,10 @@ import { timestamp } from '../shared';
 import { Instrument } from '.';
 import { Component } from './component';
 
+/**
+ * Simple trade or ticker executed on the market, it's a match of buyer
+ * and seller of the same asset.
+ */
 export class Trade implements Component {
   timestamp: timestamp;
   rate: number;

package/src/index.ts

@@ -9,3 +9,4 @@ export * from './storage';
 export * from './store';
 export * from './store/event';
 export * from './bin';
+export * from './ipc';

package/src/ipc.spec.ts

@@ -0,0 +1,56 @@
+import { Session } from './session';
+import {
+  Adapter,
+  AdapterFeedCommand,
+  AdapterAwakeCommand,
+  AdapterAccountCommand
+} from './adapter';
+import { PaperAdapter, PaperSpotExecutor } from './adapter/paper';
+import { PaperExecutor } from './adapter/paper/executor/paper-executor';
+import { IpcFeedCommand, run } from './ipc';
+import { Feed, InMemoryStorage } from './storage';
+import { instrumentOf } from './domain';
+import { handler } from './shared';
+
+class DefaultAdapter extends Adapter {
+  name = 'default';
+
+  timestamp() {
+    return 123;
+  }
+
+  createPaperExecutor(adapter: PaperAdapter): PaperExecutor {
+    return new PaperSpotExecutor(adapter);
+  }
+
+  @handler(AdapterAwakeCommand)
+  onAwake(command: AdapterAwakeCommand) {}
+
+  @handler(AdapterAccountCommand)
+  onAccount(command: AdapterAccountCommand) {}
+
+  @handler(AdapterFeedCommand)
+  onFeed(command: AdapterFeedCommand) {}
+}
+
+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()),
+        describe: (session: Session) => session.trade(instrumentOf('default:btc-usdt'))
+      },
+      command
+    );
+
+    expect(session.descriptor).toBeUndefined();
+  });
+});