pmxt-core 2.37.14 → 2.39.0

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-08T17:24:31.139Z
+ * 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-08T17:24:31.139Z
+ * 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);
             }
         });
     }

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

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

package/dist/exchanges/opinion/api.js

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

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

@@ -21,8 +21,8 @@ export declare class OpinionExchange extends PredictionMarketExchange {
     protected mapImplicitApiError(error: any): any;
     protected fetchMarketsImpl(params?: MarketFilterParams): Promise<UnifiedMarket[]>;
     protected fetchEventsImpl(params: EventFetchParams): Promise<UnifiedEvent[]>;
-    fetchOHLCV(id: string, params: OHLCVParams): Promise<PriceCandle[]>;
-    fetchOrderBook(id: string): Promise<OrderBook>;
+    fetchOHLCV(outcomeId: string, params: OHLCVParams): Promise<PriceCandle[]>;
+    fetchOrderBook(outcomeId: string): Promise<OrderBook>;
     fetchMyTrades(params?: MyTradesParams): Promise<UserTrade[]>;
     fetchPositions(): Promise<Position[]>;
     fetchOrder(orderId: string): Promise<Order>;
@@ -33,8 +33,8 @@ export declare class OpinionExchange extends PredictionMarketExchange {
     submitOrder(built: BuiltOrder): Promise<Order>;
     createOrder(params: CreateOrderParams): Promise<Order>;
     cancelOrder(orderId: string): Promise<Order>;
-    watchOrderBook(id: string): Promise<OrderBook>;
-    watchTrades(id: string): Promise<Trade[]>;
+    watchOrderBook(outcomeId: string): Promise<OrderBook>;
+    watchTrades(outcomeId: string): Promise<Trade[]>;
     close(): Promise<void>;
     /**
      * Resolve an ID (which may be a token/outcome ID or a numeric market ID string)

package/dist/exchanges/opinion/index.js

@@ -165,13 +165,13 @@ class OpinionExchange extends BaseExchange_1.PredictionMarketExchange {
         await this.enrichPrices(allMarkets);
         return events;
     }
-    async fetchOHLCV(id, params) {
-        const rawPoints = await this.fetcher.fetchRawOHLCV(id, params);
+    async fetchOHLCV(outcomeId, params) {
+        const rawPoints = await this.fetcher.fetchRawOHLCV(outcomeId, params);
         return this.normalizer.normalizeOHLCV({ history: rawPoints }, params);
     }
-    async fetchOrderBook(id) {
-        const raw = await this.fetcher.fetchRawOrderBook(id);
-        return this.normalizer.normalizeOrderBook(raw, id);
+    async fetchOrderBook(outcomeId) {
+        const raw = await this.fetcher.fetchRawOrderBook(outcomeId);
+        return this.normalizer.normalizeOrderBook(raw, outcomeId);
     }
     // -------------------------------------------------------------------------
     // User Data (fetcher -> normalizer)
@@ -323,14 +323,14 @@ class OpinionExchange extends BaseExchange_1.PredictionMarketExchange {
     // -------------------------------------------------------------------------
     // WebSocket
     // -------------------------------------------------------------------------
-    async watchOrderBook(id) {
+    async watchOrderBook(outcomeId) {
         const ws = this.ensureWebSocket();
-        const marketId = this.resolveMarketId(id);
+        const marketId = this.resolveMarketId(outcomeId);
         return ws.watchOrderBook(marketId);
     }
-    async watchTrades(id) {
+    async watchTrades(outcomeId) {
         const ws = this.ensureWebSocket();
-        const marketId = this.resolveMarketId(id);
+        const marketId = this.resolveMarketId(outcomeId);
         return ws.watchTrades(marketId);
     }
     async close() {

package/dist/exchanges/polymarket/api-clob.d.ts

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

package/dist/exchanges/polymarket/api-clob.js

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

package/dist/exchanges/polymarket/api-data.d.ts

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

package/dist/exchanges/polymarket/api-data.js

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

package/dist/exchanges/polymarket/api-gamma.d.ts

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

package/dist/exchanges/polymarket/api-gamma.js

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

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

@@ -26,9 +26,9 @@ export declare class PolymarketExchange extends PredictionMarketExchange {
      * a privateKey was provided (not apiKey/apiSecret/passphrase).
      */
     initAuth(): Promise<void>;
-    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[]>;
     /**
      * Pre-warm the SDK's internal caches for a market outcome.
      *
@@ -49,9 +49,9 @@ export declare class PolymarketExchange extends PredictionMarketExchange {
     fetchMyTrades(params?: MyTradesParams): Promise<UserTrade[]>;
     fetchPositions(address?: string): Promise<Position[]>;
     fetchBalance(address?: string): Promise<Balance[]>;
-    watchOrderBook(id: string, limit?: number): Promise<OrderBook>;
-    unwatchOrderBook(id: string): Promise<void>;
-    watchTrades(id: string, address?: string, since?: number, limit?: number): Promise<Trade[]>;
+    watchOrderBook(outcomeId: string, limit?: number): Promise<OrderBook>;
+    unwatchOrderBook(outcomeId: string): Promise<void>;
+    watchTrades(outcomeId: string, address?: string, since?: number, limit?: number): Promise<Trade[]>;
     watchAddress(address: string, types?: SubscriptionOption[]): Promise<SubscribedAddressSnapshot>;
     unwatchAddress(address: string): Promise<void>;
     close(): Promise<void>;

package/dist/exchanges/polymarket/index.js

@@ -101,29 +101,29 @@ class PolymarketExchange extends BaseExchange_1.PredictionMarketExchange {
         };
         this.cachedAddress = auth.getFunderAddress();
     }
-    async fetchOHLCV(id, params) {
-        (0, validation_1.validateIdFormat)(id, 'OHLCV');
-        (0, validation_1.validateOutcomeId)(id, 'OHLCV');
+    async fetchOHLCV(outcomeId, params) {
+        (0, validation_1.validateIdFormat)(outcomeId, 'OHLCV');
+        (0, validation_1.validateOutcomeId)(outcomeId, 'OHLCV');
         if (!params.resolution) {
             throw new Error('fetchOHLCV requires a resolution parameter. Use OHLCVParams with resolution specified.');
         }
-        const raw = await this.fetcher.fetchRawOHLCV(id, params);
+        const raw = await this.fetcher.fetchRawOHLCV(outcomeId, params);
         return this.normalizer.normalizeOHLCV(raw, params);
     }
-    async fetchOrderBook(id) {
-        (0, validation_1.validateIdFormat)(id, 'OrderBook');
-        (0, validation_1.validateOutcomeId)(id, 'OrderBook');
-        const raw = await this.fetcher.fetchRawOrderBook(id);
-        return this.normalizer.normalizeOrderBook(raw, id);
+    async fetchOrderBook(outcomeId) {
+        (0, validation_1.validateIdFormat)(outcomeId, 'OrderBook');
+        (0, validation_1.validateOutcomeId)(outcomeId, 'OrderBook');
+        const raw = await this.fetcher.fetchRawOrderBook(outcomeId);
+        return this.normalizer.normalizeOrderBook(raw, outcomeId);
     }
-    async fetchTrades(id, params) {
-        (0, validation_1.validateIdFormat)(id, 'Trades');
-        (0, validation_1.validateOutcomeId)(id, 'Trades');
+    async fetchTrades(outcomeId, params) {
+        (0, validation_1.validateIdFormat)(outcomeId, 'Trades');
+        (0, validation_1.validateOutcomeId)(outcomeId, 'Trades');
         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);
         const mappedTrades = rawTrades.map((raw, i) => this.normalizer.normalizeTrade(raw, i));
         if (params.limit && mappedTrades.length > params.limit) {
             return mappedTrades.slice(0, params.limit);
@@ -411,14 +411,14 @@ class PolymarketExchange extends BaseExchange_1.PredictionMarketExchange {
     // ----------------------------------------------------------------------------
     // WebSocket Methods
     // ----------------------------------------------------------------------------
-    async watchOrderBook(id, limit) {
-        return this.ensureWs().watchOrderBook(id);
+    async watchOrderBook(outcomeId, limit) {
+        return this.ensureWs().watchOrderBook(outcomeId);
     }
-    async unwatchOrderBook(id) {
-        return this.ensureWs().unwatchOrderBook(id);
+    async unwatchOrderBook(outcomeId) {
+        return this.ensureWs().unwatchOrderBook(outcomeId);
     }
-    async watchTrades(id, address, since, limit) {
-        return this.ensureWs().watchTrades(id, address);
+    async watchTrades(outcomeId, address, since, limit) {
+        return this.ensureWs().watchTrades(outcomeId, address);
     }
     async watchAddress(address, types = ['trades', 'positions', 'balances']) {
         return this.ensureWs().watchAddress(address, types);

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

@@ -31,9 +31,9 @@ export declare class PolymarketWebSocket {
     private config;
     private initializationPromise?;
     constructor(callApi: (operationId: string, params?: Record<string, any>) => Promise<any>, config?: PolymarketWebSocketConfig);
-    watchOrderBook(id: string): Promise<OrderBook>;
-    unwatchOrderBook(id: string): Promise<void>;
-    watchTrades(id: string, address?: string): Promise<Trade[]>;
+    watchOrderBook(outcomeId: string): Promise<OrderBook>;
+    unwatchOrderBook(outcomeId: string): Promise<void>;
+    watchTrades(outcomeId: string, address?: string): Promise<Trade[]>;
     watchAddress(address: string, types: SubscriptionOption[]): Promise<SubscribedAddressSnapshot>;
     unwatchAddress(address: string): Promise<void>;
     close(): Promise<void>;

package/dist/exchanges/polymarket/websocket.js

@@ -68,55 +68,55 @@ class PolymarketWebSocket {
             buildActivity: goldsky_1.buildPolymarketActivity,
         });
     }
-    async watchOrderBook(id) {
+    async watchOrderBook(outcomeId) {
         await this.ensureInitialized();
         // Subscribe to the asset if not already subscribed
         const currentAssets = this.manager.getAssetIds();
-        if (!currentAssets.includes(id)) {
-            await this.manager.addSubscriptions([id]);
+        if (!currentAssets.includes(outcomeId)) {
+            await this.manager.addSubscriptions([outcomeId]);
         }
         // Return a promise that resolves on the next orderbook update
         const dataPromise = new Promise((resolve, reject) => {
-            if (!this.orderBookResolvers.has(id)) {
-                this.orderBookResolvers.set(id, []);
+            if (!this.orderBookResolvers.has(outcomeId)) {
+                this.orderBookResolvers.set(outcomeId, []);
             }
-            this.orderBookResolvers.get(id).push({ resolve, reject });
+            this.orderBookResolvers.get(outcomeId).push({ resolve, reject });
         });
-        return (0, watch_timeout_1.withWatchTimeout)(dataPromise, this.config.watchTimeoutMs ?? watch_timeout_1.DEFAULT_WATCH_TIMEOUT_MS, `watchOrderBook('${id}')`);
+        return (0, watch_timeout_1.withWatchTimeout)(dataPromise, this.config.watchTimeoutMs ?? watch_timeout_1.DEFAULT_WATCH_TIMEOUT_MS, `watchOrderBook('${outcomeId}')`);
     }
-    async unwatchOrderBook(id) {
+    async unwatchOrderBook(outcomeId) {
         if (!this.manager) {
             return;
         }
-        await this.manager.removeSubscriptions([id]);
+        await this.manager.removeSubscriptions([outcomeId]);
         // Clear any pending resolvers for this asset
-        const resolvers = this.orderBookResolvers.get(id);
+        const resolvers = this.orderBookResolvers.get(outcomeId);
         if (resolvers) {
-            this.orderBookResolvers = new Map([...this.orderBookResolvers].filter(([key]) => key !== id));
+            this.orderBookResolvers = new Map([...this.orderBookResolvers].filter(([key]) => key !== outcomeId));
         }
         // Remove the cached orderbook for this asset
-        if (this.orderBooks.has(id)) {
-            this.orderBooks = new Map([...this.orderBooks].filter(([key]) => key !== id));
+        if (this.orderBooks.has(outcomeId)) {
+            this.orderBooks = new Map([...this.orderBooks].filter(([key]) => key !== outcomeId));
         }
     }
-    async watchTrades(id, address) {
+    async watchTrades(outcomeId, address) {
         if (address) {
-            return this.watcher.watch(address, ['trades'], id);
+            return this.watcher.watch(address, ['trades'], outcomeId);
         }
         await this.ensureInitialized();
         // Subscribe to the asset if not already subscribed
         const currentAssets = this.manager.getAssetIds();
-        if (!currentAssets.includes(id)) {
-            await this.manager.addSubscriptions([id]);
+        if (!currentAssets.includes(outcomeId)) {
+            await this.manager.addSubscriptions([outcomeId]);
         }
         // Return a promise that resolves on the next trade
         const dataPromise = new Promise((resolve, reject) => {
-            if (!this.tradeResolvers.has(id)) {
-                this.tradeResolvers.set(id, []);
+            if (!this.tradeResolvers.has(outcomeId)) {
+                this.tradeResolvers.set(outcomeId, []);
             }
-            this.tradeResolvers.get(id).push({ resolve, reject });
+            this.tradeResolvers.get(outcomeId).push({ resolve, reject });
         });
-        return (0, watch_timeout_1.withWatchTimeout)(dataPromise, this.config.watchTimeoutMs ?? watch_timeout_1.DEFAULT_WATCH_TIMEOUT_MS, `watchTrades('${id}')`);
+        return (0, watch_timeout_1.withWatchTimeout)(dataPromise, this.config.watchTimeoutMs ?? watch_timeout_1.DEFAULT_WATCH_TIMEOUT_MS, `watchTrades('${outcomeId}')`);
     }
     async watchAddress(address, types) {
         return this.watcher.watch(address, types);

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

@@ -46,7 +46,7 @@ export declare class PolymarketUSExchange extends PredictionMarketExchange {
     private slugFromId;
     protected fetchMarketsImpl(params?: MarketFetchParams): Promise<UnifiedMarket[]>;
     protected fetchEventsImpl(params: EventFetchParams): Promise<UnifiedEvent[]>;
-    fetchOrderBook(id: string): Promise<OrderBook>;
+    fetchOrderBook(outcomeId: string): Promise<OrderBook>;
     fetchBalance(_address?: string): Promise<Balance[]>;
     fetchPositions(_address?: string): Promise<Position[]>;
     fetchMyTrades(params?: MyTradesParams): Promise<UserTrade[]>;
@@ -62,7 +62,7 @@ export declare class PolymarketUSExchange extends PredictionMarketExchange {
      * method calls `requireAuth()` up front.
      */
     private ensureWs;
-    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/polymarket_us/index.js

@@ -166,11 +166,11 @@ class PolymarketUSExchange extends BaseExchange_1.PredictionMarketExchange {
             return events;
         });
     }
-    async fetchOrderBook(id) {
+    async fetchOrderBook(outcomeId) {
         return this.run(async () => {
-            const slug = this.slugFromId(id);
+            const slug = this.slugFromId(outcomeId);
             const book = await this.client.markets.book(slug);
-            return this.normalizer.normalizeOrderBook(book, id);
+            return this.normalizer.normalizeOrderBook(book, outcomeId);
         });
     }
     // -------------------------------------------------------------------------
@@ -321,11 +321,11 @@ class PolymarketUSExchange extends BaseExchange_1.PredictionMarketExchange {
         }
         return this.wsWrapper;
     }
-    async watchOrderBook(id, _limit) {
-        return this.run(() => this.ensureWs().watchOrderBook(id));
+    async watchOrderBook(outcomeId, _limit) {
+        return this.run(() => this.ensureWs().watchOrderBook(outcomeId));
     }
-    async watchTrades(id, _address, _since, _limit) {
-        return this.run(() => this.ensureWs().watchTrades(id));
+    async watchTrades(outcomeId, _address, _since, _limit) {
+        return this.run(() => this.ensureWs().watchTrades(outcomeId));
     }
     // -------------------------------------------------------------------------
     // Lifecycle

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

@@ -31,8 +31,8 @@ export declare class PolymarketUSWebSocket {
     private readonly orderBookResolvers;
     private readonly tradeResolvers;
     constructor(client: PolymarketUSClient, normalizer: PolymarketUSNormalizer, config?: PolymarketUSWebSocketConfig);
-    watchOrderBook(id: string): Promise<OrderBook>;
-    watchTrades(id: string): Promise<Trade[]>;
+    watchOrderBook(outcomeId: string): Promise<OrderBook>;
+    watchTrades(outcomeId: string): Promise<Trade[]>;
     close(): Promise<void>;
     private ensureInitialized;
     private handleMarketData;