hft-js 0.2.0 → 0.3.0

package/lib/trader.js

@@ -1,4 +1,3 @@
-"use strict";
 /*
  * trader.ts
  *
@@ -9,183 +8,172 @@
  *
  * https://github.com/shixiongfei/hft.js
  */
-var __extends = (this && this.__extends) || (function () {
-    var extendStatics = function (d, b) {
-        extendStatics = Object.setPrototypeOf ||
-            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
-        return extendStatics(d, b);
-    };
-    return function (d, b) {
-        if (typeof b !== "function" && b !== null)
-            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
-        extendStatics(d, b);
-        function __() { this.constructor = d; }
-        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-    };
-})();
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
+import Denque from "denque";
+import ctp, {} from "napi-ctp";
+import { CTPProvider } from "./provider.js";
+import { isValidPrice, parseSymbol } from "./utils.js";
+export class Trader extends CTPProvider {
+    traderApi;
+    tradingDay;
+    frontId;
+    sessionId;
+    orderRef;
+    accountsQueryTime;
+    positionDetailsChanged;
+    fastQueryLastTick;
+    userInfo;
+    receivers;
+    accounts;
+    positionDetails;
+    instruments;
+    positions;
+    orders;
+    trades;
+    marginRates;
+    commRates;
+    placeOrders;
+    cancelOrders;
+    marketOrdersQueue;
+    priceLimit;
+    orderStatistics;
+    marginRatesQueue;
+    commRatesQueue;
+    accountsQueue;
+    positionDetailsQueue;
+    constructor(flowTdPath, frontTdAddrs, userInfo, options) {
+        super(flowTdPath, frontTdAddrs);
+        this.tradingDay = 0;
+        this.frontId = 0;
+        this.sessionId = 0;
+        this.orderRef = 0;
+        this.accountsQueryTime = 0;
+        this.positionDetailsChanged = true;
+        this.userInfo = userInfo;
+        this.receivers = [];
+        this.accounts = [];
+        this.positionDetails = [];
+        this.instruments = new Map();
+        this.positions = new Map();
+        this.orders = new Map();
+        this.trades = new Map();
+        this.marginRates = new Map();
+        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;
         }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createTrader = exports.Trader = void 0;
-var denque_1 = __importDefault(require("denque"));
-var napi_ctp_1 = __importDefault(require("napi-ctp"));
-var provider_js_1 = require("./provider.js");
-var utils_js_1 = require("./utils.js");
-var Trader = /** @class */ (function (_super) {
-    __extends(Trader, _super);
-    function Trader(flowTdPath, frontTdAddrs, userInfo, options) {
-        var _this = _super.call(this, flowTdPath, frontTdAddrs) || this;
-        _this.tradingDay = 0;
-        _this.frontId = 0;
-        _this.sessionId = 0;
-        _this.orderRef = 0;
-        _this.accountsQueryTime = 0;
-        _this.positionDetailsChanged = true;
-        _this.userInfo = userInfo;
-        _this.receivers = [];
-        _this.accounts = [];
-        _this.positionDetails = [];
-        _this.instruments = new Map();
-        _this.positions = new Map();
-        _this.orders = new Map();
-        _this.trades = new Map();
-        _this.marginRates = new Map();
-        _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_1.default();
-        _this.commRatesQueue = new denque_1.default();
-        _this.accountsQueue = new denque_1.default();
-        _this.positionDetailsQueue = new denque_1.default();
-        if (options === null || options === void 0 ? void 0 : options.fastQueryLastTick) {
-            _this.fastQueryLastTick = options.fastQueryLastTick;
-        }
-        return _this;
     }
-    Trader.prototype.open = function (lifecycle) {
-        var _this = this;
+    open(lifecycle) {
         if (this.traderApi) {
             return true;
         }
-        this.traderApi = napi_ctp_1.default.createTrader(this.flowPath, this.frontAddrs);
-        this.traderApi.on(napi_ctp_1.default.TraderEvent.FrontConnected, function () {
-            _this._withRetry(function () { return _this.traderApi.reqAuthenticate(_this.userInfo); });
+        this.traderApi = ctp.createTrader(this.flowPath, this.frontAddrs);
+        this.traderApi.on(ctp.TraderEvent.FrontConnected, () => {
+            this._withRetry(() => this.traderApi.reqAuthenticate(this.userInfo));
         });
-        this.traderApi.on(napi_ctp_1.default.TraderEvent.FrontDisconnected, function () {
-            _this._clearAllMarketOrders();
-            _this.placeOrders.clear();
-            _this.cancelOrders.clear();
+        this.traderApi.on(ctp.TraderEvent.FrontDisconnected, () => {
+            this._clearAllMarketOrders();
+            this.placeOrders.clear();
+            this.cancelOrders.clear();
         });
-        this.traderApi.on(napi_ctp_1.default.TraderEvent.RspAuthenticate, function (_, options) {
-            if (_this._isErrorResp(lifecycle, options, "login-error")) {
+        this.traderApi.on(ctp.TraderEvent.RspAuthenticate, (_, options) => {
+            if (this._isErrorResp(lifecycle, options, "login-error")) {
                 return;
             }
-            _this._withRetry(function () { return _this.traderApi.reqUserLogin(_this.userInfo); });
+            this._withRetry(() => this.traderApi.reqUserLogin(this.userInfo));
         });
-        this.traderApi.on(napi_ctp_1.default.TraderEvent.RspUserLogin, function (rspUserLogin, options) {
-            if (_this._isErrorResp(lifecycle, options, "login-error")) {
+        this.traderApi.on(ctp.TraderEvent.RspUserLogin, (rspUserLogin, options) => {
+            if (this._isErrorResp(lifecycle, options, "login-error")) {
                 return;
             }
-            _this.frontId = rspUserLogin.FrontID;
-            _this.sessionId = rspUserLogin.SessionID;
-            _this.orderRef = parseInt(rspUserLogin.MaxOrderRef);
-            var tradingDay = parseInt(_this.traderApi.getTradingDay());
-            if (_this.tradingDay !== tradingDay) {
-                _this.marginRates.clear();
-                _this.commRates.clear();
-                _this.orderStatistics.clear();
-                _this.priceLimit.clear();
-                _this.tradingDay = tradingDay;
+            this.frontId = rspUserLogin.FrontID;
+            this.sessionId = rspUserLogin.SessionID;
+            this.orderRef = parseInt(rspUserLogin.MaxOrderRef);
+            const tradingDay = parseInt(this.traderApi.getTradingDay());
+            if (this.tradingDay !== tradingDay) {
+                this.marginRates.clear();
+                this.commRates.clear();
+                this.orderStatistics.clear();
+                this.priceLimit.clear();
+                this.tradingDay = tradingDay;
             }
-            _this._withRetry(function () {
-                return _this.traderApi.reqSettlementInfoConfirm(_this.userInfo);
-            });
+            this._withRetry(() => this.traderApi.reqSettlementInfoConfirm(this.userInfo));
         });
-        this.traderApi.on(napi_ctp_1.default.TraderEvent.RspSettlementInfoConfirm, function (_, options) {
-            if (_this._isErrorResp(lifecycle, options, "login-error")) {
+        this.traderApi.on(ctp.TraderEvent.RspSettlementInfoConfirm, (_, options) => {
+            if (this._isErrorResp(lifecycle, options, "login-error")) {
                 return;
             }
-            _this.orders.clear();
-            _this._withRetry(function () { return _this.traderApi.reqQryOrder(_this.userInfo); });
+            this.orders.clear();
+            this._withRetry(() => this.traderApi.reqQryOrder(this.userInfo));
         });
-        this.traderApi.on(napi_ctp_1.default.TraderEvent.RspQryOrder, function (order, options) {
-            if (_this._isErrorResp(lifecycle, options, "query-order-error")) {
+        this.traderApi.on(ctp.TraderEvent.RspQryOrder, (order, options) => {
+            if (this._isErrorResp(lifecycle, options, "query-order-error")) {
                 return;
             }
             if (order) {
-                var orderId = _this._calcOrderId(order);
-                _this.orders.set(orderId, order);
+                const orderId = this._calcOrderId(order);
+                this.orders.set(orderId, order);
             }
             if (options.isLast) {
-                _this.trades.clear();
-                _this._withRetry(function () { return _this.traderApi.reqQryTrade(_this.userInfo); });
+                this.trades.clear();
+                this._withRetry(() => this.traderApi.reqQryTrade(this.userInfo));
             }
         });
-        this.traderApi.on(napi_ctp_1.default.TraderEvent.RspQryTrade, function (trade, options) {
-            if (_this._isErrorResp(lifecycle, options, "query-trade-error")) {
+        this.traderApi.on(ctp.TraderEvent.RspQryTrade, (trade, options) => {
+            if (this._isErrorResp(lifecycle, options, "query-trade-error")) {
                 return;
             }
             if (trade) {
-                var orderId = _this._calcOrderId(trade);
-                var trades = _this.trades.get(orderId);
+                const orderId = this._calcOrderId(trade);
+                const trades = this.trades.get(orderId);
                 if (trades) {
                     trades.push(trade);
                 }
                 else {
-                    _this.trades.set(orderId, [trade]);
+                    this.trades.set(orderId, [trade]);
                 }
             }
             if (options.isLast) {
-                _this.instruments.clear();
-                _this._withRetry(function () { return _this.traderApi.reqQryInstrument(); });
+                this.instruments.clear();
+                this._withRetry(() => this.traderApi.reqQryInstrument());
             }
         });
-        this.traderApi.on(napi_ctp_1.default.TraderEvent.RspQryInstrument, function (instrument, options) {
-            if (_this._isErrorResp(lifecycle, options, "query-instrument-error")) {
+        this.traderApi.on(ctp.TraderEvent.RspQryInstrument, (instrument, options) => {
+            if (this._isErrorResp(lifecycle, options, "query-instrument-error")) {
                 return;
             }
             if (instrument) {
-                if (instrument.ProductClass === napi_ctp_1.default.ProductClassType.Futures ||
-                    instrument.ProductClass === napi_ctp_1.default.ProductClassType.Options) {
-                    _this.instruments.set(instrument.InstrumentID, instrument);
+                if (instrument.ProductClass === ctp.ProductClassType.Futures ||
+                    instrument.ProductClass === ctp.ProductClassType.Options) {
+                    this.instruments.set(instrument.InstrumentID, instrument);
                 }
             }
             if (options.isLast) {
-                _this.positions.clear();
-                _this._withRetry(function () {
-                    return _this.traderApi.reqQryInvestorPosition(_this.userInfo);
-                });
+                this.positions.clear();
+                this._withRetry(() => this.traderApi.reqQryInvestorPosition(this.userInfo));
             }
         });
-        var fired = false;
-        this.traderApi.on(napi_ctp_1.default.TraderEvent.RspQryInvestorPosition, function (position, options) {
-            if (_this._isErrorResp(lifecycle, options, "query-positions-error")) {
+        let fired = false;
+        this.traderApi.on(ctp.TraderEvent.RspQryInvestorPosition, (position, options) => {
+            if (this._isErrorResp(lifecycle, options, "query-positions-error")) {
                 return;
             }
             if (position) {
-                var symbol = _this._toSymbol(position.InstrumentID);
+                const symbol = this._toSymbol(position.InstrumentID);
                 if (symbol) {
-                    var posInfo = _this._ensurePositionInfo(symbol);
-                    var ExchangeSH = ["SHFE", "INE"];
+                    let posInfo = this._ensurePositionInfo(symbol);
+                    const ExchangeSH = ["SHFE", "INE"];
                     switch (position.PosiDirection) {
-                        case napi_ctp_1.default.PosiDirectionType.Long:
-                            if (position.PositionDate === napi_ctp_1.default.PositionDateType.Today) {
+                        case ctp.PosiDirectionType.Long:
+                            if (position.PositionDate === ctp.PositionDateType.Today) {
                                 if (ExchangeSH.includes(position.ExchangeID)) {
                                     posInfo.today.long.position += position.TodayPosition;
                                 }
@@ -198,8 +186,8 @@ var Trader = /** @class */ (function (_super) {
                                     position.Position - position.TodayPosition;
                             }
                             break;
-                        case napi_ctp_1.default.PosiDirectionType.Short:
-                            if (position.PositionDate === napi_ctp_1.default.PositionDateType.Today) {
+                        case ctp.PosiDirectionType.Short:
+                            if (position.PositionDate === ctp.PositionDateType.Today) {
                                 if (ExchangeSH.includes(position.ExchangeID)) {
                                     posInfo.today.short.position += position.TodayPosition;
                                 }
@@ -220,271 +208,259 @@ var Trader = /** @class */ (function (_super) {
                     fired = true;
                     lifecycle.onOpen();
                 }
-                if (_this.accountsQueue.size() > 0) {
-                    _this._withRetry(function () {
-                        return _this.traderApi.reqQryTradingAccount(_this.userInfo);
-                    });
+                if (this.accountsQueue.size() > 0) {
+                    this._withRetry(() => this.traderApi.reqQryTradingAccount(this.userInfo));
                 }
-                if (_this.positionDetailsQueue.size() > 0) {
-                    _this._withRetry(function () {
-                        return _this.traderApi.reqQryInvestorPositionDetail(_this.userInfo);
-                    });
+                if (this.positionDetailsQueue.size() > 0) {
+                    this._withRetry(() => this.traderApi.reqQryInvestorPositionDetail(this.userInfo));
                 }
-                _this._processMarginRatesQueue();
-                _this._processCommissionRatesQueue();
+                this._processMarginRatesQueue();
+                this._processCommissionRatesQueue();
             }
         });
-        this.traderApi.on(napi_ctp_1.default.TraderEvent.RtnOrder, function (order) {
-            var orderId = _this._calcOrderId(order);
-            var current = _this.orders.get(orderId);
+        this.traderApi.on(ctp.TraderEvent.RtnOrder, (order) => {
+            const orderId = this._calcOrderId(order);
+            const current = this.orders.get(orderId);
             if (current) {
                 if (order.OrderSubmitStatus === current.OrderSubmitStatus &&
                     order.OrderStatus === current.OrderStatus) {
                     return;
                 }
             }
-            _this.orders.set(orderId, order);
-            switch (_this._calcOrderStatus(order)) {
+            this.orders.set(orderId, order);
+            switch (this._calcOrderStatus(order)) {
                 case "submitted":
                     {
-                        var orderData_1 = _this._toOrderData(order);
-                        var symbol = _this._toSymbol(order.InstrumentID);
+                        const orderData = this._toOrderData(order);
+                        const symbol = this._toSymbol(order.InstrumentID);
                         if (symbol) {
-                            if (orderData_1.offset === "open") {
-                                _this._recordPending(symbol, orderData_1.side, orderData_1.offset, orderData_1.volume);
+                            if (orderData.offset === "open") {
+                                this._recordPending(symbol, orderData.side, orderData.offset, orderData.volume);
                             }
                             else {
-                                _this._freezePosition(symbol, orderData_1.side, orderData_1.offset, orderData_1.volume);
+                                this._freezePosition(symbol, orderData.side, orderData.offset, orderData.volume);
                             }
-                            var statistic = _this._ensureOrderStatistic(symbol);
+                            const statistic = this._ensureOrderStatistic(symbol);
                             statistic.entrusts += 1;
                         }
-                        _this.receivers.forEach(function (receiver) { return receiver.onEntrust(orderData_1); });
+                        this.receivers.forEach((receiver) => receiver.onEntrust(orderData));
                     }
                     break;
                 case "filled":
                     {
-                        var symbol = _this._toSymbol(order.InstrumentID);
+                        const symbol = this._toSymbol(order.InstrumentID);
                         if (symbol) {
-                            var statistic = _this._ensureOrderStatistic(symbol);
+                            const statistic = this._ensureOrderStatistic(symbol);
                             statistic.filleds += 1;
                         }
                     }
                     break;
                 case "canceled":
                     {
-                        var orderData_2 = _this._toOrderData(order);
-                        var symbol = _this._toSymbol(order.InstrumentID);
+                        const orderData = this._toOrderData(order);
+                        const symbol = this._toSymbol(order.InstrumentID);
                         if (symbol) {
-                            if (orderData_2.offset === "open") {
-                                _this._recoverPending(symbol, orderData_2.side, orderData_2.offset, orderData_2.volume);
+                            if (orderData.offset === "open") {
+                                this._recoverPending(symbol, orderData.side, orderData.offset, orderData.volume);
                             }
                             else {
-                                _this._unfreezePosition(symbol, orderData_2.side, orderData_2.offset, orderData_2.volume);
+                                this._unfreezePosition(symbol, orderData.side, orderData.offset, orderData.volume);
                             }
-                            var statistic = _this._ensureOrderStatistic(symbol);
+                            const statistic = this._ensureOrderStatistic(symbol);
                             statistic.cancels += 1;
                         }
-                        _this.receivers.forEach(function (receiver) { return receiver.onCancel(orderData_2); });
+                        this.receivers.forEach((receiver) => receiver.onCancel(orderData));
                     }
                     break;
                 case "rejected":
                     {
-                        var orderData_3 = _this._toOrderData(order);
-                        var symbol = _this._toSymbol(order.InstrumentID);
+                        const orderData = this._toOrderData(order);
+                        const symbol = this._toSymbol(order.InstrumentID);
                         if (symbol) {
-                            var statistic = _this._ensureOrderStatistic(symbol);
+                            const statistic = this._ensureOrderStatistic(symbol);
                             statistic.rejects += 1;
                         }
-                        _this.receivers.forEach(function (receiver) { return receiver.onReject(orderData_3); });
+                        this.receivers.forEach((receiver) => receiver.onReject(orderData));
                     }
                     break;
             }
         });
-        this.traderApi.on(napi_ctp_1.default.TraderEvent.RtnTrade, function (trade) {
-            var orderId = _this._calcOrderId(trade);
-            var trades = _this.trades.get(orderId);
+        this.traderApi.on(ctp.TraderEvent.RtnTrade, (trade) => {
+            const orderId = this._calcOrderId(trade);
+            const trades = this.trades.get(orderId);
             if (trades) {
                 trades.push(trade);
             }
             else {
-                _this.trades.set(orderId, [trade]);
+                this.trades.set(orderId, [trade]);
             }
-            _this.positionDetailsChanged = true;
-            var order = _this.orders.get(orderId);
+            this.positionDetailsChanged = true;
+            const order = this.orders.get(orderId);
             if (order) {
-                var orderData_4 = _this._toOrderData(order);
-                var tradeData_1 = _this._toTradeData(trade);
-                var symbol = _this._toSymbol(order.InstrumentID);
+                const orderData = this._toOrderData(order);
+                const tradeData = this._toTradeData(trade);
+                const symbol = this._toSymbol(order.InstrumentID);
                 if (symbol) {
-                    _this._calcPosition(symbol, orderData_4.side, orderData_4.offset, tradeData_1.volume);
+                    this._calcPosition(symbol, orderData.side, orderData.offset, tradeData.volume);
                 }
-                _this.receivers.forEach(function (receiver) {
-                    return receiver.onTrade(orderData_4, tradeData_1);
-                });
+                this.receivers.forEach((receiver) => receiver.onTrade(orderData, tradeData));
             }
         });
-        this.traderApi.on(napi_ctp_1.default.TraderEvent.RspQryInstrumentMarginRate, function (marginRate, options) {
-            var query = _this.marginRatesQueue.shift();
-            if (_this._isErrorResp(lifecycle, options, "query-margin-rate-error")) {
+        this.traderApi.on(ctp.TraderEvent.RspQryInstrumentMarginRate, (marginRate, options) => {
+            const query = this.marginRatesQueue.shift();
+            if (this._isErrorResp(lifecycle, options, "query-margin-rate-error")) {
                 if (query) {
                     query.receiver.onMarginRate(undefined);
                 }
                 return;
             }
             if (marginRate) {
-                _this.marginRates.set(marginRate.InstrumentID, marginRate);
+                this.marginRates.set(marginRate.InstrumentID, marginRate);
                 if (query) {
-                    query.receiver.onMarginRate(_this._toMarginRate(query.symbol, marginRate));
+                    query.receiver.onMarginRate(this._toMarginRate(query.symbol, marginRate));
                 }
             }
-            _this._processMarginRatesQueue();
+            this._processMarginRatesQueue();
         });
-        this.traderApi.on(napi_ctp_1.default.TraderEvent.RspQryInstrumentCommissionRate, function (commRate, options) {
-            var query = _this.commRatesQueue.shift();
-            if (_this._isErrorResp(lifecycle, options, "query-commission-rate-error")) {
+        this.traderApi.on(ctp.TraderEvent.RspQryInstrumentCommissionRate, (commRate, options) => {
+            const query = this.commRatesQueue.shift();
+            if (this._isErrorResp(lifecycle, options, "query-commission-rate-error")) {
                 if (query) {
                     query.receiver.onCommissionRate(undefined);
                 }
                 return;
             }
             if (commRate) {
-                _this.commRates.set(commRate.InstrumentID, commRate);
+                this.commRates.set(commRate.InstrumentID, commRate);
                 if (query) {
-                    query.receiver.onCommissionRate(_this._toCommissionRate(query.symbol, commRate));
+                    query.receiver.onCommissionRate(this._toCommissionRate(query.symbol, commRate));
                 }
             }
-            _this._processCommissionRatesQueue();
+            this._processCommissionRatesQueue();
         });
-        this.traderApi.on(napi_ctp_1.default.TraderEvent.RspQryTradingAccount, function (account, options) {
-            if (_this._isErrorResp(lifecycle, options, "query-accounts-error")) {
-                var receivers = _this.accountsQueue.toArray();
-                receivers.forEach(function (receiver) {
-                    return receiver.onTradingAccounts(undefined);
-                });
-                _this.accountsQueue.clear();
+        this.traderApi.on(ctp.TraderEvent.RspQryTradingAccount, (account, options) => {
+            if (this._isErrorResp(lifecycle, options, "query-accounts-error")) {
+                const receivers = this.accountsQueue.toArray();
+                receivers.forEach((receiver) => receiver.onTradingAccounts(undefined));
+                this.accountsQueue.clear();
                 return;
             }
             if (account) {
-                _this.accounts.push(account);
+                this.accounts.push(account);
             }
             if (options.isLast) {
-                var accounts_1 = _this.accounts.map(_this._toTradingAccount, _this);
-                var receivers = _this.accountsQueue.toArray();
-                receivers.forEach(function (receiver) { return receiver.onTradingAccounts(accounts_1); });
-                _this.accountsQueue.clear();
-                _this.accountsQueryTime = Date.now();
+                const accounts = this.accounts.map(this._toTradingAccount, this);
+                const receivers = this.accountsQueue.toArray();
+                receivers.forEach((receiver) => receiver.onTradingAccounts(accounts));
+                this.accountsQueue.clear();
+                this.accountsQueryTime = Date.now();
             }
         });
-        this.traderApi.on(napi_ctp_1.default.TraderEvent.RspQryInvestorPositionDetail, function (positionDetail, options) {
-            if (_this._isErrorResp(lifecycle, options, "query-position-details-error")) {
-                var receivers = _this.positionDetailsQueue.toArray();
-                receivers.forEach(function (receiver) {
-                    return receiver.onPositionDetails(undefined);
-                });
-                _this.positionDetailsQueue.clear();
+        this.traderApi.on(ctp.TraderEvent.RspQryInvestorPositionDetail, (positionDetail, options) => {
+            if (this._isErrorResp(lifecycle, options, "query-position-details-error")) {
+                const receivers = this.positionDetailsQueue.toArray();
+                receivers.forEach((receiver) => receiver.onPositionDetails(undefined));
+                this.positionDetailsQueue.clear();
                 return;
             }
             if (positionDetail) {
-                _this.positionDetails.push(positionDetail);
+                this.positionDetails.push(positionDetail);
             }
             if (options.isLast) {
-                var positionDetails_1 = _this.positionDetails.map(_this._toPositionDetail, _this);
-                var receivers = _this.positionDetailsQueue.toArray();
-                _this.positionDetailsChanged = false;
-                receivers.forEach(function (receiver) {
-                    return receiver.onPositionDetails(positionDetails_1);
-                });
-                _this.positionDetailsQueue.clear();
+                const positionDetails = this.positionDetails.map(this._toPositionDetail, this);
+                const receivers = this.positionDetailsQueue.toArray();
+                this.positionDetailsChanged = false;
+                receivers.forEach((receiver) => receiver.onPositionDetails(positionDetails));
+                this.positionDetailsQueue.clear();
             }
         });
-        this.traderApi.on(napi_ctp_1.default.TraderEvent.RspOrderInsert, function (order, options) {
+        this.traderApi.on(ctp.TraderEvent.RspOrderInsert, (order, options) => {
             if (options.rspInfo && order && options.requestId && options.isLast) {
-                var receiver = _this.placeOrders.get(options.requestId);
+                const receiver = this.placeOrders.get(options.requestId);
                 if (receiver) {
-                    _this.placeOrders.delete(options.requestId);
-                    receiver.onPlaceOrderError("".concat(options.rspInfo.ErrorID, ": ").concat(options.rspInfo.ErrorMsg));
+                    this.placeOrders.delete(options.requestId);
+                    receiver.onPlaceOrderError(`${options.rspInfo.ErrorID}: ${options.rspInfo.ErrorMsg}`);
                 }
             }
         });
-        this.traderApi.on(napi_ctp_1.default.TraderEvent.RspOrderAction, function (order, options) {
+        this.traderApi.on(ctp.TraderEvent.RspOrderAction, (order, options) => {
             if (options.rspInfo && order && options.requestId && options.isLast) {
-                var receiver = _this.cancelOrders.get(options.requestId);
+                const receiver = this.cancelOrders.get(options.requestId);
                 if (receiver) {
-                    _this.cancelOrders.delete(options.requestId);
-                    receiver.onCancelOrderError("".concat(options.rspInfo.ErrorID, ": ").concat(options.rspInfo.ErrorMsg));
+                    this.cancelOrders.delete(options.requestId);
+                    receiver.onCancelOrderError(`${options.rspInfo.ErrorID}: ${options.rspInfo.ErrorMsg}`);
                 }
             }
         });
-        this.traderApi.on(napi_ctp_1.default.TraderEvent.RspQryDepthMarketData, function (depthMarketData, options) {
-            if (_this._isErrorResp(lifecycle, options, "query-depth-market-data-error")) {
-                _this._clearAllMarketOrders();
+        this.traderApi.on(ctp.TraderEvent.RspQryDepthMarketData, (depthMarketData, options) => {
+            if (this._isErrorResp(lifecycle, options, "query-depth-market-data-error")) {
+                this._clearAllMarketOrders();
                 return;
             }
-            var isLimitPrice = !(0, utils_js_1.isValidPrice)(depthMarketData.BandingUpperPrice) ||
-                !(0, utils_js_1.isValidPrice)(depthMarketData.BandingLowerPrice);
+            const isLimitPrice = !isValidPrice(depthMarketData.BandingUpperPrice) ||
+                !isValidPrice(depthMarketData.BandingLowerPrice);
             if (isLimitPrice) {
-                _this.priceLimit.set(depthMarketData.InstrumentID, {
+                this.priceLimit.set(depthMarketData.InstrumentID, {
                     upper: depthMarketData.UpperLimitPrice,
                     lower: depthMarketData.LowerLimitPrice,
                 });
             }
-            var queue = _this.marketOrdersQueue.get(depthMarketData.InstrumentID);
+            const queue = this.marketOrdersQueue.get(depthMarketData.InstrumentID);
             if (!queue) {
                 return;
             }
             if (!queue.isEmpty()) {
-                var upperPrice_1 = isLimitPrice
+                const upperPrice = isLimitPrice
                     ? depthMarketData.UpperLimitPrice
                     : depthMarketData.BandingUpperPrice;
-                var lowerPrice_1 = isLimitPrice
+                const lowerPrice = isLimitPrice
                     ? depthMarketData.LowerLimitPrice
                     : depthMarketData.BandingLowerPrice;
-                var orders = queue.toArray();
-                orders.forEach(function (order) {
+                const orders = queue.toArray();
+                orders.forEach((order) => {
                     switch (order.side) {
                         case "long":
-                            _this._placeLimitOrder(order.symbol, order.offset, order.side, order.volume, upperPrice_1, order.receiver);
+                            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_1, order.receiver);
+                            this._placeLimitOrder(order.symbol, order.offset, order.side, order.volume, lowerPrice, order.receiver);
                             break;
                     }
                 });
             }
-            _this.marketOrdersQueue.delete(depthMarketData.InstrumentID);
+            this.marketOrdersQueue.delete(depthMarketData.InstrumentID);
         });
         return true;
-    };
-    Trader.prototype.close = function (lifecycle) {
+    }
+    close(lifecycle) {
         if (!this.traderApi) {
             return;
         }
         this.traderApi.close();
         this.traderApi = undefined;
         lifecycle.onClose();
-    };
-    Trader.prototype.addOrderReceiver = function (receiver) {
+    }
+    addOrderReceiver(receiver) {
         if (!this.receivers.includes(receiver)) {
             this.receivers.push(receiver);
         }
-    };
-    Trader.prototype.removeOrderReceiver = function (receiver) {
-        var index = this.receivers.indexOf(receiver);
+    }
+    removeOrderReceiver(receiver) {
+        const index = this.receivers.indexOf(receiver);
         if (index < 0) {
             return;
         }
         this.receivers.splice(index, 1);
-    };
-    Trader.prototype.getTradingDay = function () {
+    }
+    getTradingDay() {
         return this.tradingDay;
-    };
-    Trader.prototype.getOrderStatistics = function () {
-        var statistics = Array.from(this.orderStatistics.values());
-        return statistics.map(function (stat) { return Object.freeze(__assign({}, stat)); });
-    };
-    Trader.prototype.getOrderStatistic = function (symbol) {
-        var statistic = this.orderStatistics.get(symbol);
+    }
+    getOrderStatistics() {
+        const statistics = Array.from(this.orderStatistics.values());
+        return statistics.map((stat) => Object.freeze({ ...stat }));
+    }
+    getOrderStatistic(symbol) {
+        const statistic = this.orderStatistics.get(symbol);
         if (!statistic) {
             return Object.freeze({
                 symbol: symbol,
@@ -495,54 +471,53 @@ var Trader = /** @class */ (function (_super) {
                 rejects: 0,
             });
         }
-        return Object.freeze(__assign({}, statistic));
-    };
-    Trader.prototype.queryCommissionRate = function (symbol, receiver) {
-        var _this = this;
-        var instrumentId = (0, utils_js_1.parseSymbol)(symbol)[0];
-        var commRate = this.commRates.get(instrumentId);
+        return Object.freeze({ ...statistic });
+    }
+    queryCommissionRate(symbol, receiver) {
+        const [instrumentId] = parseSymbol(symbol);
+        const commRate = this.commRates.get(instrumentId);
         if (commRate) {
             receiver.onCommissionRate(this._toCommissionRate(symbol, commRate));
             return;
         }
-        this.commRatesQueue.push({ symbol: symbol, receiver: receiver });
+        this.commRatesQueue.push({ symbol, receiver });
         if (this.commRatesQueue.size() === 1) {
-            this._withRetry(function () {
-                var _a;
-                return (_a = _this.traderApi) === null || _a === void 0 ? void 0 : _a.reqQryInstrumentCommissionRate(__assign(__assign({}, _this.userInfo), { InstrumentID: instrumentId }));
-            });
+            this._withRetry(() => this.traderApi?.reqQryInstrumentCommissionRate({
+                ...this.userInfo,
+                InstrumentID: instrumentId,
+            }));
         }
-    };
-    Trader.prototype.queryMarginRate = function (symbol, receiver) {
-        var _this = this;
-        var instrumentId = (0, utils_js_1.parseSymbol)(symbol)[0];
-        var marginRate = this.marginRates.get(instrumentId);
+    }
+    queryMarginRate(symbol, receiver) {
+        const [instrumentId] = parseSymbol(symbol);
+        const marginRate = this.marginRates.get(instrumentId);
         if (marginRate) {
             receiver.onMarginRate(this._toMarginRate(symbol, marginRate));
             return;
         }
-        this.marginRatesQueue.push({ symbol: symbol, receiver: receiver });
+        this.marginRatesQueue.push({ symbol, receiver });
         if (this.marginRatesQueue.size() === 1) {
-            this._withRetry(function () {
-                var _a;
-                return (_a = _this.traderApi) === null || _a === void 0 ? void 0 : _a.reqQryInstrumentMarginRate(__assign(__assign({}, _this.userInfo), { HedgeFlag: napi_ctp_1.default.HedgeFlagType.Speculation, InstrumentID: instrumentId }));
-            });
+            this._withRetry(() => this.traderApi?.reqQryInstrumentMarginRate({
+                ...this.userInfo,
+                HedgeFlag: ctp.HedgeFlagType.Speculation,
+                InstrumentID: instrumentId,
+            }));
         }
-    };
-    Trader.prototype.queryInstrument = function (symbol, receiver) {
-        var _a = (0, utils_js_1.parseSymbol)(symbol), instrumentId = _a[0], exchangeId = _a[1];
-        var instrument = this.instruments.get(instrumentId);
+    }
+    queryInstrument(symbol, receiver) {
+        const [instrumentId, exchangeId] = parseSymbol(symbol);
+        const instrument = this.instruments.get(instrumentId);
         receiver.onInstrument(instrument && instrument.ExchangeID === exchangeId
             ? this._toInstrumentData(instrument)
             : undefined);
-    };
-    Trader.prototype.queryPosition = function (symbol, receiver) {
-        var position = this.positions.get(symbol);
+    }
+    queryPosition(symbol, receiver) {
+        const position = this.positions.get(symbol);
         if (position) {
             receiver.onPosition(this._toPositionData(position));
             return;
         }
-        var instrumentId = (0, utils_js_1.parseSymbol)(symbol)[0];
+        const [instrumentId] = parseSymbol(symbol);
         if (!this.instruments.has(instrumentId)) {
             receiver.onPosition(undefined);
             return;
@@ -559,46 +534,40 @@ var Trader = /** @class */ (function (_super) {
             }),
             pending: Object.freeze({ long: 0, short: 0 }),
         }));
-    };
-    Trader.prototype.queryInstruments = function (receiver, type) {
-        var instruments = Array.from(this.instruments.values());
+    }
+    queryInstruments(receiver, type) {
+        const instruments = Array.from(this.instruments.values());
         switch (type) {
             case "futures":
                 receiver.onInstruments(instruments
-                    .filter(function (instrument) {
-                    return instrument.ProductClass === napi_ctp_1.default.ProductClassType.Futures;
-                })
+                    .filter((instrument) => instrument.ProductClass === ctp.ProductClassType.Futures)
                     .map(this._toInstrumentData, this));
                 break;
             case "options":
                 receiver.onInstruments(instruments
-                    .filter(function (instrument) {
-                    return instrument.ProductClass === napi_ctp_1.default.ProductClassType.Options;
-                })
+                    .filter((instrument) => instrument.ProductClass === ctp.ProductClassType.Options)
                     .map(this._toInstrumentData, this));
                 break;
             default:
                 receiver.onInstruments(instruments.map(this._toInstrumentData, this));
                 break;
         }
-    };
-    Trader.prototype.queryTradingAccounts = function (receiver) {
-        var _this = this;
+    }
+    queryTradingAccounts(receiver) {
         if (this.accountsQueue.size() > 0) {
             this.accountsQueue.push(receiver);
             return;
         }
-        var elapsed = Date.now() - this.accountsQueryTime;
+        const elapsed = Date.now() - this.accountsQueryTime;
         if (elapsed < 3000) {
             receiver.onTradingAccounts(this.accounts.map(this._toTradingAccount, this));
             return;
         }
         this.accountsQueue.push(receiver);
         this.accounts.splice(0, this.accounts.length);
-        this._withRetry(function () { var _a; return (_a = _this.traderApi) === null || _a === void 0 ? void 0 : _a.reqQryTradingAccount(_this.userInfo); });
-    };
-    Trader.prototype.queryPositionDetails = function (receiver) {
-        var _this = this;
+        this._withRetry(() => this.traderApi?.reqQryTradingAccount(this.userInfo));
+    }
+    queryPositionDetails(receiver) {
         if (this.positionDetailsQueue.size() > 0) {
             this.positionDetailsQueue.push(receiver);
             return;
@@ -609,28 +578,23 @@ var Trader = /** @class */ (function (_super) {
         }
         this.positionDetailsQueue.push(receiver);
         this.positionDetails.splice(0, this.positionDetails.length);
-        this._withRetry(function () { var _a; return (_a = _this.traderApi) === null || _a === void 0 ? void 0 : _a.reqQryInvestorPositionDetail(_this.userInfo); });
-    };
-    Trader.prototype.queryPositions = function (receiver) {
-        var _this = this;
-        var positions = [];
-        this.positions.forEach(function (position) {
-            return positions.push(_this._toPositionData(position));
-        });
+        this._withRetry(() => this.traderApi?.reqQryInvestorPositionDetail(this.userInfo));
+    }
+    queryPositions(receiver) {
+        const positions = [];
+        this.positions.forEach((position) => positions.push(this._toPositionData(position)));
         receiver.onPositions(positions);
-    };
-    Trader.prototype.queryOrders = function (receiver) {
-        var _this = this;
-        var orders = [];
-        this.orders.forEach(function (order) {
-            orders.push(_this._toOrderData(order));
+    }
+    queryOrders(receiver) {
+        const orders = [];
+        this.orders.forEach((order) => {
+            orders.push(this._toOrderData(order));
         });
         receiver.onOrders(orders);
-    };
-    Trader.prototype._placeLimitOrder = function (symbol, offset, side, volume, price, receiver) {
-        var _this = this;
-        var _a = (0, utils_js_1.parseSymbol)(symbol), instrumentId = _a[0], exchangeId = _a[1];
-        var instrument = this.instruments.get(instrumentId);
+    }
+    _placeLimitOrder(symbol, offset, side, volume, price, receiver) {
+        const [instrumentId, exchangeId] = parseSymbol(symbol);
+        const instrument = this.instruments.get(instrumentId);
         if (!instrument) {
             receiver.onPlaceOrderError("Instrument Not Found");
             return;
@@ -639,37 +603,52 @@ var Trader = /** @class */ (function (_super) {
             receiver.onPlaceOrderError("Exchange Id Error");
             return;
         }
-        var orderRef = 0;
-        this._withRetry(function () {
-            var _a;
-            orderRef = ++_this.orderRef;
-            return (_a = _this.traderApi) === null || _a === void 0 ? void 0 : _a.reqOrderInsert(__assign(__assign({}, _this.userInfo), { OrderRef: "".concat(orderRef), InstrumentID: instrumentId, ExchangeID: instrument.ExchangeID, LimitPrice: price, VolumeTotalOriginal: volume, VolumeCondition: napi_ctp_1.default.VolumeConditionType.AV, TimeCondition: napi_ctp_1.default.TimeConditionType.GFD, Direction: _this._toDirection(side), OrderPriceType: napi_ctp_1.default.OrderPriceTypeType.LimitPrice, CombOffsetFlag: _this._toOffsetFlag(offset), CombHedgeFlag: napi_ctp_1.default.HedgeFlagType.Speculation, ContingentCondition: napi_ctp_1.default.ContingentConditionType.Immediately, ForceCloseReason: napi_ctp_1.default.ForceCloseReasonType.NotForceClose, IsAutoSuspend: 0, UserForceClose: 0 }));
-        }).then(function (requestId) {
+        let orderRef = 0;
+        this._withRetry(() => {
+            orderRef = ++this.orderRef;
+            return this.traderApi?.reqOrderInsert({
+                ...this.userInfo,
+                OrderRef: `${orderRef}`,
+                InstrumentID: instrumentId,
+                ExchangeID: instrument.ExchangeID,
+                LimitPrice: price,
+                VolumeTotalOriginal: volume,
+                VolumeCondition: ctp.VolumeConditionType.AV,
+                TimeCondition: ctp.TimeConditionType.GFD,
+                Direction: this._toDirection(side),
+                OrderPriceType: ctp.OrderPriceTypeType.LimitPrice,
+                CombOffsetFlag: this._toOffsetFlag(offset),
+                CombHedgeFlag: ctp.HedgeFlagType.Speculation,
+                ContingentCondition: ctp.ContingentConditionType.Immediately,
+                ForceCloseReason: ctp.ForceCloseReasonType.NotForceClose,
+                IsAutoSuspend: 0,
+                UserForceClose: 0,
+            });
+        }).then((requestId) => {
             if (!requestId || requestId < 0) {
                 receiver.onPlaceOrderError("Request Error");
                 return;
             }
-            var statistic = _this._ensureOrderStatistic(symbol);
+            const statistic = this._ensureOrderStatistic(symbol);
             statistic.places += 1;
-            _this.placeOrders.set(requestId, receiver);
-            var receiptId = "".concat(_this.frontId, ":").concat(_this.sessionId, ":").concat(orderRef);
+            this.placeOrders.set(requestId, receiver);
+            const receiptId = `${this.frontId}:${this.sessionId}:${orderRef}`;
             receiver.onPlaceOrderSent(receiptId);
             return receiptId;
         });
-    };
-    Trader.prototype._clearAllMarketOrders = function () {
-        this.marketOrdersQueue.forEach(function (queue) {
-            var orders = queue.toArray();
-            orders.forEach(function (order) {
+    }
+    _clearAllMarketOrders() {
+        this.marketOrdersQueue.forEach((queue) => {
+            const orders = queue.toArray();
+            orders.forEach((order) => {
                 order.receiver.onPlaceOrderError("Request Error");
             });
         });
         this.marketOrdersQueue.clear();
-    };
-    Trader.prototype._placeMarketOrder = function (symbol, offset, side, volume, receiver) {
-        var _this = this;
-        var _a = (0, utils_js_1.parseSymbol)(symbol), instrumentId = _a[0], exchangeId = _a[1];
-        var instrument = this.instruments.get(instrumentId);
+    }
+    _placeMarketOrder(symbol, offset, side, volume, receiver) {
+        const [instrumentId, exchangeId] = parseSymbol(symbol);
+        const instrument = this.instruments.get(instrumentId);
         if (!instrument) {
             receiver.onPlaceOrderError("Instrument Not Found");
             return;
@@ -678,7 +657,7 @@ var Trader = /** @class */ (function (_super) {
             receiver.onPlaceOrderError("Exchange Id Error");
             return;
         }
-        var priceRange = this.priceLimit.get(instrumentId);
+        const priceRange = this.priceLimit.get(instrumentId);
         if (priceRange) {
             switch (side) {
                 case "long":
@@ -691,17 +670,17 @@ var Trader = /** @class */ (function (_super) {
             return;
         }
         if (this.fastQueryLastTick) {
-            var lastTick = this.fastQueryLastTick(instrumentId);
+            const lastTick = this.fastQueryLastTick(instrumentId);
             if (lastTick && lastTick.tradingDay === this.tradingDay) {
-                var isLimitPrice = !(0, utils_js_1.isValidPrice)(lastTick.bandings.upper) ||
-                    !(0, utils_js_1.isValidPrice)(lastTick.bandings.lower);
+                const isLimitPrice = !isValidPrice(lastTick.bandings.upper) ||
+                    !isValidPrice(lastTick.bandings.lower);
                 if (isLimitPrice) {
-                    this.priceLimit.set(instrumentId, __assign({}, lastTick.limits));
+                    this.priceLimit.set(instrumentId, { ...lastTick.limits });
                 }
-                var upperPrice = isLimitPrice
+                const upperPrice = isLimitPrice
                     ? lastTick.limits.upper
                     : lastTick.bandings.upper;
-                var lowerPrice = isLimitPrice
+                const lowerPrice = isLimitPrice
                     ? lastTick.limits.lower
                     : lastTick.bandings.lower;
                 switch (side) {
@@ -715,42 +694,42 @@ var Trader = /** @class */ (function (_super) {
                 return;
             }
         }
-        var queue = this.marketOrdersQueue.get(instrumentId);
+        let queue = this.marketOrdersQueue.get(instrumentId);
         if (queue) {
-            queue.push({ symbol: symbol, offset: offset, side: side, volume: volume, receiver: receiver });
+            queue.push({ symbol, offset, side, volume, receiver });
             return;
         }
-        queue = new denque_1.default();
+        queue = new Denque();
         this.marketOrdersQueue.set(instrumentId, queue);
-        this._withRetry(function () {
-            var _a;
-            return (_a = _this.traderApi) === null || _a === void 0 ? void 0 : _a.reqQryDepthMarketData({
-                ExchangeID: exchangeId,
-                InstrumentID: instrumentId,
-            });
-        }).then(function (requestId) {
+        this._withRetry(() => this.traderApi?.reqQryDepthMarketData({
+            ExchangeID: exchangeId,
+            InstrumentID: instrumentId,
+        })).then((requestId) => {
             if (!requestId || requestId < 0) {
-                var orders = queue.toArray();
-                orders.forEach(function (order) {
+                const orders = queue.toArray();
+                orders.forEach((order) => {
                     order.receiver.onPlaceOrderError("Request Error");
                 });
-                _this.marketOrdersQueue.delete(instrumentId);
+                this.marketOrdersQueue.delete(instrumentId);
                 return;
             }
-            queue.push({ symbol: symbol, offset: offset, side: side, volume: volume, receiver: receiver });
+            queue.push({ symbol, offset, side, volume, receiver });
         });
-    };
-    Trader.prototype.placeOrder = function (symbol, offset, side, volume, price, flag, receiver) {
+    }
+    placeOrder(symbol, offset, side, volume, price, flag, receiver) {
+        if (volume <= 0) {
+            receiver.onPlaceOrderError("Invalid Volume");
+            return;
+        }
         switch (flag) {
             case "limit":
                 return this._placeLimitOrder(symbol, offset, side, volume, price, receiver);
             case "market":
                 return this._placeMarketOrder(symbol, offset, side, volume, receiver);
         }
-    };
-    Trader.prototype.cancelOrder = function (order, receiver) {
-        var _this = this;
-        var current = this.orders.get(order.id);
+    }
+    cancelOrder(order, receiver) {
+        const current = this.orders.get(order.id);
         if (!current) {
             receiver.onCancelOrderError("Order Not Found");
             return;
@@ -759,43 +738,49 @@ var Trader = /** @class */ (function (_super) {
             receiver.onCancelOrderError("Already Canceled");
             return;
         }
-        this._withRetry(function () {
-            var _a;
-            return (_a = _this.traderApi) === null || _a === void 0 ? void 0 : _a.reqOrderAction(__assign(__assign({}, _this.userInfo), { InstrumentID: current.InstrumentID, FrontID: current.FrontID, SessionID: current.SessionID, OrderRef: current.OrderRef, ExchangeID: current.ExchangeID, OrderSysID: current.OrderSysID, ActionFlag: napi_ctp_1.default.ActionFlagType.Delete }));
-        }).then(function (requestId) {
+        this._withRetry(() => this.traderApi?.reqOrderAction({
+            ...this.userInfo,
+            InstrumentID: current.InstrumentID,
+            FrontID: current.FrontID,
+            SessionID: current.SessionID,
+            OrderRef: current.OrderRef,
+            ExchangeID: current.ExchangeID,
+            OrderSysID: current.OrderSysID,
+            ActionFlag: ctp.ActionFlagType.Delete,
+        })).then((requestId) => {
             if (!requestId || requestId < 0) {
                 receiver.onCancelOrderError("Request Error");
                 return;
             }
-            _this.cancelOrders.set(requestId, receiver);
+            this.cancelOrders.set(requestId, receiver);
             receiver.onCancelOrderSent();
         });
-    };
-    Trader.prototype._toSymbol = function (instrumentId) {
-        var instrument = this.instruments.get(instrumentId);
+    }
+    _toSymbol(instrumentId) {
+        const instrument = this.instruments.get(instrumentId);
         if (!instrument) {
             return undefined;
         }
-        return "".concat(instrument.InstrumentID, ".").concat(instrument.ExchangeID);
-    };
-    Trader.prototype._calcOrderId = function (orderOrTrade) {
-        var ExchangeID = orderOrTrade.ExchangeID, TraderID = orderOrTrade.TraderID, OrderLocalID = orderOrTrade.OrderLocalID;
-        return "".concat(ExchangeID, ":").concat(TraderID, ":").concat(OrderLocalID);
-    };
-    Trader.prototype._calcReceiptId = function (order) {
-        return "".concat(order.FrontID, ":").concat(order.SessionID, ":").concat(parseInt(order.OrderRef));
-    };
-    Trader.prototype._calcOrderStatus = function (order, traded) {
+        return `${instrument.InstrumentID}.${instrument.ExchangeID}`;
+    }
+    _calcOrderId(orderOrTrade) {
+        const { ExchangeID, TraderID, OrderLocalID } = orderOrTrade;
+        return `${ExchangeID}:${TraderID}:${OrderLocalID}`;
+    }
+    _calcReceiptId(order) {
+        return `${order.FrontID}:${order.SessionID}:${parseInt(order.OrderRef)}`;
+    }
+    _calcOrderStatus(order, traded) {
         switch (order.OrderStatus) {
-            case napi_ctp_1.default.OrderStatusType.Unknown:
+            case ctp.OrderStatusType.Unknown:
                 return "submitted";
-            case napi_ctp_1.default.OrderStatusType.AllTraded:
+            case ctp.OrderStatusType.AllTraded:
                 return "filled";
-            case napi_ctp_1.default.OrderStatusType.Canceled:
+            case ctp.OrderStatusType.Canceled:
                 switch (order.OrderSubmitStatus) {
-                    case napi_ctp_1.default.OrderSubmitStatusType.InsertRejected:
-                    case napi_ctp_1.default.OrderSubmitStatusType.CancelRejected:
-                    case napi_ctp_1.default.OrderSubmitStatusType.ModifyRejected:
+                    case ctp.OrderSubmitStatusType.InsertRejected:
+                    case ctp.OrderSubmitStatusType.CancelRejected:
+                    case ctp.OrderSubmitStatusType.ModifyRejected:
                         return "rejected";
                     default:
                         return "canceled";
@@ -805,63 +790,77 @@ var Trader = /** @class */ (function (_super) {
                     ? "filled"
                     : "partially-filled";
         }
-    };
-    Trader.prototype._calcOrderFlag = function (orderPriceType) {
+    }
+    _calcOrderFlag(orderPriceType) {
         switch (orderPriceType) {
-            case napi_ctp_1.default.OrderPriceTypeType.LimitPrice:
+            case ctp.OrderPriceTypeType.LimitPrice:
                 return "limit";
             default:
                 return "market";
         }
-    };
-    Trader.prototype._calcSideType = function (direction) {
+    }
+    _calcSideType(direction) {
         switch (direction) {
-            case napi_ctp_1.default.DirectionType.Buy:
+            case ctp.DirectionType.Buy:
                 return "long";
-            case napi_ctp_1.default.DirectionType.Sell:
+            case ctp.DirectionType.Sell:
                 return "short";
         }
-    };
-    Trader.prototype._toDirection = function (side) {
+    }
+    _toDirection(side) {
         switch (side) {
             case "long":
-                return napi_ctp_1.default.DirectionType.Buy;
+                return ctp.DirectionType.Buy;
             case "short":
-                return napi_ctp_1.default.DirectionType.Sell;
+                return ctp.DirectionType.Sell;
         }
-    };
-    Trader.prototype._calcOffsetType = function (offset) {
+    }
+    _calcOffsetType(offset) {
         switch (offset) {
-            case napi_ctp_1.default.OffsetFlagType.Open:
+            case ctp.OffsetFlagType.Open:
                 return "open";
-            case napi_ctp_1.default.OffsetFlagType.CloseToday:
+            case ctp.OffsetFlagType.CloseToday:
                 return "close-today";
             default:
                 return "close";
         }
-    };
-    Trader.prototype._toOffsetFlag = function (offset) {
+    }
+    _toOffsetFlag(offset) {
         switch (offset) {
             case "open":
-                return napi_ctp_1.default.OffsetFlagType.Open;
+                return ctp.OffsetFlagType.Open;
             case "close":
-                return napi_ctp_1.default.OffsetFlagType.Close;
+                return ctp.OffsetFlagType.Close;
             case "close-today":
-                return napi_ctp_1.default.OffsetFlagType.CloseToday;
+                return ctp.OffsetFlagType.CloseToday;
         }
-    };
-    Trader.prototype._calcProductType = function (productClass) {
+    }
+    _calcProductType(productClass) {
         switch (productClass) {
-            case napi_ctp_1.default.ProductClassType.Futures:
+            case ctp.ProductClassType.Futures:
                 return "futures";
-            case napi_ctp_1.default.ProductClassType.Options:
+            case ctp.ProductClassType.Options:
                 return "options";
+            case ctp.ProductClassType.Spot:
+                return "spot";
+            case ctp.ProductClassType.SpotOption:
+                return "spot-options";
             default:
-                throw new Error("Unsupported product class: ".concat(productClass));
+                throw new Error(`Unsupported product class: ${productClass}`);
         }
-    };
-    Trader.prototype._ensurePositionInfo = function (symbol) {
-        var position = this.positions.get(symbol);
+    }
+    _calcOptionsType(optionsType) {
+        switch (optionsType) {
+            case ctp.OptionsTypeType.CallOptions:
+                return "call";
+            case ctp.OptionsTypeType.PutOptions:
+                return "put";
+            default:
+                return undefined;
+        }
+    }
+    _ensurePositionInfo(symbol) {
+        let position = this.positions.get(symbol);
         if (!position) {
             position = {
                 symbol: symbol,
@@ -878,9 +877,9 @@ var Trader = /** @class */ (function (_super) {
             this.positions.set(symbol, position);
         }
         return position;
-    };
-    Trader.prototype._ensureOrderStatistic = function (symbol) {
-        var statistic = this.orderStatistics.get(symbol);
+    }
+    _ensureOrderStatistic(symbol) {
+        let statistic = this.orderStatistics.get(symbol);
         if (!statistic) {
             statistic = {
                 symbol: symbol,
@@ -893,9 +892,9 @@ var Trader = /** @class */ (function (_super) {
             this.orderStatistics.set(symbol, statistic);
         }
         return statistic;
-    };
-    Trader.prototype._calcPosition = function (symbol, side, offset, volume) {
-        var position = this._ensurePositionInfo(symbol);
+    }
+    _calcPosition(symbol, side, offset, volume) {
+        const position = this._ensurePositionInfo(symbol);
         switch (offset) {
             case "open":
                 switch (side) {
@@ -926,7 +925,7 @@ var Trader = /** @class */ (function (_super) {
                             position.history.short.position -= volume;
                         }
                         else {
-                            var rest = volume - position.history.short.position;
+                            const rest = volume - position.history.short.position;
                             position.history.short.position -=
                                 position.history.short.position;
                             if (rest > 0) {
@@ -942,7 +941,7 @@ var Trader = /** @class */ (function (_super) {
                             position.history.short.frozen -= volume;
                         }
                         else {
-                            var rest = volume - position.history.short.frozen;
+                            const rest = volume - position.history.short.frozen;
                             position.history.short.frozen -= position.history.short.frozen;
                             if (rest > 0) {
                                 if (position.today.short.frozen >= rest) {
@@ -959,7 +958,7 @@ var Trader = /** @class */ (function (_super) {
                             position.history.long.position -= volume;
                         }
                         else {
-                            var rest = volume - position.history.long.position;
+                            const rest = volume - position.history.long.position;
                             position.history.long.position -= position.history.long.position;
                             if (rest > 0) {
                                 if (position.today.long.position >= rest) {
@@ -974,7 +973,7 @@ var Trader = /** @class */ (function (_super) {
                             position.history.long.frozen -= volume;
                         }
                         else {
-                            var rest = volume - position.history.long.frozen;
+                            const rest = volume - position.history.long.frozen;
                             position.history.long.frozen -= position.history.long.frozen;
                             if (rest > 0) {
                                 if (position.today.long.frozen >= rest) {
@@ -1021,12 +1020,12 @@ var Trader = /** @class */ (function (_super) {
                 }
                 break;
         }
-    };
-    Trader.prototype._recordPending = function (symbol, side, offset, volume) {
+    }
+    _recordPending(symbol, side, offset, volume) {
         if (offset !== "open") {
             return;
         }
-        var position = this._ensurePositionInfo(symbol);
+        const position = this._ensurePositionInfo(symbol);
         switch (side) {
             case "long":
                 position.pending.long += volume;
@@ -1035,12 +1034,12 @@ var Trader = /** @class */ (function (_super) {
                 position.pending.short += volume;
                 break;
         }
-    };
-    Trader.prototype._recoverPending = function (symbol, side, offset, volume) {
+    }
+    _recoverPending(symbol, side, offset, volume) {
         if (offset !== "open") {
             return;
         }
-        var position = this.positions.get(symbol);
+        const position = this.positions.get(symbol);
         if (!position) {
             return;
         }
@@ -1052,9 +1051,9 @@ var Trader = /** @class */ (function (_super) {
                 position.pending.short -= volume;
                 break;
         }
-    };
-    Trader.prototype._freezePosition = function (symbol, side, offset, volume) {
-        var position = this.positions.get(symbol);
+    }
+    _freezePosition(symbol, side, offset, volume) {
+        const position = this.positions.get(symbol);
         if (!position) {
             return;
         }
@@ -1080,9 +1079,9 @@ var Trader = /** @class */ (function (_super) {
                 }
                 break;
         }
-    };
-    Trader.prototype._unfreezePosition = function (symbol, side, offset, volume) {
-        var position = this.positions.get(symbol);
+    }
+    _unfreezePosition(symbol, side, offset, volume) {
+        const position = this.positions.get(symbol);
         if (!position) {
             return;
         }
@@ -1128,8 +1127,8 @@ var Trader = /** @class */ (function (_super) {
                 }
                 break;
         }
-    };
-    Trader.prototype._toTradeData = function (trade) {
+    }
+    _toTradeData(trade) {
         return Object.freeze({
             id: trade.TradeID,
             date: parseInt(trade.TradeDate),
@@ -1137,18 +1136,17 @@ var Trader = /** @class */ (function (_super) {
             price: trade.Price,
             volume: trade.Volume,
         });
-    };
-    Trader.prototype._toOrderData = function (order) {
-        var _a;
-        var orderId = this._calcOrderId(order);
-        var trades = (_a = this.trades.get(orderId)) !== null && _a !== void 0 ? _a : [];
-        var traded = trades
-            .map(function (trade) { return trade.Volume; })
-            .reduce(function (a, b) { return a + b; }, 0);
+    }
+    _toOrderData(order) {
+        const orderId = this._calcOrderId(order);
+        const trades = this.trades.get(orderId) ?? [];
+        const traded = trades
+            .map((trade) => trade.Volume)
+            .reduce((a, b) => a + b, 0);
         return Object.freeze({
             id: orderId,
             receiptId: this._calcReceiptId(order),
-            symbol: "".concat(order.InstrumentID, ".").concat(order.ExchangeID),
+            symbol: `${order.InstrumentID}.${order.ExchangeID}`,
             date: parseInt(order.InsertDate),
             time: this._parseTime(order.InsertTime),
             flag: this._calcOrderFlag(order.OrderPriceType),
@@ -1161,10 +1159,10 @@ var Trader = /** @class */ (function (_super) {
             trades: trades.map(this._toTradeData, this),
             cancelTime: order.CancelTime !== "" ? this._parseTime(order.CancelTime) : undefined,
         });
-    };
-    Trader.prototype._toInstrumentData = function (instrument) {
+    }
+    _toInstrumentData(instrument) {
         return Object.freeze({
-            symbol: "".concat(instrument.InstrumentID, ".").concat(instrument.ExchangeID),
+            symbol: `${instrument.InstrumentID}.${instrument.ExchangeID}`,
             id: instrument.InstrumentID,
             name: instrument.InstrumentName,
             exchangeId: instrument.ExchangeID,
@@ -1178,9 +1176,11 @@ var Trader = /** @class */ (function (_super) {
             priceTick: instrument.PriceTick,
             maxLimitOrderVolume: instrument.MaxLimitOrderVolume,
             minLimitOrderVolume: instrument.MinLimitOrderVolume,
+            strikePrice: instrument.StrikePrice,
+            optionsType: this._calcOptionsType(instrument.OptionsType),
         });
-    };
-    Trader.prototype._toCommissionRate = function (symbol, commRate) {
+    }
+    _toCommissionRate(symbol, commRate) {
         return Object.freeze({
             symbol: symbol,
             open: Object.freeze({
@@ -1196,8 +1196,8 @@ var Trader = /** @class */ (function (_super) {
                 amount: commRate.CloseTodayRatioByVolume,
             }),
         });
-    };
-    Trader.prototype._toMarginRate = function (symbol, marginRate) {
+    }
+    _toMarginRate(symbol, marginRate) {
         return Object.freeze({
             symbol: symbol,
             long: Object.freeze({
@@ -1209,12 +1209,13 @@ var Trader = /** @class */ (function (_super) {
                 amount: marginRate.ShortMarginRatioByVolume,
             }),
         });
-    };
-    Trader.prototype._toTradingAccount = function (account) {
+    }
+    _toTradingAccount(account) {
         return Object.freeze({
             id: account.AccountID,
             currency: account.CurrencyID,
             preBalance: account.PreBalance - account.Withdraw + account.Deposit,
+            preMargin: account.PreMargin,
             balance: account.Balance,
             cash: account.Available,
             margin: account.CurrMargin,
@@ -1223,8 +1224,8 @@ var Trader = /** @class */ (function (_super) {
             frozenCash: account.FrozenCash,
             frozenCommission: account.FrozenCommission,
         });
-    };
-    Trader.prototype._toPositionDetail = function (positionDetail) {
+    }
+    _toPositionDetail(positionDetail) {
         return Object.freeze({
             symbol: this._toSymbol(positionDetail.InstrumentID),
             date: parseInt(positionDetail.OpenDate),
@@ -1233,66 +1234,56 @@ var Trader = /** @class */ (function (_super) {
             volume: positionDetail.Volume,
             margin: positionDetail.Margin,
         });
-    };
-    Trader.prototype._toPositionData = function (position) {
+    }
+    _toPositionData(position) {
         return Object.freeze({
             symbol: position.symbol,
             today: Object.freeze({
-                long: Object.freeze(__assign({}, position.today.long)),
-                short: Object.freeze(__assign({}, position.today.short)),
+                long: Object.freeze({ ...position.today.long }),
+                short: Object.freeze({ ...position.today.short }),
             }),
             history: Object.freeze({
-                long: Object.freeze(__assign({}, position.history.long)),
-                short: Object.freeze(__assign({}, position.history.short)),
+                long: Object.freeze({ ...position.history.long }),
+                short: Object.freeze({ ...position.history.short }),
             }),
-            pending: Object.freeze(__assign({}, position.pending)),
+            pending: Object.freeze({ ...position.pending }),
         });
-    };
-    Trader.prototype._processMarginRatesQueue = function () {
-        var _this = this;
-        var _loop_1 = function () {
-            var nextQuery = this_1.marginRatesQueue.peekFront();
-            var instrumentId = (0, utils_js_1.parseSymbol)(nextQuery.symbol)[0];
-            var marginRate = this_1.marginRates.get(instrumentId);
+    }
+    _processMarginRatesQueue() {
+        while (!this.marginRatesQueue.isEmpty()) {
+            const nextQuery = this.marginRatesQueue.peekFront();
+            const [instrumentId] = parseSymbol(nextQuery.symbol);
+            const marginRate = this.marginRates.get(instrumentId);
             if (marginRate) {
-                nextQuery.receiver.onMarginRate(this_1._toMarginRate(nextQuery.symbol, marginRate));
-                this_1.marginRatesQueue.shift();
+                nextQuery.receiver.onMarginRate(this._toMarginRate(nextQuery.symbol, marginRate));
+                this.marginRatesQueue.shift();
             }
             else {
-                this_1._withRetry(function () {
-                    return _this.traderApi.reqQryInstrumentMarginRate(__assign(__assign({}, _this.userInfo), { HedgeFlag: napi_ctp_1.default.HedgeFlagType.Speculation, InstrumentID: instrumentId }));
-                });
+                this._withRetry(() => this.traderApi.reqQryInstrumentMarginRate({
+                    ...this.userInfo,
+                    HedgeFlag: ctp.HedgeFlagType.Speculation,
+                    InstrumentID: instrumentId,
+                }));
             }
-        };
-        var this_1 = this;
-        while (!this.marginRatesQueue.isEmpty()) {
-            _loop_1();
         }
-    };
-    Trader.prototype._processCommissionRatesQueue = function () {
-        var _this = this;
-        var _loop_2 = function () {
-            var nextQuery = this_2.commRatesQueue.peekFront();
-            var instrumentId = (0, utils_js_1.parseSymbol)(nextQuery.symbol)[0];
-            var commRate = this_2.commRates.get(instrumentId);
+    }
+    _processCommissionRatesQueue() {
+        while (!this.commRatesQueue.isEmpty()) {
+            const nextQuery = this.commRatesQueue.peekFront();
+            const [instrumentId] = parseSymbol(nextQuery.symbol);
+            const commRate = this.commRates.get(instrumentId);
             if (commRate) {
-                nextQuery.receiver.onCommissionRate(this_2._toCommissionRate(nextQuery.symbol, commRate));
-                this_2.commRatesQueue.shift();
+                nextQuery.receiver.onCommissionRate(this._toCommissionRate(nextQuery.symbol, commRate));
+                this.commRatesQueue.shift();
             }
             else {
-                this_2._withRetry(function () {
-                    return _this.traderApi.reqQryInstrumentCommissionRate(__assign(__assign({}, _this.userInfo), { InstrumentID: instrumentId }));
-                });
+                this._withRetry(() => this.traderApi.reqQryInstrumentCommissionRate({
+                    ...this.userInfo,
+                    InstrumentID: instrumentId,
+                }));
             }
-        };
-        var this_2 = this;
-        while (!this.commRatesQueue.isEmpty()) {
-            _loop_2();
         }
-    };
-    return Trader;
-}(provider_js_1.CTPProvider));
-exports.Trader = Trader;
-var createTrader = function (flowTdPath, frontTdAddrs, userInfo, options) { return new Trader(flowTdPath, frontTdAddrs, userInfo, options); };
-exports.createTrader = createTrader;
+    }
+}
+export const createTrader = (flowTdPath, frontTdAddrs, userInfo, options) => new Trader(flowTdPath, frontTdAddrs, userInfo, options);
 //# sourceMappingURL=trader.js.map