pmxt-core 2.37.14 → 2.39.0

package/dist/exchanges/hyperliquid/normalizer.js

@@ -0,0 +1,339 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HyperliquidNormalizer = void 0;
+const market_utils_1 = require("../../utils/market-utils");
+const utils_1 = require("./utils");
+const config_1 = require("./config");
+function parseDescription(description) {
+    // Hyperliquid outcome descriptions use key:value pairs separated by |
+    // e.g. "class:priceBinary|underlying:BTC|expiry:20260509-0600|targetPrice:79583|period:1d"
+    // or simple values like "other", "index:0"
+    const result = { raw: description };
+    const parts = description.split('|');
+    for (const part of parts) {
+        const colonIdx = part.indexOf(':');
+        if (colonIdx === -1)
+            continue;
+        const key = part.slice(0, colonIdx);
+        const value = part.slice(colonIdx + 1);
+        switch (key) {
+            case 'class':
+                result.class = value;
+                break;
+            case 'underlying':
+                result.underlying = value;
+                break;
+            case 'expiry': {
+                result.expiry = value;
+                result.expiryDate = parseExpiryDate(value);
+                break;
+            }
+            case 'targetPrice':
+                result.targetPrice = value;
+                break;
+            case 'priceThresholds':
+                result.priceThresholds = value.split(',');
+                break;
+            case 'period':
+                result.period = value;
+                break;
+            case 'index':
+                result.index = value;
+                break;
+        }
+    }
+    return result;
+}
+/**
+ * Parse Hyperliquid's expiry format "YYYYMMDD-HHmm" into a Date.
+ * Example: "20260509-0600" -> 2026-05-09T06:00:00Z
+ */
+function parseExpiryDate(expiry) {
+    const match = expiry.match(/^(\d{4})(\d{2})(\d{2})-(\d{2})(\d{2})$/);
+    if (!match)
+        return undefined;
+    const [, year, month, day, hour, minute] = match;
+    return new Date(`${year}-${month}-${day}T${hour}:${minute}:00Z`);
+}
+/**
+ * Build a human-readable title from the parsed description.
+ */
+function buildTitle(rawName, parsed, questionParsed) {
+    // priceBinary: "BTC > $79,583 @ May 9, 2026"
+    if (parsed.class === 'priceBinary' && parsed.underlying && parsed.targetPrice) {
+        const price = Number(parsed.targetPrice).toLocaleString('en-US');
+        const dateStr = parsed.expiryDate
+            ? parsed.expiryDate.toISOString().replace('T', ' ').replace(':00.000Z', ' UTC')
+            : '';
+        return `${parsed.underlying} > $${price}${dateStr ? ` @ ${dateStr}` : ''}`;
+    }
+    // Named outcome in a priceBucket question: use thresholds from question
+    if (parsed.index !== undefined && questionParsed?.priceThresholds && questionParsed.underlying) {
+        const idx = parseInt(parsed.index, 10);
+        const thresholds = questionParsed.priceThresholds;
+        const underlying = questionParsed.underlying;
+        if (idx === 0 && thresholds.length > 0) {
+            return `${underlying} < $${Number(thresholds[0]).toLocaleString('en-US')}`;
+        }
+        if (idx === thresholds.length) {
+            return `${underlying} > $${Number(thresholds[thresholds.length - 1]).toLocaleString('en-US')}`;
+        }
+        if (idx > 0 && idx <= thresholds.length) {
+            const lo = Number(thresholds[idx - 1]).toLocaleString('en-US');
+            const hi = Number(thresholds[idx]).toLocaleString('en-US');
+            return `${underlying} $${lo} - $${hi}`;
+        }
+    }
+    return rawName;
+}
+function buildMarketUrl(outcomeId) {
+    return `https://app.hyperliquid.xyz/trade/${encodeURIComponent(`#${outcomeId * 10}`)}`;
+}
+function buildEventUrl(questionId) {
+    return `https://app.hyperliquid.xyz/trade/${encodeURIComponent(`#${questionId}`)}`;
+}
+function isOutcomeCoin(coin) {
+    return coin.startsWith('#');
+}
+// ----------------------------------------------------------------------------
+// Normalizer
+// ----------------------------------------------------------------------------
+class HyperliquidNormalizer {
+    normalizeMarket(raw) {
+        if (!raw || !raw.outcome)
+            return null;
+        const outcome = raw.outcome;
+        const outcomeId = outcome.outcome;
+        const parsed = parseDescription(outcome.description);
+        // Also parse the question description for context (e.g. priceThresholds)
+        const questionParsed = raw.question
+            ? parseDescription(raw.question.description)
+            : undefined;
+        const midPrice = raw.midPrice ? parseFloat(raw.midPrice) : 0.5;
+        const yesPrice = Math.max(0, Math.min(1, midPrice));
+        const noPrice = Math.max(0, Math.min(1, 1 - midPrice));
+        const outcomes = [];
+        for (const side of outcome.sideSpecs) {
+            const sideKey = side.name.toLowerCase() === 'yes' ? 'yes' : 'no';
+            outcomes.push({
+                outcomeId: (0, utils_1.toOutcomeId)(outcomeId, sideKey),
+                marketId: (0, utils_1.toMarketId)(outcomeId),
+                label: side.name,
+                price: sideKey === 'yes' ? yesPrice : noPrice,
+            });
+        }
+        // If no sideSpecs provided, default to Yes/No
+        if (outcomes.length === 0) {
+            outcomes.push({
+                outcomeId: (0, utils_1.toOutcomeId)(outcomeId, 'yes'),
+                marketId: (0, utils_1.toMarketId)(outcomeId),
+                label: 'Yes',
+                price: yesPrice,
+            }, {
+                outcomeId: (0, utils_1.toOutcomeId)(outcomeId, 'no'),
+                marketId: (0, utils_1.toMarketId)(outcomeId),
+                label: 'No',
+                price: noPrice,
+            });
+        }
+        // Resolution date: prefer outcome-level expiry, fall back to question-level
+        const expiryDate = parsed.expiryDate
+            ?? questionParsed?.expiryDate
+            ?? undefined;
+        // Build a descriptive title from the parsed description
+        const title = buildTitle(outcome.name, parsed, questionParsed);
+        // Derive underlying from outcome or question
+        const underlying = parsed.underlying ?? questionParsed?.underlying;
+        const tags = [];
+        if (underlying) {
+            tags.push(underlying);
+        }
+        tags.push('Outcome Markets');
+        const category = underlying ? 'Crypto' : undefined;
+        const um = {
+            marketId: (0, utils_1.toMarketId)(outcomeId),
+            eventId: raw.question ? String(raw.question.question) : undefined,
+            title,
+            description: outcome.description,
+            slug: `hl-${outcomeId}`,
+            outcomes,
+            resolutionDate: expiryDate ?? new Date(0),
+            volume24h: 0,
+            liquidity: 0,
+            url: buildMarketUrl(outcomeId),
+            category,
+            tags,
+            tickSize: 0.001,
+            status: 'active',
+        };
+        (0, market_utils_1.addBinaryOutcomes)(um);
+        return um;
+    }
+    normalizeEvent(raw) {
+        if (!raw)
+            return null;
+        const parsed = parseDescription(raw.description);
+        const underlying = parsed.underlying;
+        // Build a more descriptive event title
+        let title = raw.name;
+        if (parsed.class === 'priceBucket' && underlying && parsed.priceThresholds) {
+            const thresholds = parsed.priceThresholds.map(t => `$${Number(t).toLocaleString('en-US')}`).join(', ');
+            const dateStr = parsed.expiryDate
+                ? parsed.expiryDate.toISOString().replace('T', ' ').replace(':00.000Z', ' UTC')
+                : '';
+            title = `${underlying} Price Bucket [${thresholds}]${dateStr ? ` @ ${dateStr}` : ''}`;
+        }
+        const tags = ['Outcome Markets'];
+        if (underlying)
+            tags.push(underlying);
+        return {
+            id: String(raw.question),
+            title,
+            description: raw.description,
+            slug: `hl-question-${raw.question}`,
+            markets: [],
+            volume24h: 0,
+            url: buildEventUrl(raw.question),
+            category: underlying ? 'Crypto' : undefined,
+            tags,
+        };
+    }
+    normalizeEventWithMarkets(raw, outcomeMeta, mids) {
+        const event = this.normalizeEvent(raw);
+        if (!event)
+            return null;
+        const markets = [];
+        for (const outcomeId of raw.namedOutcomes) {
+            if (raw.settledNamedOutcomes.includes(outcomeId))
+                continue;
+            const outcome = outcomeMeta.outcomes.find(o => o.outcome === outcomeId);
+            if (!outcome)
+                continue;
+            const yesCoin = (0, utils_1.toCoinNotation)(outcomeId, 'yes');
+            const midPrice = mids[yesCoin];
+            const market = this.normalizeMarket({
+                outcome,
+                question: raw,
+                midPrice,
+            });
+            if (market) {
+                markets.push(market);
+            }
+        }
+        return {
+            ...event,
+            markets,
+            volume24h: markets.reduce((sum, m) => sum + m.volume24h, 0),
+        };
+    }
+    normalizeOrderBook(raw, _id) {
+        const [rawBids, rawAsks] = raw.levels;
+        const bids = rawBids.map(level => ({
+            price: parseFloat(level.px),
+            size: parseFloat(level.sz),
+        }));
+        const asks = rawAsks.map(level => ({
+            price: parseFloat(level.px),
+            size: parseFloat(level.sz),
+        }));
+        return {
+            bids: [...bids].sort((a, b) => b.price - a.price),
+            asks: [...asks].sort((a, b) => a.price - b.price),
+            timestamp: raw.time,
+        };
+    }
+    normalizeOHLCV(raw, _params) {
+        return raw.map(candle => ({
+            timestamp: candle.t,
+            open: parseFloat(candle.o),
+            high: parseFloat(candle.h),
+            low: parseFloat(candle.l),
+            close: parseFloat(candle.c),
+            volume: parseFloat(candle.v),
+        }));
+    }
+    normalizeTrade(raw, _index) {
+        return {
+            id: String(raw.tid),
+            timestamp: raw.time,
+            price: parseFloat(raw.px),
+            amount: parseFloat(raw.sz),
+            side: raw.side === 'B' ? 'buy' : raw.side === 'A' ? 'sell' : 'unknown',
+        };
+    }
+    normalizeUserTrade(raw, _index) {
+        return {
+            id: String(raw.tid),
+            timestamp: raw.time,
+            price: parseFloat(raw.px),
+            amount: parseFloat(raw.sz),
+            side: raw.side === 'B' ? 'buy' : raw.side === 'A' ? 'sell' : 'unknown',
+            orderId: String(raw.oid),
+        };
+    }
+    normalizeOpenOrder(raw) {
+        const origSz = parseFloat(raw.origSz);
+        const currentSz = parseFloat(raw.sz);
+        return {
+            id: String(raw.oid),
+            marketId: this.coinToMarketId(raw.coin),
+            outcomeId: this.coinToOutcomeId(raw.coin),
+            side: raw.side === 'B' ? 'buy' : 'sell',
+            type: 'limit',
+            price: parseFloat(raw.limitPx),
+            amount: origSz,
+            status: currentSz < origSz ? 'open' : 'pending',
+            filled: origSz - currentSz,
+            remaining: currentSz,
+            timestamp: raw.timestamp,
+        };
+    }
+    normalizePosition(raw) {
+        if (!isOutcomeCoin(raw.coin)) {
+            return {
+                marketId: raw.coin,
+                outcomeId: raw.coin,
+                outcomeLabel: raw.coin,
+                size: parseFloat(raw.szi),
+                entryPrice: raw.entryPx ? parseFloat(raw.entryPx) : 0,
+                currentPrice: 0,
+                unrealizedPnL: parseFloat(raw.unrealizedPnl),
+            };
+        }
+        return {
+            marketId: this.coinToMarketId(raw.coin),
+            outcomeId: this.coinToOutcomeId(raw.coin),
+            outcomeLabel: raw.coin,
+            size: parseFloat(raw.szi),
+            entryPrice: raw.entryPx ? parseFloat(raw.entryPx) : 0,
+            currentPrice: 0,
+            unrealizedPnL: parseFloat(raw.unrealizedPnl),
+        };
+    }
+    normalizeBalance(raw) {
+        const summary = raw.crossMarginSummary;
+        const total = parseFloat(summary.accountValue);
+        const locked = parseFloat(summary.totalMarginUsed);
+        return [{
+                currency: 'USDH',
+                total,
+                available: total - locked,
+                locked,
+            }];
+    }
+    // -- Private helpers -------------------------------------------------------
+    coinToMarketId(coin) {
+        if (!coin.startsWith('#'))
+            return coin;
+        const encoding = parseInt(coin.slice(1), 10);
+        const { outcomeId } = (0, utils_1.decodeAssetId)(config_1.OUTCOME_ASSET_BASE + encoding);
+        return (0, utils_1.toMarketId)(outcomeId);
+    }
+    coinToOutcomeId(coin) {
+        if (!coin.startsWith('#'))
+            return coin;
+        const encoding = parseInt(coin.slice(1), 10);
+        return String(config_1.OUTCOME_ASSET_BASE + encoding);
+    }
+}
+exports.HyperliquidNormalizer = HyperliquidNormalizer;

package/dist/exchanges/hyperliquid/utils.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Encode an outcome ID and side into a Hyperliquid asset ID.
+ *
+ * Formula: 100_000_000 + (10 * outcomeId) + side
+ * where side = 0 (Yes) or 1 (No).
+ */
+export declare function encodeAssetId(outcomeId: number, side: 'yes' | 'no'): number;
+/**
+ * Decode a Hyperliquid asset ID back into outcome ID and side.
+ */
+export declare function decodeAssetId(assetId: number): {
+    outcomeId: number;
+    side: 'yes' | 'no';
+};
+/**
+ * Convert an outcome ID and side to the Hyperliquid coin notation (#encoding).
+ *
+ * Example: outcome 1, Yes -> "#10"
+ */
+export declare function toCoinNotation(outcomeId: number, side: 'yes' | 'no'): string;
+/**
+ * Convert an asset encoding (the number after #) to outcome ID and side.
+ */
+export declare function fromCoinEncoding(encoding: number): {
+    outcomeId: number;
+    side: 'yes' | 'no';
+};
+/**
+ * Build a unique market ID string from an outcome.
+ * We use "hl-outcome-{outcomeId}" as the market ID.
+ */
+export declare function toMarketId(outcomeId: number): string;
+/**
+ * Extract the numeric outcome ID from our market ID format.
+ */
+export declare function fromMarketId(marketId: string): number;
+/**
+ * Build an outcome ID string for the unified type.
+ * Format: "{assetId}" which is the full numeric asset ID.
+ */
+export declare function toOutcomeId(outcomeId: number, side: 'yes' | 'no'): string;

package/dist/exchanges/hyperliquid/utils.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.encodeAssetId = encodeAssetId;
+exports.decodeAssetId = decodeAssetId;
+exports.toCoinNotation = toCoinNotation;
+exports.fromCoinEncoding = fromCoinEncoding;
+exports.toMarketId = toMarketId;
+exports.fromMarketId = fromMarketId;
+exports.toOutcomeId = toOutcomeId;
+const config_1 = require("./config");
+/**
+ * Encode an outcome ID and side into a Hyperliquid asset ID.
+ *
+ * Formula: 100_000_000 + (10 * outcomeId) + side
+ * where side = 0 (Yes) or 1 (No).
+ */
+function encodeAssetId(outcomeId, side) {
+    const sideValue = side === 'yes' ? config_1.SIDE_YES : config_1.SIDE_NO;
+    return config_1.OUTCOME_ASSET_BASE + (config_1.OUTCOME_MULTIPLIER * outcomeId) + sideValue;
+}
+/**
+ * Decode a Hyperliquid asset ID back into outcome ID and side.
+ */
+function decodeAssetId(assetId) {
+    const offset = assetId - config_1.OUTCOME_ASSET_BASE;
+    const sideValue = offset % config_1.OUTCOME_MULTIPLIER;
+    const outcomeId = (offset - sideValue) / config_1.OUTCOME_MULTIPLIER;
+    return {
+        outcomeId,
+        side: sideValue === config_1.SIDE_YES ? 'yes' : 'no',
+    };
+}
+/**
+ * Convert an outcome ID and side to the Hyperliquid coin notation (#encoding).
+ *
+ * Example: outcome 1, Yes -> "#10"
+ */
+function toCoinNotation(outcomeId, side) {
+    const encoding = config_1.OUTCOME_MULTIPLIER * outcomeId + (side === 'yes' ? config_1.SIDE_YES : config_1.SIDE_NO);
+    return `#${encoding}`;
+}
+/**
+ * Convert an asset encoding (the number after #) to outcome ID and side.
+ */
+function fromCoinEncoding(encoding) {
+    const sideValue = encoding % config_1.OUTCOME_MULTIPLIER;
+    const outcomeId = (encoding - sideValue) / config_1.OUTCOME_MULTIPLIER;
+    return {
+        outcomeId,
+        side: sideValue === config_1.SIDE_YES ? 'yes' : 'no',
+    };
+}
+/**
+ * Build a unique market ID string from an outcome.
+ * We use "hl-outcome-{outcomeId}" as the market ID.
+ */
+function toMarketId(outcomeId) {
+    return `hl-outcome-${outcomeId}`;
+}
+/**
+ * Extract the numeric outcome ID from our market ID format.
+ */
+function fromMarketId(marketId) {
+    const match = marketId.match(/^hl-outcome-(\d+)$/);
+    if (!match) {
+        throw new Error(`Invalid Hyperliquid market ID: ${marketId}`);
+    }
+    return parseInt(match[1], 10);
+}
+/**
+ * Build an outcome ID string for the unified type.
+ * Format: "{assetId}" which is the full numeric asset ID.
+ */
+function toOutcomeId(outcomeId, side) {
+    return String(encodeAssetId(outcomeId, side));
+}

package/dist/exchanges/kalshi/api.d.ts

@@ -1,6 +1,6 @@
 /**
  * Auto-generated from /home/runner/work/pmxt/pmxt/core/specs/kalshi/Kalshi.yaml
- * Generated at: 2026-05-08T17:24:31.092Z
+ * Generated at: 2026-05-08T20:27:07.004Z
  * Do not edit manually -- run "npm run fetch:openapi" to regenerate.
  */
 export declare const kalshiApiSpec: {

package/dist/exchanges/kalshi/api.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.kalshiApiSpec = void 0;
 /**
  * Auto-generated from /home/runner/work/pmxt/pmxt/core/specs/kalshi/Kalshi.yaml
- * Generated at: 2026-05-08T17:24:31.092Z
+ * Generated at: 2026-05-08T20:27:07.004Z
  * Do not edit manually -- run "npm run fetch:openapi" to regenerate.
  */
 exports.kalshiApiSpec = {

package/dist/exchanges/kalshi/index.d.ts

@@ -23,9 +23,9 @@ export declare class KalshiExchange extends PredictionMarketExchange {
     private ensureAuth;
     protected fetchMarketsImpl(params?: MarketFilterParams): Promise<UnifiedMarket[]>;
     protected fetchEventsImpl(params: EventFetchParams): Promise<UnifiedEvent[]>;
-    fetchOHLCV(id: string, params: OHLCVParams): Promise<PriceCandle[]>;
-    fetchOrderBook(id: string): Promise<OrderBook>;
-    fetchTrades(id: string, params: TradesParams | HistoryFilterParams): Promise<Trade[]>;
+    fetchOHLCV(outcomeId: string, params: OHLCVParams): Promise<PriceCandle[]>;
+    fetchOrderBook(outcomeId: string): Promise<OrderBook>;
+    fetchTrades(outcomeId: string, params: TradesParams | HistoryFilterParams): Promise<Trade[]>;
     fetchBalance(): Promise<Balance[]>;
     fetchMyTrades(params?: MyTradesParams): Promise<UserTrade[]>;
     fetchPositions(): Promise<Position[]>;
@@ -38,8 +38,8 @@ export declare class KalshiExchange extends PredictionMarketExchange {
     fetchOrder(orderId: string): Promise<Order>;
     fetchOpenOrders(marketId?: string): Promise<Order[]>;
     private ws?;
-    watchOrderBook(id: string, limit?: number): Promise<OrderBook>;
-    watchOrderBooks(ids: string[], limit?: number): Promise<Record<string, OrderBook>>;
-    watchTrades(id: string, address?: string, since?: number, limit?: number): Promise<Trade[]>;
+    watchOrderBook(outcomeId: string, limit?: number): Promise<OrderBook>;
+    watchOrderBooks(outcomeIds: string[], limit?: number): Promise<Record<string, OrderBook>>;
+    watchTrades(outcomeId: string, address?: string, since?: number, limit?: number): Promise<Trade[]>;
     close(): Promise<void>;
 }

package/dist/exchanges/kalshi/index.js

@@ -117,21 +117,21 @@ class KalshiExchange extends BaseExchange_1.PredictionMarketExchange {
             .filter((e) => e !== null)
             .slice(0, limit);
     }
-    async fetchOHLCV(id, params) {
-        const rawCandles = await this.fetcher.fetchRawOHLCV(id, params);
+    async fetchOHLCV(outcomeId, params) {
+        const rawCandles = await this.fetcher.fetchRawOHLCV(outcomeId, params);
         return this.normalizer.normalizeOHLCV(rawCandles, params);
     }
-    async fetchOrderBook(id) {
-        (0, validation_1.validateIdFormat)(id, "OrderBook");
-        const raw = await this.fetcher.fetchRawOrderBook(id);
-        return this.normalizer.normalizeOrderBook(raw, id);
+    async fetchOrderBook(outcomeId) {
+        (0, validation_1.validateIdFormat)(outcomeId, "OrderBook");
+        const raw = await this.fetcher.fetchRawOrderBook(outcomeId);
+        return this.normalizer.normalizeOrderBook(raw, outcomeId);
     }
-    async fetchTrades(id, params) {
+    async fetchTrades(outcomeId, params) {
         if ("resolution" in params && params.resolution !== undefined) {
             console.warn('[pmxt] Warning: The "resolution" parameter is deprecated for fetchTrades() and will be ignored. ' +
                 "It will be removed in v3.0.0. Please remove it from your code.");
         }
-        const rawTrades = await this.fetcher.fetchRawTrades(id, params);
+        const rawTrades = await this.fetcher.fetchRawTrades(outcomeId, params);
         return rawTrades.map((raw, i) => this.normalizer.normalizeTrade(raw, i));
     }
     // ----------------------------------------------------------------------------
@@ -251,7 +251,7 @@ class KalshiExchange extends BaseExchange_1.PredictionMarketExchange {
     // WebSocket
     // ----------------------------------------------------------------------------
     ws;
-    async watchOrderBook(id, limit) {
+    async watchOrderBook(outcomeId, limit) {
         const auth = this.ensureAuth();
         if (!this.ws) {
             const wsConfigWithUrl = {
@@ -260,10 +260,10 @@ class KalshiExchange extends BaseExchange_1.PredictionMarketExchange {
             };
             this.ws = new websocket_1.KalshiWebSocket(auth, wsConfigWithUrl);
         }
-        const marketTicker = id.replace(/-NO$/, "");
+        const marketTicker = outcomeId.replace(/-NO$/, "");
         return this.ws.watchOrderBook(marketTicker);
     }
-    async watchOrderBooks(ids, limit) {
+    async watchOrderBooks(outcomeIds, limit) {
         const auth = this.ensureAuth();
         if (!this.ws) {
             const wsConfigWithUrl = {
@@ -272,10 +272,10 @@ class KalshiExchange extends BaseExchange_1.PredictionMarketExchange {
             };
             this.ws = new websocket_1.KalshiWebSocket(auth, wsConfigWithUrl);
         }
-        const marketTickers = ids.map((id) => id.replace(/-NO$/, ""));
+        const marketTickers = outcomeIds.map((oid) => oid.replace(/-NO$/, ""));
         return this.ws.watchOrderBooks(marketTickers);
     }
-    async watchTrades(id, address, since, limit) {
+    async watchTrades(outcomeId, address, since, limit) {
         const auth = this.ensureAuth();
         if (!this.ws) {
             const wsConfigWithUrl = {
@@ -284,7 +284,7 @@ class KalshiExchange extends BaseExchange_1.PredictionMarketExchange {
             };
             this.ws = new websocket_1.KalshiWebSocket(auth, wsConfigWithUrl);
         }
-        const marketTicker = id.replace(/-NO$/, "");
+        const marketTicker = outcomeId.replace(/-NO$/, "");
         return this.ws.watchTrades(marketTicker);
     }
     async close() {

package/dist/exchanges/limitless/api.d.ts

@@ -1,6 +1,6 @@
 /**
  * Auto-generated from /home/runner/work/pmxt/pmxt/core/specs/limitless/Limitless.yaml
- * Generated at: 2026-05-08T17:24:31.127Z
+ * Generated at: 2026-05-08T20:27:07.072Z
  * Do not edit manually -- run "npm run fetch:openapi" to regenerate.
  */
 export declare const limitlessApiSpec: {

package/dist/exchanges/limitless/api.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.limitlessApiSpec = void 0;
 /**
  * Auto-generated from /home/runner/work/pmxt/pmxt/core/specs/limitless/Limitless.yaml
- * Generated at: 2026-05-08T17:24:31.127Z
+ * Generated at: 2026-05-08T20:27:07.072Z
  * Do not edit manually -- run "npm run fetch:openapi" to regenerate.
  */
 exports.limitlessApiSpec = {

package/dist/exchanges/limitless/index.d.ts

@@ -27,10 +27,10 @@ export declare class LimitlessExchange extends PredictionMarketExchange {
     private getHeaders;
     protected fetchMarketsImpl(params?: MarketFetchParams): Promise<UnifiedMarket[]>;
     protected fetchEventsImpl(params: EventFetchParams): Promise<UnifiedEvent[]>;
-    fetchOHLCV(id: string, params: OHLCVParams): Promise<PriceCandle[]>;
-    fetchOrderBook(id: string, side?: 'yes' | 'no'): Promise<OrderBook>;
+    fetchOHLCV(outcomeId: string, params: OHLCVParams): Promise<PriceCandle[]>;
+    fetchOrderBook(outcomeId: string, side?: 'yes' | 'no'): Promise<OrderBook>;
     private isNoOutcome;
-    fetchTrades(id: string, params: TradesParams | HistoryFilterParams): Promise<Trade[]>;
+    fetchTrades(outcomeId: string, params: TradesParams | HistoryFilterParams): Promise<Trade[]>;
     fetchMyTrades(params?: MyTradesParams): Promise<UserTrade[]>;
     createOrder(params: CreateOrderParams): Promise<Order>;
     cancelOrder(orderId: string): Promise<Order>;
@@ -40,8 +40,8 @@ export declare class LimitlessExchange extends PredictionMarketExchange {
     fetchAllOrders(params?: OrderHistoryParams): Promise<Order[]>;
     fetchPositions(address?: string): Promise<Position[]>;
     fetchBalance(address?: string): Promise<Balance[]>;
-    watchOrderBook(id: string, limit?: number): Promise<OrderBook>;
-    watchTrades(id: string, address?: string, since?: number, limit?: number): Promise<Trade[]>;
+    watchOrderBook(outcomeId: string, limit?: number): Promise<OrderBook>;
+    watchTrades(outcomeId: string, address?: string, since?: number, limit?: number): Promise<Trade[]>;
     /**
      * Watch AMM price updates for a market address (Limitless only).
      * Requires WebSocket connection.