hft-js 0.1.8 → 0.2.0

package/src/market.ts

@@ -12,8 +12,8 @@
 import ctp from "napi-ctp";
 import { CTPProvider } from "./provider.js";
 import { InstrumentData, OrderBook, TickData } from "./typedef.js";
+import { isValidPrice, isValidVolume, parseSymbol } from "./utils.js";
 import { calcTapeData } from "./tape.js";
-import { parseSymbol } from "./utils.js";
 import {
   ILifecycleListener,
   IMarketProvider,
@@ -23,14 +23,15 @@ import {
   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 interface IMarketListener {
   onSubscribed: (symbol: string) => void;
   onUnsubscribed: (symbol: string) => void;
 }
 
+export type MarketOptions = {
+  listener?: IMarketListener;
+};
+
 export class Market
   extends CTPProvider
   implements IMarketProvider, IMarketRecorderProvider
@@ -48,15 +49,18 @@ export class Market
   constructor(
     flowMdPath: string,
     frontMdAddrs: string | string[],
-    listener?: IMarketListener,
+    options?: MarketOptions,
   ) {
     super(flowMdPath, frontMdAddrs);
-    this.listener = listener;
     this.tradingDay = 0;
     this.recordings = new Set();
     this.symbols = new Map();
     this.lastTicks = new Map();
     this.subscribers = new Map();
+
+    if (options?.listener) {
+      this.listener = options.listener;
+    }
   }
 
   getRecorder() {
@@ -75,6 +79,10 @@ export class Market
     this.recorderSymbols = symbols;
   }
 
+  getLastTick(instrumentId: string) {
+    return this.lastTicks.get(instrumentId);
+  }
+
   open(lifecycle: ILifecycleListener) {
     if (this.marketApi) {
       return true;
@@ -423,5 +431,5 @@ export class Market
 export const createMarket = (
   flowMdPath: string,
   frontMdAddrs: string | string[],
-  listener?: IMarketListener,
-) => new Market(flowMdPath, frontMdAddrs, listener);
+  options?: MarketOptions,
+) => new Market(flowMdPath, frontMdAddrs, options);

package/src/provider.ts

@@ -9,6 +9,7 @@
  * https://github.com/shixiongfei/hft.js
  */
 
+import fs from "node:fs";
 import ctp from "napi-ctp";
 import { ErrorType, ILifecycleListener } from "./interfaces.js";
 
@@ -19,6 +20,12 @@ export class CTPProvider {
   constructor(flowPath: string, frontAddrs: string | string[]) {
     this.flowPath = flowPath;
     this.frontAddrs = frontAddrs;
+
+    try {
+      fs.accessSync(this.flowPath);
+    } catch {
+      fs.mkdirSync(this.flowPath, { recursive: true });
+    }
   }
 
   private _sleep(ms: number) {
@@ -35,11 +42,12 @@ export class CTPProvider {
         return ctp.getLastRequestId();
       }
 
-      if (-2 !== retval && -3 !== retval) {
-        return retval;
+      if (-2 === retval || -3 === retval) {
+        await this._sleep(ms);
+        continue;
       }
 
-      await this._sleep(ms);
+      return retval;
     }
   }
 

package/src/trader.ts

@@ -12,7 +12,7 @@
 import Denque from "denque";
 import ctp from "napi-ctp";
 import { CTPProvider } from "./provider.js";
-import { parseSymbol } from "./utils.js";
+import { isValidPrice, parseSymbol } from "./utils.js";
 import {
   CommissionRate,
   InstrumentData,
@@ -24,8 +24,10 @@ import {
   OrderStatus,
   PositionData,
   PositionDetail,
+  PriceRange,
   ProductType,
   SideType,
+  TickData,
   TradeData,
   TradingAccount,
   Writeable,
@@ -47,15 +49,26 @@ import {
   ITradingAccountsReceiver,
 } from "./interfaces.js";
 
-type MarginRateQuery = { symbol: string; receiver: IMarginRateReceiver };
+type PositionInfo = Writeable<PositionData>;
+type OrderStat = Writeable<OrderStatistic>;
+
+type MarginRateQuery = {
+  symbol: string;
+  receiver: IMarginRateReceiver;
+};
 
 type CommissionRateQuery = {
   symbol: string;
   receiver: ICommissionRateReceiver;
 };
 
-type PositionInfo = Writeable<PositionData>;
-type OrderStat = Writeable<OrderStatistic>;
+type MarketOrder = {
+  symbol: string;
+  offset: OffsetType;
+  side: SideType;
+  volume: number;
+  receiver: IPlaceOrderResultReceiver;
+};
 
 export type CTPUserInfo = {
   BrokerID: string;
@@ -67,6 +80,14 @@ export type CTPUserInfo = {
   AppID: string;
 };
 
+export type FastQueryLastTickFunc = (
+  instrumentId: string,
+) => TickData | undefined;
+
+export type TraderOptions = {
+  fastQueryLastTick?: FastQueryLastTickFunc;
+};
+
 export class Trader extends CTPProvider implements ITraderProvider {
   private traderApi?: ctp.Trader;
   private tradingDay: number;
@@ -75,6 +96,7 @@ export class Trader extends CTPProvider implements ITraderProvider {
   private orderRef: number;
   private accountsQueryTime: number;
   private positionDetailsChanged: boolean;
+  private readonly fastQueryLastTick?: FastQueryLastTickFunc;
   private readonly userInfo: CTPUserInfo;
   private readonly receivers: IOrderReceiver[];
   private readonly accounts: ctp.TradingAccountField[];
@@ -87,6 +109,8 @@ export class Trader extends CTPProvider implements ITraderProvider {
   private readonly commRates: Map<string, ctp.InstrumentCommissionRateField>;
   private readonly placeOrders: Map<number, IPlaceOrderResultReceiver>;
   private readonly cancelOrders: Map<number, ICancelOrderResultReceiver>;
+  private readonly marketOrdersQueue: Map<string, Denque<MarketOrder>>;
+  private readonly priceLimit: Map<string, PriceRange>;
   private readonly orderStatistics: Map<string, OrderStat>;
   private readonly marginRatesQueue: Denque<MarginRateQuery>;
   private readonly commRatesQueue: Denque<CommissionRateQuery>;
@@ -97,6 +121,7 @@ export class Trader extends CTPProvider implements ITraderProvider {
     flowTdPath: string,
     frontTdAddrs: string | string[],
     userInfo: CTPUserInfo,
+    options?: TraderOptions,
   ) {
     super(flowTdPath, frontTdAddrs);
     this.tradingDay = 0;
@@ -117,11 +142,17 @@ export class Trader extends CTPProvider implements ITraderProvider {
     this.commRates = new Map();
     this.placeOrders = new Map();
     this.cancelOrders = new Map();
+    this.marketOrdersQueue = new Map();
+    this.priceLimit = new Map();
     this.orderStatistics = new Map();
     this.marginRatesQueue = new Denque();
     this.commRatesQueue = new Denque();
     this.accountsQueue = new Denque();
     this.positionDetailsQueue = new Denque();
+
+    if (options?.fastQueryLastTick) {
+      this.fastQueryLastTick = options.fastQueryLastTick;
+    }
   }
 
   open(lifecycle: ILifecycleListener) {
@@ -136,6 +167,7 @@ export class Trader extends CTPProvider implements ITraderProvider {
     });
 
     this.traderApi.on(ctp.TraderEvent.FrontDisconnected, () => {
+      this._clearAllMarketOrders();
       this.placeOrders.clear();
       this.cancelOrders.clear();
     });
@@ -168,6 +200,7 @@ export class Trader extends CTPProvider implements ITraderProvider {
           this.marginRates.clear();
           this.commRates.clear();
           this.orderStatistics.clear();
+          this.priceLimit.clear();
           this.tradingDay = tradingDay;
         }
 
@@ -627,6 +660,75 @@ export class Trader extends CTPProvider implements ITraderProvider {
       },
     );
 
+    this.traderApi.on<ctp.DepthMarketDataField>(
+      ctp.TraderEvent.RspQryDepthMarketData,
+      (depthMarketData, options) => {
+        if (
+          this._isErrorResp(lifecycle, options, "query-depth-market-data-error")
+        ) {
+          this._clearAllMarketOrders();
+          return;
+        }
+
+        const isLimitPrice =
+          !isValidPrice(depthMarketData.BandingUpperPrice) ||
+          !isValidPrice(depthMarketData.BandingLowerPrice);
+
+        if (isLimitPrice) {
+          this.priceLimit.set(depthMarketData.InstrumentID, {
+            upper: depthMarketData.UpperLimitPrice,
+            lower: depthMarketData.LowerLimitPrice,
+          });
+        }
+
+        const queue = this.marketOrdersQueue.get(depthMarketData.InstrumentID);
+
+        if (!queue) {
+          return;
+        }
+
+        if (!queue.isEmpty()) {
+          const upperPrice = isLimitPrice
+            ? depthMarketData.UpperLimitPrice
+            : depthMarketData.BandingUpperPrice;
+
+          const lowerPrice = isLimitPrice
+            ? depthMarketData.LowerLimitPrice
+            : depthMarketData.BandingLowerPrice;
+
+          const orders = queue.toArray();
+
+          orders.forEach((order) => {
+            switch (order.side) {
+              case "long":
+                this._placeLimitOrder(
+                  order.symbol,
+                  order.offset,
+                  order.side,
+                  order.volume,
+                  upperPrice,
+                  order.receiver,
+                );
+                break;
+
+              case "short":
+                this._placeLimitOrder(
+                  order.symbol,
+                  order.offset,
+                  order.side,
+                  order.volume,
+                  lowerPrice,
+                  order.receiver,
+                );
+                break;
+            }
+          });
+        }
+
+        this.marketOrdersQueue.delete(depthMarketData.InstrumentID);
+      },
+    );
+
     return true;
   }
 
@@ -862,21 +964,15 @@ export class Trader extends CTPProvider implements ITraderProvider {
     receiver.onOrders(orders);
   }
 
-  placeOrder(
+  private _placeLimitOrder(
     symbol: string,
     offset: OffsetType,
     side: SideType,
     volume: number,
     price: number,
-    flag: OrderFlag,
     receiver: IPlaceOrderResultReceiver,
   ) {
-    if (flag !== "limit") {
-      receiver.onPlaceOrderError("Only Supports Limit Order");
-      return;
-    }
-
-    const [instrumentId] = parseSymbol(symbol);
+    const [instrumentId, exchangeId] = parseSymbol(symbol);
     const instrument = this.instruments.get(instrumentId);
 
     if (!instrument) {
@@ -884,6 +980,11 @@ export class Trader extends CTPProvider implements ITraderProvider {
       return;
     }
 
+    if (exchangeId !== instrument.ExchangeID) {
+      receiver.onPlaceOrderError("Exchange Id Error");
+      return;
+    }
+
     let orderRef = 0;
 
     this._withRetry(() => {
@@ -908,12 +1009,7 @@ export class Trader extends CTPProvider implements ITraderProvider {
         UserForceClose: 0,
       });
     }).then((requestId) => {
-      if (!requestId) {
-        receiver.onPlaceOrderError("Request Failed");
-        return;
-      }
-
-      if (requestId < 0) {
+      if (!requestId || requestId < 0) {
         receiver.onPlaceOrderError("Request Error");
         return;
       }
@@ -932,6 +1028,173 @@ export class Trader extends CTPProvider implements ITraderProvider {
     });
   }
 
+  private _clearAllMarketOrders() {
+    this.marketOrdersQueue.forEach((queue) => {
+      const orders = queue.toArray();
+
+      orders.forEach((order) => {
+        order.receiver.onPlaceOrderError("Request Error");
+      });
+    });
+
+    this.marketOrdersQueue.clear();
+  }
+
+  private _placeMarketOrder(
+    symbol: string,
+    offset: OffsetType,
+    side: SideType,
+    volume: number,
+    receiver: IPlaceOrderResultReceiver,
+  ) {
+    const [instrumentId, exchangeId] = parseSymbol(symbol);
+    const instrument = this.instruments.get(instrumentId);
+
+    if (!instrument) {
+      receiver.onPlaceOrderError("Instrument Not Found");
+      return;
+    }
+
+    if (exchangeId !== instrument.ExchangeID) {
+      receiver.onPlaceOrderError("Exchange Id Error");
+      return;
+    }
+
+    const priceRange = this.priceLimit.get(instrumentId);
+
+    if (priceRange) {
+      switch (side) {
+        case "long":
+          this._placeLimitOrder(
+            symbol,
+            offset,
+            side,
+            volume,
+            priceRange.upper,
+            receiver,
+          );
+          break;
+
+        case "short":
+          this._placeLimitOrder(
+            symbol,
+            offset,
+            side,
+            volume,
+            priceRange.lower,
+            receiver,
+          );
+          break;
+      }
+
+      return;
+    }
+
+    if (this.fastQueryLastTick) {
+      const lastTick = this.fastQueryLastTick(instrumentId);
+
+      if (lastTick && lastTick.tradingDay === this.tradingDay) {
+        const isLimitPrice =
+          !isValidPrice(lastTick.bandings.upper) ||
+          !isValidPrice(lastTick.bandings.lower);
+
+        if (isLimitPrice) {
+          this.priceLimit.set(instrumentId, { ...lastTick.limits });
+        }
+
+        const upperPrice = isLimitPrice
+          ? lastTick.limits.upper
+          : lastTick.bandings.upper;
+
+        const lowerPrice = isLimitPrice
+          ? lastTick.limits.lower
+          : lastTick.bandings.lower;
+
+        switch (side) {
+          case "long":
+            this._placeLimitOrder(
+              symbol,
+              offset,
+              side,
+              volume,
+              upperPrice,
+              receiver,
+            );
+            break;
+
+          case "short":
+            this._placeLimitOrder(
+              symbol,
+              offset,
+              side,
+              volume,
+              lowerPrice,
+              receiver,
+            );
+            break;
+        }
+
+        return;
+      }
+    }
+
+    let queue = this.marketOrdersQueue.get(instrumentId);
+
+    if (queue) {
+      queue.push({ symbol, offset, side, volume, receiver });
+      return;
+    }
+
+    queue = new Denque();
+    this.marketOrdersQueue.set(instrumentId, queue);
+
+    this._withRetry(() =>
+      this.traderApi?.reqQryDepthMarketData({
+        ExchangeID: exchangeId,
+        InstrumentID: instrumentId,
+      }),
+    ).then((requestId) => {
+      if (!requestId || requestId < 0) {
+        const orders = queue.toArray();
+
+        orders.forEach((order) => {
+          order.receiver.onPlaceOrderError("Request Error");
+        });
+
+        this.marketOrdersQueue.delete(instrumentId);
+
+        return;
+      }
+
+      queue.push({ symbol, offset, side, volume, receiver });
+    });
+  }
+
+  placeOrder(
+    symbol: string,
+    offset: OffsetType,
+    side: SideType,
+    volume: number,
+    price: number,
+    flag: OrderFlag,
+    receiver: IPlaceOrderResultReceiver,
+  ) {
+    switch (flag) {
+      case "limit":
+        return this._placeLimitOrder(
+          symbol,
+          offset,
+          side,
+          volume,
+          price,
+          receiver,
+        );
+
+      case "market":
+        return this._placeMarketOrder(symbol, offset, side, volume, receiver);
+    }
+  }
+
   cancelOrder(order: OrderData, receiver: ICancelOrderResultReceiver) {
     const current = this.orders.get(order.id);
 
@@ -957,12 +1220,7 @@ export class Trader extends CTPProvider implements ITraderProvider {
         ActionFlag: ctp.ActionFlagType.Delete,
       }),
     ).then((requestId) => {
-      if (!requestId) {
-        receiver.onCancelOrderError("Request Failed");
-        return;
-      }
-
-      if (requestId < 0) {
+      if (!requestId || requestId < 0) {
         receiver.onCancelOrderError("Request Error");
         return;
       }
@@ -1605,4 +1863,5 @@ export const createTrader = (
   flowTdPath: string,
   frontTdAddrs: string | string[],
   userInfo: CTPUserInfo,
-) => new Trader(flowTdPath, frontTdAddrs, userInfo);
+  options?: TraderOptions,
+) => new Trader(flowTdPath, frontTdAddrs, userInfo, options);

package/src/utils.ts

@@ -17,6 +17,9 @@ import {
   IStrategy,
 } from "./interfaces.js";
 
+export const isValidPrice = (x: number) => x !== Number.MAX_VALUE && x !== 0;
+export const isValidVolume = (x: number) => x !== Number.MAX_VALUE && x !== 0;
+
 export const parseSymbol = (symbol: string): [string, string] => {
   const [instrumentId, exchangeId] = symbol.split(".");
   return [instrumentId, exchangeId];
@@ -130,7 +133,7 @@ export const buyOpen = (
     "long",
     volume,
     price,
-    flag,
+    price > 0 && flag === "limit" ? "limit" : "market",
     receiver,
   );
 
@@ -151,7 +154,7 @@ export const buyClose = (
     "long",
     volume,
     price,
-    flag,
+    price > 0 && flag === "limit" ? "limit" : "market",
     receiver,
   );
 
@@ -171,7 +174,7 @@ export const sellOpen = (
     "short",
     volume,
     price,
-    flag,
+    price > 0 && flag === "limit" ? "limit" : "market",
     receiver,
   );
 
@@ -192,6 +195,6 @@ export const sellClose = (
     "short",
     volume,
     price,
-    flag,
+    price > 0 && flag === "limit" ? "limit" : "market",
     receiver,
   );