hft-js 0.0.0 → 0.1.1

package/src/market.ts

@@ -0,0 +1,370 @@
+/*
+ * market.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 ctp from "napi-ctp";
+import { CTPProvider, CTPUserInfo } from "./provider.js";
+import { InstrumentData, OrderBook, TickData } from "./typedef.js";
+import {
+  ILifecycleListener,
+  IMarketProvider,
+  IMarketRecorderReceiver,
+  IMarketRecorderSymbols,
+  ITickReceiver,
+} from "./interfaces.js";
+
+const isValidPrice = (x: number) => x !== Number.MAX_VALUE && x !== 0;
+const isValidVolume = (x: number) => x !== Number.MAX_VALUE && x !== 0;
+
+export class Market extends CTPProvider implements IMarketProvider {
+  private marketApi?: ctp.MarketData;
+  private recorder?: IMarketRecorderReceiver;
+  private recorderSymbols?: IMarketRecorderSymbols;
+  private readonly recordings: Set<string>;
+  private readonly symbols: Map<string, string>;
+  private readonly subscribers: Map<string, ITickReceiver[]>;
+
+  constructor(
+    flowMdPath: string,
+    frontMdAddrs: string | string[],
+    userInfo: CTPUserInfo,
+  ) {
+    super(flowMdPath, frontMdAddrs, userInfo);
+    this.recordings = new Set();
+    this.symbols = new Map();
+    this.subscribers = new Map();
+  }
+
+  hasRecorder() {
+    return !!this.recorder;
+  }
+
+  setRecorder(
+    receiver: IMarketRecorderReceiver,
+    symbols: IMarketRecorderSymbols,
+  ) {
+    this.recorder = receiver;
+    this.recorderSymbols = symbols;
+  }
+
+  open(lifecycle: ILifecycleListener) {
+    if (this.marketApi) {
+      return true;
+    }
+
+    this.marketApi = ctp.createMarketData(this.flowPath, this.frontAddrs);
+
+    this.marketApi.on(ctp.MarketDataEvent.FrontConnected, () => {
+      this._withRetry(() => this.marketApi!.reqUserLogin(this.userInfo));
+    });
+
+    let fired = false;
+
+    this.marketApi.on<ctp.RspUserLoginField>(
+      ctp.MarketDataEvent.RspUserLogin,
+      (_, options) => {
+        if (this._isErrorResp(lifecycle, options, "login-error")) {
+          return;
+        }
+
+        const instrumentIds = new Set([
+          ...Array.from(this.recordings),
+          ...Object.keys(this.subscribers),
+        ]);
+
+        if (instrumentIds.size > 0) {
+          this._withRetry(() =>
+            this.marketApi!.subscribeMarketData(Array.from(instrumentIds)),
+          );
+        }
+
+        if (!fired) {
+          fired = true;
+          lifecycle.onOpen();
+        }
+      },
+    );
+
+    this.marketApi.on<ctp.DepthMarketDataField>(
+      ctp.MarketDataEvent.RtnDepthMarketData,
+      (depthMarketData) => {
+        const instrumentId = depthMarketData.InstrumentID;
+
+        if (this.recorder && this.recordings.has(instrumentId)) {
+          this.recorder.onMarketData(depthMarketData);
+        }
+
+        const symbol = this.symbols.get(instrumentId);
+
+        if (!symbol) {
+          return;
+        }
+
+        const receivers = this.subscribers.get(instrumentId);
+
+        if (!receivers || receivers.length === 0) {
+          return;
+        }
+
+        const orderBook: OrderBook = {
+          asks: { price: [], volume: [] },
+          bids: { price: [], volume: [] },
+        };
+
+        if (
+          isValidPrice(depthMarketData.AskPrice1) &&
+          isValidVolume(depthMarketData.AskVolume1)
+        ) {
+          orderBook.asks.price.push(depthMarketData.AskPrice1);
+          orderBook.asks.volume.push(depthMarketData.AskVolume1);
+
+          if (
+            isValidPrice(depthMarketData.AskPrice2) &&
+            isValidVolume(depthMarketData.AskVolume2)
+          ) {
+            orderBook.asks.price.push(depthMarketData.AskPrice2);
+            orderBook.asks.volume.push(depthMarketData.AskVolume2);
+
+            if (
+              isValidPrice(depthMarketData.AskPrice3) &&
+              isValidVolume(depthMarketData.AskVolume3)
+            ) {
+              orderBook.asks.price.push(depthMarketData.AskPrice3);
+              orderBook.asks.volume.push(depthMarketData.AskVolume3);
+
+              if (
+                isValidPrice(depthMarketData.AskPrice4) &&
+                isValidVolume(depthMarketData.AskVolume4)
+              ) {
+                orderBook.asks.price.push(depthMarketData.AskPrice4);
+                orderBook.asks.volume.push(depthMarketData.AskVolume4);
+
+                if (
+                  isValidPrice(depthMarketData.AskPrice5) &&
+                  isValidVolume(depthMarketData.AskVolume5)
+                ) {
+                  orderBook.asks.price.push(depthMarketData.AskPrice5);
+                  orderBook.asks.volume.push(depthMarketData.AskVolume5);
+                }
+              }
+            }
+          }
+        }
+
+        if (
+          isValidPrice(depthMarketData.BidPrice1) &&
+          isValidVolume(depthMarketData.BidVolume1)
+        ) {
+          orderBook.bids.price.push(depthMarketData.BidPrice1);
+          orderBook.bids.volume.push(depthMarketData.BidVolume1);
+
+          if (
+            isValidPrice(depthMarketData.BidPrice2) &&
+            isValidVolume(depthMarketData.BidVolume2)
+          ) {
+            orderBook.bids.price.push(depthMarketData.BidPrice2);
+            orderBook.bids.volume.push(depthMarketData.BidVolume2);
+
+            if (
+              isValidPrice(depthMarketData.BidPrice3) &&
+              isValidVolume(depthMarketData.BidVolume3)
+            ) {
+              orderBook.bids.price.push(depthMarketData.BidPrice3);
+              orderBook.bids.volume.push(depthMarketData.BidVolume3);
+
+              if (
+                isValidPrice(depthMarketData.BidPrice4) &&
+                isValidVolume(depthMarketData.BidVolume4)
+              ) {
+                orderBook.bids.price.push(depthMarketData.BidPrice4);
+                orderBook.bids.volume.push(depthMarketData.BidVolume4);
+
+                if (
+                  isValidPrice(depthMarketData.BidPrice5) &&
+                  isValidVolume(depthMarketData.BidVolume5)
+                ) {
+                  orderBook.bids.price.push(depthMarketData.BidPrice5);
+                  orderBook.bids.volume.push(depthMarketData.BidVolume5);
+                }
+              }
+            }
+          }
+        }
+
+        const time = this._parseTime(depthMarketData.UpdateTime);
+
+        const tick: TickData = Object.freeze({
+          symbol: symbol,
+          date: parseInt(depthMarketData.ActionDay),
+          time: time + depthMarketData.UpdateMillisec / 1000,
+          tradingDay: parseInt(depthMarketData.TradingDay),
+          preOpenInterest: depthMarketData.PreOpenInterest,
+          preClose: depthMarketData.PreClosePrice,
+          openInterest: depthMarketData.OpenInterest,
+          openPrice: depthMarketData.OpenPrice,
+          highPrice: depthMarketData.HighestPrice,
+          lowPrice: depthMarketData.LowestPrice,
+          lastPrice: depthMarketData.LastPrice,
+          volume: depthMarketData.Volume,
+          amount: depthMarketData.Turnover,
+          limits: Object.freeze({
+            upper: depthMarketData.UpperLimitPrice,
+            lower: depthMarketData.LowerLimitPrice,
+          }),
+          bandings: Object.freeze({
+            upper: depthMarketData.BandingUpperPrice,
+            lower: depthMarketData.BandingLowerPrice,
+          }),
+          orderBook: Object.freeze(orderBook),
+        });
+
+        receivers.forEach((receiver) => receiver.onTick(tick));
+      },
+    );
+
+    return true;
+  }
+
+  close(lifecycle: ILifecycleListener) {
+    if (!this.marketApi) {
+      return;
+    }
+
+    this.marketApi.close();
+    this.marketApi = undefined;
+
+    lifecycle.onClose();
+  }
+
+  startRecorder(instrument: InstrumentData[]) {
+    if (!this.recorderSymbols) {
+      return;
+    }
+
+    const symbols = this.recorderSymbols(instrument);
+    const instrumentIds = new Set<string>();
+
+    symbols.forEach((symbol) => {
+      const [instrumentId] = this._parseSymbol(symbol);
+
+      if (this.recordings.has(instrumentId)) {
+        return;
+      }
+
+      this.recordings.add(instrumentId);
+
+      if (!this.subscribers.has(instrumentId)) {
+        this.symbols.set(instrumentId, symbol);
+        instrumentIds.add(instrumentId);
+      }
+    });
+
+    if (instrumentIds.size > 0) {
+      this._withRetry(() =>
+        this.marketApi?.subscribeMarketData(Array.from(instrumentIds)),
+      );
+    }
+  }
+
+  stopRecorder() {
+    if (this.recordings.size === 0) {
+      return;
+    }
+
+    const instrumentIds = new Set<string>();
+
+    this.recordings.forEach((instrumentId) => {
+      if (!this.subscribers.has(instrumentId)) {
+        this.symbols.delete(instrumentId);
+        instrumentIds.add(instrumentId);
+      }
+    });
+
+    this.recordings.clear();
+
+    if (instrumentIds.size > 0) {
+      this._withRetry(() =>
+        this.marketApi?.unsubscribeMarketData(Array.from(instrumentIds)),
+      );
+    }
+  }
+
+  subscribe(symbols: string[], receiver: ITickReceiver) {
+    const instrumentIds = new Set<string>();
+
+    symbols.forEach((symbol) => {
+      const [instrumentId] = this._parseSymbol(symbol);
+      const receivers = this.subscribers.get(instrumentId);
+
+      if (receivers) {
+        if (!receivers.includes(receiver)) {
+          receivers.push(receiver);
+        }
+      } else {
+        this.subscribers.set(instrumentId, [receiver]);
+
+        if (!this.recordings.has(instrumentId)) {
+          this.symbols.set(instrumentId, symbol);
+          instrumentIds.add(instrumentId);
+        }
+      }
+    });
+
+    if (instrumentIds.size > 0) {
+      this._withRetry(() =>
+        this.marketApi?.subscribeMarketData(Array.from(instrumentIds)),
+      );
+    }
+  }
+
+  unsubscribe(symbols: string[], receiver: ITickReceiver) {
+    const instrumentIds = new Set<string>();
+
+    symbols.forEach((symbol) => {
+      const [instrumentId] = this._parseSymbol(symbol);
+      const receivers = this.subscribers.get(instrumentId);
+
+      if (!receivers) {
+        return;
+      }
+
+      if (receivers.length > 0) {
+        const index = receivers.indexOf(receiver);
+
+        if (index < 0) {
+          return;
+        }
+
+        receivers.splice(index, 1);
+      }
+
+      if (receivers.length === 0) {
+        this.subscribers.delete(instrumentId);
+
+        if (!this.recordings.has(instrumentId)) {
+          this.symbols.delete(instrumentId);
+          instrumentIds.add(instrumentId);
+        }
+      }
+    });
+
+    if (instrumentIds.size > 0) {
+      this._withRetry(() =>
+        this.marketApi?.unsubscribeMarketData(Array.from(instrumentIds)),
+      );
+    }
+  }
+}
+
+export const createMarket = (
+  flowMdPath: string,
+  frontMdAddrs: string | string[],
+  userInfo: CTPUserInfo,
+) => new Market(flowMdPath, frontMdAddrs, userInfo);

package/src/provider.ts

@@ -0,0 +1,88 @@
+/*
+ * provider.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 ctp from "napi-ctp";
+import { ErrorType, ILifecycleListener } from "./interfaces.js";
+
+export type CTPUserInfo = {
+  BrokerID: string;
+  UserID: string;
+  Password: string;
+  InvestorID: string;
+  UserProductInfo: string;
+  AuthCode: string;
+  AppID: string;
+};
+
+export class CTPProvider {
+  protected readonly flowPath: string;
+  protected readonly frontAddrs: string | string[];
+  protected readonly userInfo: CTPUserInfo;
+
+  constructor(
+    flowPath: string,
+    frontAddrs: string | string[],
+    userInfo: CTPUserInfo,
+  ) {
+    this.flowPath = flowPath;
+    this.frontAddrs = frontAddrs;
+    this.userInfo = userInfo;
+  }
+
+  private _sleep(ms: number) {
+    return new Promise<void>((resolve) => {
+      setTimeout(resolve, ms);
+    });
+  }
+
+  protected async _withRetry(request: () => number | undefined, ms = 100) {
+    for (;;) {
+      const retval = request();
+
+      if (retval === 0) {
+        return ctp.getLastRequestId();
+      }
+
+      if (-2 !== retval && -3 !== retval) {
+        return retval;
+      }
+
+      await this._sleep(ms);
+    }
+  }
+
+  protected _parseSymbol(symbol: string): [string, string] {
+    const [instrumentId, exchangeId] = symbol.split(".");
+    return [instrumentId, exchangeId];
+  }
+
+  protected _isErrorResp(
+    lifecycle: ILifecycleListener,
+    options: ctp.CallbackOptions,
+    error: ErrorType,
+  ) {
+    if (!options.rspInfo) {
+      return false;
+    }
+
+    lifecycle.onError(
+      error,
+      `${options.rspInfo.ErrorID}:${options.rspInfo.ErrorMsg}`,
+    );
+
+    return true;
+  }
+
+  protected _parseTime(time: string) {
+    const [hour, minute, second] = time.split(":").map((x) => parseInt(x));
+    return hour * 10000 + minute * 100 + second;
+  }
+}

package/src/tape.ts

@@ -0,0 +1,169 @@
+/*
+ * tape.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 {
+  TapeData,
+  TapeDirection,
+  TapeStatus,
+  TapeType,
+  TickData,
+} from "./typedef.js";
+
+const calcTapeType = (volumeDelta: number, interestDelta: number): TapeType => {
+  if (interestDelta > 0) {
+    return volumeDelta === interestDelta ? "dual-open" : "open";
+  }
+
+  if (interestDelta < 0) {
+    return volumeDelta + interestDelta === 0 ? "dual-close" : "close";
+  }
+
+  if (volumeDelta > 0) {
+    return "turnover";
+  }
+
+  return "no-deal";
+};
+
+const calcTapeDirection = (
+  tick: TickData,
+  preTick?: TickData,
+): TapeDirection => {
+  const lastPrice = tick.lastPrice;
+
+  if (preTick) {
+    const preAskPrice1 = preTick.orderBook.asks.price[0] ?? Number.MAX_VALUE;
+
+    if (lastPrice >= preAskPrice1) {
+      return "up";
+    }
+
+    const preBidPrice1 = preTick.orderBook.bids.price[0] ?? Number.MIN_VALUE;
+
+    if (lastPrice <= preBidPrice1) {
+      return "down";
+    }
+
+    const askPrice1 = tick.orderBook.asks.price[0] ?? Number.MAX_VALUE;
+
+    if (lastPrice >= askPrice1) {
+      return "up";
+    }
+
+    const bidPrice1 = tick.orderBook.bids.price[0] ?? Number.MIN_VALUE;
+
+    if (lastPrice <= bidPrice1) {
+      return "down";
+    }
+
+    const prePrice = preTick.lastPrice;
+
+    if (lastPrice > prePrice) {
+      return "up";
+    }
+
+    if (lastPrice < prePrice) {
+      return "down";
+    }
+
+    if (bidPrice1 >= preAskPrice1) {
+      return "up";
+    }
+
+    if (askPrice1 <= preBidPrice1) {
+      return "down";
+    }
+
+    return "none";
+  } else {
+    const askPrice1 = tick.orderBook.asks.price[0] ?? Number.MAX_VALUE;
+
+    if (lastPrice >= askPrice1) {
+      return "up";
+    }
+
+    const bidPrice1 = tick.orderBook.bids.price[0] ?? Number.MIN_VALUE;
+
+    if (lastPrice <= bidPrice1) {
+      return "down";
+    }
+
+    if (lastPrice > tick.preClose) {
+      return "up";
+    }
+
+    if (lastPrice < tick.preClose) {
+      return "down";
+    }
+
+    return "none";
+  }
+};
+
+const calcTapeStatus = (
+  tapeType: TapeType,
+  tapeDirection: TapeDirection,
+): TapeStatus => {
+  if (tapeType === "open" && tapeDirection === "up") {
+    return "open-long";
+  }
+
+  if (tapeType === "open" && tapeDirection === "down") {
+    return "open-short";
+  }
+
+  if (tapeType === "close" && tapeDirection === "up") {
+    return "close-short";
+  }
+
+  if (tapeType === "close" && tapeDirection === "down") {
+    return "close-long";
+  }
+
+  if (tapeType === "turnover" && tapeDirection === "up") {
+    return "turnover-long";
+  }
+
+  if (tapeType === "turnover" && tapeDirection === "down") {
+    return "turnover-short";
+  }
+
+  if (tapeType === "dual-open") {
+    return "dual-open";
+  }
+
+  if (tapeType === "dual-close") {
+    return "dual-close";
+  }
+
+  return "invalid";
+};
+
+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 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,
+    type: tapeType,
+    direction: tapeDirection,
+    status: tapeStatus,
+  };
+};