@tigeropenapi/tigeropen 0.5.4 → 0.5.7

package/dist/esm/auth/oauth2/token-store.js

@@ -0,0 +1,214 @@
+/**
+ * File-backed OAuth 2.0 authorization state.
+ *
+ * Storage layout:
+ *
+ *     ~/.tiger/openapi/
+ *       tokens/{clientId}.json                authorization state, mode 0600, removed on logout
+ *       clients/{issuerHash}-{surface}.json   dynamic registration, retained across logout
+ *
+ * Registration files are keyed by issuer because the client ID is not yet available
+ * during lookup, and by surface so that each entry point registers its own client.
+ * Without the surface, whichever entry point ran first would own the registration and
+ * every other one would silently inherit its identity: one name on the user's
+ * authorization page, one revocation switch for all of them, and one shared token file
+ * whose refresh-token rotation they would race over.
+ *
+ * Token files need no surface: each surface registers a distinct client ID, so their
+ * token files are already distinct. A manually configured client ID is shared on
+ * purpose -- one client ID means one application.
+ *
+ * Storage root precedence is: explicit argument, `TIGEROPEN_HOME`, then
+ * `~/.tiger/openapi`. The format is shared with the Java and Python SDKs.
+ */
+import { createHash } from 'crypto';
+import * as fs from 'fs';
+import { homedir } from 'os';
+import * as path from 'path';
+import { OAuth2ClientRegistration } from './client-registration.js';
+import { OAuth2Category, OAuth2Error } from './errors.js';
+import { OAuth2Token, TOKEN_SCHEMA_VERSION } from './token.js';
+export const ENV_HOME = 'TIGEROPEN_HOME';
+/**
+ * Entry point owning a registration. Tools built on this SDK must pass their own value,
+ * otherwise they would be filed as the TypeScript SDK and share its client. Keep in
+ * step with the Java SDK's `sdk-java` and the Python SDK's `sdk-python`.
+ */
+export const DEFAULT_SURFACE = 'sdk-typescript';
+const SAFE_CHARS = /[^a-zA-Z0-9\-_.]/g;
+/**
+ * Surfaces become part of a file name, so they are restricted rather than sanitised: a
+ * silently rewritten surface would file two entry points under one name.
+ */
+const SURFACE_PATTERN = /^[a-z0-9][a-z0-9-]*$/;
+export class OAuth2TokenStore {
+    /**
+     * @param home storage root; defaults to `TIGEROPEN_HOME` then `~/.tiger/openapi`
+     * @param surface entry point owning the registration, e.g. `sdk-typescript`, `cli`.
+     *   Lowercase alphanumerics and hyphens only
+     */
+    constructor(home, surface = DEFAULT_SURFACE) {
+        const base = home || process.env[ENV_HOME] || path.join(homedir(), '.tiger', 'openapi');
+        this.home = path.resolve(expandHome(base));
+        this.surface = validateSurface(surface);
+    }
+    /** Load a token, treating a missing file or issuer mismatch as a cache miss. */
+    loadToken(clientId, expectedIssuer) {
+        const file = this.tokenFile(clientId);
+        if (!fs.existsSync(file))
+            return null;
+        let token;
+        try {
+            token = OAuth2Token.fromJSON(JSON.parse(fs.readFileSync(file, 'utf-8')));
+        }
+        catch (e) {
+            // A corrupt file tells us nothing; treat it as no authorization rather than crash.
+            console.error(`[TigerOpen] read token file fail: ${file}`, e);
+            return null;
+        }
+        if (!token)
+            return null;
+        if (token.schemaVersion !== TOKEN_SCHEMA_VERSION) {
+            // Unknown schema versions are not interpreted.
+            throw new OAuth2Error(OAuth2Category.StorageFailed, `unsupported token schema_version: ${token.schemaVersion}`);
+        }
+        if (expectedIssuer !== undefined && expectedIssuer !== token.issuer) {
+            return null;
+        }
+        return token;
+    }
+    saveToken(token) {
+        if (!token || !token.clientId) {
+            throw new OAuth2Error(OAuth2Category.StorageFailed, 'token or clientId is empty, cannot save');
+        }
+        writeAtomic(this.tokenFile(token.clientId), JSON.stringify(token.toJSON(), null, 2));
+    }
+    /**
+     * Delete authorization state while retaining client registration.
+     *
+     * @returns the path removed, or null when there was nothing to remove. A clientId is
+     *   not its own file name, so a caller reporting what it deleted has to be told rather
+     *   than build the path itself
+     */
+    deleteToken(clientId) {
+        if (!clientId)
+            return null;
+        const file = this.tokenFile(clientId);
+        return deleteFile(file) ? file : null;
+    }
+    loadClientId(issuer) {
+        return this.loadClientRegistration(issuer)?.clientId ?? null;
+    }
+    loadClientRegistration(issuer) {
+        const file = this.clientFile(issuer);
+        if (!fs.existsSync(file))
+            return null;
+        try {
+            return OAuth2ClientRegistration.fromJSON(JSON.parse(fs.readFileSync(file, 'utf-8')));
+        }
+        catch (e) {
+            console.error(`[TigerOpen] read client registration file fail: ${file}`, e);
+            return null;
+        }
+    }
+    saveClientRegistration(registration) {
+        if (!registration || !registration.issuer) {
+            throw new OAuth2Error(OAuth2Category.StorageFailed, 'registration or issuer is empty, cannot save');
+        }
+        writeAtomic(this.clientFile(registration.issuer), JSON.stringify(registration.toJSON(), null, 2));
+    }
+    /** Delete registration state after an `invalid_client` response. */
+    deleteClientRegistration(issuer) {
+        if (!issuer)
+            return;
+        deleteFile(this.clientFile(issuer));
+    }
+    tokenFile(clientId) {
+        return path.join(this.home, 'tokens', `${safeFileName(clientId)}.json`);
+    }
+    clientFile(issuer) {
+        return path.join(this.home, 'clients', `${hashIssuer(issuer)}-${this.surface}.json`);
+    }
+}
+/** Return the Java-compatible 32-character SHA-256 issuer file key. */
+export function hashIssuer(issuer) {
+    return createHash('sha256').update(issuer || '', 'utf-8').digest('hex').slice(0, 32);
+}
+/** Sanitize an untrusted client ID for use as a file name. */
+function safeFileName(raw) {
+    let name = (raw || '').replace(SAFE_CHARS, '_');
+    while (name.includes('..')) {
+        name = name.replace(/\.\./g, '__');
+    }
+    return name || '_';
+}
+/** Reject a surface that cannot be used verbatim as part of a file name. */
+function validateSurface(surface) {
+    if (typeof surface !== 'string' || !SURFACE_PATTERN.test(surface)) {
+        throw new OAuth2Error(OAuth2Category.StorageFailed, `invalid surface '${surface}': expected lowercase alphanumerics and hyphens, e.g. 'cli'`);
+    }
+    return surface;
+}
+function expandHome(value) {
+    if (value === '~')
+        return homedir();
+    if (value.startsWith('~/') || value.startsWith(`~${path.sep}`)) {
+        return path.join(homedir(), value.slice(2));
+    }
+    return value;
+}
+/** @returns true when the file was there and is now gone */
+function deleteFile(file) {
+    try {
+        if (fs.existsSync(file)) {
+            fs.unlinkSync(file);
+            return true;
+        }
+    }
+    catch (e) {
+        console.error(`[TigerOpen] delete file fail: ${file}`, e);
+    }
+    return false;
+}
+/**
+ * Atomically replace a file through a same-directory temporary file.
+ *
+ * Same-filesystem replacement prevents partial JSON writes. Directories and files are
+ * restricted to modes 0700 and 0600 where supported.
+ */
+function writeAtomic(file, content) {
+    const dir = path.dirname(file);
+    try {
+        fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+        restrict(dir, 0o700);
+        // Same directory, so the rename below stays on one filesystem and is atomic.
+        const tmp = path.join(dir, `.tmp-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2)}.json`);
+        try {
+            fs.writeFileSync(tmp, content, { encoding: 'utf-8', mode: 0o600 });
+            restrict(tmp, 0o600);
+            fs.renameSync(tmp, file);
+        }
+        catch (e) {
+            try {
+                fs.unlinkSync(tmp);
+            }
+            catch {
+                // The temporary file was never created; nothing to clean up.
+            }
+            throw e;
+        }
+        restrict(file, 0o600);
+    }
+    catch (e) {
+        throw new OAuth2Error(OAuth2Category.StorageFailed, `write file fail: ${file}`, e);
+    }
+}
+/** Restrict a credential file or directory where the platform supports it. */
+function restrict(target, mode) {
+    try {
+        fs.chmodSync(target, mode);
+    }
+    catch {
+        // Windows and some network filesystems have no POSIX modes; the write still stands.
+    }
+}

package/dist/esm/auth/oauth2/token.js

@@ -0,0 +1,71 @@
+/**
+ * Persisted OAuth 2.0 authorization state.
+ *
+ * The `issuer` and `clientId` bind credentials to an authorization server and client,
+ * preventing credential reuse across environments. The on-disk field names are
+ * snake_case and shared with the Java and Python SDKs.
+ */
+/** On-disk format version. An unrecognised version is an error, not a guess. */
+export const TOKEN_SCHEMA_VERSION = 1;
+export function currentMillis() {
+    return Date.now();
+}
+/** An access token and its metadata. */
+export class OAuth2Token {
+    constructor(init = {}) {
+        this.schemaVersion = init.schemaVersion ?? TOKEN_SCHEMA_VERSION;
+        this.issuer = init.issuer;
+        this.clientId = init.clientId;
+        this.accessToken = init.accessToken;
+        this.refreshToken = init.refreshToken;
+        this.tokenType = init.tokenType || 'Bearer';
+        this.scope = init.scope;
+        this.expiresAt = init.expiresAt ?? 0;
+    }
+    /** Time until expiry; negative once already expired. */
+    remainingMillis() {
+        return this.expiresAt - currentMillis();
+    }
+    /**
+     * @param aheadMillis how early to refresh. The window exists because time passes
+     *   between sending a request and the server validating it, so using a token right up
+     *   to its expiry produces intermittent 401s
+     */
+    needsRefresh(aheadMillis) {
+        return this.remainingMillis() <= aheadMillis;
+    }
+    hasRefreshToken() {
+        return !!this.refreshToken;
+    }
+    toJSON() {
+        return {
+            schema_version: this.schemaVersion,
+            issuer: this.issuer,
+            client_id: this.clientId,
+            access_token: this.accessToken,
+            refresh_token: this.refreshToken,
+            token_type: this.tokenType,
+            scope: this.scope,
+            expires_at: this.expiresAt,
+        };
+    }
+    static fromJSON(data) {
+        if (!data)
+            return null;
+        return new OAuth2Token({
+            schemaVersion: data.schema_version ?? TOKEN_SCHEMA_VERSION,
+            issuer: data.issuer,
+            clientId: data.client_id,
+            accessToken: data.access_token,
+            refreshToken: data.refresh_token,
+            tokenType: data.token_type || 'Bearer',
+            scope: data.scope,
+            expiresAt: data.expires_at ?? 0,
+        });
+    }
+    /** Prints no token values. */
+    toString() {
+        return `OAuth2Token{clientId=${this.clientId}, issuer=${this.issuer}, scope=${this.scope}, `
+            + `expiresAt=${this.expiresAt}, hasRefreshToken=${this.hasRefreshToken()}}`;
+    }
+}

package/dist/esm/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}

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/pb/Request.js

@@ -200,7 +200,7 @@ export const Request_Connect = {
     },
 };
 function createBaseRequest_Subscribe() {
-    return { dataType: 0, symbols: undefined, account: undefined, market: undefined };
+    return { dataType: 0, symbols: undefined, account: undefined, market: undefined, assetQuoteType: undefined };
 }
 export const Request_Subscribe = {
     encode(message, writer = new BinaryWriter()) {
@@ -216,6 +216,9 @@ export const Request_Subscribe = {
         if (message.market !== undefined) {
             writer.uint32(34).string(message.market);
         }
+        if (message.assetQuoteType !== undefined) {
+            writer.uint32(42).string(message.assetQuoteType);
+        }
         return writer;
     },
     decode(input, length) {
@@ -253,6 +256,13 @@ export const Request_Subscribe = {
                     message.market = reader.string();
                     continue;
                 }
+                case 5: {
+                    if (tag !== 42) {
+                        break;
+                    }
+                    message.assetQuoteType = reader.string();
+                    continue;
+                }
             }
             if ((tag & 7) === 4 || tag === 0) {
                 break;
@@ -270,6 +280,7 @@ export const Request_Subscribe = {
         message.symbols = object.symbols ?? undefined;
         message.account = object.account ?? undefined;
         message.market = object.market ?? undefined;
+        message.assetQuoteType = object.assetQuoteType ?? undefined;
         return message;
     },
 };

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

@@ -45,8 +45,11 @@ export function buildHeartBeatMessage() {
 }
 /**
  * 构建 SUBSCRIBE 请求消息
+ *
+ * @param assetQuoteType 资产行情类型枚举名（ETH / RTH / OVERNIGHT），
+ *   仅对 Asset / Position 两种订阅有意义，其余场景传 undefined
  */
-export function buildSubscribeMessage(dataType, symbols, account, market) {
+export function buildSubscribeMessage(dataType, symbols, account, market, assetQuoteType) {
     return Request.fromPartial({
         command: SocketCommon_Command.SUBSCRIBE,
         id: nextRequestId(),
@@ -55,6 +58,7 @@ export function buildSubscribeMessage(dataType, symbols, account, market) {
             symbols,
             account,
             market,
+            assetQuoteType,
         }),
     });
 }

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';
@@ -58,6 +59,8 @@ export class PushClient {
         this.subscriptions = new Map();
         /** Account-level subscriptions: subject -> account string used at subscribe time */
         this.accountSubs = new Map();
+        /** Account-level subscriptions: subject -> assetQuoteType used at subscribe time (reconnect replay) */
+        this.accountSubQuoteTypes = new Map();
         this.heartbeatTimer = null;
         this.reconnectTimer = null;
         this.stopped = false;
@@ -318,7 +321,7 @@ export class PushClient {
             this.doSubscribe(subject, Array.from(symbols));
         }
         for (const [subject, account] of this.accountSubs) {
-            this.doSubscribe(subject, undefined, account);
+            this.doSubscribe(subject, undefined, account, undefined, this.accountSubQuoteTypes.get(subject));
         }
     }
     /** Dispatch push data to the appropriate callback based on dataType */
@@ -342,8 +345,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,18 +384,17 @@ 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;
         }
     }
     /** Internal subscribe method */
-    doSubscribe(subject, symbols, account, market) {
+    doSubscribe(subject, symbols, account, market, assetQuoteType) {
         const dataType = subjectToDataType(subject);
         const symbolsStr = symbols ? symbols.join(',') : undefined;
-        const req = buildSubscribeMessage(dataType, symbolsStr, account, market);
+        const req = buildSubscribeMessage(dataType, symbolsStr, account, market, assetQuoteType);
         this.sendMessage(req);
     }
     /** Internal unsubscribe method */
@@ -550,27 +554,41 @@ export class PushClient {
         this.removeSubscription(SubjectType.Market, [market]);
     }
     // ===== Account push subscribe/unsubscribe =====
-    /** Subscribe to asset changes */
-    subscribeAsset(account) {
-        const acct = account || this.config.account;
-        this.doSubscribe(SubjectType.Asset, undefined, acct);
-        this.accountSubs.set(SubjectType.Asset, acct);
+    /**
+     * Shared implementation for the account/options overloads of
+     * subscribeAsset / subscribePosition.
+     */
+    subscribeAccount(subject, accountOrOptions) {
+        const opts = typeof accountOrOptions === 'string'
+            ? { account: accountOrOptions }
+            : (accountOrOptions ?? {});
+        const acct = opts.account || this.config.account;
+        this.doSubscribe(subject, undefined, acct, undefined, opts.assetQuoteType);
+        this.accountSubs.set(subject, acct);
+        if (opts.assetQuoteType) {
+            this.accountSubQuoteTypes.set(subject, opts.assetQuoteType);
+        }
+        else {
+            this.accountSubQuoteTypes.delete(subject);
+        }
+    }
+    subscribeAsset(accountOrOptions) {
+        this.subscribeAccount(SubjectType.Asset, accountOrOptions);
     }
     /** Unsubscribe from asset changes */
     unsubscribeAsset() {
         this.doUnsubscribe(SubjectType.Asset);
         this.accountSubs.delete(SubjectType.Asset);
+        this.accountSubQuoteTypes.delete(SubjectType.Asset);
     }
-    /** Subscribe to position changes */
-    subscribePosition(account) {
-        const acct = account || this.config.account;
-        this.doSubscribe(SubjectType.Position, undefined, acct);
-        this.accountSubs.set(SubjectType.Position, acct);
+    subscribePosition(accountOrOptions) {
+        this.subscribeAccount(SubjectType.Position, accountOrOptions);
     }
     /** Unsubscribe from position changes */
     unsubscribePosition() {
         this.doUnsubscribe(SubjectType.Position);
         this.accountSubs.delete(SubjectType.Position);
+        this.accountSubQuoteTypes.delete(SubjectType.Position);
     }
     /** Subscribe to order status */
     subscribeOrder(account) {

package/dist/esm/push/tick-util.js

@@ -0,0 +1,165 @@
+const PART_CODE_NAME_MAP = {
+    a: 'NYSE American, LLC (NYSE American)',
+    b: 'NASDAQ OMX BX, Inc. (NASDAQ OMX BX)',
+    c: 'NYSE National, Inc. (NYSE National)',
+    d: 'FINRA Alternative Display Facility (ADF)',
+    h: 'MIAX Pearl Exchange, LLC (MIAX)',
+    i: 'International Securities Exchange, LLC (ISE)',
+    j: 'Cboe EDGA Exchange, Inc. (Cboe EDGA)',
+    k: 'Cboe EDGX Exchange, Inc. (Cboe EDGX)',
+    l: 'Long-Term Stock Exchange, Inc. (LTSE)',
+    m: 'NYSE Chicago, Inc. (NYSE Chicago)',
+    n: 'New York Stock Exchange, LLC (NYSE)',
+    p: 'NYSE Arca, Inc. (NYSE Arca)',
+    s: 'Consolidated Tape System (CTS)',
+    t: 'NASDAQ Stock Market, LLC (NASDAQ)',
+    u: 'Members Exchange, LLC (MEMX)',
+    v: "Investors' Exchange, LLC. (IEX)",
+    w: 'CBOE Stock Exchange, Inc. (CBSX)',
+    x: 'NASDAQ OMX PSX, Inc. (NASDAQ OMX PSX)',
+    y: 'Cboe BYX Exchange, Inc. (Cboe BYX)',
+    z: 'Cboe BZX Exchange, Inc. (Cboe BZX)',
+};
+const PART_CODE_SHORT_NAME_MAP = {
+    a: 'AMEX',
+    b: 'BX',
+    c: 'NSX',
+    d: 'ADF',
+    h: 'MIAX',
+    i: 'ISE',
+    j: 'EDGA',
+    k: 'EDGX',
+    l: 'LTSE',
+    m: 'CHO',
+    n: 'NYSE',
+    p: 'ARCA',
+    s: 'CTS',
+    t: 'NSDQ',
+    u: 'MEMX',
+    v: 'IEX',
+    w: 'CBSX',
+    x: 'PSX',
+    y: 'BYX',
+    z: 'BZX',
+};
+const US_TRADE_COND = {
+    ' ': 'US_REGULAR_SALE',
+    B: 'US_BUNCHED_TRADE',
+    C: 'US_CASH_TRADE',
+    F: 'US_INTERMARKET_SWEEP',
+    G: 'US_BUNCHED_SOLD_TRADE',
+    H: 'US_PRICE_VARIATION_TRADE',
+    I: 'US_ODD_LOT_TRADE',
+    K: 'US_RULE_127_OR_155_TRADE',
+    L: 'US_SOLD_LAST',
+    M: 'US_MARKET_CENTER_CLOSE_PRICE',
+    N: 'US_NEXT_DAY_TRADE',
+    O: 'US_MARKET_CENTER_OPENING_TRADE',
+    P: 'US_PRIOR_REFERENCE_PRICE',
+    Q: 'US_MARKET_CENTER_OPEN_PRICE',
+    R: 'US_SELLER',
+    T: 'US_FORM_T',
+    U: 'US_EXTENDED_TRADING_HOURS',
+    V: 'US_CONTINGENT_TRADE',
+    W: 'US_AVERAGE_PRICE_TRADE',
+    X: 'US_CROSS_TRADE',
+    Z: 'US_SOLD_OUT_OF_SEQUENCE',
+    '0': 'US_ODD_LOST_CROSS_TRADE',
+    '4': 'US_DERIVATIVELY_PRICED',
+    '5': 'US_MARKET_CENTER_RE_OPENING_TRADE',
+    '6': 'US_MARKET_CENTER_CLOSING_TRADE',
+    '7': 'US_QUALIFIED_CONTINGENT_TRADE',
+    '9': 'US_CONSOLIDATED_LAST_PRICE_PER_LISTING_PACKET',
+};
+const HK_TRADE_COND = {
+    ' ': 'HK_AUTOMATCH_NORMAL',
+    D: 'HK_ODD_LOT_TRADE',
+    U: 'HK_AUCTION_TRADE',
+    '*': 'HK_OVERSEAS_TRADE',
+    P: 'HK_LATE_TRADE_OFF_EXCHG',
+    M: 'HK_NON_DIRECT_OFF_EXCHG_TRADE',
+    X: 'HK_DIRECT_OFF_EXCHG_TRADE',
+    Y: 'HK_AUTOMATIC_INTERNALIZED',
+};
+/** Returns the full exchange name for a partCode letter, or the raw code if unknown. */
+export function getPartNameByCode(code) {
+    if (!code)
+        return code;
+    return PART_CODE_NAME_MAP[code] ?? code;
+}
+/** Returns the short exchange name for a partCode letter, or the raw code if unknown. */
+export function getPartShortNameByCode(code) {
+    if (!code)
+        return code;
+    return PART_CODE_SHORT_NAME_MAP[code] ?? code;
+}
+/** Resolves a raw cond character to a readable string. */
+export function getTradeCondByCode(isUs, ch) {
+    const map = isUs ? US_TRADE_COND : HK_TRADE_COND;
+    return map[ch] ?? ch;
+}
+const US_SYMBOL_RE = /^[A-Z]+(\.[A-Z0-9]+)?$/;
+/** Reports whether symbol is a US stock (uppercase letters, optional dot suffix). */
+export function isUsStockSymbol(symbol) {
+    return US_SYMBOL_RE.test(symbol);
+}
+function isUsSymbol(symbol) {
+    return US_SYMBOL_RE.test(symbol);
+}
+function getTradeCond(isUs, ch) {
+    const map = isUs ? US_TRADE_COND : HK_TRADE_COND;
+    return map[ch] ?? ch;
+}
+/** Decodes a TradeTickData pb message into a PushTradeTick with resolved partCode/partName. */
+export function convertTradeTick(src) {
+    if (src.secType === 'FUT')
+        return convertFutureTick(src);
+    return convertStockTick(src);
+}
+function convertStockTick(src) {
+    const isUs = isUsSymbol(src.symbol);
+    const denominator = Math.pow(10, src.priceOffset);
+    const ticks = [];
+    let currentTime = 0;
+    for (let i = 0; i < src.time.length; i++) {
+        currentTime += src.time[i];
+        const condCh = src.cond.length > i ? src.cond[i] : ' ';
+        const rawCode = i < src.partCode.length ? src.partCode[i] : '';
+        ticks.push({
+            sn: src.sn + i,
+            time: currentTime,
+            price: (src.priceBase + src.price[i]) / denominator,
+            volume: src.volume[i],
+            tickType: src.type.length > i ? src.type[i] : '',
+            cond: getTradeCond(isUs, condCh),
+            partCode: getPartShortNameByCode(rawCode),
+            partName: getPartNameByCode(rawCode),
+        });
+    }
+    return { symbol: src.symbol, secType: src.secType, quoteLevel: src.quoteLevel, timestamp: src.timestamp, ticks };
+}
+function convertFutureTick(src) {
+    const denominator = Math.pow(10, src.priceOffset);
+    const ticks = [];
+    let currentTime = 0;
+    let startSn = src.sn;
+    for (let i = 0; i < src.time.length; i++) {
+        currentTime += src.time[i];
+        const curPrice = (src.priceBase + src.price[i]) / denominator;
+        const mv = src.mergedVols[i];
+        for (let j = 0; j < mv.vol.length; j++) {
+            ticks.push({
+                sn: startSn * 10 + j,
+                time: currentTime,
+                price: curPrice,
+                volume: mv.vol[j],
+                tickType: '',
+                cond: '',
+                partCode: '',
+                partName: '',
+            });
+        }
+        startSn++;
+    }
+    return { symbol: src.symbol, secType: src.secType, quoteLevel: '', timestamp: src.timestamp, ticks };
+}