pmxt-core 2.38.0 → 2.39.0

package/dist/BaseExchange.d.ts

@@ -449,7 +449,7 @@ export declare abstract class PredictionMarketExchange {
     /**
      * Fetch historical OHLCV (candlestick) price data for a specific market outcome.
      *
-     * @param id - The Outcome ID (outcomeId). Use outcome.outcomeId, NOT market.marketId
+     * @param outcomeId - The Outcome ID (outcomeId). Use outcome.outcomeId, NOT market.marketId
      * @param params - OHLCV parameters including resolution (required)
      * @returns Array of price candles
      *
@@ -457,29 +457,29 @@ export declare abstract class PredictionMarketExchange {
      * @notes Polymarket: outcomeId is the CLOB Token ID. Kalshi: outcomeId is the Market Ticker.
      * @notes Common resolutions: '1m' | '5m' | '15m' | '1h' | '6h' | '1d'. Arbitrary intervals (e.g. '30s', '120s', '3h') accepted by venues that support them.
      */
-    fetchOHLCV(id: string, params: OHLCVParams): Promise<PriceCandle[]>;
+    fetchOHLCV(outcomeId: string, params: OHLCVParams): Promise<PriceCandle[]>;
     /**
      * Fetch the current order book (bids/asks) for a specific outcome.
      * Essential for calculating spread, depth, and execution prices.
      *
-     * @param id - The Outcome ID (outcomeId) or market slug
+     * @param outcomeId - The Outcome ID (outcomeId) or market slug
      * @param side - Optional 'yes' or 'no' to explicitly indicate the
      *   outcome side. Required for exchanges where the API returns a
      *   single orderbook per market (e.g. Limitless) and the caller
      *   passes a slug instead of a token ID.
      * @returns Current order book with bids and asks
      */
-    fetchOrderBook(id: string, side?: 'yes' | 'no'): Promise<OrderBook>;
+    fetchOrderBook(outcomeId: string, side?: 'yes' | 'no'): Promise<OrderBook>;
     /**
      * Fetch raw trade history for a specific outcome.
      *
-     * @param id - The Outcome ID (outcomeId)
+     * @param outcomeId - The Outcome ID (outcomeId)
      * @param params - Trade filter parameters
      * @returns Array of recent trades
      *
      * @notes Polymarket requires an API key for trade history. Use fetchOHLCV for public historical data.
      */
-    fetchTrades(id: string, params: TradesParams | HistoryFilterParams): Promise<Trade[]>;
+    fetchTrades(outcomeId: string, params: TradesParams | HistoryFilterParams): Promise<Trade[]>;
     /**
      * Place a new order on the exchange.
      *
@@ -582,39 +582,39 @@ export declare abstract class PredictionMarketExchange {
      * Watch order book updates in real-time via WebSocket.
      * Returns a promise that resolves with the next order book update. Call repeatedly in a loop to stream updates (CCXT Pro pattern).
      *
-     * @param id - The Outcome ID to watch
+     * @param outcomeId - The Outcome ID to watch
      * @param limit - Optional limit for orderbook depth
      * @returns Promise that resolves with the current orderbook state
      */
-    watchOrderBook(id: string, limit?: number): Promise<OrderBook>;
+    watchOrderBook(outcomeId: string, limit?: number): Promise<OrderBook>;
     /**
      * Watch multiple order books simultaneously via WebSocket.
      * Returns a promise that resolves with a record of order book snapshots keyed by ID.
      * Exchanges with native batch support (e.g. Kalshi) send a single subscribe message
      * for all tickers; others fall back to individual watchOrderBook calls.
      *
-     * @param ids - Array of Outcome IDs to watch
+     * @param outcomeIds - Array of Outcome IDs to watch
      * @param limit - Optional limit for orderbook depth
      * @returns Promise that resolves with order books keyed by ID
      */
-    watchOrderBooks(ids: string[], limit?: number): Promise<Record<string, OrderBook>>;
+    watchOrderBooks(outcomeIds: string[], limit?: number): Promise<Record<string, OrderBook>>;
     /**
      * Unsubscribe from a previously watched order book stream.
      *
-     * @param id - The Outcome ID to stop watching
+     * @param outcomeId - The Outcome ID to stop watching
      */
-    unwatchOrderBook(id: string): Promise<void>;
+    unwatchOrderBook(outcomeId: string): Promise<void>;
     /**
      * Watch trade executions in real-time via WebSocket.
      * Returns a promise that resolves with the next trade(s). Call repeatedly in a loop to stream updates (CCXT Pro pattern).
      *
-     * @param id - The Outcome ID to watch
+     * @param outcomeId - The Outcome ID to watch
      * @param address - Public wallet address
      * @param since - Optional timestamp to filter trades from
      * @param limit - Optional limit for number of trades
      * @returns Promise that resolves with recent trades
      */
-    watchTrades(id: string, address?: string, since?: number, limit?: number): Promise<Trade[]>;
+    watchTrades(outcomeId: string, address?: string, since?: number, limit?: number): Promise<Trade[]>;
     /**
      * Stream activity for a public wallet address
      * Returns a promise that resolves with the next activity snapshot whenever a change

package/dist/BaseExchange.js

@@ -391,7 +391,7 @@ class PredictionMarketExchange {
     /**
      * Fetch historical OHLCV (candlestick) price data for a specific market outcome.
      *
-     * @param id - The Outcome ID (outcomeId). Use outcome.outcomeId, NOT market.marketId
+     * @param outcomeId - The Outcome ID (outcomeId). Use outcome.outcomeId, NOT market.marketId
      * @param params - OHLCV parameters including resolution (required)
      * @returns Array of price candles
      *
@@ -399,33 +399,33 @@ class PredictionMarketExchange {
      * @notes Polymarket: outcomeId is the CLOB Token ID. Kalshi: outcomeId is the Market Ticker.
      * @notes Common resolutions: '1m' | '5m' | '15m' | '1h' | '6h' | '1d'. Arbitrary intervals (e.g. '30s', '120s', '3h') accepted by venues that support them.
      */
-    async fetchOHLCV(id, params) {
+    async fetchOHLCV(outcomeId, params) {
         throw new Error("Method fetchOHLCV not implemented.");
     }
     /**
      * Fetch the current order book (bids/asks) for a specific outcome.
      * Essential for calculating spread, depth, and execution prices.
      *
-     * @param id - The Outcome ID (outcomeId) or market slug
+     * @param outcomeId - The Outcome ID (outcomeId) or market slug
      * @param side - Optional 'yes' or 'no' to explicitly indicate the
      *   outcome side. Required for exchanges where the API returns a
      *   single orderbook per market (e.g. Limitless) and the caller
      *   passes a slug instead of a token ID.
      * @returns Current order book with bids and asks
      */
-    async fetchOrderBook(id, side) {
+    async fetchOrderBook(outcomeId, side) {
         throw new Error("Method fetchOrderBook not implemented.");
     }
     /**
      * Fetch raw trade history for a specific outcome.
      *
-     * @param id - The Outcome ID (outcomeId)
+     * @param outcomeId - The Outcome ID (outcomeId)
      * @param params - Trade filter parameters
      * @returns Array of recent trades
      *
      * @notes Polymarket requires an API key for trade history. Use fetchOHLCV for public historical data.
      */
-    async fetchTrades(id, params) {
+    async fetchTrades(outcomeId, params) {
         // Deprecation warning for resolution parameter
         if ('resolution' in params && params.resolution !== undefined) {
             console.warn('[pmxt] Warning: The "resolution" parameter is deprecated for fetchTrades() and will be ignored. ' +
@@ -761,11 +761,11 @@ class PredictionMarketExchange {
      * Watch order book updates in real-time via WebSocket.
      * Returns a promise that resolves with the next order book update. Call repeatedly in a loop to stream updates (CCXT Pro pattern).
      *
-     * @param id - The Outcome ID to watch
+     * @param outcomeId - The Outcome ID to watch
      * @param limit - Optional limit for orderbook depth
      * @returns Promise that resolves with the current orderbook state
      */
-    async watchOrderBook(id, limit) {
+    async watchOrderBook(outcomeId, limit) {
         throw new Error(`watchOrderBook() is not supported by ${this.name}`);
     }
     /**
@@ -774,30 +774,30 @@ class PredictionMarketExchange {
      * Exchanges with native batch support (e.g. Kalshi) send a single subscribe message
      * for all tickers; others fall back to individual watchOrderBook calls.
      *
-     * @param ids - Array of Outcome IDs to watch
+     * @param outcomeIds - Array of Outcome IDs to watch
      * @param limit - Optional limit for orderbook depth
      * @returns Promise that resolves with order books keyed by ID
      */
-    async watchOrderBooks(ids, limit) {
+    async watchOrderBooks(outcomeIds, limit) {
         // Default implementation: subscribe to each ID individually.
         // Exchanges with native batch support (e.g. Kalshi) override this
         // to send a single subscribe message for all tickers.
-        const entries = await Promise.all(ids.map(async (id) => {
-            const book = await this.watchOrderBook(id, limit);
-            return [id, book];
+        const entries = await Promise.all(outcomeIds.map(async (oid) => {
+            const book = await this.watchOrderBook(oid, limit);
+            return [oid, book];
         }));
         const result = {};
-        for (const [id, book] of entries) {
-            result[id] = book;
+        for (const [oid, book] of entries) {
+            result[oid] = book;
         }
         return result;
     }
     /**
      * Unsubscribe from a previously watched order book stream.
      *
-     * @param id - The Outcome ID to stop watching
+     * @param outcomeId - The Outcome ID to stop watching
      */
-    async unwatchOrderBook(id) {
+    async unwatchOrderBook(outcomeId) {
         throw new Error(`unwatchOrderBook() is not supported by ${this.name}`);
     }
     // ----------------------------------------------------------------------------
@@ -807,13 +807,13 @@ class PredictionMarketExchange {
      * Watch trade executions in real-time via WebSocket.
      * Returns a promise that resolves with the next trade(s). Call repeatedly in a loop to stream updates (CCXT Pro pattern).
      *
-     * @param id - The Outcome ID to watch
+     * @param outcomeId - The Outcome ID to watch
      * @param address - Public wallet address
      * @param since - Optional timestamp to filter trades from
      * @param limit - Optional limit for number of trades
      * @returns Promise that resolves with recent trades
      */
-    async watchTrades(id, address, since, limit) {
+    async watchTrades(outcomeId, address, since, limit) {
         throw new Error(`watchTrades() is not supported by ${this.name}`);
     }
     /**

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

@@ -23,7 +23,7 @@ export declare class BaoziExchange extends PredictionMarketExchange {
     protected fetchMarketsImpl(params?: MarketFetchParams): Promise<UnifiedMarket[]>;
     protected fetchEventsImpl(params: EventFetchParams): Promise<UnifiedEvent[]>;
     fetchOHLCV(): Promise<PriceCandle[]>;
-    fetchOrderBook(id: string): Promise<OrderBook>;
+    fetchOrderBook(outcomeId: string): Promise<OrderBook>;
     fetchTrades(): Promise<Trade[]>;
     fetchBalance(): Promise<Balance[]>;
     fetchPositions(): Promise<Position[]>;
@@ -31,7 +31,7 @@ export declare class BaoziExchange extends PredictionMarketExchange {
     cancelOrder(): Promise<Order>;
     fetchOrder(orderId: string): Promise<Order>;
     fetchOpenOrders(): Promise<Order[]>;
-    watchOrderBook(id: string): Promise<OrderBook>;
+    watchOrderBook(outcomeId: string): Promise<OrderBook>;
     watchTrades(): Promise<Trade[]>;
     close(): Promise<void>;
     private ensureAuth;

package/dist/exchanges/baozi/index.js

@@ -71,9 +71,9 @@ class BaoziExchange extends BaseExchange_1.PredictionMarketExchange {
         // Baozi has no historical price/trade API without a custom indexer
         return [];
     }
-    async fetchOrderBook(id) {
-        const rawMarket = await this.fetcher.fetchRawOrderBook(id);
-        return this.normalizer.normalizeOrderBook(rawMarket, id);
+    async fetchOrderBook(outcomeId) {
+        const rawMarket = await this.fetcher.fetchRawOrderBook(outcomeId);
+        return this.normalizer.normalizeOrderBook(rawMarket, outcomeId);
     }
     async fetchTrades() {
         // Baozi has no trade history API without a custom indexer
@@ -313,11 +313,11 @@ class BaoziExchange extends BaseExchange_1.PredictionMarketExchange {
     // -----------------------------------------------------------------------
     // WebSocket
     // -----------------------------------------------------------------------
-    async watchOrderBook(id) {
+    async watchOrderBook(outcomeId) {
         if (!this.ws) {
             this.ws = new websocket_1.BaoziWebSocket();
         }
-        return this.ws.watchOrderBook(this.connection, id);
+        return this.ws.watchOrderBook(this.connection, outcomeId);
     }
     async watchTrades() {
         throw new errors_1.ExchangeNotAvailable('Trade streaming is not available for Baozi', 'Baozi');

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-08T19:42:37.498Z
+ * 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-08T19:42:37.498Z
+ * 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-08T19:42:37.536Z
+ * 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-08T19:42:37.536Z
+ * 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.

package/dist/exchanges/limitless/index.js

@@ -149,19 +149,19 @@ class LimitlessExchange extends BaseExchange_1.PredictionMarketExchange {
             .map((raw) => this.normalizer.normalizeEvent(raw))
             .filter((e) => e !== null);
     }
-    async fetchOHLCV(id, params) {
-        const slug = await this.resolveSlug(id);
+    async fetchOHLCV(outcomeId, params) {
+        const slug = await this.resolveSlug(outcomeId);
         const rawPrices = await this.fetcher.fetchRawOHLCV(slug, params);
         return this.normalizer.normalizeOHLCV(rawPrices, params);
     }
-    async fetchOrderBook(id, side) {
-        const slug = await this.resolveSlug(id);
+    async fetchOrderBook(outcomeId, side) {
+        const slug = await this.resolveSlug(outcomeId);
         const rawOrderBook = await this.fetcher.fetchRawOrderBook(slug);
-        const orderBook = this.normalizer.normalizeOrderBook(rawOrderBook, id);
+        const orderBook = this.normalizer.normalizeOrderBook(rawOrderBook, outcomeId);
         // The Limitless API always returns the Yes-side order book regardless
         // of which token is queried. If the caller asked for the No token,
         // flip: noBid = 1 - yesAsk, noAsk = 1 - yesBid.
-        const isNoToken = side === 'no' || (!side && await this.isNoOutcome(id, slug));
+        const isNoToken = side === 'no' || (!side && await this.isNoOutcome(outcomeId, slug));
         if (isNoToken) {
             return {
                 bids: orderBook.asks.map((level) => ({ price: 1 - level.price, size: level.size }))
@@ -187,12 +187,13 @@ class LimitlessExchange extends BaseExchange_1.PredictionMarketExchange {
         }
         return false;
     }
-    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 slug = await this.resolveSlug(outcomeId);
+        const rawTrades = await this.fetcher.fetchRawTrades(slug, params);
         return rawTrades.map((raw, i) => this.normalizer.normalizeTrade(raw, i));
     }
     async fetchMyTrades(params) {
@@ -358,13 +359,15 @@ class LimitlessExchange extends BaseExchange_1.PredictionMarketExchange {
     // ------------------------------------------------------------------------
     // WebSocket
     // ------------------------------------------------------------------------
-    async watchOrderBook(id, limit) {
+    async watchOrderBook(outcomeId, limit) {
+        const slug = await this.resolveSlug(outcomeId);
         const ws = this.ensureWs();
-        return ws.watchOrderBook(id);
+        return ws.watchOrderBook(slug);
     }
-    async watchTrades(id, address, since, limit) {
+    async watchTrades(outcomeId, address, since, limit) {
+        const slug = await this.resolveSlug(outcomeId);
         const ws = this.ensureWs();
-        return ws.watchTrades(id, address);
+        return ws.watchTrades(slug, address);
     }
     /**
      * Watch AMM price updates for a market address (Limitless only).

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

@@ -1,6 +1,6 @@
 /**
  * Auto-generated from /home/runner/work/pmxt/pmxt/core/specs/myriad/myriad.yaml
- * Generated at: 2026-05-08T19:42:37.550Z
+ * Generated at: 2026-05-08T20:27:07.090Z
  * Do not edit manually -- run "npm run fetch:openapi" to regenerate.
  */
 export declare const myriadApiSpec: {

package/dist/exchanges/myriad/api.js

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

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

@@ -23,9 +23,9 @@ export declare class MyriadExchange 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[]>;
     fetchMyTrades(params?: MyTradesParams): Promise<UserTrade[]>;
     createOrder(params: CreateOrderParams): Promise<Order>;
     cancelOrder(_orderId: string): Promise<Order>;
@@ -33,7 +33,7 @@ export declare class MyriadExchange extends PredictionMarketExchange {
     fetchOpenOrders(_marketId?: string): Promise<Order[]>;
     fetchPositions(): Promise<Position[]>;
     fetchBalance(): 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[]>;
     close(): Promise<void>;
 }

package/dist/exchanges/myriad/index.js

@@ -79,25 +79,25 @@ class MyriadExchange extends BaseExchange_1.PredictionMarketExchange {
             .map((raw) => this.normalizer.normalizeEvent(raw))
             .filter((e) => e !== null);
     }
-    async fetchOHLCV(id, params) {
+    async fetchOHLCV(outcomeId, params) {
         if (!params.resolution) {
             throw new Error('fetchOHLCV requires a resolution parameter.');
         }
-        const parts = id.split(':');
-        const outcomeId = parts.length >= 3 ? parts[2] : undefined;
-        const rawMarket = await this.fetcher.fetchRawOHLCV(id, params);
-        return this.normalizer.normalizeOHLCV(rawMarket, params, outcomeId);
+        const parts = outcomeId.split(':');
+        const parsedOutcomeId = parts.length >= 3 ? parts[2] : undefined;
+        const rawMarket = await this.fetcher.fetchRawOHLCV(outcomeId, params);
+        return this.normalizer.normalizeOHLCV(rawMarket, params, parsedOutcomeId);
     }
-    async fetchOrderBook(id) {
-        const rawMarket = await this.fetcher.fetchRawOrderBook(id);
-        return this.normalizer.normalizeOrderBook(rawMarket, id);
+    async fetchOrderBook(outcomeId) {
+        const rawMarket = await this.fetcher.fetchRawOrderBook(outcomeId);
+        return this.normalizer.normalizeOrderBook(rawMarket, 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));
     }
     async fetchMyTrades(params) {
@@ -178,19 +178,19 @@ class MyriadExchange extends BaseExchange_1.PredictionMarketExchange {
     // ------------------------------------------------------------------------
     // WebSocket (poll-based)
     // ------------------------------------------------------------------------
-    async watchOrderBook(id, _limit) {
+    async watchOrderBook(outcomeId, _limit) {
         this.ensureAuth();
         if (!this.ws) {
             this.ws = new websocket_1.MyriadWebSocket(this.callApi.bind(this), (id) => this.fetchOrderBook(id));
         }
-        return this.ws.watchOrderBook(id);
+        return this.ws.watchOrderBook(outcomeId);
     }
-    async watchTrades(id, address, _since, _limit) {
+    async watchTrades(outcomeId, address, _since, _limit) {
         this.ensureAuth();
         if (!this.ws) {
             this.ws = new websocket_1.MyriadWebSocket(this.callApi.bind(this), (id) => this.fetchOrderBook(id));
         }
-        return this.ws.watchTrades(id);
+        return this.ws.watchTrades(outcomeId);
     }
     async close() {
         if (this.ws) {

package/dist/exchanges/myriad/websocket.d.ts

@@ -11,8 +11,8 @@ export declare class MyriadWebSocket {
     private lastTradeTimestamp;
     private closed;
     constructor(callApi: (operationId: string, params?: Record<string, any>) => Promise<any>, fetchOrderBook: FetchOrderBookFn, pollInterval?: number);
-    watchOrderBook(id: string): Promise<OrderBook>;
-    watchTrades(id: string): Promise<Trade[]>;
+    watchOrderBook(outcomeId: string): Promise<OrderBook>;
+    watchTrades(outcomeId: string): Promise<Trade[]>;
     close(): Promise<void>;
     private startOrderBookPolling;
     private startTradePolling;

package/dist/exchanges/myriad/websocket.js

@@ -20,29 +20,29 @@ class MyriadWebSocket {
         this.fetchOrderBook = fetchOrderBook;
         this.pollInterval = pollInterval || DEFAULT_POLL_INTERVAL;
     }
-    async watchOrderBook(id) {
+    async watchOrderBook(outcomeId) {
         if (this.closed)
             throw new Error('WebSocket connection is closed');
         return new Promise((resolve) => {
-            if (!this.orderBookResolvers.has(id)) {
-                this.orderBookResolvers.set(id, []);
+            if (!this.orderBookResolvers.has(outcomeId)) {
+                this.orderBookResolvers.set(outcomeId, []);
             }
-            this.orderBookResolvers.get(id).push(resolve);
-            if (!this.orderBookTimers.has(id)) {
-                this.startOrderBookPolling(id);
+            this.orderBookResolvers.get(outcomeId).push(resolve);
+            if (!this.orderBookTimers.has(outcomeId)) {
+                this.startOrderBookPolling(outcomeId);
             }
         });
     }
-    async watchTrades(id) {
+    async watchTrades(outcomeId) {
         if (this.closed)
             throw new Error('WebSocket connection is closed');
         return new Promise((resolve) => {
-            if (!this.tradeResolvers.has(id)) {
-                this.tradeResolvers.set(id, []);
+            if (!this.tradeResolvers.has(outcomeId)) {
+                this.tradeResolvers.set(outcomeId, []);
             }
-            this.tradeResolvers.get(id).push(resolve);
-            if (!this.tradeTimers.has(id)) {
-                this.startTradePolling(id);
+            this.tradeResolvers.get(outcomeId).push(resolve);
+            if (!this.tradeTimers.has(outcomeId)) {
+                this.startTradePolling(outcomeId);
             }
         });
     }