@tigeropenapi/tigeropen 0.5.3 → 0.5.5

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

@@ -1,4 +1,37 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.QuoteClient = void 0;
 exports.parseOptionIdentifier = parseOptionIdentifier;
@@ -12,6 +45,8 @@ exports.parseOptionIdentifier = parseOptionIdentifier;
 const http_client_1 = require("../client/http-client");
 const api_request_1 = require("../client/api-request");
 const api_response_1 = require("../client/api-response");
+const tokenMethods = __importStar(require("../client/token-methods"));
+const tick_util_1 = require("../push/tick-util");
 /**
  * resolveOptionTimezone returns the timezone string to use for expiry conversion.
  * Explicit tz takes precedence; otherwise infer from symbol (.HK suffix → Asia/Hong_Kong, else America/New_York).
@@ -94,6 +129,25 @@ class QuoteClient {
     static fromConfig(config) {
         return new QuoteClient(new http_client_1.HttpClient(config, undefined, { useQuoteServerUrl: true }));
     }
+    // ── Token management ──────────────────────────────────────────────────────
+    /** Call the `user_token_refresh` API and return the new token. Read-only. */
+    async queryToken() {
+        return tokenMethods.queryToken(this.httpClient);
+    }
+    /** Refresh the token and update the in-memory config token. */
+    async refreshToken(tokenManager) {
+        return tokenMethods.refreshToken(this.httpClient, tokenManager);
+    }
+    /**
+     * Start background token auto-refresh. Returns a TokenManager to stop with `tm.stopAutoRefresh()`.
+     *
+     * @param refreshDurationSecs - Refresh threshold in seconds (minimum 30).
+     * @param checkIntervalMs - How often to check, in milliseconds (default 300 000 / 5 min).
+     * @param tokenWriter - Optional callback invoked after each successful refresh.
+     */
+    startTokenAutoRefresh(refreshDurationSecs, checkIntervalMs, tokenWriter) {
+        return tokenMethods.startTokenAutoRefresh(this.httpClient, refreshDurationSecs, checkIntervalMs, tokenWriter);
+    }
     async callInto(method, bizParams, version) {
         const request = (0, api_request_1.createApiRequest)(method, bizParams, version);
         const response = await this.httpClient.executeRequest(request);
@@ -132,12 +186,22 @@ class QuoteClient {
     async getKline(req) {
         return this.callInto('kline', req);
     }
-    async getTimeline(symbols) {
-        return this.callInto('timeline', { symbols });
+    async getTimeline(symbolsOrRequest) {
+        const req = Array.isArray(symbolsOrRequest) ? { symbols: symbolsOrRequest } : symbolsOrRequest;
+        return this.callInto('timeline', req, req.secType === 'CC' ? '3.0' : undefined);
     }
     /** Tick-by-tick trades. wire: trade_tick */
     async getTradeTick(req) {
-        return this.callInto('trade_tick', req);
+        const out = await this.callInto('trade_tick', req);
+        for (const tick of out) {
+            const isUs = (0, tick_util_1.isUsStockSymbol)(tick.symbol);
+            for (const item of tick.items) {
+                if (item.cond && item.cond.length > 0) {
+                    item.cond = (0, tick_util_1.getTradeCondByCode)(isUs, item.cond[0]);
+                }
+            }
+        }
+        return out;
     }
     /** Depth snapshot. wire: quote_depth */
     async getQuoteDepth(req) {
@@ -303,6 +367,7 @@ class QuoteClient {
         while (acc.length < totalSize) {
             const sub = {
                 symbols: req.symbol ? [req.symbol] : undefined,
+                secType: req.secType,
                 period: req.period,
                 right: req.right,
                 beginTime,
@@ -353,7 +418,7 @@ class QuoteClient {
     async getStockIndustry(req) {
         return this.callInto('stock_industry', req);
     }
-    /** Quote permission detail. wire: get_quote_permission */
+    /** Market data permission entries. wire: get_quote_permission */
     async getQuotePermission(req) {
         return this.callInto('get_quote_permission', req);
     }
@@ -364,9 +429,16 @@ class QuoteClient {
     // ==========================================================================
     // Batch 4: option / future extensions
     // ==========================================================================
-    /** Option tick trades. wire: option_trade_tick */
+    /** Option tick trades. wire: option_trade_tick
+     *
+     * Server expects `biz_content` as a top-level JSON array (matches Java's
+     * `BatchApiModel` and Python's `MultipleContractParams.to_openapi_dict`).
+     * We unwrap the request here so the array is emitted directly instead of
+     * `{"contracts": [...]}`. Sending it as an object triggers
+     * `biz param error(failed to parse parameters in 'biz_content')`.
+     */
     async getOptionTradeTicks(req) {
-        return this.callInto('option_trade_tick', req);
+        return this.callInto('option_trade_tick', req.contracts ?? []);
     }
     /** Option intraday timeline. wire: option_timeline */
     async getOptionTimeline(req) {
@@ -405,10 +477,16 @@ class QuoteClient {
         return this.callInto('future_main_contract', req);
     }
     /** Futures K-line. wire: future_kline
-     * beginTime / endTime default to -1 when unset (server requires them present). */
+     * beginTime / endTime default to -1 when unset (server requires them present).
+     * Server expects `contract_codes` (plural) — normalize singular `contractCode`
+     * to the plural form so callers can pass either shape. */
     async getFutureKline(req) {
+        const contractCodes = req.contractCodes
+            ?? (req.contractCode ? [req.contractCode] : undefined);
+        const { contractCode: _drop, ...rest } = req;
         const body = {
-            ...req,
+            ...rest,
+            ...(contractCodes ? { contractCodes } : {}),
             beginTime: req.beginTime ?? -1,
             endTime: req.endTime ?? -1,
         };
@@ -426,8 +504,9 @@ class QuoteClient {
             endTime = -1;
         const acc = [];
         while (acc.length < totalSize) {
+            // Server rejects singular `contract_code` — send the plural form.
             const sub = {
-                contractCode: req.contractCode,
+                contractCodes: req.contractCode ? [req.contractCode] : undefined,
                 period: req.period,
                 beginTime,
                 endTime,
@@ -506,9 +585,30 @@ class QuoteClient {
     async getWarrantFilter(req) {
         return this.callInto('warrant_filter', req);
     }
-    /** Industry list. wire: industry_list */
-    async getIndustryList(req) {
-        return this.callInto('industry_list', req);
+    /** Industry list. wire: industry_list
+     *
+     * `industryLevel` is required by the server — omitting it returns
+     * `industry level error, all supported is: [GSECTOR, GGROUP, GIND, GSUBIND]`.
+     * Defaults to `GGROUP` when unset, matching Python SDK's
+     * `IndustryLevel.GGROUP` default.
+     *
+     * Wire fields differ from other endpoints (see `IndustryItem`): server sends
+     * `nameCN` / `nameEN` / `industryLevel`. This method hydrates the
+     * backwards-compat `name` (from `nameEN || nameCN`) and mirrors
+     * `industryLevel` to `level` so existing callers keep working.
+     */
+    async getIndustryList(req = {}) {
+        const payload = { industryLevel: 'GGROUP', ...req };
+        const items = await this.callInto('industry_list', payload);
+        if (!Array.isArray(items))
+            return [];
+        for (const it of items) {
+            if (it.name === undefined)
+                it.name = it.nameEN || it.nameCN;
+            if (it.level === undefined)
+                it.level = it.industryLevel;
+        }
+        return items;
     }
     /** Stocks inside an industry. wire: industry_stock_list */
     async getIndustryStocks(req) {

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

@@ -1,4 +1,37 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TradeClient = void 0;
 /**
@@ -13,6 +46,7 @@ exports.TradeClient = void 0;
 const http_client_1 = require("../client/http-client");
 const api_request_1 = require("../client/api-request");
 const api_response_1 = require("../client/api-response");
+const tokenMethods = __importStar(require("../client/token-methods"));
 const order_status_1 = require("../model/order-status");
 /** Normalize `Order.status` field in-place (handles int → string). */
 function normalizeOrderInPlace(o) {
@@ -44,6 +78,31 @@ class TradeClient {
     static fromConfig(config, account, secretKey) {
         return new TradeClient(new http_client_1.HttpClient(config), account, secretKey);
     }
+    // ── Token management ──────────────────────────────────────────────────────
+    /** Call the `user_token_refresh` API and return the new token. Read-only. */
+    async queryToken() {
+        return tokenMethods.queryToken(this.httpClient);
+    }
+    /**
+     * Refresh the token: call the API, update the in-memory config token, and
+     * optionally persist via the provided TokenManager (file + writer callback).
+     *
+     * @param tokenManager - optional TokenManager for file persistence and writer callback
+     */
+    async refreshToken(tokenManager) {
+        return tokenMethods.refreshToken(this.httpClient, tokenManager);
+    }
+    /**
+     * Start background token auto-refresh. Returns a TokenManager that can be
+     * used to stop the background task via `tm.stopAutoRefresh()`.
+     *
+     * @param refreshDurationSecs - Refresh threshold in seconds (minimum 30).
+     * @param checkIntervalMs - How often to check, in milliseconds (default 300 000 / 5 min).
+     * @param tokenWriter - Optional callback invoked after each successful refresh.
+     */
+    startTokenAutoRefresh(refreshDurationSecs, checkIntervalMs, tokenWriter) {
+        return tokenMethods.startTokenAutoRefresh(this.httpClient, refreshDurationSecs, checkIntervalMs, tokenWriter);
+    }
     async callInto(method, bizParams) {
         // Inject secretKey into every request when available (institution accounts require it).
         // Individual methods that already set secretKey will not be overwritten (|| not &&).
@@ -86,14 +145,54 @@ class TradeClient {
         });
     }
     // === Order operations ===
+    /**
+     * Prepare an order request for the wire.
+     *
+     * The gateway expects `algo_params` as a `[{tag, value}, ...]` array
+     * (matching the Python SDK's AlgoParams.to_dict serialization), not the
+     * plain object shape that reads naturally in TypeScript. This helper
+     * normalizes the object form into the array form on outbound payloads
+     * so callers can pass the natural object and TWAP/VWAP orders work end
+     * to end without wire-format workarounds.
+     *
+     * Fields with undefined/null values are dropped; empty algoParams
+     * becomes an empty array rather than being stripped, matching the
+     * Python SDK behavior when the user passes an empty AlgoParams().
+     */
+    marshalOrderForWire(order) {
+        const { algoParams, ...rest } = order;
+        const withAccount = { ...rest, account: this.account };
+        if (algoParams === undefined)
+            return withAccount;
+        // Already a tag/value array (advanced callers who want raw control)
+        if (Array.isArray(algoParams)) {
+            withAccount.algoParams = algoParams;
+            return withAccount;
+        }
+        // Object shape → tag/value array.
+        // Keys are converted to snake_case explicitly here (e.g. `startTime` →
+        // `start_time`) so they land correctly in the `tag` string that the
+        // gateway reads. `keysToSnakeCase` only rewrites object *keys*, not
+        // string *values*, so `tag` would be left camelCase if we didn't do
+        // this conversion ourselves.
+        const tagValues = [];
+        for (const [key, value] of Object.entries(algoParams)) {
+            if (value === undefined || value === null)
+                continue;
+            const snakeKey = key.replace(/[A-Z]/g, (c) => '_' + c.toLowerCase());
+            tagValues.push({ tag: snakeKey, value });
+        }
+        withAccount.algoParams = tagValues;
+        return withAccount;
+    }
     async placeOrder(order) {
-        return this.callInto('place_order', { ...order, account: this.account });
+        return this.callInto('place_order', this.marshalOrderForWire(order));
     }
     async previewOrder(order) {
-        return this.callInto('preview_order', { ...order, account: this.account });
+        return this.callInto('preview_order', this.marshalOrderForWire(order));
     }
     async modifyOrder(id, order) {
-        return this.callInto('modify_order', { ...order, account: this.account, id });
+        return this.callInto('modify_order', { ...this.marshalOrderForWire(order), id });
     }
     async cancelOrder(id, secretKey) {
         const params = { account: this.account, id };

package/dist/esm/client/token-methods.js

@@ -0,0 +1,37 @@
+/**
+ * Call the `user_token_refresh` API and return the new token string.
+ * Read-only: does NOT update the stored token.
+ * Use `refreshToken()` to also update the in-memory config and optionally persist.
+ */
+export async function queryToken(httpClient) {
+    return httpClient.queryToken();
+}
+/**
+ * Refresh the token: call the API, update the in-memory config token, and
+ * optionally persist via the provided TokenManager (file + writer callback).
+ *
+ * @param httpClient - The underlying HTTP client
+ * @param tokenManager - optional TokenManager for file persistence and writer callback
+ */
+export async function refreshToken(httpClient, tokenManager) {
+    return httpClient.refreshToken(tokenManager);
+}
+/**
+ * Start background token auto-refresh. Returns a TokenManager that can be
+ * used to stop the background task via `tm.stopAutoRefresh()`.
+ *
+ * @param httpClient - The underlying HTTP client
+ * @param refreshDurationSecs - Refresh threshold in seconds (minimum 30).
+ *   When the token age exceeds this value the refresh is triggered.
+ * @param checkIntervalMs - How often to check whether a refresh is needed,
+ *   in milliseconds. Defaults to 300 000 ms (5 minutes).
+ * @param tokenWriter - Optional callback invoked with the new token string
+ *   after each successful refresh.
+ */
+export function startTokenAutoRefresh(httpClient, refreshDurationSecs, checkIntervalMs, tokenWriter) {
+    return httpClient.startTokenAutoRefresh(null, {
+        refreshDuration: refreshDurationSecs,
+        refreshInterval: checkIntervalMs,
+        tokenWriter,
+    });
+}

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

@@ -9,7 +9,7 @@
  * Priority: environment variables > code options (incl. config file) > defaults
  */
 import { readFileSync, existsSync, statSync } from 'fs';
-import { join } from 'path';
+import { join, dirname } from 'path';
 import { homedir, networkInterfaces } from 'os';
 import { parsePropertiesString } from './config-parser.js';
 import { queryDomains, resolveDynamicServerUrl, resolveDynamicQuoteServerUrl } from './domain.js';
@@ -108,23 +108,32 @@ export function createClientConfig(options) {
     const opts = options ?? {};
     // Load properties: explicit path > auto-discovery
     let fileProps = {};
+    let configFileDir;
     if (opts.propertiesFilePath) {
         // Support both directory path and full file path
         let filePath = opts.propertiesFilePath;
         if (existsSync(filePath) && statSync(filePath).isDirectory()) {
+            configFileDir = filePath;
             filePath = join(filePath, CONFIG_FILE_NAME);
         }
         else if (!existsSync(filePath) && !filePath.endsWith('.properties')) {
             // Path doesn't exist as-is; try treating it as a directory
             const asDir = join(filePath, CONFIG_FILE_NAME);
-            if (existsSync(asDir))
+            if (existsSync(asDir)) {
+                configFileDir = filePath;
                 filePath = asDir;
+            }
+        }
+        else {
+            // It's a file path: derive directory from it
+            configFileDir = dirname(filePath);
         }
         fileProps = loadPropertiesFile(filePath);
     }
     else {
         const discovered = discoverConfigFile();
         if (discovered) {
+            configFileDir = dirname(discovered);
             fileProps = loadPropertiesFile(discovered);
         }
     }
@@ -184,8 +193,9 @@ export function createClientConfig(options) {
             }
         }
         else {
-            // Load from token file: TIGEROPEN_TOKEN_FILE env var > default file
-            const tokenFilePath = process.env[ENV_TOKEN_FILE] || 'tiger_openapi_token.properties';
+            // Load from token file: TIGEROPEN_TOKEN_FILE env var > config dir > default
+            const tokenFilePath = process.env[ENV_TOKEN_FILE]
+                || (configFileDir ? join(configFileDir, 'tiger_openapi_token.properties') : 'tiger_openapi_token.properties');
             const tm = new TokenManager({ filePath: tokenFilePath });
             try {
                 token = tm.loadTokenSync();

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

@@ -88,26 +88,11 @@ export function algoOrder(account, symbol, secType, action, quantity, limitPrice
     };
 }
 /**
- * Iceberg order (basic) — only displaySize required.
- */
-export function icebergOrder(account, symbol, secType, action, quantity, limitPrice, displaySize) {
-    return {
-        account, symbol, secType, action,
-        orderType: OrderType.ICEBERG,
-        totalQuantity: quantity,
-        limitPrice,
-        timeInForce: TimeInForce.DAY,
-        outsideRth: false,
-        displaySize,
-        priceType: PriceType.LIMIT_PRICE,
-    };
-}
-/**
- * Iceberg order (full params).
- * Pass `priceType` as empty string to use server default (LIMIT_PRICE).
+ * Iceberg order. `displaySize` is required; all other parameters are optional.
+ * Pass `priceType` as empty string to use the server default (LIMIT_PRICE).
  * Pass `startTime` / `endTime` as 0 to omit the time window.
  */
-export function icebergOrderFull(account, symbol, secType, action, quantity, limitPrice, displaySize, minDisplaySize, checkIntervals, priceType, startTime, endTime) {
+export function icebergOrder(account, symbol, secType, action, quantity, limitPrice, displaySize, minDisplaySize, checkIntervals, priceType, startTime, endTime) {
     const req = {
         account, symbol, secType, action,
         orderType: OrderType.ICEBERG,
@@ -116,13 +101,12 @@ export function icebergOrderFull(account, symbol, secType, action, quantity, lim
         timeInForce: TimeInForce.DAY,
         outsideRth: false,
         displaySize,
+        priceType: priceType || PriceType.LIMIT_PRICE,
     };
     if (minDisplaySize !== undefined && minDisplaySize > 0)
         req.minDisplaySize = minDisplaySize;
     if (checkIntervals !== undefined && checkIntervals > 0)
         req.checkIntervals = checkIntervals;
-    if (priceType)
-        req.priceType = priceType;
     if (startTime && startTime > 0)
         req.startTime = startTime;
     if (endTime && endTime > 0)
@@ -133,3 +117,118 @@ export function icebergOrderFull(account, symbol, secType, action, quantity, lim
 export function orderLeg(legType, price, timeInForce) {
     return { legType, price, timeInForce };
 }
+/**
+ * Market order by cash amount (instead of quantity).
+ * Server uses `isQuantityByAmount=true` + `amount` field.
+ */
+export function marketOrderByAmount(account, symbol, secType, action, amount) {
+    return {
+        account, symbol, secType, action,
+        orderType: OrderType.MKT,
+        totalQuantity: 0,
+        cashAmount: amount,
+        timeInForce: TimeInForce.DAY,
+        outsideRth: false,
+    };
+}
+/**
+ * Limit order by cash amount (instead of quantity).
+ */
+export function limitOrderByAmount(account, symbol, secType, action, amount, limitPrice) {
+    return {
+        account, symbol, secType, action,
+        orderType: OrderType.LMT,
+        totalQuantity: 0,
+        cashAmount: amount,
+        limitPrice,
+        timeInForce: TimeInForce.DAY,
+        outsideRth: false,
+    };
+}
+/**
+ * Trailing stop order using a fixed price offset (auxPrice) instead of a percentage.
+ * Use `trailOrder()` for percentage-based trailing stops.
+ */
+export function trailOrderByPrice(account, symbol, secType, action, quantity, auxPrice) {
+    return {
+        account, symbol, secType, action,
+        orderType: OrderType.TRAIL,
+        totalQuantity: quantity,
+        auxPrice,
+        timeInForce: TimeInForce.DAY,
+        outsideRth: false,
+    };
+}
+/**
+ * Limit order with attached profit/loss legs (bracket order).
+ * At most 2 legs are supported.
+ *
+ * @param orderLegs - Array of `OrderLegRequest` (use `orderLeg()` helper)
+ */
+export function limitOrderWithLegs(account, symbol, secType, action, quantity, limitPrice, orderLegs) {
+    if (orderLegs.length === 0) {
+        throw new Error('At least 1 order leg is required for a bracket order');
+    }
+    if (orderLegs.length > 2) {
+        throw new Error('At most 2 order legs are supported');
+    }
+    return {
+        account, symbol, secType, action,
+        orderType: OrderType.LMT,
+        totalQuantity: quantity,
+        limitPrice,
+        orderLegs,
+        timeInForce: TimeInForce.DAY,
+        outsideRth: false,
+    };
+}
+/**
+ * Multi-leg (combo/MLEG) order for options combos.
+ *
+ * @param contractLegs - Array of `ContractLegRequest` (use `contractLeg()` helper)
+ * @param comboType - e.g. `'MLEG'`
+ */
+export function comboOrder(account, action, quantity, orderType, contractLegs, comboType = 'MLEG', limitPrice, auxPrice, trailingPercent) {
+    return {
+        account,
+        symbol: '', // not used for combo orders
+        secType: 'MLEG',
+        action,
+        orderType,
+        totalQuantity: quantity,
+        limitPrice,
+        auxPrice,
+        trailingPercent,
+        contractLegs,
+        comboType,
+        timeInForce: TimeInForce.DAY,
+        outsideRth: false,
+    };
+}
+/**
+ * OCA (One-Cancels-All) order.
+ * Server expects `orderType: 'OCA'` and an `ocaOrders` list.
+ *
+ * @param ocaOrders - The contained orders (use any order helper to build each)
+ */
+export function ocaOrder(account, symbol, secType, action, quantity, ocaOrders) {
+    return {
+        account, symbol, secType, action,
+        orderType: OrderType.OCA,
+        totalQuantity: quantity,
+        ocaOrders,
+        timeInForce: TimeInForce.DAY,
+        outsideRth: false,
+    };
+}
+/**
+ * Build a single leg for a multi-leg (MLEG / combo) order.
+ *
+ * @param symbol   - Underlying symbol
+ * @param secType  - Security type (e.g. `'OPT'`)
+ * @param action   - `'BUY'` or `'SELL'`
+ * @param ratio    - Number of contracts for this leg
+ */
+export function contractLeg(symbol, secType, action, ratio, expiry, strike, right) {
+    return { symbol, secType, action, ratio, expiry, strike, right };
+}

package/dist/esm/push/index.js

@@ -4,5 +4,6 @@
 export { SubjectType } from './push-message.js';
 export * from './callbacks.js';
 export * from './varint.js';
+export * from './tick-util.js';
 export * from './proto-message.js';
 export { PushClient, ConnectionState } from './push-client.js';

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

@@ -11,6 +11,7 @@
 import * as tls from 'tls';
 import { signWithRSA } from '../signer/signer.js';
 import { SubjectType } from './push-message.js';
+import { convertTradeTick } from './tick-util.js';
 import { Request } from './pb/Request.js';
 import { Response } from './pb/Response.js';
 import { SocketCommon_Command, SocketCommon_DataType } from './pb/SocketCommon.js';
@@ -342,8 +343,10 @@ export class PushClient {
                     cb.onDepth?.(pushData.quoteDepthData);
                 break;
             case SocketCommon_DataType.TradeTick:
+                if (pushData.tickData)
+                    cb.onFullTick?.(pushData.tickData);
                 if (pushData.tradeTickData)
-                    cb.onTick?.(pushData.tradeTickData);
+                    cb.onTick?.(convertTradeTick(pushData.tradeTickData));
                 break;
             case SocketCommon_DataType.Asset:
                 if (pushData.assetData)
@@ -379,8 +382,7 @@ export class PushClient {
                     cb.onQuote?.(pushData.quoteData);
                 break;
             default:
-                // FullTick and QuoteBBO use TradeTick/Quote dataType
-                // TickData (fullTick) via tickData field
+                // QuoteBBO and some full-tick payloads reuse an existing dataType.
                 if (pushData.tickData)
                     cb.onFullTick?.(pushData.tickData);
                 break;