hft-js 0.1.0 → 0.1.2

package/src/interfaces.ts

@@ -10,6 +10,7 @@
  */
 
 import {
+  BarData,
   CommissionRate,
   InstrumentData,
   MarginRate,
@@ -20,6 +21,7 @@ import {
   PositionDetail,
   ProductType,
   SideType,
+  TapeData,
   TickData,
   TradeData,
   TradingAccount,
@@ -69,7 +71,6 @@ export interface ILifecycleListener extends IErrorReceiver {
 export interface IOrderReceiver {
   onEntrust: (order: OrderData) => void;
   onTrade: (order: OrderData, trade: TradeData) => void;
-  onFinish: (order: OrderData) => void;
   onCancel: (order: OrderData) => void;
   onReject: (order: OrderData) => void;
 }
@@ -79,7 +80,7 @@ export interface IOrdersReceiver {
 }
 
 export interface ITickReceiver {
-  onTick: (tick: TickData) => void;
+  onTick: (tick: TickData, tape: TapeData) => void;
 }
 
 export interface ITickSubscriber {
@@ -90,9 +91,21 @@ export interface ITickUnsubscriber {
   unsubscribe: (symbols: string[], receiver: ITickReceiver) => void;
 }
 
+export interface IBarReceiver {
+  onBar: (bar: BarData) => void;
+}
+
+export interface IBarSubscriber {
+  subscribeBar: (symbols: string[], receiver: IBarReceiver) => void;
+}
+
+export interface IBarUnsubscriber {
+  unsubscribeBar: (symbols: string[], receiver: IBarReceiver) => void;
+}
+
 export interface IStrategy extends IRiskManagerReceiver, IOrderReceiver {
-  onInit: (subscriber: ITickSubscriber) => void;
-  onDestroy: (unsubscriber: ITickUnsubscriber) => void;
+  onInit: () => void;
+  onDestroy: () => void;
 }
 
 export interface ICommissionRateReceiver {
@@ -208,7 +221,9 @@ export interface ITraderProvider extends IProvider, IOrderEmitter, IQueryApi {
 export interface IRuntimeEngine
   extends IQueryApi,
     ITickSubscriber,
-    ITickUnsubscriber {
+    ITickUnsubscriber,
+    IBarSubscriber,
+    IBarUnsubscriber {
   addStrategy: (strategy: IStrategy) => void;
   removeStrategy: (strategy: IStrategy) => void;
 
@@ -231,4 +246,38 @@ export interface IRuntimeEngine
     order: OrderData,
     receiver: ICancelOrderResultReceiver,
   ) => void;
+
+  buyOpen: (
+    strategy: IStrategy,
+    symbol: string,
+    volume: number,
+    price: number,
+    receiver: IPlaceOrderResultReceiver,
+  ) => void;
+
+  buyClose: (
+    strategy: IStrategy,
+    symbol: string,
+    volume: number,
+    price: number,
+    isToday: boolean,
+    receiver: IPlaceOrderResultReceiver,
+  ) => void;
+
+  sellOpen: (
+    strategy: IStrategy,
+    symbol: string,
+    volume: number,
+    price: number,
+    receiver: IPlaceOrderResultReceiver,
+  ) => void;
+
+  sellClose: (
+    strategy: IStrategy,
+    symbol: string,
+    volume: number,
+    price: number,
+    isToday: boolean,
+    receiver: IPlaceOrderResultReceiver,
+  ) => void;
 }

package/src/market.ts

@@ -12,6 +12,8 @@
 import ctp from "napi-ctp";
 import { CTPProvider, CTPUserInfo } from "./provider.js";
 import { InstrumentData, OrderBook, TickData } from "./typedef.js";
+import { calcTapeData } from "./tape.js";
+import { parseSymbol } from "./utils.js";
 import {
   ILifecycleListener,
   IMarketProvider,
@@ -27,8 +29,10 @@ export class Market extends CTPProvider implements IMarketProvider {
   private marketApi?: ctp.MarketData;
   private recorder?: IMarketRecorderReceiver;
   private recorderSymbols?: IMarketRecorderSymbols;
+  private tradingDay: number;
   private readonly recordings: Set<string>;
   private readonly symbols: Map<string, string>;
+  private readonly lastTicks: Map<string, TickData>;
   private readonly subscribers: Map<string, ITickReceiver[]>;
 
   constructor(
@@ -37,8 +41,10 @@ export class Market extends CTPProvider implements IMarketProvider {
     userInfo: CTPUserInfo,
   ) {
     super(flowMdPath, frontMdAddrs, userInfo);
+    this.tradingDay = 0;
     this.recordings = new Set();
     this.symbols = new Map();
+    this.lastTicks = new Map();
     this.subscribers = new Map();
   }
 
@@ -74,6 +80,13 @@ export class Market extends CTPProvider implements IMarketProvider {
           return;
         }
 
+        const tradingDay = parseInt(this.marketApi!.getTradingDay());
+
+        if (this.tradingDay !== tradingDay) {
+          this.lastTicks.clear();
+          this.tradingDay = tradingDay;
+        }
+
         const instrumentIds = new Set([
           ...Array.from(this.recordings),
           ...Object.keys(this.subscribers),
@@ -107,12 +120,6 @@ export class Market extends CTPProvider implements IMarketProvider {
           return;
         }
 
-        const receivers = this.subscribers.get(instrumentId);
-
-        if (!receivers || receivers.length === 0) {
-          return;
-        }
-
         const orderBook: OrderBook = {
           asks: { price: [], volume: [] },
           bids: { price: [], volume: [] },
@@ -225,7 +232,16 @@ export class Market extends CTPProvider implements IMarketProvider {
           orderBook: Object.freeze(orderBook),
         });
 
-        receivers.forEach((receiver) => receiver.onTick(tick));
+        const receivers = this.subscribers.get(instrumentId);
+
+        if (receivers && receivers.length > 0) {
+          const lastTick = this.lastTicks.get(instrumentId);
+          const tape = calcTapeData(tick, lastTick);
+
+          receivers.forEach((receiver) => receiver.onTick(tick, tape));
+        }
+
+        this.lastTicks.set(instrumentId, tick);
       },
     );
 
@@ -252,7 +268,7 @@ export class Market extends CTPProvider implements IMarketProvider {
     const instrumentIds = new Set<string>();
 
     symbols.forEach((symbol) => {
-      const [instrumentId] = this._parseSymbol(symbol);
+      const [instrumentId] = parseSymbol(symbol);
 
       if (this.recordings.has(instrumentId)) {
         return;
@@ -300,7 +316,7 @@ export class Market extends CTPProvider implements IMarketProvider {
     const instrumentIds = new Set<string>();
 
     symbols.forEach((symbol) => {
-      const [instrumentId] = this._parseSymbol(symbol);
+      const [instrumentId] = parseSymbol(symbol);
       const receivers = this.subscribers.get(instrumentId);
 
       if (receivers) {
@@ -328,7 +344,7 @@ export class Market extends CTPProvider implements IMarketProvider {
     const instrumentIds = new Set<string>();
 
     symbols.forEach((symbol) => {
-      const [instrumentId] = this._parseSymbol(symbol);
+      const [instrumentId] = parseSymbol(symbol);
       const receivers = this.subscribers.get(instrumentId);
 
       if (!receivers) {

package/src/provider.ts

@@ -59,11 +59,6 @@ export class CTPProvider {
     }
   }
 
-  protected _parseSymbol(symbol: string): [string, string] {
-    const [instrumentId, exchangeId] = symbol.split(".");
-    return [instrumentId, exchangeId];
-  }
-
   protected _isErrorResp(
     lifecycle: ILifecycleListener,
     options: ctp.CallbackOptions,

package/src/tape.ts

@@ -148,22 +148,23 @@ const calcTapeStatus = (
 };
 
 export const calcTapeData = (tick: TickData, preTick?: TickData): TapeData => {
-  const [volumeDelta, interestDelta] = preTick
-    ? [tick.volume - preTick.volume, tick.openInterest - preTick.openInterest]
-    : [tick.volume, tick.openInterest - tick.preOpenInterest];
+  const volumeDelta = preTick ? tick.volume - preTick.volume : tick.volume;
+  const amountDelta = preTick ? tick.amount - preTick.amount : tick.amount;
+
+  const interestDelta = preTick
+    ? tick.openInterest - preTick.openInterest
+    : tick.openInterest - tick.preOpenInterest;
 
   const tapeType = calcTapeType(volumeDelta, interestDelta);
   const tapeDirection = calcTapeDirection(tick, preTick);
   const tapeStatus = calcTapeStatus(tapeType, tapeDirection);
 
-  return {
-    symbol: tick.symbol,
-    date: tick.date,
-    time: tick.time,
-    volumeDelta: volumeDelta,
-    interestDelta: interestDelta,
+  return Object.freeze({
     type: tapeType,
     direction: tapeDirection,
     status: tapeStatus,
-  };
+    interestDelta: interestDelta,
+    volumeDelta: volumeDelta,
+    amountDelta: amountDelta,
+  });
 };

package/src/trader.ts

@@ -12,6 +12,7 @@
 import Denque from "denque";
 import ctp from "napi-ctp";
 import { CTPProvider, CTPUserInfo } from "./provider.js";
+import { parseSymbol } from "./utils.js";
 import {
   CommissionRate,
   InstrumentData,
@@ -63,10 +64,9 @@ export class Trader extends CTPProvider implements ITraderProvider {
   private accountsQueryTime: number;
   private positionDetailsChanged: boolean;
   private readonly receivers: IOrderReceiver[];
-  private readonly instruments: ctp.InstrumentField[];
   private readonly accounts: ctp.TradingAccountField[];
   private readonly positionDetails: ctp.InvestorPositionDetailField[];
-  private readonly symbols: Map<string, string>;
+  private readonly instruments: Map<string, ctp.InstrumentField>;
   private readonly positions: Map<string, PositionInfo>;
   private readonly orders: Map<string, ctp.OrderField>;
   private readonly trades: Map<string, ctp.TradeField[]>;
@@ -92,10 +92,9 @@ export class Trader extends CTPProvider implements ITraderProvider {
     this.accountsQueryTime = 0;
     this.positionDetailsChanged = true;
     this.receivers = [];
-    this.instruments = [];
     this.accounts = [];
     this.positionDetails = [];
-    this.symbols = new Map();
+    this.instruments = new Map();
     this.positions = new Map();
     this.orders = new Map();
     this.trades = new Map();
@@ -211,8 +210,7 @@ export class Trader extends CTPProvider implements ITraderProvider {
         }
 
         if (options.isLast) {
-          this.symbols.clear();
-          this.instruments.splice(0, this.instruments.length);
+          this.instruments.clear();
           this._withRetry(() => this.traderApi!.reqQryInstrument());
         }
       },
@@ -230,12 +228,7 @@ export class Trader extends CTPProvider implements ITraderProvider {
             instrument.ProductClass === ctp.ProductClassType.Futures ||
             instrument.ProductClass === ctp.ProductClassType.Options
           ) {
-            this.symbols.set(
-              instrument.InstrumentID,
-              `${instrument.InstrumentID}.${instrument.ExchangeID}`,
-            );
-
-            this.instruments.push(instrument);
+            this.instruments.set(instrument.InstrumentID, instrument);
           }
         }
 
@@ -259,7 +252,7 @@ export class Trader extends CTPProvider implements ITraderProvider {
         }
 
         if (position) {
-          const symbol = this.symbols.get(position.InstrumentID);
+          const symbol = this._toSymbol(position.InstrumentID);
 
           if (symbol) {
             let posInfo = this._ensurePositionInfo(symbol);
@@ -338,7 +331,7 @@ export class Trader extends CTPProvider implements ITraderProvider {
         case "submitted":
           {
             const orderData = this._toOrderData(order);
-            const symbol = this.symbols.get(order.InstrumentID);
+            const symbol = this._toSymbol(order.InstrumentID);
 
             if (symbol) {
               if (orderData.offset === "open") {
@@ -365,7 +358,7 @@ export class Trader extends CTPProvider implements ITraderProvider {
         case "canceled":
           {
             const orderData = this._toOrderData(order);
-            const symbol = this.symbols.get(order.InstrumentID);
+            const symbol = this._toSymbol(order.InstrumentID);
 
             if (symbol) {
               if (orderData.offset === "open") {
@@ -415,24 +408,20 @@ export class Trader extends CTPProvider implements ITraderProvider {
       if (order) {
         const orderData = this._toOrderData(order);
         const tradeData = this._toTradeData(trade);
-        const symbol = this.symbols.get(order.InstrumentID);
+        const symbol = this._toSymbol(order.InstrumentID);
 
         if (symbol) {
           this._calcPosition(
             symbol,
             orderData.side,
             orderData.offset,
-            orderData.volume,
+            tradeData.volume,
           );
         }
 
         this.receivers.forEach((receiver) =>
           receiver.onTrade(orderData, tradeData),
         );
-
-        if (orderData.status === "filled") {
-          this.receivers.forEach((receiver) => receiver.onFinish(orderData));
-        }
       }
     });
 
@@ -627,7 +616,7 @@ export class Trader extends CTPProvider implements ITraderProvider {
   }
 
   queryCommissionRate(symbol: string, receiver: ICommissionRateReceiver) {
-    const [instrumentId] = this._parseSymbol(symbol);
+    const [instrumentId] = parseSymbol(symbol);
     const commRate = this.commRates.get(instrumentId);
 
     if (commRate) {
@@ -648,7 +637,7 @@ export class Trader extends CTPProvider implements ITraderProvider {
   }
 
   queryMarginRate(symbol: string, receiver: IMarginRateReceiver) {
-    const [instrumentId] = this._parseSymbol(symbol);
+    const [instrumentId] = parseSymbol(symbol);
     const marginRate = this.marginRates.get(instrumentId);
 
     if (marginRate) {
@@ -670,16 +659,13 @@ export class Trader extends CTPProvider implements ITraderProvider {
   }
 
   queryInstrument(symbol: string, receiver: IInstrumentReceiver) {
-    const [instrumentId, exchangeId] = this._parseSymbol(symbol);
-
-    const instrument = this.instruments.find(
-      (instrument) =>
-        instrument.InstrumentID === instrumentId &&
-        instrument.ExchangeID === exchangeId,
-    );
+    const [instrumentId, exchangeId] = parseSymbol(symbol);
+    const instrument = this.instruments.get(instrumentId);
 
     receiver.onInstrument(
-      instrument ? this._toInstrumentData(instrument) : undefined,
+      instrument && instrument.ExchangeID === exchangeId
+        ? this._toInstrumentData(instrument)
+        : undefined,
     );
   }
 
@@ -691,9 +677,9 @@ export class Trader extends CTPProvider implements ITraderProvider {
       return;
     }
 
-    const [instrumentId] = this._parseSymbol(symbol);
+    const [instrumentId] = parseSymbol(symbol);
 
-    if (!this.symbols.has(instrumentId)) {
+    if (!this.instruments.has(instrumentId)) {
       receiver.onPosition(undefined);
       return;
     }
@@ -715,10 +701,12 @@ export class Trader extends CTPProvider implements ITraderProvider {
   }
 
   queryInstruments(receiver: IInstrumentsReceiver, type?: ProductType) {
+    const instruments = Array.from(this.instruments.values());
+
     switch (type) {
       case "future":
         receiver.onInstruments(
-          this.instruments
+          instruments
             .filter(
               (instrument) =>
                 instrument.ProductClass === ctp.ProductClassType.Futures,
@@ -729,7 +717,7 @@ export class Trader extends CTPProvider implements ITraderProvider {
 
       case "option":
         receiver.onInstruments(
-          this.instruments
+          instruments
             .filter(
               (instrument) =>
                 instrument.ProductClass === ctp.ProductClassType.Options,
@@ -739,9 +727,7 @@ export class Trader extends CTPProvider implements ITraderProvider {
         break;
 
       default:
-        receiver.onInstruments(
-          this.instruments.map(this._toInstrumentData, this),
-        );
+        receiver.onInstruments(instruments.map(this._toInstrumentData, this));
         break;
     }
   }
@@ -822,11 +808,8 @@ export class Trader extends CTPProvider implements ITraderProvider {
       return;
     }
 
-    const [instrumentId] = this._parseSymbol(symbol);
-
-    const instrument = this.instruments.find(
-      (instrument) => instrument.InstrumentID === instrumentId,
-    );
+    const [instrumentId] = parseSymbol(symbol);
+    const instrument = this.instruments.get(instrumentId);
 
     if (!instrument) {
       receiver.onPlaceOrderError("Instrument Not Found");
@@ -918,6 +901,16 @@ export class Trader extends CTPProvider implements ITraderProvider {
     });
   }
 
+  private _toSymbol(instrumentId: string) {
+    const instrument = this.instruments.get(instrumentId);
+
+    if (!instrument) {
+      return undefined;
+    }
+
+    return `${instrument.InstrumentID}.${instrument.ExchangeID}`;
+  }
+
   private _calcOrderId(orderOrTrade: ctp.OrderField | ctp.TradeField) {
     const { ExchangeID, TraderID, OrderLocalID } = orderOrTrade;
     return `${ExchangeID}:${TraderID}:${OrderLocalID}`;
@@ -1442,7 +1435,7 @@ export class Trader extends CTPProvider implements ITraderProvider {
     positionDetail: ctp.InvestorPositionDetailField,
   ): PositionDetail {
     return Object.freeze({
-      symbol: this.symbols.get(positionDetail.InstrumentID)!,
+      symbol: this._toSymbol(positionDetail.InstrumentID)!,
       date: parseInt(positionDetail.OpenDate),
       side: this._calcSideType(positionDetail.Direction),
       price: positionDetail.OpenPrice,
@@ -1471,7 +1464,7 @@ export class Trader extends CTPProvider implements ITraderProvider {
     while (!this.marginRatesQueue.isEmpty()) {
       const nextQuery = this.marginRatesQueue.peekFront()!;
 
-      const [instrumentId] = this._parseSymbol(nextQuery.symbol);
+      const [instrumentId] = parseSymbol(nextQuery.symbol);
       const marginRate = this.marginRates.get(instrumentId);
 
       if (marginRate) {
@@ -1496,7 +1489,7 @@ export class Trader extends CTPProvider implements ITraderProvider {
     while (!this.commRatesQueue.isEmpty()) {
       const nextQuery = this.commRatesQueue.peekFront()!;
 
-      const [instrumentId] = this._parseSymbol(nextQuery.symbol);
+      const [instrumentId] = parseSymbol(nextQuery.symbol);
       const commRate = this.commRates.get(instrumentId);
 
       if (commRate) {

package/src/typedef.ts

@@ -65,14 +65,12 @@ export type TapeStatus =
   | "invalid";
 
 export type TapeData = Readonly<{
-  symbol: string;
-  date: number;
-  time: number;
-  volumeDelta: number;
-  interestDelta: number;
   type: TapeType;
   direction: TapeDirection;
   status: TapeStatus;
+  interestDelta: number;
+  volumeDelta: number;
+  amountDelta: number;
 }>;
 
 export type PositionCell = Readonly<{
@@ -89,7 +87,7 @@ export type PositionData = Readonly<{
   symbol: string;
   today: PositionSide;
   history: PositionSide;
-  pending: { long: number; short: number };
+  pending: Readonly<{ long: number; short: number }>;
 }>;
 
 export type SideType = "long" | "short";
@@ -198,4 +196,25 @@ export type InstrumentData = Readonly<{
   minLimitOrderVolume: number;
 }>;
 
+export type PriceVolume = Readonly<{
+  [price: number]: number;
+}>;
+
+export type BarData = Readonly<{
+  symbol: string;
+  date: number;
+  time: number;
+  openInterest: number;
+  openPrice: number;
+  highPrice: number;
+  lowPrice: number;
+  closePrice: number;
+  volume: number;
+  amount: number;
+  delta: number;
+  poc: number;
+  buyVolumes: PriceVolume;
+  sellVolumes: PriceVolume;
+}>;
+
 export type Writeable<T> = { -readonly [P in keyof T]: Writeable<T[P]> };

package/src/utils.ts

@@ -0,0 +1,110 @@
+/*
+ * utils.ts
+ *
+ * Copyright (c) 2025 Xiongfei Shi
+ *
+ * Author: Xiongfei Shi <xiongfei.shi(a)icloud.com>
+ * License: Apache-2.0
+ *
+ * https://github.com/shixiongfei/hft.js
+ */
+
+import { BarData } from "./typedef.js";
+import { BarInfo } from "./bar.js";
+
+export const parseSymbol = (symbol: string): [string, string] => {
+  const [instrumentId, exchangeId] = symbol.split(".");
+  return [instrumentId, exchangeId];
+};
+
+export const getBarBuyVolume = (bar: BarData, price: number) =>
+  bar.buyVolumes[price] ?? 0;
+
+export const getBarSellVolume = (bar: BarData, price: number) =>
+  bar.sellVolumes[price] ?? 0;
+
+export const getBarVolume = (bar: BarData, price: number) =>
+  getBarBuyVolume(bar, price) + getBarSellVolume(bar, price);
+
+export const mergeBarData = (bars: BarData[]): BarData => {
+  if (bars.length === 0) {
+    throw new Error("Bars is empty");
+  }
+
+  if (bars.length === 1) {
+    return bars[1];
+  }
+
+  const bar: BarInfo = {
+    symbol: bars[0].symbol,
+    date: bars[0].date,
+    time: bars[0].time,
+    openInterest: bars[0].openInterest,
+    openPrice: bars[0].openPrice,
+    highPrice: bars[0].highPrice,
+    lowPrice: bars[0].lowPrice,
+    closePrice: bars[0].closePrice,
+    volume: bars[0].volume,
+    amount: bars[0].volume,
+    delta: bars[0].delta,
+    poc: bars[0].poc,
+    buyVolumes: { ...bars[0].buyVolumes },
+    sellVolumes: { ...bars[0].sellVolumes },
+  };
+
+  for (let i = 1; i < bars.length; ++i) {
+    const nextBar = bars[i];
+
+    bar.openInterest = nextBar.openInterest;
+    bar.closePrice = nextBar.closePrice;
+
+    bar.highPrice = Math.max(bar.highPrice, nextBar.highPrice);
+    bar.lowPrice = Math.min(bar.lowPrice, nextBar.lowPrice);
+
+    bar.volume += nextBar.volume;
+    bar.amount += nextBar.amount;
+
+    for (const price in nextBar.buyVolumes) {
+      const volumeDelta = nextBar.buyVolumes[price];
+
+      if (price in bar.buyVolumes) {
+        bar.buyVolumes[price] += volumeDelta;
+      } else {
+        bar.buyVolumes[price] = volumeDelta;
+      }
+
+      bar.delta += volumeDelta;
+
+      const priceVP = bar.buyVolumes[price] + (bar.sellVolumes[price] ?? 0);
+      const pocVP = getBarVolume(bar, bar.poc);
+
+      if (priceVP > pocVP) {
+        bar.poc = parseFloat(price);
+      }
+    }
+
+    for (const price in nextBar.sellVolumes) {
+      const volumeDelta = nextBar.sellVolumes[price];
+
+      if (price in bar.sellVolumes) {
+        bar.sellVolumes[price] += volumeDelta;
+      } else {
+        bar.sellVolumes[price] = volumeDelta;
+      }
+
+      bar.delta -= volumeDelta;
+
+      const priceVP = bar.sellVolumes[price] + (bar.buyVolumes[price] ?? 0);
+      const pocVP = getBarVolume(bar, bar.poc);
+
+      if (priceVP > pocVP) {
+        bar.poc = parseFloat(price);
+      }
+    }
+  }
+
+  Object.freeze(bar.buyVolumes);
+  Object.freeze(bar.sellVolumes);
+
+  return Object.freeze(bar);
+};