@tigeropenapi/tigeropen 0.1.0

package/dist/esm/model/enums.js

@@ -0,0 +1,107 @@
+/**
+ * 枚举类型定义
+ * 所有枚举值与 API JSON 保持一致
+ */
+/** 市场枚举 */
+export var Market;
+(function (Market) {
+    Market["All"] = "ALL";
+    Market["US"] = "US";
+    Market["HK"] = "HK";
+    Market["CN"] = "CN";
+    Market["SG"] = "SG";
+})(Market || (Market = {}));
+/** 证券类型枚举 */
+export var SecurityType;
+(function (SecurityType) {
+    SecurityType["All"] = "ALL";
+    SecurityType["STK"] = "STK";
+    SecurityType["OPT"] = "OPT";
+    SecurityType["WAR"] = "WAR";
+    SecurityType["IOPT"] = "IOPT";
+    SecurityType["FUT"] = "FUT";
+    SecurityType["FOP"] = "FOP";
+    SecurityType["CASH"] = "CASH";
+    SecurityType["MLEG"] = "MLEG";
+    SecurityType["FUND"] = "FUND";
+})(SecurityType || (SecurityType = {}));
+/** 货币枚举 */
+export var Currency;
+(function (Currency) {
+    Currency["All"] = "ALL";
+    Currency["USD"] = "USD";
+    Currency["HKD"] = "HKD";
+    Currency["CNH"] = "CNH";
+    Currency["SGD"] = "SGD";
+})(Currency || (Currency = {}));
+/** 订单类型枚举 */
+export var OrderType;
+(function (OrderType) {
+    OrderType["MKT"] = "MKT";
+    OrderType["LMT"] = "LMT";
+    OrderType["STP"] = "STP";
+    OrderType["STP_LMT"] = "STP_LMT";
+    OrderType["TRAIL"] = "TRAIL";
+    OrderType["AM"] = "AM";
+    OrderType["AL"] = "AL";
+    OrderType["TWAP"] = "TWAP";
+    OrderType["VWAP"] = "VWAP";
+    OrderType["OCA"] = "OCA";
+})(OrderType || (OrderType = {}));
+/** 订单状态枚举 */
+export var OrderStatus;
+(function (OrderStatus) {
+    OrderStatus["PendingNew"] = "PendingNew";
+    OrderStatus["Initial"] = "Initial";
+    OrderStatus["Submitted"] = "Submitted";
+    OrderStatus["PartiallyFilled"] = "PartiallyFilled";
+    OrderStatus["Filled"] = "Filled";
+    OrderStatus["Cancelled"] = "Cancelled";
+    OrderStatus["PendingCancel"] = "PendingCancel";
+    OrderStatus["Inactive"] = "Inactive";
+    OrderStatus["Invalid"] = "Invalid";
+})(OrderStatus || (OrderStatus = {}));
+/** K 线周期枚举 */
+export var BarPeriod;
+(function (BarPeriod) {
+    BarPeriod["Day"] = "day";
+    BarPeriod["Week"] = "week";
+    BarPeriod["Month"] = "month";
+    BarPeriod["Year"] = "year";
+    BarPeriod["Min1"] = "1min";
+    BarPeriod["Min5"] = "5min";
+    BarPeriod["Min15"] = "15min";
+    BarPeriod["Min30"] = "30min";
+    BarPeriod["Min60"] = "60min";
+})(BarPeriod || (BarPeriod = {}));
+/** 语言枚举 */
+export var Language;
+(function (Language) {
+    Language["ZhCN"] = "zh_CN";
+    Language["ZhTW"] = "zh_TW";
+    Language["EnUS"] = "en_US";
+})(Language || (Language = {}));
+/** 复权类型枚举 */
+export var QuoteRight;
+(function (QuoteRight) {
+    /** 前复权 */
+    QuoteRight["Br"] = "br";
+    /** 不复权 */
+    QuoteRight["Nr"] = "nr";
+})(QuoteRight || (QuoteRight = {}));
+/** 牌照类型枚举 */
+export var License;
+(function (License) {
+    License["TBNZ"] = "TBNZ";
+    License["TBSG"] = "TBSG";
+    License["TBHK"] = "TBHK";
+    License["TBAU"] = "TBAU";
+    License["TBUS"] = "TBUS";
+})(License || (License = {}));
+/** 订单有效期枚举 */
+export var TimeInForce;
+(function (TimeInForce) {
+    TimeInForce["DAY"] = "DAY";
+    TimeInForce["GTC"] = "GTC";
+    TimeInForce["OPG"] = "OPG";
+})(TimeInForce || (TimeInForce = {}));

package/dist/esm/model/order-helpers.js

@@ -0,0 +1,93 @@
+import { OrderType, TimeInForce } from './enums';
+/** 构造市价单 */
+export function marketOrder(account, symbol, secType, action, quantity) {
+    return {
+        account, symbol, secType, action,
+        orderType: OrderType.MKT,
+        totalQuantity: quantity,
+        timeInForce: TimeInForce.DAY,
+        outsideRth: false,
+    };
+}
+/** 构造限价单 */
+export function limitOrder(account, symbol, secType, action, quantity, limitPrice) {
+    return {
+        account, symbol, secType, action,
+        orderType: OrderType.LMT,
+        totalQuantity: quantity,
+        limitPrice,
+        timeInForce: TimeInForce.DAY,
+        outsideRth: false,
+    };
+}
+/** 构造止损单 */
+export function stopOrder(account, symbol, secType, action, quantity, auxPrice) {
+    return {
+        account, symbol, secType, action,
+        orderType: OrderType.STP,
+        totalQuantity: quantity,
+        auxPrice,
+        timeInForce: TimeInForce.DAY,
+        outsideRth: false,
+    };
+}
+/** 构造止损限价单 */
+export function stopLimitOrder(account, symbol, secType, action, quantity, limitPrice, auxPrice) {
+    return {
+        account, symbol, secType, action,
+        orderType: OrderType.STP_LMT,
+        totalQuantity: quantity,
+        limitPrice,
+        auxPrice,
+        timeInForce: TimeInForce.DAY,
+        outsideRth: false,
+    };
+}
+/** 构造跟踪止损单 */
+export function trailOrder(account, symbol, secType, action, quantity, trailingPercent) {
+    return {
+        account, symbol, secType, action,
+        orderType: OrderType.TRAIL,
+        totalQuantity: quantity,
+        trailingPercent,
+        timeInForce: TimeInForce.DAY,
+        outsideRth: false,
+    };
+}
+/** 构造竞价限价单 */
+export function auctionLimitOrder(account, symbol, secType, action, quantity, limitPrice) {
+    return {
+        account, symbol, secType, action,
+        orderType: OrderType.AL,
+        totalQuantity: quantity,
+        limitPrice,
+        timeInForce: TimeInForce.DAY,
+        outsideRth: false,
+    };
+}
+/** 构造竞价市价单 */
+export function auctionMarketOrder(account, symbol, secType, action, quantity) {
+    return {
+        account, symbol, secType, action,
+        orderType: OrderType.AM,
+        totalQuantity: quantity,
+        timeInForce: TimeInForce.DAY,
+        outsideRth: false,
+    };
+}
+/** 构造算法订单（TWAP/VWAP） */
+export function algoOrder(account, symbol, secType, action, quantity, limitPrice, algoType, params) {
+    return {
+        account, symbol, secType, action,
+        orderType: algoType,
+        totalQuantity: quantity,
+        limitPrice,
+        algoParams: params,
+        timeInForce: TimeInForce.DAY,
+        outsideRth: false,
+    };
+}
+/** 构造附加订单（止盈/止损） */
+export function orderLeg(legType, price, timeInForce) {
+    return { legType, price, timeInForce };
+}

package/dist/esm/model/order.js

@@ -0,0 +1,5 @@
+/**
+ * Order 订单接口
+ * 字段名 camelCase 与 API JSON 天然一致，不改名、不加封装层
+ */
+export {};

package/dist/esm/model/position.js

@@ -0,0 +1,5 @@
+/**
+ * Position 持仓接口
+ * 字段名 camelCase 与 API JSON 天然一致，不改名、不加封装层
+ */
+export {};

package/dist/esm/push/callbacks.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/push/index.js

@@ -0,0 +1,6 @@
+/**
+ * 推送模块导出
+ */
+export * from './push-message';
+export * from './callbacks';
+export { PushClient, ConnectionState } from './push-client';

package/dist/esm/push/push-client.js

@@ -0,0 +1,419 @@
+import { signWithRSA } from '../signer/signer';
+import { MessageType, SubjectType, createPushMessage, serializeMessage, deserializeMessage, } from './push-message';
+/** 默认推送服务器地址 */
+const DEFAULT_PUSH_URL = 'wss://openapi-push.tigerfintech.com';
+/** 默认心跳间隔（毫秒） */
+const DEFAULT_HEARTBEAT_INTERVAL = 10000;
+/** 默认重连间隔（毫秒） */
+const DEFAULT_RECONNECT_INTERVAL = 5000;
+/** 最大重连间隔（毫秒） */
+const MAX_RECONNECT_INTERVAL = 60000;
+/** 默认连接超时（毫秒） */
+const DEFAULT_CONNECT_TIMEOUT = 30000;
+/** 连接状态 */
+export var ConnectionState;
+(function (ConnectionState) {
+    ConnectionState[ConnectionState["Disconnected"] = 0] = "Disconnected";
+    ConnectionState[ConnectionState["Connecting"] = 1] = "Connecting";
+    ConnectionState[ConnectionState["Connected"] = 2] = "Connected";
+})(ConnectionState || (ConnectionState = {}));
+/**
+ * PushClient WebSocket 推送客户端
+ */
+export class PushClient {
+    constructor(config, options) {
+        this.ws = null;
+        this._state = ConnectionState.Disconnected;
+        this.callbacks = {};
+        /** 订阅状态管理：subject -> Set<symbol> */
+        this.subscriptions = new Map();
+        /** 账户级别订阅 */
+        this.accountSubs = new Set();
+        this.heartbeatTimer = null;
+        this.reconnectTimer = null;
+        this.stopped = false;
+        /** 可注入的 WebSocket 工厂（用于测试） */
+        this.wsFactory = null;
+        this.config = config;
+        this.pushUrl = options?.pushUrl ?? DEFAULT_PUSH_URL;
+        this.heartbeatInterval = options?.heartbeatInterval ?? DEFAULT_HEARTBEAT_INTERVAL;
+        this.reconnectInterval = options?.reconnectInterval ?? DEFAULT_RECONNECT_INTERVAL;
+        this.autoReconnect = options?.autoReconnect ?? true;
+        this.connectTimeout = options?.connectTimeout ?? DEFAULT_CONNECT_TIMEOUT;
+    }
+    /** 获取当前连接状态 */
+    get state() {
+        return this._state;
+    }
+    /** 设置回调函数集合 */
+    setCallbacks(cb) {
+        this.callbacks = cb;
+    }
+    /** 连接到推送服务器并进行认证 */
+    connect() {
+        return new Promise((resolve, reject) => {
+            if (this._state !== ConnectionState.Disconnected) {
+                reject(new Error('客户端已连接或正在连接中'));
+                return;
+            }
+            this._state = ConnectionState.Connecting;
+            this.stopped = false;
+            const ws = this.createWebSocket(this.pushUrl);
+            this.ws = ws;
+            const timeout = setTimeout(() => {
+                ws.close();
+                this._state = ConnectionState.Disconnected;
+                this.ws = null;
+                reject(new Error('连接超时'));
+            }, this.connectTimeout);
+            ws.onopen = () => {
+                clearTimeout(timeout);
+                // 发送认证消息
+                try {
+                    this.authenticate();
+                    this._state = ConnectionState.Connected;
+                    this.startHeartbeat();
+                    this.callbacks.onConnect?.();
+                    resolve();
+                }
+                catch (err) {
+                    ws.close();
+                    this._state = ConnectionState.Disconnected;
+                    this.ws = null;
+                    reject(err);
+                }
+            };
+            ws.onmessage = (ev) => {
+                this.handleMessage(String(ev.data));
+            };
+            ws.onclose = () => {
+                if (this.stopped)
+                    return;
+                this.stopHeartbeat();
+                const wasConnected = this._state === ConnectionState.Connected;
+                this._state = ConnectionState.Disconnected;
+                this.ws = null;
+                if (wasConnected && this.autoReconnect && !this.stopped) {
+                    this.scheduleReconnect();
+                }
+            };
+            ws.onerror = (ev) => {
+                if (this._state === ConnectionState.Connecting) {
+                    clearTimeout(timeout);
+                    this._state = ConnectionState.Disconnected;
+                    this.ws = null;
+                    reject(new Error('WebSocket 连接失败'));
+                }
+                else {
+                    this.callbacks.onError?.(new Error('WebSocket 错误'));
+                }
+            };
+        });
+    }
+    /** 断开连接 */
+    disconnect() {
+        this.stopped = true;
+        this.stopHeartbeat();
+        this.clearReconnectTimer();
+        if (this.ws) {
+            this.ws.onclose = null;
+            this.ws.onerror = null;
+            this.ws.onmessage = null;
+            this.ws.close();
+            this.ws = null;
+        }
+        this._state = ConnectionState.Disconnected;
+        this.callbacks.onDisconnect?.();
+    }
+    /** 发送认证消息 */
+    authenticate() {
+        const ts = new Date().toISOString().replace('T', ' ').substring(0, 19);
+        const sign = signWithRSA(this.config.privateKey, this.config.tigerId);
+        const req = {
+            tigerId: this.config.tigerId,
+            sign,
+            timestamp: ts,
+            version: '2.0',
+        };
+        const msg = createPushMessage(MessageType.Connect, undefined, req);
+        this.sendMessage(msg);
+    }
+    /** 发送消息 */
+    sendMessage(msg) {
+        if (!this.ws)
+            throw new Error('WebSocket 连接未建立');
+        this.ws.send(serializeMessage(msg));
+    }
+    /** 创建 WebSocket 实例 */
+    createWebSocket(url) {
+        if (this.wsFactory)
+            return this.wsFactory(url);
+        // 动态导入 ws 库（Node.js 环境）
+        // eslint-disable-next-line @typescript-eslint/no-require-imports
+        const WS = require('ws');
+        return new WS(url);
+    }
+    /** 心跳保活 */
+    startHeartbeat() {
+        this.stopHeartbeat();
+        this.heartbeatTimer = setInterval(() => {
+            try {
+                const msg = createPushMessage(MessageType.Heartbeat);
+                this.sendMessage(msg);
+            }
+            catch {
+                // 心跳发送失败，连接可能已断开
+            }
+        }, this.heartbeatInterval);
+    }
+    stopHeartbeat() {
+        if (this.heartbeatTimer) {
+            clearInterval(this.heartbeatTimer);
+            this.heartbeatTimer = null;
+        }
+    }
+    /** 自动重连 */
+    scheduleReconnect() {
+        let interval = this.reconnectInterval;
+        const attempt = () => {
+            if (this.stopped)
+                return;
+            this.connect().then(() => {
+                this.resubscribe();
+            }).catch(() => {
+                interval = Math.min(interval * 2, MAX_RECONNECT_INTERVAL);
+                if (!this.stopped) {
+                    this.reconnectTimer = setTimeout(attempt, interval);
+                }
+            });
+        };
+        this.reconnectTimer = setTimeout(attempt, interval);
+    }
+    clearReconnectTimer() {
+        if (this.reconnectTimer) {
+            clearTimeout(this.reconnectTimer);
+            this.reconnectTimer = null;
+        }
+    }
+    /** 重连后恢复订阅 */
+    resubscribe() {
+        for (const [subject, symbols] of this.subscriptions) {
+            this.doSubscribe(subject, Array.from(symbols));
+        }
+        for (const subject of this.accountSubs) {
+            this.doSubscribe(subject, undefined, this.config.account);
+        }
+    }
+    /** 处理收到的消息 */
+    handleMessage(raw) {
+        let msg;
+        try {
+            msg = deserializeMessage(raw);
+        }
+        catch {
+            this.callbacks.onError?.(new Error('反序列化消息失败'));
+            return;
+        }
+        const cb = this.callbacks;
+        switch (msg.type) {
+            case MessageType.Kickout:
+                cb.onKickout?.(msg.data);
+                break;
+            case MessageType.Error:
+                cb.onError?.(new Error(`服务端错误: ${msg.data}`));
+                break;
+            case MessageType.Quote:
+                cb.onQuote?.(msg.data);
+                break;
+            case MessageType.Tick:
+                cb.onTick?.(msg.data);
+                break;
+            case MessageType.Depth:
+                cb.onDepth?.(msg.data);
+                break;
+            case MessageType.Option:
+                cb.onOption?.(msg.data);
+                break;
+            case MessageType.Future:
+                cb.onFuture?.(msg.data);
+                break;
+            case MessageType.Kline:
+                cb.onKline?.(msg.data);
+                break;
+            case MessageType.Asset:
+                cb.onAsset?.(msg.data);
+                break;
+            case MessageType.Position:
+                cb.onPosition?.(msg.data);
+                break;
+            case MessageType.Order:
+                cb.onOrder?.(msg.data);
+                break;
+            case MessageType.Transaction:
+                cb.onTransaction?.(msg.data);
+                break;
+            case MessageType.StockTop:
+                cb.onStockTop?.(msg.data);
+                break;
+            case MessageType.OptionTop:
+                cb.onOptionTop?.(msg.data);
+                break;
+            case MessageType.FullTick:
+                cb.onFullTick?.(msg.data);
+                break;
+            case MessageType.QuoteBBO:
+                cb.onQuoteBBO?.(msg.data);
+                break;
+        }
+    }
+    /** 内部订阅方法 */
+    doSubscribe(subject, symbols, account, market) {
+        const req = { subject, symbols, account, market };
+        const msg = createPushMessage(MessageType.Subscribe, subject, req);
+        this.sendMessage(msg);
+    }
+    /** 内部退订方法 */
+    doUnsubscribe(subject, symbols) {
+        const req = { subject, symbols };
+        const msg = createPushMessage(MessageType.Unsubscribe, subject, req);
+        this.sendMessage(msg);
+    }
+    /** 添加订阅记录 */
+    addSubscription(subject, symbols) {
+        if (!this.subscriptions.has(subject)) {
+            this.subscriptions.set(subject, new Set());
+        }
+        const set = this.subscriptions.get(subject);
+        for (const s of symbols)
+            set.add(s);
+    }
+    /** 移除订阅记录 */
+    removeSubscription(subject, symbols) {
+        if (!symbols) {
+            this.subscriptions.delete(subject);
+            return;
+        }
+        const set = this.subscriptions.get(subject);
+        if (set) {
+            for (const s of symbols)
+                set.delete(s);
+            if (set.size === 0)
+                this.subscriptions.delete(subject);
+        }
+    }
+    // ===== 行情订阅/退订 =====
+    /** 订阅行情 */
+    subscribeQuote(symbols) {
+        this.doSubscribe(SubjectType.Quote, symbols);
+        this.addSubscription(SubjectType.Quote, symbols);
+    }
+    /** 退订行情 */
+    unsubscribeQuote(symbols) {
+        this.doUnsubscribe(SubjectType.Quote, symbols);
+        this.removeSubscription(SubjectType.Quote, symbols);
+    }
+    /** 订阅逐笔成交 */
+    subscribeTick(symbols) {
+        this.doSubscribe(SubjectType.Tick, symbols);
+        this.addSubscription(SubjectType.Tick, symbols);
+    }
+    /** 退订逐笔成交 */
+    unsubscribeTick(symbols) {
+        this.doUnsubscribe(SubjectType.Tick, symbols);
+        this.removeSubscription(SubjectType.Tick, symbols);
+    }
+    /** 订阅深度行情 */
+    subscribeDepth(symbols) {
+        this.doSubscribe(SubjectType.Depth, symbols);
+        this.addSubscription(SubjectType.Depth, symbols);
+    }
+    /** 退订深度行情 */
+    unsubscribeDepth(symbols) {
+        this.doUnsubscribe(SubjectType.Depth, symbols);
+        this.removeSubscription(SubjectType.Depth, symbols);
+    }
+    /** 订阅期权行情 */
+    subscribeOption(symbols) {
+        this.doSubscribe(SubjectType.Option, symbols);
+        this.addSubscription(SubjectType.Option, symbols);
+    }
+    /** 退订期权行情 */
+    unsubscribeOption(symbols) {
+        this.doUnsubscribe(SubjectType.Option, symbols);
+        this.removeSubscription(SubjectType.Option, symbols);
+    }
+    /** 订阅期货行情 */
+    subscribeFuture(symbols) {
+        this.doSubscribe(SubjectType.Future, symbols);
+        this.addSubscription(SubjectType.Future, symbols);
+    }
+    /** 退订期货行情 */
+    unsubscribeFuture(symbols) {
+        this.doUnsubscribe(SubjectType.Future, symbols);
+        this.removeSubscription(SubjectType.Future, symbols);
+    }
+    /** 订阅 K 线 */
+    subscribeKline(symbols) {
+        this.doSubscribe(SubjectType.Kline, symbols);
+        this.addSubscription(SubjectType.Kline, symbols);
+    }
+    /** 退订 K 线 */
+    unsubscribeKline(symbols) {
+        this.doUnsubscribe(SubjectType.Kline, symbols);
+        this.removeSubscription(SubjectType.Kline, symbols);
+    }
+    // ===== 账户推送订阅/退订 =====
+    /** 订阅资产变动 */
+    subscribeAsset(account) {
+        this.doSubscribe(SubjectType.Asset, undefined, account || this.config.account);
+        this.accountSubs.add(SubjectType.Asset);
+    }
+    /** 退订资产变动 */
+    unsubscribeAsset() {
+        this.doUnsubscribe(SubjectType.Asset);
+        this.accountSubs.delete(SubjectType.Asset);
+    }
+    /** 订阅持仓变动 */
+    subscribePosition(account) {
+        this.doSubscribe(SubjectType.Position, undefined, account || this.config.account);
+        this.accountSubs.add(SubjectType.Position);
+    }
+    /** 退订持仓变动 */
+    unsubscribePosition() {
+        this.doUnsubscribe(SubjectType.Position);
+        this.accountSubs.delete(SubjectType.Position);
+    }
+    /** 订阅订单状态 */
+    subscribeOrder(account) {
+        this.doSubscribe(SubjectType.Order, undefined, account || this.config.account);
+        this.accountSubs.add(SubjectType.Order);
+    }
+    /** 退订订单状态 */
+    unsubscribeOrder() {
+        this.doUnsubscribe(SubjectType.Order);
+        this.accountSubs.delete(SubjectType.Order);
+    }
+    /** 订阅成交明细 */
+    subscribeTransaction(account) {
+        this.doSubscribe(SubjectType.Transaction, undefined, account || this.config.account);
+        this.accountSubs.add(SubjectType.Transaction);
+    }
+    /** 退订成交明细 */
+    unsubscribeTransaction() {
+        this.doUnsubscribe(SubjectType.Transaction);
+        this.accountSubs.delete(SubjectType.Transaction);
+    }
+    // ===== 查询订阅状态 =====
+    /** 获取当前行情订阅状态 */
+    getSubscriptions() {
+        const result = new Map();
+        for (const [subject, symbols] of this.subscriptions) {
+            result.set(subject, Array.from(symbols));
+        }
+        return result;
+    }
+    /** 获取账户级别订阅状态 */
+    getAccountSubscriptions() {
+        return Array.from(this.accountSubs);
+    }
+}