@tigeropenapi/tigeropen 0.1.0 → 0.3.0

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

@@ -1,39 +1,9 @@
 /**
- * 推送消息类型定义和数据结构
+ * 推送消息类型定义
  *
- * 定义 WebSocket 推送消息的类型、主题和数据结构，
- * 使用 JSON 序列化/反序列化（简化替代 Protobuf）。
+ * 仅保留 SubjectType 枚举，用于订阅/退订 API。
+ * JSON 消息类型定义和序列化函数已移除，改用 Protobuf 协议。
  */
-/** 推送消息类型 */
-export var MessageType;
-(function (MessageType) {
-    // 连接相关
-    MessageType["Connect"] = "connect";
-    MessageType["Connected"] = "connected";
-    MessageType["Disconnect"] = "disconnect";
-    MessageType["Heartbeat"] = "heartbeat";
-    MessageType["Kickout"] = "kickout";
-    MessageType["Error"] = "error";
-    // 订阅相关
-    MessageType["Subscribe"] = "subscribe";
-    MessageType["Unsubscribe"] = "unsubscribe";
-    // 行情推送
-    MessageType["Quote"] = "quote";
-    MessageType["Tick"] = "tick";
-    MessageType["Depth"] = "depth";
-    MessageType["Option"] = "option";
-    MessageType["Future"] = "future";
-    MessageType["Kline"] = "kline";
-    MessageType["StockTop"] = "stock_top";
-    MessageType["OptionTop"] = "option_top";
-    MessageType["FullTick"] = "full_tick";
-    MessageType["QuoteBBO"] = "quote_bbo";
-    // 账户推送
-    MessageType["Asset"] = "asset";
-    MessageType["Position"] = "position";
-    MessageType["Order"] = "order";
-    MessageType["Transaction"] = "transaction";
-})(MessageType || (MessageType = {}));
 /** 订阅主题类型 */
 export var SubjectType;
 (function (SubjectType) {
@@ -52,26 +22,3 @@ export var SubjectType;
     SubjectType["Order"] = "order";
     SubjectType["Transaction"] = "transaction";
 })(SubjectType || (SubjectType = {}));
-/**
- * 创建推送消息
- */
-export function createPushMessage(type, subject, data) {
-    const msg = { type };
-    if (subject)
-        msg.subject = subject;
-    if (data !== undefined)
-        msg.data = data;
-    return msg;
-}
-/**
- * 序列化推送消息为 JSON 字符串
- */
-export function serializeMessage(msg) {
-    return JSON.stringify(msg);
-}
-/**
- * 反序列化 JSON 字符串为推送消息
- */
-export function deserializeMessage(data) {
-    return JSON.parse(data);
-}

package/dist/esm/push/varint.js

@@ -0,0 +1,72 @@
+/**
+ * Varint32 帧编解码器
+ *
+ * 兼容 Netty 的 ProtobufVarint32FrameDecoder / ProtobufVarint32LengthFieldPrepender。
+ * 每个字节低 7 位存数据，最高位为延续标志（1=后续还有字节，0=最后一个字节），最大 5 字节。
+ */
+/**
+ * 在 protobuf 字节前添加 varint32 长度前缀
+ *
+ * @param data - 待编码的 protobuf 二进制数据
+ * @returns varint32 长度前缀 + 原始数据
+ */
+export function encodeVarint32(data) {
+    const length = data.length;
+    const header = encodeVarint32Length(length);
+    const result = new Uint8Array(header.length + data.length);
+    result.set(header, 0);
+    result.set(data, header.length);
+    return result;
+}
+/**
+ * 将一个非负整数编码为 varint32 字节序列
+ */
+function encodeVarint32Length(value) {
+    const bytes = [];
+    while (value > 0x7f) {
+        bytes.push((value & 0x7f) | 0x80);
+        value >>>= 7;
+    }
+    bytes.push(value & 0x7f);
+    return new Uint8Array(bytes);
+}
+/**
+ * 从缓冲区解码一个 varint32 帧
+ *
+ * @param buffer - 包含 varint32 长度前缀 + protobuf 数据的缓冲区
+ * @returns 解码结果 `{ message, remaining }`，数据不足时返回 `null`
+ */
+export function decodeVarint32(buffer) {
+    if (buffer.length === 0) {
+        return null;
+    }
+    // 读取 varint32 长度前缀
+    let value = 0;
+    let shift = 0;
+    let i = 0;
+    while (i < buffer.length) {
+        // varint32 最多 5 字节
+        if (i >= 5) {
+            throw new Error('varint32 overflow: more than 5 bytes');
+        }
+        const byte = buffer[i];
+        value |= (byte & 0x7f) << shift;
+        i++;
+        if ((byte & 0x80) === 0) {
+            // 最后一个字节，延续标志为 0
+            const messageLength = value >>> 0; // 确保无符号
+            const totalNeeded = i + messageLength;
+            if (buffer.length < totalNeeded) {
+                // 数据不足，等待更多数据
+                return null;
+            }
+            return {
+                message: buffer.slice(i, i + messageLength),
+                remaining: buffer.slice(i + messageLength),
+            };
+        }
+        shift += 7;
+    }
+    // 缓冲区中 varint 前缀不完整，等待更多数据
+    return null;
+}

package/dist/esm/quote/index.js

@@ -1,4 +1,4 @@
 /**
- * 行情模块导出
+ * Quote module exports
  */
-export { QuoteClient } from './quote-client';
+export { QuoteClient, parseOptionIdentifier } from './quote-client';

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

@@ -1,106 +1,139 @@
 import { createApiRequest } from '../client/api-request';
+import { unmarshalData } from '../client/api-response';
 /**
- * 行情查询客户端，封装所有行情相关 API。
+ * Parse an OCC-style option identifier like "AAPL  260619C00150000"
+ * into its component parts.
  */
+export function parseOptionIdentifier(identifier) {
+    const trimmed = identifier.trim();
+    const spaceIdx = trimmed.indexOf(' ');
+    if (spaceIdx === -1) {
+        throw new Error(`invalid option identifier: ${identifier}`);
+    }
+    const symbol = trimmed.substring(0, spaceIdx);
+    const rest = trimmed.substring(spaceIdx + 1).trim();
+    if (rest.length < 15) {
+        throw new Error(`option code too short: ${rest}`);
+    }
+    const datePart = rest.substring(0, 6);
+    const rightChar = rest.substring(6, 7);
+    const strikePart = rest.substring(7);
+    const yy = parseInt(datePart.substring(0, 2), 10);
+    const mm = parseInt(datePart.substring(2, 4), 10);
+    const dd = parseInt(datePart.substring(4, 6), 10);
+    const expiryMs = Date.UTC(2000 + yy, mm - 1, dd);
+    const right = rightChar === 'C' ? 'CALL' : rightChar === 'P' ? 'PUT' : '';
+    if (!right)
+        throw new Error(`invalid right character: ${rightChar}`);
+    const strikeInt = parseInt(strikePart, 10);
+    if (Number.isNaN(strikeInt))
+        throw new Error(`invalid strike digits: ${strikePart}`);
+    const strike = strikeInt / 1000;
+    return { symbol, expiryMs, right, strike };
+}
+/** Market data client wrapping all quote-related APIs. */
 export class QuoteClient {
     constructor(httpClient) {
         this.httpClient = httpClient;
     }
+    async callInto(method, bizParams, version) {
+        const request = createApiRequest(method, bizParams, version);
+        const response = await this.httpClient.executeRequest(request);
+        return unmarshalData(response.data);
+    }
+    // === Basic market data ===
+    async getMarketState(market) {
+        return this.callInto('market_state', { market });
+    }
+    async getBrief(symbols) {
+        return this.callInto('quote_real_time', { symbols });
+    }
+    async getKline(symbol, period) {
+        return this.callInto('kline', { symbols: [symbol], period });
+    }
+    async getTimeline(symbols) {
+        return this.callInto('timeline', { symbols });
+    }
+    async getTradeTick(symbols) {
+        return this.callInto('trade_tick', { symbols });
+    }
+    /** Depth snapshot. market is required (US / HK supported). */
+    async getQuoteDepth(symbol, market) {
+        return this.callInto('quote_depth', { symbols: [symbol], market });
+    }
+    // === Options ===
+    async getOptionExpiration(symbol) {
+        return this.callInto('option_expiration', { symbols: [symbol] });
+    }
+    /** Option chain; `expiry` is "YYYY-MM-DD". */
+    async getOptionChain(symbol, expiry) {
+        const d = new Date(expiry + 'T00:00:00Z');
+        const expiryMs = d.getTime();
+        if (Number.isNaN(expiryMs)) {
+            throw new Error(`invalid expiry date, expected YYYY-MM-DD: ${expiry}`);
+        }
+        return this.callInto('option_chain', { option_basic: [{ symbol, expiry: expiryMs }] }, '3.0');
+    }
+    async getOptionBrief(identifiers) {
+        const optionBasic = identifiers.map((id) => {
+            const p = parseOptionIdentifier(id);
+            return { symbol: p.symbol, expiry: p.expiryMs, right: p.right, strike: p.strike };
+        });
+        return this.callInto('option_brief', { option_basic: optionBasic }, '2.0');
+    }
+    async getOptionKline(identifier, period) {
+        const p = parseOptionIdentifier(identifier);
+        return this.callInto('option_kline', {
+            option_query: [{ symbol: p.symbol, expiry: p.expiryMs, right: p.right, strike: p.strike, period }],
+        }, '2.0');
+    }
+    // === Futures ===
+    async getFutureExchange() {
+        return this.callInto('future_exchange', { secType: 'FUT' });
+    }
+    async getFutureContracts(exchange) {
+        return this.callInto('future_contract_by_exchange_code', { exchangeCode: exchange });
+    }
+    async getFutureRealTimeQuote(contractCodes) {
+        return this.callInto('future_real_time_quote', { contractCodes });
+    }
+    /** Futures K-line; use -1 for unbounded beginTime / endTime. */
+    async getFutureKline(req) {
+        const body = {
+            ...req,
+            beginTime: req.beginTime ?? -1,
+            endTime: req.endTime ?? -1,
+        };
+        return this.callInto('future_kline', body);
+    }
+    // === Fundamentals ===
+    async getFinancialDaily(req) {
+        return this.callInto('financial_daily', req);
+    }
+    async getFinancialReport(req) {
+        return this.callInto('financial_report', req);
+    }
     /**
-     * 内部通用方法：构造请求、发送、返回 data 字段
+     * Corporate actions. Server returns {symbol: [...]}, this method flattens into a single list.
      */
-    async execute(method, bizParams) {
-        const request = createApiRequest(method, bizParams);
-        const response = await this.httpClient.executeRequest(request);
-        return response.data;
-    }
-    // === 基础行情方法 ===
-    /** 获取市场状态 */
-    async marketState(market) {
-        return this.execute('market_state', { market });
-    }
-    /** 获取实时报价 */
-    async quoteRealTime(symbols) {
-        return this.execute('quote_real_time', { symbols });
-    }
-    /** 获取 K 线数据 */
-    async kline(symbol, period) {
-        return this.execute('kline', { symbols: [symbol], period });
-    }
-    /** 获取分时数据 */
-    async timeline(symbols) {
-        return this.execute('timeline', { symbols });
-    }
-    /** 获取逐笔成交数据 */
-    async tradeTick(symbols) {
-        return this.execute('trade_tick', { symbols });
-    }
-    /** 获取深度行情 */
-    async quoteDepth(symbol) {
-        return this.execute('quote_depth', { symbol });
-    }
-    // === 期权行情方法 ===
-    /** 获取期权到期日 */
-    async optionExpiration(symbol) {
-        return this.execute('option_expiration', { symbols: [symbol] });
-    }
-    /** 获取期权链 */
-    async optionChain(symbol, expiry) {
-        return this.execute('option_chain', { symbol, expiry });
-    }
-    /** 获取期权报价 */
-    async optionBrief(identifiers) {
-        return this.execute('option_brief', { identifiers });
-    }
-    /** 获取期权 K 线 */
-    async optionKline(identifier, period) {
-        return this.execute('option_kline', { identifier, period });
-    }
-    // === 期货行情方法 ===
-    /** 获取期货交易所列表 */
-    async futureExchange() {
-        return this.execute('future_exchange', { sec_type: 'FUT' });
-    }
-    /** 获取期货合约列表 */
-    async futureContracts(exchange) {
-        return this.execute('future_contracts', { exchange });
-    }
-    /** 获取期货实时报价 */
-    async futureRealTimeQuote(symbols) {
-        return this.execute('future_real_time_quote', { symbols });
-    }
-    /** 获取期货 K 线 */
-    async futureKline(symbol, period) {
-        return this.execute('future_kline', { symbol, period });
-    }
-    // === 基本面和资金流向方法 ===
-    /** 获取财务日报 */
-    async financialDaily(symbol) {
-        return this.execute('financial_daily', { symbol });
-    }
-    /** 获取财务报告 */
-    async financialReport(symbol) {
-        return this.execute('financial_report', { symbol });
-    }
-    /** 获取公司行动 */
-    async corporateAction(symbol) {
-        return this.execute('corporate_action', { symbol });
-    }
-    /** 获取资金流向 */
-    async capitalFlow(symbol) {
-        return this.execute('capital_flow', { symbol });
-    }
-    /** 获取资金分布 */
-    async capitalDistribution(symbol) {
-        return this.execute('capital_distribution', { symbol });
-    }
-    // === 选股器和行情权限方法 ===
-    /** 选股器 */
-    async marketScanner(params) {
-        return this.execute('market_scanner', params);
-    }
-    /** 获取行情权限 */
+    async getCorporateAction(req) {
+        const grouped = await this.callInto('corporate_action', req);
+        if (!grouped || typeof grouped !== 'object')
+            return [];
+        return Object.values(grouped).flat();
+    }
+    // === Capital flow ===
+    async getCapitalFlow(symbol, market, period) {
+        return this.callInto('capital_flow', { symbol, market, period });
+    }
+    async getCapitalDistribution(symbol, market) {
+        return this.callInto('capital_distribution', { symbol, market });
+    }
+    // === Scanner & permission ===
+    async marketScanner(req) {
+        return this.callInto('market_scanner', req);
+    }
     async grabQuotePermission() {
-        return this.execute('grab_quote_permission');
+        return this.callInto('grab_quote_permission');
     }
 }

package/dist/esm/signer/signer.js

@@ -73,16 +73,16 @@ export function signWithRSA(privateKeyStr, content) {
     return sign.sign(key, 'base64');
 }
 /**
- * 使用 RSA 公钥验证 SHA1WithRSA 签名。
+ * Verify a SHA1WithRSA signature using an RSA public key.
  *
- * @param publicKey - 公钥对象
- * @param content - 原始内容
- * @param signature - Base64 编码的签名字符串
- * @returns 验签是否成功
+ * @param publicKeyBase64 - Base64-encoded public key (DER / PKCS#1 or SPKI)
+ * @param content - Original content that was signed
+ * @param signatureBase64 - Base64-encoded signature
+ * @returns Whether the signature is valid
  */
-export function verifyWithRSA(publicKey, content, signature) {
-    const verify = createVerify('SHA1');
-    verify.update(content);
-    verify.end();
-    return verify.verify(publicKey, signature, 'base64');
+export function verifyWithRSA(publicKeyBase64, content, signatureBase64) {
+    const pem = `-----BEGIN PUBLIC KEY-----\n${publicKeyBase64}\n-----END PUBLIC KEY-----`;
+    const verifier = createVerify('SHA1');
+    verifier.update(content);
+    return verifier.verify(pem, signatureBase64, 'base64');
 }

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

@@ -1,95 +1,89 @@
 import { createApiRequest } from '../client/api-request';
-/**
- * 交易客户端，封装所有交易相关 API。
- */
+import { unmarshalData } from '../client/api-response';
+/** Trading client wrapping all trade-related APIs. */
 export class TradeClient {
     constructor(httpClient, account) {
         this.httpClient = httpClient;
         this.account = account;
     }
-    /**
-     * 内部通用方法：构造请求、发送、返回 data 字段
-     */
-    async execute(method, bizParams) {
+    async callInto(method, bizParams) {
         const request = createApiRequest(method, bizParams);
         const response = await this.httpClient.executeRequest(request);
-        return response.data;
-    }
-    // === 合约查询方法 ===
-    /** 查询单个合约 */
-    async contract(symbol, secType) {
-        return this.execute('contract', {
+        return unmarshalData(response.data);
+    }
+    /** Strip `{items: [...]}` envelope used by most trade read endpoints. */
+    async callIntoItems(method, bizParams) {
+        const wrap = await this.callInto(method, bizParams);
+        if (Array.isArray(wrap))
+            return wrap;
+        return wrap?.items ?? [];
+    }
+    // === Contracts ===
+    async getContract(symbol, secType) {
+        return this.callIntoItems('contract', {
             account: this.account, symbol, secType,
         });
     }
-    /** 批量查询合约 */
-    async contracts(symbols, secType) {
-        return this.execute('contracts', {
+    async getContracts(symbols, secType) {
+        return this.callIntoItems('contracts', {
             account: this.account, symbols, secType,
         });
     }
-    /** 查询衍生品合约 */
-    async quoteContract(symbol, secType) {
-        return this.execute('quote_contract', {
-            account: this.account, symbol, secType,
+    /**
+     * Derivative contracts (OPT / WAR / IOPT only).
+     * `symbol` is the underlying (e.g. "AAPL"); `expiry` is "YYYYMMDD".
+     */
+    async getQuoteContract(symbol, secType, expiry) {
+        return this.callIntoItems('quote_contract', {
+            account: this.account, symbols: [symbol], secType, expiry,
         });
     }
-    // === 订单操作方法 ===
-    /** 下单 */
+    // === Order operations ===
     async placeOrder(order) {
-        const params = { ...order, account: this.account };
-        return this.execute('place_order', params);
+        return this.callInto('place_order', { ...order, account: this.account });
     }
-    /** 预览订单 */
     async previewOrder(order) {
-        const params = { ...order, account: this.account };
-        return this.execute('preview_order', params);
+        return this.callInto('preview_order', { ...order, account: this.account });
     }
-    /** 修改订单 */
     async modifyOrder(id, order) {
-        const params = { ...order, account: this.account, id };
-        return this.execute('modify_order', params);
+        return this.callInto('modify_order', { ...order, account: this.account, id });
     }
-    /** 取消订单 */
     async cancelOrder(id) {
-        return this.execute('cancel_order', {
-            account: this.account, id,
-        });
+        return this.callInto('cancel_order', { account: this.account, id });
     }
-    // === 订单查询方法 ===
-    /** 查询全部订单 */
-    async orders() {
-        return this.execute('orders', { account: this.account });
+    // === Order queries ===
+    async getOrders() {
+        return this.callIntoItems('orders', { account: this.account });
     }
-    /** 查询待成交订单 */
-    async activeOrders() {
-        return this.execute('active_orders', { account: this.account });
+    async getActiveOrders() {
+        return this.callIntoItems('active_orders', { account: this.account });
     }
-    /** 查询已撤销订单 */
-    async inactiveOrders() {
-        return this.execute('inactive_orders', { account: this.account });
+    async getInactiveOrders() {
+        return this.callIntoItems('inactive_orders', { account: this.account });
     }
-    /** 查询已成交订单 */
-    async filledOrders() {
-        return this.execute('filled_orders', { account: this.account });
+    /**
+     * Filled orders in a time range (ms timestamps required by the server).
+     * Use `Date.now() - 30*24*3600*1000` for "last 30 days".
+     */
+    async getFilledOrders(startDateMs, endDateMs) {
+        return this.callIntoItems('filled_orders', {
+            account: this.account, startDate: startDateMs, endDate: endDateMs,
+        });
     }
-    // === 持仓和资产查询方法 ===
-    /** 查询持仓 */
-    async positions() {
-        return this.execute('positions', { account: this.account });
+    /** Transactions for a specific order; `symbol` and `secType` are required. */
+    async getOrderTransactions(id, symbol, secType) {
+        return this.callIntoItems('order_transactions', {
+            account: this.account, orderId: id, symbol, secType,
+        });
     }
-    /** 查询资产 */
-    async assets() {
-        return this.execute('assets', { account: this.account });
+    // === Positions & assets ===
+    async getPositions() {
+        return this.callIntoItems('positions', { account: this.account });
     }
-    /** 查询综合账户资产 */
-    async primeAssets() {
-        return this.execute('prime_assets', { account: this.account });
+    async getAssets() {
+        return this.callIntoItems('assets', { account: this.account });
     }
-    /** 查询订单成交明细 */
-    async orderTransactions(id) {
-        return this.execute('order_transactions', {
-            account: this.account, id,
-        });
+    async getPrimeAssets() {
+        return this.callInto('prime_assets', { account: this.account });
     }
 }

package/dist/types/client/api-request.d.ts

@@ -1,18 +1,19 @@
-/**
- * API 请求构造模块
- */
-/** API 请求接口 */
+/** API request interface */
 export interface ApiRequest {
-    /** API 方法名（如 "market_state"、"place_order"） */
+    /** API method name (e.g. "market_state", "place_order") */
     method: string;
-    /** 业务参数 JSON 字符串 */
+    /** Business parameters as JSON string (already snake_case) */
     bizContent: string;
+    /** Optional API version override (default: "2.0") */
+    version?: string;
 }
 /**
- * 创建 API 请求，将业务参数序列化为 JSON 字符串作为 bizContent。
+ * Create an API request, serializing business parameters to JSON as bizContent.
+ * camelCase keys are automatically converted to snake_case to match the server.
  *
- * @param method - API 方法名
- * @param bizParams - 业务参数（对象、字符串或 null）
- * @returns ApiRequest 对象
+ * @param method - API method name
+ * @param bizParams - Business parameters (object, string, or null); objects are converted recursively
+ * @param version - Optional API version override
+ * @returns ApiRequest object
  */
-export declare function createApiRequest(method: string, bizParams: unknown): ApiRequest;
+export declare function createApiRequest(method: string, bizParams: unknown, version?: string): ApiRequest;

package/dist/types/client/api-response.d.ts

@@ -1,16 +1,24 @@
-/** API 响应接口 */
+/** API response envelope */
 export interface ApiResponse {
-    /** 状态码（0=成功） */
+    /** Result code (0 = success) */
     code: number;
-    /** 状态描述 */
+    /** Human-readable message */
     message: string;
-    /** 业务数据 */
+    /** Business payload */
     data: unknown;
-    /** 服务器时间戳 */
+    /** Server timestamp */
     timestamp: number;
+    /** Response signature for verification */
+    sign?: string;
 }
 /**
- * 解析 API 响应 JSON 字符串。
- * code 为 0 时返回 ApiResponse；code 不为 0 时抛出 TigerError。
+ * Parse the raw HTTP response body.
+ * Throws TigerError when code != 0.
  */
 export declare function parseApiResponse(body: string): ApiResponse;
+/**
+ * Decode an ApiResponse.data payload into a typed value.
+ * Handles the server's occasional double-encoded JSON (where `data` is a
+ * JSON string that itself wraps JSON), seen on some trade endpoints.
+ */
+export declare function unmarshalData<T>(data: unknown): T | undefined;

package/dist/types/client/case-convert.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Case conversion utilities.
+ *
+ * TypeScript SDK uses camelCase idiomatically. The server expects
+ * snake_case for request field names and returns camelCase for responses.
+ * These helpers convert camelCase objects to snake_case before
+ * serialization; response side needs no conversion.
+ */
+/** Convert a single camelCase key to snake_case. */
+export declare function camelToSnake(key: string): string;
+/**
+ * Recursively convert all object keys from camelCase to snake_case.
+ * Preserves arrays, primitives, and Date/null/undefined.
+ * Keys already containing an underscore are kept as-is (already snake_case).
+ */
+export declare function keysToSnakeCase(value: unknown): unknown;