@fullstackcraftllc/floe 0.0.13 → 0.0.15

package/dist/client/brokers/IBKRClient.js

@@ -0,0 +1,797 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IBKRClient = exports.IBKR_FIELD_TAGS = void 0;
+const indexOptions_1 = require("../../utils/indexOptions");
+const occ_1 = require("../../utils/occ");
+const BaseBrokerClient_1 = require("./BaseBrokerClient");
+// ==================== IBKR Market Data Field Tags ====================
+// Reference: https://www.interactivebrokers.com/campus/ibkr-api-page/webapi-ref/#tag/Market-Data
+/**
+ * IBKR market data field tags for snapshot and streaming requests
+ */
+exports.IBKR_FIELD_TAGS = {
+    // Price fields
+    LAST_PRICE: '31',
+    BID_PRICE: '84',
+    BID_SIZE: '85',
+    ASK_PRICE: '86',
+    ASK_SIZE: '88',
+    // Volume fields
+    VOLUME: '7059',
+    VOLUME_LONG: '7762',
+    // Option-specific fields
+    OPEN_INTEREST: '7089',
+    IMPLIED_VOLATILITY: '7283',
+    IMPLIED_VOLATILITY_PERCENT: '7284',
+    DELTA: '7308',
+    GAMMA: '7309',
+    THETA: '7310',
+    VEGA: '7311',
+    // Time and sales
+    LAST_SIZE: '32',
+    LAST_TIMESTAMP: '7295',
+    // Additional fields
+    OPEN: '7296',
+    HIGH: '7297',
+    LOW: '7298',
+    CLOSE: '7299',
+    CHANGE: '82',
+    CHANGE_PERCENT: '83',
+    // Contract info
+    UNDERLYING_CONID: '6457',
+    CONTRACT_DESC: '6509',
+    // Mark/Mid
+    MARK: '7219',
+};
+/**
+ * IBKRClient handles real-time streaming connections to the Interactive Brokers Web API.
+ *
+ * @remarks
+ * This client manages WebSocket connections to IBKR's streaming API,
+ * normalizes incoming quote and trade data, and emits events for upstream
+ * consumption by the FloeClient.
+ *
+ * IBKR uses contract IDs (conids) to identify instruments. This client maintains
+ * a mapping between OCC option symbols and IBKR conids for seamless integration.
+ *
+ * @example
+ * ```typescript
+ * // Using Client Portal Gateway (local)
+ * const client = new IBKRClient({
+ *   baseUrl: 'https://localhost:5000/v1/api',
+ *   rejectUnauthorized: false
+ * });
+ *
+ * // Using OAuth (direct API)
+ * const client = new IBKRClient({
+ *   baseUrl: 'https://api.ibkr.com/v1/api',
+ *   accessToken: 'your-oauth-token'
+ * });
+ *
+ * client.on('tickerUpdate', (ticker) => {
+ *   console.log(`${ticker.symbol}: ${ticker.spot}`);
+ * });
+ *
+ * await client.connect();
+ * client.subscribe(['QQQ', 'AAPL240119C00500000']);
+ * ```
+ */
+class IBKRClient extends BaseBrokerClient_1.BaseBrokerClient {
+    /**
+     * Creates a new IBKRClient instance.
+     *
+     * @param options - Client configuration options
+     */
+    constructor(options) {
+        super(options);
+        this.brokerName = 'IBKR';
+        /** WebSocket connection */
+        this.ws = null;
+        /** Connection state */
+        this.connected = false;
+        /**
+         * Mapping from OCC symbol to IBKR conid
+         * This is populated as options are discovered/subscribed
+         */
+        this.occToConid = new Map();
+        /**
+         * Mapping from IBKR conid to OCC symbol (reverse lookup)
+         */
+        this.conidToOcc = new Map();
+        /**
+         * Mapping from ticker symbol to IBKR conid (for underlyings)
+         */
+        this.symbolToConid = new Map();
+        /**
+         * Mapping from conid to ticker symbol (reverse lookup for underlyings)
+         */
+        this.conidToSymbol = new Map();
+        /**
+         * Set of conids that have been "primed" for market data
+         * (IBKR requires a pre-flight request before streaming)
+         */
+        this.primedConids = new Set();
+        this.baseUrl = options.baseUrl.replace(/\/$/, ''); // Remove trailing slash
+        this.accessToken = options.accessToken;
+        this.accountId = options.accountId;
+        this.rejectUnauthorized = options.rejectUnauthorized ?? true;
+    }
+    // ==================== Public API ====================
+    /**
+     * Establishes a connection to IBKR.
+     *
+     * @returns Promise that resolves when connected
+     * @throws {Error} If connection fails
+     */
+    async connect() {
+        // First, validate the brokerage session
+        await this.validateSession();
+        // Connect WebSocket for streaming
+        await this.connectWebSocket();
+    }
+    /**
+     * Disconnects from the IBKR API.
+     */
+    disconnect() {
+        if (this.ws) {
+            this.ws.close(1000, 'Client disconnect');
+            this.ws = null;
+        }
+        this.connected = false;
+        this.subscribedSymbols.clear();
+        this.primedConids.clear();
+    }
+    /**
+     * Subscribes to real-time updates for the specified symbols.
+     *
+     * @param symbols - Array of ticker symbols and/or OCC option symbols
+     */
+    async subscribe(symbols) {
+        // Separate options from underlyings
+        const optionSymbols = symbols.filter(s => this.isOptionSymbol(s));
+        const tickerSymbols = symbols.filter(s => !this.isOptionSymbol(s));
+        // Resolve conids for all symbols
+        await this.resolveConids([...tickerSymbols], [...optionSymbols]);
+        // Add to tracked symbols
+        symbols.forEach(s => this.subscribedSymbols.add(s));
+        if (!this.connected || !this.ws) {
+            // Symbols queued for subscription when connected
+            return;
+        }
+        // Prime market data for all conids (IBKR requires this)
+        await this.primeMarketData(symbols);
+        // Subscribe via WebSocket
+        for (const symbol of symbols) {
+            const conid = this.getConidForSymbol(symbol);
+            if (conid) {
+                this.subscribeToConid(conid);
+            }
+        }
+    }
+    /**
+     * Unsubscribes from real-time updates for the specified symbols.
+     *
+     * @param symbols - Array of symbols to unsubscribe from
+     */
+    unsubscribe(symbols) {
+        symbols.forEach(s => this.subscribedSymbols.delete(s));
+        if (!this.connected || !this.ws) {
+            return;
+        }
+        for (const symbol of symbols) {
+            const conid = this.getConidForSymbol(symbol);
+            if (conid) {
+                this.unsubscribeFromConid(conid);
+            }
+        }
+    }
+    /**
+     * Unsubscribes from all symbols.
+     */
+    unsubscribeFromAll() {
+        const symbols = Array.from(this.subscribedSymbols);
+        this.unsubscribe(symbols);
+    }
+    /**
+     * Returns whether the client is currently connected.
+     */
+    isConnected() {
+        return this.connected;
+    }
+    /**
+     * Fetches open interest and other static data for subscribed options via REST API.
+     *
+     * @param occSymbols - Array of OCC option symbols to fetch data for
+     * @returns Promise that resolves when all data is fetched
+     */
+    async fetchOpenInterest(occSymbols) {
+        // For IBKR, we need to fetch market data snapshots to get open interest
+        const conids = [];
+        for (const occSymbol of occSymbols) {
+            const conid = this.occToConid.get(occSymbol);
+            if (conid) {
+                conids.push(conid);
+            }
+            else {
+                // Try to resolve the conid first
+                await this.resolveOptionConid(occSymbol);
+                const resolvedConid = this.occToConid.get(occSymbol);
+                if (resolvedConid) {
+                    conids.push(resolvedConid);
+                }
+            }
+        }
+        if (conids.length === 0)
+            return;
+        // Fetch market data snapshots with open interest field
+        const fields = [
+            exports.IBKR_FIELD_TAGS.BID_PRICE,
+            exports.IBKR_FIELD_TAGS.BID_SIZE,
+            exports.IBKR_FIELD_TAGS.ASK_PRICE,
+            exports.IBKR_FIELD_TAGS.ASK_SIZE,
+            exports.IBKR_FIELD_TAGS.LAST_PRICE,
+            exports.IBKR_FIELD_TAGS.VOLUME,
+            exports.IBKR_FIELD_TAGS.OPEN_INTEREST,
+            exports.IBKR_FIELD_TAGS.IMPLIED_VOLATILITY,
+        ];
+        // Prime and fetch in batches (IBKR has limits)
+        const batchSize = 50;
+        for (let i = 0; i < conids.length; i += batchSize) {
+            const batch = conids.slice(i, i + batchSize);
+            // Prime first
+            await this.primeMarketDataByConids(batch, fields);
+            // Wait a moment for data to be ready
+            await this.sleep(250);
+            // Fetch snapshots
+            const snapshots = await this.fetchMarketDataSnapshots(batch, fields);
+            // Process snapshots
+            for (const snapshot of snapshots) {
+                this.processOptionSnapshot(snapshot);
+            }
+        }
+    }
+    /**
+     * Fetches options chain data for a given underlying.
+     *
+     * @param underlying - Underlying symbol (e.g., 'QQQ')
+     * @param expiration - Expiration date in YYYY-MM-DD format
+     * @returns Array of option contract info
+     */
+    async fetchOptionsChain(underlying, expiration) {
+        try {
+            // Step 1: Get underlying conid and available months
+            const underlyingConid = await this.resolveUnderlyingConid(underlying);
+            if (!underlyingConid) {
+                this.log(`Could not resolve conid for ${underlying}`);
+                return [];
+            }
+            // Convert expiration to MMMYY format (e.g., "2024-01-19" -> "JAN24")
+            const expDate = new Date(expiration + 'T12:00:00');
+            const monthNames = ['JAN', 'FEB', 'MAR', 'APR', 'MAY', 'JUN',
+                'JUL', 'AUG', 'SEP', 'OCT', 'NOV', 'DEC'];
+            const month = `${monthNames[expDate.getMonth()]}${expDate.getFullYear().toString().slice(-2)}`;
+            // Step 2: Get valid strikes
+            const strikesResponse = await this.makeRequest(`/iserver/secdef/strikes?conid=${underlyingConid}&sectype=OPT&month=${month}&exchange=SMART`);
+            if (!strikesResponse || !strikesResponse.call) {
+                this.log(`No strikes found for ${underlying} ${expiration}`);
+                return [];
+            }
+            const allStrikes = Array.from(new Set([...strikesResponse.call, ...strikesResponse.put]));
+            // Step 3: Fetch option contracts for each strike (batched)
+            const allOptions = [];
+            for (const strike of allStrikes) {
+                const options = await this.makeRequest(`/iserver/secdef/info?conid=${underlyingConid}&sectype=OPT&month=${month}&strike=${strike}&exchange=SMART`);
+                if (options && Array.isArray(options)) {
+                    // Filter to exact expiration date
+                    const filteredOptions = options.filter(opt => {
+                        if (!opt.maturityDate)
+                            return false;
+                        // maturityDate format: YYYYMMDD
+                        const optExpDate = opt.maturityDate;
+                        const targetExpDate = expiration.replace(/-/g, '');
+                        return optExpDate === targetExpDate;
+                    });
+                    for (const opt of filteredOptions) {
+                        allOptions.push(opt);
+                        // Build and store OCC symbol mapping
+                        const occSymbol = this.ibkrOptionToOCC(opt);
+                        if (occSymbol) {
+                            this.occToConid.set(occSymbol, opt.conid);
+                            this.conidToOcc.set(opt.conid, occSymbol);
+                        }
+                    }
+                }
+            }
+            return allOptions;
+        }
+        catch (error) {
+            this.emit('error', error instanceof Error ? error : new Error(String(error)));
+            return [];
+        }
+    }
+    /**
+     * Resolves an OCC option symbol to an IBKR conid.
+     *
+     * @param occSymbol - OCC option symbol
+     * @returns The IBKR conid, or null if not found
+     */
+    async resolveOptionConid(occSymbol) {
+        // Check cache first
+        const cached = this.occToConid.get(occSymbol);
+        if (cached)
+            return cached;
+        try {
+            // Parse the OCC symbol
+            const parsed = (0, occ_1.parseOCCSymbol)(occSymbol);
+            const underlying = (0, indexOptions_1.getUnderlyingFromOptionRoot)(parsed.symbol);
+            const expiration = parsed.expiration.toISOString().split('T')[0];
+            // Fetch the options chain for this expiration
+            await this.fetchOptionsChain(underlying, expiration);
+            // Check if we found it
+            return this.occToConid.get(occSymbol) ?? null;
+        }
+        catch (error) {
+            this.log(`Failed to resolve conid for ${occSymbol}: ${error}`);
+            return null;
+        }
+    }
+    /**
+     * Resolves an underlying symbol to an IBKR conid.
+     *
+     * @param symbol - Ticker symbol
+     * @returns The IBKR conid, or null if not found
+     */
+    async resolveUnderlyingConid(symbol) {
+        // Check cache first
+        const cached = this.symbolToConid.get(symbol);
+        if (cached)
+            return cached;
+        try {
+            // Search for the symbol
+            const results = await this.makeRequest(`/iserver/secdef/search?symbol=${encodeURIComponent(symbol)}&secType=STK`);
+            if (!results || results.length === 0) {
+                // Try as index
+                const indexResults = await this.makeRequest(`/iserver/secdef/search?symbol=${encodeURIComponent(symbol)}&secType=IND`);
+                if (!indexResults || indexResults.length === 0) {
+                    this.log(`No results found for symbol ${symbol}`);
+                    return null;
+                }
+                // Use the first matching result
+                const conid = parseInt(indexResults[0].conid, 10);
+                this.symbolToConid.set(symbol, conid);
+                this.conidToSymbol.set(conid, symbol);
+                return conid;
+            }
+            // Find the US-listed version (or first result)
+            const conid = parseInt(results[0].conid, 10);
+            this.symbolToConid.set(symbol, conid);
+            this.conidToSymbol.set(conid, symbol);
+            return conid;
+        }
+        catch (error) {
+            this.log(`Failed to resolve conid for ${symbol}: ${error}`);
+            return null;
+        }
+    }
+    // ==================== Private Methods ====================
+    /**
+     * Validates the brokerage session with IBKR.
+     */
+    async validateSession() {
+        try {
+            const response = await this.makeRequest('/sso/validate');
+            if (!response?.validated) {
+                throw new Error('IBKR session not validated. Please ensure you are logged in.');
+            }
+            this.log('Session validated');
+        }
+        catch (error) {
+            throw new Error(`Failed to validate IBKR session: ${error}`);
+        }
+    }
+    /**
+     * Connects to the IBKR WebSocket for streaming data.
+     */
+    connectWebSocket() {
+        return new Promise((resolve, reject) => {
+            // Derive WebSocket URL from REST API URL
+            const wsUrl = this.baseUrl
+                .replace('https://', 'wss://')
+                .replace('http://', 'ws://')
+                .replace('/v1/api', '/v1/api/ws');
+            this.ws = new WebSocket(wsUrl);
+            this.ws.onopen = () => {
+                this.connected = true;
+                this.reconnectAttempts = 0;
+                this.log('WebSocket connected');
+                this.emit('connected', undefined);
+                // Subscribe to any queued symbols
+                if (this.subscribedSymbols.size > 0) {
+                    this.subscribe(Array.from(this.subscribedSymbols));
+                }
+                resolve();
+            };
+            this.ws.onmessage = (event) => {
+                this.handleWebSocketMessage(event.data);
+            };
+            this.ws.onclose = (event) => {
+                this.connected = false;
+                this.emit('disconnected', { reason: event.reason });
+                // Attempt reconnection if not a clean close
+                if (event.code !== 1000) {
+                    this.attemptReconnect();
+                }
+            };
+            this.ws.onerror = (error) => {
+                this.emit('error', new Error('WebSocket error'));
+                reject(error);
+            };
+        });
+    }
+    /**
+     * Handles incoming WebSocket messages.
+     */
+    handleWebSocketMessage(data) {
+        try {
+            const message = JSON.parse(data);
+            // Check message type from topic
+            if (message.topic?.startsWith('smd+')) {
+                this.handleMarketDataMessage(message);
+            }
+            else if (message.topic === 'sts') {
+                // Status message
+                this.log(`Status: ${JSON.stringify(message)}`);
+            }
+            else if (message.topic === 'system') {
+                // System message
+                this.log(`System: ${JSON.stringify(message)}`);
+            }
+        }
+        catch (error) {
+            // Ignore parse errors for heartbeat/status messages
+        }
+    }
+    /**
+     * Handles streaming market data messages.
+     */
+    handleMarketDataMessage(message) {
+        const conid = message.conid;
+        const timestamp = message._updated ?? Date.now();
+        // Determine if this is an option or underlying
+        const occSymbol = this.conidToOcc.get(conid);
+        const tickerSymbol = this.conidToSymbol.get(conid);
+        if (occSymbol) {
+            this.updateOptionFromWSMessage(occSymbol, message, timestamp);
+        }
+        else if (tickerSymbol) {
+            this.updateTickerFromWSMessage(tickerSymbol, message, timestamp);
+        }
+    }
+    /**
+     * Updates option data from a WebSocket message.
+     */
+    updateOptionFromWSMessage(occSymbol, message, timestamp) {
+        const bid = this.toNumber(message[exports.IBKR_FIELD_TAGS.BID_PRICE]);
+        const bidSize = this.toNumber(message[exports.IBKR_FIELD_TAGS.BID_SIZE]);
+        const ask = this.toNumber(message[exports.IBKR_FIELD_TAGS.ASK_PRICE]);
+        const askSize = this.toNumber(message[exports.IBKR_FIELD_TAGS.ASK_SIZE]);
+        const last = this.toNumber(message[exports.IBKR_FIELD_TAGS.LAST_PRICE]);
+        const volume = this.toNumber(message[exports.IBKR_FIELD_TAGS.VOLUME]);
+        const openInterest = this.toNumber(message[exports.IBKR_FIELD_TAGS.OPEN_INTEREST]);
+        const iv = this.toNumber(message[exports.IBKR_FIELD_TAGS.IMPLIED_VOLATILITY]);
+        // Check if this is a trade update (has last price and last size)
+        const lastSize = this.toNumber(message[exports.IBKR_FIELD_TAGS.LAST_SIZE]);
+        const isTradeUpdate = lastSize > 0 && last > 0;
+        if (isTradeUpdate && bid > 0 && ask > 0) {
+            // Record the trade for OI tracking
+            this.recordTrade(occSymbol, last, lastSize, bid, ask, timestamp);
+        }
+        const existing = this.optionCache.get(occSymbol);
+        let parsed;
+        try {
+            parsed = (0, occ_1.parseOCCSymbol)(occSymbol);
+        }
+        catch {
+            if (!existing)
+                return;
+            parsed = {
+                symbol: existing.underlying,
+                expiration: new Date(existing.expirationTimestamp),
+                optionType: existing.optionType,
+                strike: existing.strike,
+            };
+        }
+        // Set base open interest if we have it and haven't set it yet
+        if (openInterest > 0) {
+            this.setBaseOpenInterest(occSymbol, openInterest);
+        }
+        const option = {
+            occSymbol,
+            underlying: parsed.symbol,
+            strike: parsed.strike,
+            expiration: parsed.expiration.toISOString().split('T')[0],
+            expirationTimestamp: parsed.expiration.getTime(),
+            optionType: parsed.optionType,
+            bid: bid || existing?.bid || 0,
+            bidSize: bidSize || existing?.bidSize || 0,
+            ask: ask || existing?.ask || 0,
+            askSize: askSize || existing?.askSize || 0,
+            mark: (bid && ask) ? (bid + ask) / 2 : existing?.mark || 0,
+            last: last || existing?.last || 0,
+            volume: volume || existing?.volume || 0,
+            openInterest: openInterest || existing?.openInterest || 0,
+            liveOpenInterest: this.calculateLiveOpenInterest(occSymbol),
+            impliedVolatility: iv || existing?.impliedVolatility || 0,
+            timestamp,
+        };
+        this.optionCache.set(occSymbol, option);
+        this.emit('optionUpdate', option);
+    }
+    /**
+     * Updates ticker data from a WebSocket message.
+     */
+    updateTickerFromWSMessage(symbol, message, timestamp) {
+        const existing = this.tickerCache.get(symbol);
+        const bid = this.toNumber(message[exports.IBKR_FIELD_TAGS.BID_PRICE]);
+        const bidSize = this.toNumber(message[exports.IBKR_FIELD_TAGS.BID_SIZE]);
+        const ask = this.toNumber(message[exports.IBKR_FIELD_TAGS.ASK_PRICE]);
+        const askSize = this.toNumber(message[exports.IBKR_FIELD_TAGS.ASK_SIZE]);
+        const last = this.toNumber(message[exports.IBKR_FIELD_TAGS.LAST_PRICE]);
+        const volume = this.toNumber(message[exports.IBKR_FIELD_TAGS.VOLUME]);
+        const ticker = {
+            symbol,
+            spot: (bid && ask) ? (bid + ask) / 2 : last || existing?.spot || 0,
+            bid: bid || existing?.bid || 0,
+            bidSize: bidSize || existing?.bidSize || 0,
+            ask: ask || existing?.ask || 0,
+            askSize: askSize || existing?.askSize || 0,
+            last: last || existing?.last || 0,
+            volume: volume || existing?.volume || 0,
+            timestamp,
+        };
+        this.tickerCache.set(symbol, ticker);
+        this.emit('tickerUpdate', ticker);
+    }
+    /**
+     * Processes an option snapshot response.
+     */
+    processOptionSnapshot(snapshot) {
+        const conid = snapshot.conid;
+        const occSymbol = this.conidToOcc.get(conid);
+        if (!occSymbol)
+            return;
+        const timestamp = snapshot._updated ?? Date.now();
+        const openInterest = this.toNumber(snapshot[exports.IBKR_FIELD_TAGS.OPEN_INTEREST]);
+        const iv = this.toNumber(snapshot[exports.IBKR_FIELD_TAGS.IMPLIED_VOLATILITY]);
+        const bid = this.toNumber(snapshot[exports.IBKR_FIELD_TAGS.BID_PRICE]);
+        const bidSize = this.toNumber(snapshot[exports.IBKR_FIELD_TAGS.BID_SIZE]);
+        const ask = this.toNumber(snapshot[exports.IBKR_FIELD_TAGS.ASK_PRICE]);
+        const askSize = this.toNumber(snapshot[exports.IBKR_FIELD_TAGS.ASK_SIZE]);
+        const last = this.toNumber(snapshot[exports.IBKR_FIELD_TAGS.LAST_PRICE]);
+        const volume = this.toNumber(snapshot[exports.IBKR_FIELD_TAGS.VOLUME]);
+        // Set base open interest for live OI tracking
+        if (openInterest > 0) {
+            this.setBaseOpenInterest(occSymbol, openInterest);
+        }
+        const existing = this.optionCache.get(occSymbol);
+        let parsed;
+        try {
+            parsed = (0, occ_1.parseOCCSymbol)(occSymbol);
+        }
+        catch {
+            if (!existing)
+                return;
+            parsed = {
+                symbol: existing.underlying,
+                expiration: new Date(existing.expirationTimestamp),
+                optionType: existing.optionType,
+                strike: existing.strike,
+            };
+        }
+        const option = {
+            occSymbol,
+            underlying: parsed.symbol,
+            strike: parsed.strike,
+            expiration: parsed.expiration.toISOString().split('T')[0],
+            expirationTimestamp: parsed.expiration.getTime(),
+            optionType: parsed.optionType,
+            bid: bid || existing?.bid || 0,
+            bidSize: bidSize || existing?.bidSize || 0,
+            ask: ask || existing?.ask || 0,
+            askSize: askSize || existing?.askSize || 0,
+            mark: (bid && ask) ? (bid + ask) / 2 : existing?.mark || 0,
+            last: last || existing?.last || 0,
+            volume: volume || existing?.volume || 0,
+            openInterest: openInterest || existing?.openInterest || 0,
+            liveOpenInterest: this.calculateLiveOpenInterest(occSymbol),
+            impliedVolatility: iv || existing?.impliedVolatility || 0,
+            timestamp,
+        };
+        this.optionCache.set(occSymbol, option);
+        this.emit('optionUpdate', option);
+    }
+    /**
+     * Sends a subscription message for a conid.
+     */
+    subscribeToConid(conid) {
+        if (!this.ws || this.ws.readyState !== WebSocket.OPEN)
+            return;
+        const fields = [
+            exports.IBKR_FIELD_TAGS.LAST_PRICE,
+            exports.IBKR_FIELD_TAGS.BID_PRICE,
+            exports.IBKR_FIELD_TAGS.BID_SIZE,
+            exports.IBKR_FIELD_TAGS.ASK_PRICE,
+            exports.IBKR_FIELD_TAGS.ASK_SIZE,
+            exports.IBKR_FIELD_TAGS.VOLUME,
+            exports.IBKR_FIELD_TAGS.OPEN_INTEREST,
+            exports.IBKR_FIELD_TAGS.IMPLIED_VOLATILITY,
+            exports.IBKR_FIELD_TAGS.LAST_SIZE,
+        ];
+        const message = `smd+${conid}+${JSON.stringify({ fields })}`;
+        this.ws.send(message);
+        this.log(`Subscribed to conid ${conid}`);
+    }
+    /**
+     * Sends an unsubscription message for a conid.
+     */
+    unsubscribeFromConid(conid) {
+        if (!this.ws || this.ws.readyState !== WebSocket.OPEN)
+            return;
+        const message = `umd+${conid}+{}`;
+        this.ws.send(message);
+        this.log(`Unsubscribed from conid ${conid}`);
+    }
+    /**
+     * Primes market data for the given symbols.
+     * IBKR requires a "pre-flight" snapshot request before streaming works.
+     */
+    async primeMarketData(symbols) {
+        const conids = [];
+        for (const symbol of symbols) {
+            const conid = this.getConidForSymbol(symbol);
+            if (conid && !this.primedConids.has(conid)) {
+                conids.push(conid);
+            }
+        }
+        if (conids.length === 0)
+            return;
+        await this.primeMarketDataByConids(conids);
+    }
+    /**
+     * Primes market data for specific conids.
+     */
+    async primeMarketDataByConids(conids, fields) {
+        const fieldsToUse = fields ?? [
+            exports.IBKR_FIELD_TAGS.LAST_PRICE,
+            exports.IBKR_FIELD_TAGS.BID_PRICE,
+            exports.IBKR_FIELD_TAGS.BID_SIZE,
+            exports.IBKR_FIELD_TAGS.ASK_PRICE,
+            exports.IBKR_FIELD_TAGS.ASK_SIZE,
+            exports.IBKR_FIELD_TAGS.VOLUME,
+        ];
+        try {
+            await this.makeRequest(`/iserver/marketdata/snapshot?conids=${conids.join(',')}&fields=${fieldsToUse.join(',')}`);
+            conids.forEach(c => this.primedConids.add(c));
+            this.log(`Primed market data for ${conids.length} conids`);
+        }
+        catch (error) {
+            this.log(`Failed to prime market data: ${error}`);
+        }
+    }
+    /**
+     * Fetches market data snapshots for given conids.
+     */
+    async fetchMarketDataSnapshots(conids, fields) {
+        try {
+            const response = await this.makeRequest(`/iserver/marketdata/snapshot?conids=${conids.join(',')}&fields=${fields.join(',')}`);
+            return response ?? [];
+        }
+        catch (error) {
+            this.log(`Failed to fetch market data snapshots: ${error}`);
+            return [];
+        }
+    }
+    /**
+     * Resolves conids for both ticker symbols and OCC option symbols.
+     */
+    async resolveConids(tickerSymbols, optionSymbols) {
+        // Resolve underlying conids
+        for (const symbol of tickerSymbols) {
+            if (!this.symbolToConid.has(symbol)) {
+                await this.resolveUnderlyingConid(symbol);
+            }
+        }
+        // Resolve option conids
+        for (const occSymbol of optionSymbols) {
+            if (!this.occToConid.has(occSymbol)) {
+                await this.resolveOptionConid(occSymbol);
+            }
+        }
+    }
+    /**
+     * Gets the conid for a symbol (either option or underlying).
+     */
+    getConidForSymbol(symbol) {
+        if (this.isOptionSymbol(symbol)) {
+            return this.occToConid.get(symbol);
+        }
+        return this.symbolToConid.get(symbol);
+    }
+    /**
+     * Converts an IBKR option info to OCC symbol format.
+     */
+    ibkrOptionToOCC(opt) {
+        try {
+            // maturityDate format: YYYYMMDD
+            if (!opt.maturityDate || opt.maturityDate.length !== 8)
+                return null;
+            const year = parseInt(opt.maturityDate.slice(0, 4), 10);
+            const month = parseInt(opt.maturityDate.slice(4, 6), 10) - 1;
+            const day = parseInt(opt.maturityDate.slice(6, 8), 10);
+            const expiration = new Date(year, month, day, 12, 0, 0);
+            const optionType = opt.right === 'C' ? 'call' : 'put';
+            return (0, occ_1.buildOCCSymbol)({
+                symbol: opt.symbol,
+                expiration,
+                optionType,
+                strike: opt.strike,
+            });
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Makes an authenticated request to the IBKR API.
+     */
+    async makeRequest(endpoint, options) {
+        const url = `${this.baseUrl}${endpoint}`;
+        const headers = {
+            'Accept': 'application/json',
+            'Content-Type': 'application/json',
+        };
+        if (this.accessToken) {
+            headers['Authorization'] = `Bearer ${this.accessToken}`;
+        }
+        try {
+            const response = await fetch(url, {
+                ...options,
+                headers: {
+                    ...headers,
+                    ...options?.headers,
+                },
+            });
+            if (!response.ok) {
+                const errorText = await response.text();
+                this.log(`API error ${response.status}: ${errorText}`);
+                return null;
+            }
+            const data = await response.json();
+            return data;
+        }
+        catch (error) {
+            this.log(`Request failed: ${error}`);
+            return null;
+        }
+    }
+    /**
+     * Attempts to reconnect with exponential backoff.
+     */
+    async attemptReconnect() {
+        if (this.reconnectAttempts >= this.maxReconnectAttempts) {
+            this.emit('error', new Error('Max reconnection attempts reached'));
+            return;
+        }
+        this.reconnectAttempts++;
+        const delay = this.getReconnectDelay();
+        this.log(`Reconnection attempt ${this.reconnectAttempts}/${this.maxReconnectAttempts} in ${delay}ms`);
+        await this.sleep(delay);
+        try {
+            await this.connect();
+        }
+        catch {
+            // Reconnect attempt failed, will try again via onclose
+        }
+    }
+}
+exports.IBKRClient = IBKRClient;