@quantform/core 0.5.15 → 0.5.23

package/src/storage/feed.ts

@@ -1,6 +1,9 @@
-import { Candle, InstrumentSelector } from '../domain';
-import { StoreEvent } from '../store';
-import { Storage, StorageQueryOptions } from './storage';
+import { InstrumentSelector } from '../domain';
+import { d } from '../shared';
+import { OrderbookPatchEvent, TradePatchEvent } from '../store';
+import { Storage, StorageDocument, StorageQueryOptions } from './storage';
+
+export type StorageEvent = TradePatchEvent | OrderbookPatchEvent;
 
 /**
  * Represents a storage supposed to store historical data.
@@ -18,25 +21,29 @@ export class Feed {
 
   /**
    *
-   * @param instrument
-   * @param candles
+   * @param events
    * @returns
    */
-  save(instrument: InstrumentSelector, candles: Candle[]): Promise<void> {
-    return this.storage.save(
-      instrument.toString(),
-      candles.map(it => ({
-        timestamp: it.timestamp,
-        kind: 'candle',
-        json: JSON.stringify({
-          o: it.open,
-          h: it.high,
-          l: it.low,
-          c: it.close,
-          v: it.volume
-        })
-      }))
-    );
+  async save(events: StorageEvent[]): Promise<void> {
+    const grouped = events.reduce((aggregate, it) => {
+      const document = this.serializeEvent(it);
+
+      if (!document) {
+        return aggregate;
+      }
+
+      if (aggregate[it.instrument.id]) {
+        aggregate[it.instrument.id].push(document);
+      } else {
+        aggregate[it.instrument.id] = [document];
+      }
+
+      return aggregate;
+    }, {} as Record<string, StorageDocument[]>);
+
+    for (const instrument in grouped) {
+      await this.storage.save(instrument, grouped[instrument]);
+    }
   }
 
   /**
@@ -48,20 +55,68 @@ export class Feed {
   async query(
     instrument: InstrumentSelector,
     options: StorageQueryOptions
-  ): Promise<Candle[]> {
-    const rows = await this.storage.query(instrument.id, options);
-
-    return rows.map(it => {
-      const payload = JSON.parse(it.json);
-
-      return new Candle(
-        it.timestamp,
-        payload.o,
-        payload.h,
-        payload.l,
-        payload.c,
-        payload.v
+  ): Promise<StorageEvent[]> {
+    const documents = await this.storage.query(instrument.id, options);
+
+    return documents.map(it => this.deserializeEvent(it, instrument));
+  }
+
+  /**
+   * Converts a StorageEvent to a persisted StorageDocument.
+   */
+  protected serializeEvent(event: StorageEvent): StorageDocument | undefined {
+    if (event instanceof OrderbookPatchEvent) {
+      return {
+        timestamp: event.timestamp,
+        kind: 'orderbook',
+        json: JSON.stringify({
+          ar: event.ask.rate.toString(),
+          ab: event.ask.quantity.toString(),
+          br: event.bid.rate.toString(),
+          bb: event.bid.quantity.toString()
+        })
+      };
+    }
+
+    if (event instanceof TradePatchEvent) {
+      return {
+        timestamp: event.timestamp,
+        kind: 'trade',
+        json: JSON.stringify({
+          r: event.rate.toString(),
+          q: event.quantity.toString()
+        })
+      };
+    }
+
+    return undefined;
+  }
+
+  /**
+   * Converts a persisted StorageDocument to a StorageEvent.
+   */
+  protected deserializeEvent(
+    document: StorageDocument,
+    instrument: InstrumentSelector
+  ): StorageEvent {
+    const payload = JSON.parse(document.json);
+
+    if (document.kind === 'trade') {
+      return new TradePatchEvent(
+        instrument,
+        d(payload.r),
+        d(payload.q),
+        document.timestamp
+      );
+    }
+
+    if (document.kind === 'orderbook') {
+      return new OrderbookPatchEvent(
+        instrument,
+        { rate: d(payload.ar), quantity: d(payload.aq), next: undefined },
+        { rate: d(payload.bb), quantity: d(payload.bq), next: undefined },
+        document.timestamp
       );
-    });
+    }
   }
 }

package/src/store/store-balance.event.spec.ts

@@ -1,5 +1,5 @@
 import { Asset, Commission } from '../domain';
-import { now } from '../shared';
+import { d, now } from '../shared';
 import { Store } from '.';
 import { BalancePatchEvent } from './store-balance.event';
 import { InstrumentPatchEvent } from './store-instrument.event';
@@ -15,15 +15,15 @@ describe('BalancePatchEvent', () => {
     store.changes$.subscribe(it => (component = it));
 
     store.dispatch(
-      new InstrumentPatchEvent(timestamp, base, quote, new Commission(0, 0), '')
+      new InstrumentPatchEvent(timestamp, base, quote, new Commission(d.Zero, d.Zero), '')
     );
-    store.dispatch(new BalancePatchEvent(base, 100, 0, timestamp));
+    store.dispatch(new BalancePatchEvent(base, d(100), d.Zero, timestamp));
 
     const balance = store.snapshot.balance.get(base.id);
 
     expect(balance).toEqual(component);
-    expect(balance.free).toEqual(100);
-    expect(balance.locked).toEqual(0);
+    expect(balance.free).toEqual(d(100));
+    expect(balance.locked).toEqual(d.Zero);
     expect(balance.timestamp).toEqual(timestamp);
     expect(store.snapshot.timestamp).toEqual(timestamp);
   });

package/src/store/store-balance.event.ts

@@ -1,5 +1,5 @@
 import { AssetSelector, Balance, InstrumentSelector } from '../domain';
-import { timestamp } from '../shared';
+import { decimal, timestamp } from '../shared';
 import { StoreEvent } from './store.event';
 import { State, StateChangeTracker } from './store-state';
 
@@ -9,8 +9,8 @@ import { State, StateChangeTracker } from './store-state';
 export class BalancePatchEvent implements StoreEvent {
   constructor(
     readonly asset: AssetSelector,
-    readonly free: number,
-    readonly freezed: number,
+    readonly free: decimal,
+    readonly freezed: decimal,
     readonly timestamp: timestamp
   ) {}
 
@@ -37,7 +37,7 @@ export class BalancePatchEvent implements StoreEvent {
 export class BalanceTransactEvent implements StoreEvent {
   constructor(
     readonly asset: AssetSelector,
-    readonly amount: number,
+    readonly amount: decimal,
     readonly timestamp: timestamp
   ) {}
 
@@ -76,14 +76,14 @@ export class BalanceLockOrderEvent implements StoreEvent {
 
     state.timestamp = this.timestamp;
 
-    if (balanceToLock.base > 0) {
+    if (balanceToLock.base.greaterThan(0)) {
       base.timestamp = this.timestamp;
       base.lock(this.orderId, balanceToLock.base);
 
       changes.commit(base);
     }
 
-    if (balanceToLock.quote > 0) {
+    if (balanceToLock.quote.greaterThan(0)) {
       quote.timestamp = this.timestamp;
       quote.lock(this.orderId, balanceToLock.quote);
 

package/src/store/store-instrument.event.spec.ts

@@ -1,6 +1,6 @@
 import { Store } from '..';
 import { Asset, Commission } from '../domain';
-import { now } from '../shared';
+import { d, now } from '../shared';
 import { InstrumentPatchEvent } from './store-instrument.event';
 
 describe('InstrumentPatchEvent', () => {
@@ -11,7 +11,7 @@ describe('InstrumentPatchEvent', () => {
     const quote = new Asset('usd', 'cex', 2);
 
     store.dispatch(
-      new InstrumentPatchEvent(timestamp, base, quote, new Commission(0, 0), '')
+      new InstrumentPatchEvent(timestamp, base, quote, new Commission(d.Zero, d.Zero), '')
     );
 
     const { universe } = store.snapshot;

package/src/store/store-instrument.event.ts

@@ -1,8 +1,8 @@
-import { Asset, Commission, InstrumentSelector, Instrument } from '../domain';
+import { Asset, Commission, Instrument, InstrumentSelector } from '../domain';
 import { timestamp } from '../shared';
 import { State, StateChangeTracker } from '../store';
-import { InnerSet } from './store-state';
 import { StoreEvent } from './store.event';
+import { InnerSet } from './store-state';
 
 export class InstrumentPatchEvent implements StoreEvent {
   constructor(

package/src/store/store-order.event.spec.ts

@@ -1,5 +1,5 @@
 import { Asset, Instrument, Order } from '../domain';
-import { now } from '../shared';
+import { d, now } from '../shared';
 import { Store } from '../store';
 import { OrderLoadEvent } from './store-order.event';
 
@@ -13,7 +13,7 @@ describe('OrderLoadEvent', () => {
   test('should load order to store', () => {
     const timestamp = now();
     const store = new Store();
-    const order = Order.market(instrument, 1.0);
+    const order = Order.market(instrument, d(1.0));
 
     order.state = 'PENDING';
 

package/src/store/store-order.event.ts

@@ -1,5 +1,5 @@
 import { InstrumentSelector, Order } from '../domain';
-import { timestamp } from '../shared';
+import { decimal, timestamp } from '../shared';
 import { StoreEvent } from './store.event';
 import { InnerSet, State, StateChangeTracker } from './store-state';
 
@@ -71,7 +71,7 @@ export class OrderFilledEvent implements StoreEvent {
   constructor(
     readonly id: string,
     readonly instrument: InstrumentSelector,
-    readonly averageExecutionRate: number,
+    readonly averageExecutionRate: decimal,
     readonly timestamp: timestamp
   ) {}
 

package/src/store/store-orderbook.event.spec.ts

@@ -0,0 +1,37 @@
+import { Store } from '..';
+import { Asset, Instrument, Liquidity } from '../domain';
+import { d, now } from '../shared';
+import { OrderbookPatchEvent } from '.';
+
+const instrument = new Instrument(
+  new Asset('btc', 'binance', 8),
+  new Asset('usdt', 'binance', 2),
+  'binance:btc-usdt'
+);
+
+describe('OrderbookPatchEvent', () => {
+  let store: Store;
+
+  beforeEach(() => {
+    store = new Store();
+    store.snapshot.universe.instrument.upsert(instrument);
+    store.snapshot.subscription.instrument.upsert(instrument);
+  });
+
+  test('should set a best bid and ask', () => {
+    const timestamp = now();
+
+    const ask: Liquidity = { rate: d(2), quantity: d(2), next: undefined };
+    const bid: Liquidity = { rate: d(1), quantity: d(1), next: undefined };
+
+    store.dispatch(new OrderbookPatchEvent(instrument, ask, bid, timestamp));
+
+    const orderbook = store.snapshot.orderbook.get(instrument.id);
+
+    expect(orderbook.timestamp).toEqual(timestamp);
+    expect(orderbook.instrument.id).toEqual(orderbook.instrument.id);
+    expect(orderbook.asks).toEqual(ask);
+    expect(orderbook.bids).toEqual(bid);
+    expect(store.snapshot.timestamp).toEqual(timestamp);
+  });
+});

package/src/store/store-orderbook.event.ts

@@ -1,4 +1,4 @@
-import { InstrumentSelector, Orderbook } from '../domain';
+import { InstrumentSelector, Liquidity, Orderbook } from '../domain';
 import { timestamp } from '../shared';
 import { StoreEvent } from './store.event';
 import { State, StateChangeTracker } from './store-state';
@@ -6,10 +6,8 @@ import { State, StateChangeTracker } from './store-state';
 export class OrderbookPatchEvent implements StoreEvent {
   constructor(
     readonly instrument: InstrumentSelector,
-    readonly bestAskRate: number,
-    readonly bestAskQuantity: number,
-    readonly bestBidRate: number,
-    readonly bestBidQuantity: number,
+    readonly ask: Liquidity,
+    readonly bid: Liquidity,
     readonly timestamp: timestamp
   ) {}
 
@@ -26,10 +24,8 @@ export class OrderbookPatchEvent implements StoreEvent {
     state.timestamp = this.timestamp;
 
     orderbook.timestamp = this.timestamp;
-    orderbook.bestAskRate = orderbook.instrument.quote.fixed(this.bestAskRate);
-    orderbook.bestAskQuantity = orderbook.instrument.base.fixed(this.bestAskQuantity);
-    orderbook.bestBidRate = orderbook.instrument.quote.fixed(this.bestBidRate);
-    orderbook.bestBidQuantity = orderbook.instrument.base.fixed(this.bestBidQuantity);
+    orderbook.asks = this.ask;
+    orderbook.bids = this.bid;
 
     const quote = state.balance.get(orderbook.instrument.quote.id);
 
@@ -39,13 +35,17 @@ export class OrderbookPatchEvent implements StoreEvent {
           continue;
         }
 
-        const rate = position.size >= 0 ? orderbook.bestBidRate : orderbook.bestAskRate;
+        const rate = position.size.greaterThanOrEqualTo(0)
+          ? orderbook.bids.rate
+          : orderbook.asks.rate;
 
-        position.calculateEstimatedUnrealizedPnL(rate);
+        if (rate) {
+          position.calculateEstimatedUnrealizedPnL(rate);
+        }
       }
 
-      if (quote.total < 0) {
-        throw new Error('liquidated');
+      if (quote.total.lessThan(0)) {
+        throw new Error('You have been liquidated.');
       }
     }
 

package/src/store/store-position.event.ts

@@ -1,5 +1,5 @@
 import { Instrument, Position, PositionMode } from '../domain';
-import { timestamp } from '../shared';
+import { decimal, timestamp } from '../shared';
 import { StoreEvent } from './store.event';
 import { State, StateChangeTracker } from './store-state';
 
@@ -21,10 +21,13 @@ export class PositionLoadEvent implements StoreEvent {
     balance.position[this.position.id] = this.position;
 
     if (orderbook) {
-      const rate =
-        this.position.size >= 0 ? orderbook.bestBidRate : orderbook.bestAskRate;
+      const rate = this.position.size.greaterThanOrEqualTo(0)
+        ? orderbook.bids.rate
+        : orderbook.asks.rate;
 
-      this.position.calculateEstimatedUnrealizedPnL(rate);
+      if (rate) {
+        this.position.calculateEstimatedUnrealizedPnL(rate);
+      }
     }
   }
 }
@@ -33,13 +36,14 @@ export class PositionPatchEvent implements StoreEvent {
   constructor(
     readonly id: string,
     readonly instrument: Instrument,
-    readonly rate: number,
-    readonly size: number,
+    readonly rate: decimal,
+    readonly size: decimal,
     readonly leverage: number,
     readonly mode: PositionMode,
     readonly timestamp: timestamp
   ) {}
 
+  // eslint-disable-next-line complexity
   handle(state: State, changes: StateChangeTracker): void {
     if (!state.subscription.instrument.get(this.instrument.id)) {
       throw new Error(`Trying to patch unsubscribed instrument: ${this.instrument.id}`);
@@ -50,18 +54,22 @@ export class PositionPatchEvent implements StoreEvent {
 
     let position = balance.position[this.id];
 
-    if (this.size == 0) {
+    if (this.size.equals(0)) {
       if (position) {
-        position.averageExecutionRate = this.instrument.quote.fixed(this.rate);
-        position.size = this.instrument.base.fixed(this.size);
+        position.averageExecutionRate = this.instrument.quote.floor(this.rate);
+        position.size = this.instrument.base.floor(this.size);
         position.leverage = this.leverage;
 
         delete balance.position[this.id];
 
         if (orderbook) {
-          const rate = position.size >= 0 ? orderbook.bestBidRate : orderbook.bestAskRate;
+          const rate = position.size.greaterThanOrEqualTo(0)
+            ? orderbook.bids.rate
+            : orderbook.asks.rate;
 
-          position.calculateEstimatedUnrealizedPnL(rate);
+          if (rate) {
+            position.calculateEstimatedUnrealizedPnL(rate);
+          }
         }
 
         changes.commit(position);
@@ -69,9 +77,9 @@ export class PositionPatchEvent implements StoreEvent {
       }
     }
 
-    const size = (position.size = this.instrument.base.fixed(this.size));
+    const size = (position.size = this.instrument.base.floor(this.size));
     const averageExecutionRate = (position.averageExecutionRate =
-      this.instrument.quote.fixed(this.rate));
+      this.instrument.quote.floor(this.rate));
 
     if (!position) {
       position = new Position(
@@ -91,9 +99,13 @@ export class PositionPatchEvent implements StoreEvent {
     }
 
     if (orderbook) {
-      const rate = position.size >= 0 ? orderbook.bestBidRate : orderbook.bestAskRate;
+      const rate = position.size.greaterThanOrEqualTo(0)
+        ? orderbook.bids.rate
+        : orderbook.asks.rate;
 
-      position.calculateEstimatedUnrealizedPnL(rate);
+      if (rate) {
+        position.calculateEstimatedUnrealizedPnL(rate);
+      }
     }
 
     changes.commit(position);

package/src/store/store-trade.event.spec.ts

@@ -1,6 +1,6 @@
 import { Store } from '..';
 import { Asset, Instrument } from '../domain';
-import { now } from '../shared';
+import { d, now } from '../shared';
 import { TradePatchEvent } from '.';
 
 const instrument = new Instrument(
@@ -17,14 +17,14 @@ describe('TradePatchEvent', () => {
     store.snapshot.universe.instrument.upsert(instrument);
     store.snapshot.subscription.instrument.upsert(instrument);
 
-    store.dispatch(new TradePatchEvent(instrument, 1000, 0.1, timestamp));
+    store.dispatch(new TradePatchEvent(instrument, d(1000), d(0.1), timestamp));
 
     const trade = store.snapshot.trade.get(instrument.id);
 
     expect(trade.timestamp).toEqual(timestamp);
     expect(trade.instrument.id).toEqual(trade.instrument.id);
-    expect(trade.rate).toEqual(1000);
-    expect(trade.quantity).toEqual(0.1);
+    expect(trade.rate).toEqual(d(1000));
+    expect(trade.quantity).toEqual(d(0.1));
     expect(store.snapshot.timestamp).toEqual(timestamp);
   });
 
@@ -35,16 +35,16 @@ describe('TradePatchEvent', () => {
     store.snapshot.universe.instrument.upsert(instrument);
     store.snapshot.subscription.instrument.upsert(instrument);
 
-    store.dispatch(new TradePatchEvent(instrument, 1000, 0.1, timestamp));
+    store.dispatch(new TradePatchEvent(instrument, d(1000), d(0.1), timestamp));
 
     const trade = store.snapshot.trade.get(instrument.id);
 
-    store.dispatch(new TradePatchEvent(instrument, 2000, 0.2, timestamp));
+    store.dispatch(new TradePatchEvent(instrument, d(2000), d(0.2), timestamp));
 
     expect(trade.timestamp).toEqual(timestamp);
     expect(trade.instrument.id).toEqual(instrument.id);
-    expect(trade.rate).toEqual(2000);
-    expect(trade.quantity).toEqual(0.2);
+    expect(trade.rate).toEqual(d(2000));
+    expect(trade.quantity).toEqual(d(0.2));
     expect(store.snapshot.timestamp).toEqual(timestamp);
   });
 
@@ -52,7 +52,7 @@ describe('TradePatchEvent', () => {
     const store = new Store();
 
     const fn = () => {
-      store.dispatch(new TradePatchEvent(instrument, 1000, 0.1, now()));
+      store.dispatch(new TradePatchEvent(instrument, d(1000), d(0.1), now()));
     };
 
     expect(fn).toThrow(Error);

package/src/store/store-trade.event.ts

@@ -1,5 +1,5 @@
 import { InstrumentSelector, Trade } from '../domain';
-import { timestamp } from '../shared';
+import { decimal, timestamp } from '../shared';
 import { StoreEvent } from './store.event';
 import { State, StateChangeTracker } from './store-state';
 
@@ -10,8 +10,8 @@ import { State, StateChangeTracker } from './store-state';
 export class TradePatchEvent implements StoreEvent {
   constructor(
     readonly instrument: InstrumentSelector,
-    readonly rate: number,
-    readonly quantity: number,
+    readonly rate: decimal,
+    readonly quantity: decimal,
     readonly timestamp: timestamp
   ) {}
 
@@ -28,8 +28,8 @@ export class TradePatchEvent implements StoreEvent {
     state.timestamp = this.timestamp;
 
     trade.timestamp = this.timestamp;
-    trade.rate = trade.instrument.quote.fixed(this.rate);
-    trade.quantity = trade.instrument.base.fixed(this.quantity);
+    trade.rate = trade.instrument.quote.floor(this.rate);
+    trade.quantity = trade.instrument.base.floor(this.quantity);
 
     changes.commit(trade);
   }

package/src/store/store.spec.ts

@@ -1,7 +1,7 @@
 import { withLatestFrom } from 'rxjs';
 
 import { Asset, balance, Instrument, Order, order } from '../domain';
-import { now } from '../shared';
+import { d, now } from '../shared';
 import { Store } from './store';
 import { BalanceTransactEvent } from './store-balance.event';
 import {
@@ -35,7 +35,7 @@ describe('Store', () => {
       }
     });
 
-    store.dispatch(new OrderLoadEvent(Order.market(instrument, 10), now()));
+    store.dispatch(new OrderLoadEvent(Order.market(instrument, d(10)), now()));
 
     expect(hasUpdatedOrder).toBe(false);
   });
@@ -49,7 +49,7 @@ describe('Store', () => {
       }
     });
 
-    store.dispatch(new OrderNewEvent(Order.market(instrument, 10), now()));
+    store.dispatch(new OrderNewEvent(Order.market(instrument, d(10)), now()));
 
     expect(hasUpdatedOrder).toBe(true);
   });
@@ -63,7 +63,7 @@ describe('Store', () => {
       }
     });
 
-    const buyOrder = Order.market(instrument, 10);
+    const buyOrder = Order.market(instrument, d(10));
 
     store.dispatch(new OrderNewEvent(buyOrder, now()));
     store.dispatch(new OrderPendingEvent(buyOrder.id, instrument, now()));
@@ -81,14 +81,14 @@ describe('Store', () => {
       }
     });
 
-    const buyOrder = Order.market(instrument, 10);
+    const buyOrder = Order.market(instrument, d(10));
 
     store.dispatch(new OrderNewEvent(buyOrder, now()));
     store.dispatch(new OrderPendingEvent(buyOrder.id, instrument, now()));
-    store.dispatch(new OrderFilledEvent(buyOrder.id, instrument, 44, now()));
+    store.dispatch(new OrderFilledEvent(buyOrder.id, instrument, d(44), now()));
 
     expect(buyOrder.state).toBe('FILLED');
-    expect(buyOrder.averageExecutionRate).toBe(44);
+    expect(buyOrder.averageExecutionRate).toEqual(d(44));
     expect(states.length).toBe(0);
   });
 
@@ -101,7 +101,7 @@ describe('Store', () => {
       }
     });
 
-    const buyOrder = Order.market(instrument, 10);
+    const buyOrder = Order.market(instrument, d(10));
 
     store.dispatch(new OrderNewEvent(buyOrder, now()));
     store.dispatch(new OrderPendingEvent(buyOrder.id, instrument, now()));
@@ -123,19 +123,19 @@ describe('Store', () => {
       )
       .subscribe({
         next: ([balance, order]) => {
-          expect(balance.free).toBe(10);
-          expect(order.state).toBe('PENDING');
+          expect(balance.free).toEqual(d(10));
+          expect(order.state).toEqual('PENDING');
 
           done();
         }
       });
 
-    const buyOrder = Order.market(instrument, 10);
+    const buyOrder = Order.market(instrument, d(10));
 
     store.dispatch(
       new OrderNewEvent(buyOrder, now()),
       new OrderPendingEvent(buyOrder.id, instrument, now()),
-      new BalanceTransactEvent(instrument.quote, 10, now())
+      new BalanceTransactEvent(instrument.quote, d(10), now())
     );
   });
 
@@ -149,7 +149,7 @@ describe('Store', () => {
       next: it => {
         counter--;
 
-        expect(it.free).toBe(10);
+        expect(it.free).toEqual(d(10));
 
         if (!counter) {
           done();
@@ -161,7 +161,7 @@ describe('Store', () => {
       next: it => {
         counter--;
 
-        expect(it.state).toBe('PENDING');
+        expect(it.state).toEqual('PENDING');
 
         if (!counter) {
           done();
@@ -169,12 +169,12 @@ describe('Store', () => {
       }
     });
 
-    const buyOrder = Order.market(instrument, 10);
+    const buyOrder = Order.market(instrument, d(10));
 
     store.dispatch(
       new OrderNewEvent(buyOrder, now()),
       new OrderPendingEvent(buyOrder.id, instrument, now()),
-      new BalanceTransactEvent(instrument.quote, 10, now())
+      new BalanceTransactEvent(instrument.quote, d(10), now())
     );
   });
 });

package/dist/indicator/truerange.d.ts

@@ -1,3 +0,0 @@
-import { Observable } from 'rxjs';
-import { Candle } from '../domain';
-export declare function truerange<T>(fn: (it: T) => Candle): (source: Observable<T>) => Observable<[T, number]>;