hft-js 0.0.0 → 0.1.1

package/src/index.test.ts

@@ -0,0 +1,240 @@
+/*
+ * index.test.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 fs from "node:fs";
+import { exit } from "node:process";
+import ctp from "napi-ctp";
+import * as hft from ".";
+
+export type Configure = {
+  FlowTdPath: string;
+  FlowMdPath: string;
+  FrontTdAddrs: string[];
+  FrontMdAddrs: string[];
+  UserInfo: hft.CTPUserInfo;
+};
+
+const existsFile = (filename: string) => {
+  try {
+    fs.accessSync(filename);
+    return true;
+  } catch {
+    return false;
+  }
+};
+
+const config = JSON.parse(
+  fs.readFileSync("test.conf.json", "utf8"),
+) as Configure;
+
+if (!existsFile(config.FlowTdPath)) {
+  fs.mkdirSync(config.FlowTdPath, { recursive: true });
+}
+
+if (!existsFile(config.FlowMdPath)) {
+  fs.mkdirSync(config.FlowMdPath, { recursive: true });
+}
+
+class Strategy implements hft.IStrategy, hft.ITickReceiver {
+  private lastTick?: hft.TickData;
+  private engine: hft.IRuntimeEngine;
+  readonly symbol = "ni2505.SHFE";
+
+  constructor(engine: hft.IRuntimeEngine) {
+    this.engine = engine;
+  }
+
+  onInit(subscriber: hft.ITickSubscriber) {
+    subscriber.subscribe([this.symbol], this);
+    console.log("Strategy init");
+
+    console.log("Trading Day", this.engine.getTradingDay());
+
+    this.engine.queryInstrument(this.symbol, {
+      onInstrument: (instrument) => {
+        if (!instrument) {
+          console.error("Symbol", this.symbol, "error");
+          exit(1);
+        }
+
+        console.log("Instrument", instrument);
+      },
+    });
+
+    this.engine.queryCommissionRate(this.symbol, {
+      onCommissionRate: (rate) => {
+        console.log("Commission Rate", rate);
+      },
+    });
+
+    this.engine.queryMarginRate(this.symbol, {
+      onMarginRate: (rate) => {
+        console.log("Margin Rate", rate);
+      },
+    });
+
+    this.engine.queryTradingAccounts({
+      onTradingAccounts: (accounts) => {
+        console.log("Trading Accounts", accounts);
+      },
+    });
+
+    this.engine.queryOrders({
+      onOrders: (orders) => {
+        console.log("Orders", orders);
+      },
+    });
+
+    this.engine.queryPositionDetails({
+      onPositionDetails: (positionDetails) => {
+        console.log("Position Details", positionDetails);
+      },
+    });
+
+    this.engine.queryPositions({
+      onPositions: (positions) => {
+        console.log("Positions", positions);
+      },
+    });
+
+    setTimeout(() => {
+      if (!this.lastTick) {
+        console.error("Market data is not found");
+        return;
+      }
+
+      this.engine.buyOpen(
+        this,
+        this.symbol,
+        1,
+        this.lastTick.orderBook.asks.price[0],
+        {
+          onPlaceOrderSent: (receiptId) => {
+            console.log("Open Place Order Receipt Id", receiptId);
+          },
+
+          onPlaceOrderError: (reason) => {
+            console.error("Open Place Order Error", reason);
+          },
+        },
+      );
+    }, 30 * 1000);
+  }
+
+  onDestroy(unsubscriber: hft.ITickUnsubscriber) {
+    unsubscriber.unsubscribe([this.symbol], this);
+    console.log("Strategy destroy");
+  }
+
+  onRisk(type: hft.RiskType, reason?: string) {
+    console.log("Trigger Risk Control", type, reason);
+  }
+
+  onEntrust(order: hft.OrderData) {
+    console.log("Entrust order", order);
+  }
+
+  onTrade(order: hft.OrderData, trade: hft.TradeData) {
+    console.log("Order", order, "Traded", trade);
+
+    if (order.status === "filled") {
+      setTimeout(() => {
+        this.engine.queryPosition(this.symbol, {
+          onPosition: (position) => {
+            if (!position || !this.lastTick) {
+              return;
+            }
+
+            const todayLong =
+              position.today.long.position - position.today.long.frozen;
+
+            if (todayLong > 0) {
+              this.engine.sellClose(
+                this,
+                this.symbol,
+                todayLong,
+                this.lastTick.orderBook.bids.price[0],
+                true,
+                {
+                  onPlaceOrderSent: (receiptId) => {
+                    console.log("Close Place Order Receipt Id", receiptId);
+                  },
+
+                  onPlaceOrderError: (reason) => {
+                    console.error("Close Place Order Error", reason);
+                  },
+                },
+              );
+            }
+          },
+        });
+      }, 30 * 1000);
+    }
+  }
+
+  onCancel(order: hft.OrderData) {
+    console.log("Cancel Order", order);
+  }
+
+  onReject(order: hft.OrderData) {
+    console.log("Reject Order", order);
+  }
+
+  onTick(tick: hft.TickData) {
+    //const tape = hft.calcTapeData(tick, this.lastTick);
+
+    //console.log(tick);
+    //console.log(tape);
+
+    this.lastTick = tick;
+  }
+}
+
+const trader = hft.createTrader(
+  config.FlowTdPath,
+  config.FrontTdAddrs,
+  config.UserInfo,
+);
+
+const market = hft.createMarket(
+  config.FlowMdPath,
+  config.FrontMdAddrs,
+  config.UserInfo,
+);
+
+const enableRecorder = false;
+
+if (enableRecorder) {
+  market.setRecorder(
+    {
+      onMarketData: (marketData: ctp.DepthMarketDataField) => {
+        console.log(marketData.InstrumentID, marketData.LastPrice);
+      },
+    },
+    (instruments) =>
+      instruments
+        .filter((instrument) => instrument.productType === "future")
+        .map((instrument) => instrument.symbol),
+  );
+}
+
+const broker = hft.createBroker(trader, market, {
+  onError(error, message) {
+    console.error(error, message);
+  },
+});
+
+broker.addStrategy(new Strategy(broker));
+
+if (!broker.start()) {
+  console.error("Broker start failed");
+  exit(1);
+}

package/src/index.ts

@@ -1 +1,18 @@
-console.log("High-Frequency Trading in Node.js");
+/*
+ * index.ts
+ *
+ * Copyright (c) 2025 Xiongfei Shi
+ *
+ * Author: Xiongfei Shi <xiongfei.shi(a)icloud.com>
+ * License: Apache-2.0
+ *
+ * https://github.com/shixiongfei/hft.js
+ */
+
+export * from "./typedef.js";
+export * from "./interfaces.js";
+export * from "./broker.js";
+export * from "./tape.js";
+export * from "./trader.js";
+export * from "./market.js";
+export { CTPUserInfo } from "./provider.js";

package/src/interfaces.ts

@@ -0,0 +1,267 @@
+/*
+ * interfaces.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 {
+  CommissionRate,
+  InstrumentData,
+  MarginRate,
+  OffsetType,
+  OrderData,
+  OrderFlag,
+  PositionData,
+  PositionDetail,
+  ProductType,
+  SideType,
+  TickData,
+  TradeData,
+  TradingAccount,
+} from "./typedef.js";
+
+export type RiskType = "place-order-risk" | "cancel-order-risk";
+
+export interface IPlaceOrderRiskManager {
+  onPlaceOrder: (
+    symbol: string,
+    offset: OffsetType,
+    side: SideType,
+    volume: number,
+    price: number,
+    flag: OrderFlag,
+  ) => boolean | string;
+}
+
+export interface ICancelOrderRiskManager {
+  onCancelOrder: (order: OrderData) => boolean | string;
+}
+
+export interface IRiskManagerReceiver {
+  onRisk: (type: RiskType, reason?: string) => void;
+}
+
+export type ErrorType =
+  | "login-error"
+  | "query-order-error"
+  | "query-trade-error"
+  | "query-instrument-error"
+  | "query-margin-rate-error"
+  | "query-commission-rate-error"
+  | "query-accounts-error"
+  | "query-positions-error"
+  | "query-position-details-error";
+
+export interface IErrorReceiver {
+  onError: (error: ErrorType, message: string) => void;
+}
+
+export interface ILifecycleListener extends IErrorReceiver {
+  onOpen: () => void;
+  onClose: () => void;
+}
+
+export interface IOrderReceiver {
+  onEntrust: (order: OrderData) => void;
+  onTrade: (order: OrderData, trade: TradeData) => void;
+  onCancel: (order: OrderData) => void;
+  onReject: (order: OrderData) => void;
+}
+
+export interface IOrdersReceiver {
+  onOrders: (orders: OrderData[]) => void;
+}
+
+export interface ITickReceiver {
+  onTick: (tick: TickData) => void;
+}
+
+export interface ITickSubscriber {
+  subscribe: (symbols: string[], receiver: ITickReceiver) => void;
+}
+
+export interface ITickUnsubscriber {
+  unsubscribe: (symbols: string[], receiver: ITickReceiver) => void;
+}
+
+export interface IStrategy extends IRiskManagerReceiver, IOrderReceiver {
+  onInit: (subscriber: ITickSubscriber) => void;
+  onDestroy: (unsubscriber: ITickUnsubscriber) => void;
+}
+
+export interface ICommissionRateReceiver {
+  onCommissionRate: (rate: CommissionRate | undefined) => void;
+}
+
+export interface IMarginRateReceiver {
+  onMarginRate: (rate: MarginRate | undefined) => void;
+}
+
+export interface IInstrumentReceiver {
+  onInstrument: (instrument: InstrumentData | undefined) => void;
+}
+
+export interface IInstrumentsReceiver {
+  onInstruments: (instruments: InstrumentData[] | undefined) => void;
+}
+
+export interface ITradingAccountsReceiver {
+  onTradingAccounts: (accounts: TradingAccount[] | undefined) => void;
+}
+
+export interface IPositionReceiver {
+  onPosition: (position: PositionData | undefined) => void;
+}
+
+export interface IPositionsReceiver {
+  onPositions: (positions: PositionData[] | undefined) => void;
+}
+
+export interface IPositionDetailsReceiver {
+  onPositionDetails: (positionDetails: PositionDetail[] | undefined) => void;
+}
+
+export interface IProvider {
+  open: (lifecycle: ILifecycleListener) => boolean;
+  close: (lifecycle: ILifecycleListener) => void;
+}
+
+export interface IOrderEmitter {
+  addReceiver: (receiver: IOrderReceiver) => void;
+  removeReceiver: (receiver: IOrderReceiver) => void;
+}
+
+export interface IQueryApi {
+  getTradingDay: () => number;
+
+  queryCommissionRate: (
+    symbol: string,
+    receiver: ICommissionRateReceiver,
+  ) => void;
+
+  queryMarginRate: (symbol: string, receiver: IMarginRateReceiver) => void;
+  queryInstrument: (symbol: string, receiver: IInstrumentReceiver) => void;
+  queryPosition: (symbol: string, receiver: IPositionReceiver) => void;
+
+  queryInstruments: (
+    receiver: IInstrumentsReceiver,
+    type?: ProductType,
+  ) => void;
+
+  queryTradingAccounts: (receiver: ITradingAccountsReceiver) => void;
+  queryPositions: (receiver: IPositionsReceiver) => void;
+  queryPositionDetails: (receiver: IPositionDetailsReceiver) => void;
+  queryOrders: (receiver: IOrdersReceiver) => void;
+}
+
+export interface IMarketRecorderReceiver {
+  onMarketData: (marketData: any) => void;
+}
+
+export type IMarketRecorderSymbols = (instrument: InstrumentData[]) => string[];
+
+export interface IMarketProvider
+  extends IProvider,
+    ITickSubscriber,
+    ITickUnsubscriber {
+  hasRecorder: () => boolean;
+
+  setRecorder: (
+    receiver: IMarketRecorderReceiver,
+    symbols: IMarketRecorderSymbols,
+  ) => void;
+
+  startRecorder: (instrument: InstrumentData[]) => void;
+  stopRecorder: () => void;
+}
+
+export type IPlaceOrderResultReceiver = {
+  onPlaceOrderSent: (receiptId: string) => void;
+  onPlaceOrderError: (reason: string) => void;
+};
+
+export type ICancelOrderResultReceiver = {
+  onCancelOrderSent: () => void;
+  onCancelOrderError: (reason: string) => void;
+};
+
+export interface ITraderProvider extends IProvider, IOrderEmitter, IQueryApi {
+  placeOrder: (
+    symbol: string,
+    offset: OffsetType,
+    side: SideType,
+    volume: number,
+    price: number,
+    flag: OrderFlag,
+    receiver: IPlaceOrderResultReceiver,
+  ) => void;
+
+  cancelOrder: (order: OrderData, receiver: ICancelOrderResultReceiver) => void;
+}
+
+export interface IRuntimeEngine
+  extends IQueryApi,
+    ITickSubscriber,
+    ITickUnsubscriber {
+  addStrategy: (strategy: IStrategy) => void;
+  removeStrategy: (strategy: IStrategy) => void;
+
+  addPlaceOrderRiskManager: (riskMgr: IPlaceOrderRiskManager) => void;
+  addCancelOrderRiskManager: (riskMgr: ICancelOrderRiskManager) => void;
+
+  placeOrder: (
+    strategy: IStrategy,
+    symbol: string,
+    offset: OffsetType,
+    side: SideType,
+    volume: number,
+    price: number,
+    flag: OrderFlag,
+    receiver: IPlaceOrderResultReceiver,
+  ) => void;
+
+  cancelOrder: (
+    strategy: IStrategy,
+    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;
+}