pmxt-core 2.38.0 → 2.39.1

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-08T19:42:37.556Z
+ * Generated at: 2026-05-08T20:51:55.548Z
  * 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-08T19:42:37.556Z
+ * Generated at: 2026-05-08T20:51:55.548Z
  * 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-08T19:42:37.506Z
+ * Generated at: 2026-05-08T20:51:55.496Z
  * 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-08T19:42:37.506Z
+ * Generated at: 2026-05-08T20:51:55.496Z
  * 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-08T19:42:37.518Z
+ * Generated at: 2026-05-08T20:51:55.511Z
  * 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-08T19:42:37.518Z
+ * Generated at: 2026-05-08T20:51:55.511Z
  * 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-08T19:42:37.516Z
+ * Generated at: 2026-05-08T20:51:55.508Z
  * 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-08T19:42:37.516Z
+ * Generated at: 2026-05-08T20:51:55.508Z
  * Do not edit manually -- run "npm run fetch:openapi" to regenerate.
  */
 exports.polymarketGammaSpec = {

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

@@ -3,8 +3,8 @@ import { SubscribedAddressSnapshot, SubscriptionOption } from '../../subscriber/
 import { buildPolymarketTradesActivity, POLYMARKET_DEFAULT_SUBSCRIPTION } from '../../subscriber/external/goldsky';
 import { WatcherConfig } from '../../subscriber/watcher';
 import { Balance, BuiltOrder, CreateOrderParams, Order, OrderBook, Position, PriceCandle, Trade, UnifiedEvent, UnifiedMarket, UserTrade } from '../../types';
-import { PolymarketWebSocketConfig } from './websocket';
-export type { PolymarketWebSocketConfig, WatcherConfig };
+import { PolymarketWebSocketConfig, UserChannelCallback, UserChannelEvent, PolymarketUserChannelCreds } from './websocket';
+export type { PolymarketWebSocketConfig, WatcherConfig, UserChannelCallback, UserChannelEvent, PolymarketUserChannelCreds };
 export { POLYMARKET_DEFAULT_SUBSCRIPTION, buildPolymarketTradesActivity };
 export interface PolymarketExchangeOptions {
     credentials?: ExchangeCredentials;
@@ -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

@@ -8,6 +8,34 @@
 import { SubscribedAddressSnapshot, SubscriptionOption } from '../../subscriber/base';
 import { WatcherConfig } from '../../subscriber/watcher';
 import { OrderBook, Trade } from '../../types';
+export interface PolymarketUserChannelCreds {
+    apiKey: string;
+    secret: string;
+    passphrase: string;
+}
+export interface UserTradeEvent {
+    asset_id: string;
+    event_type: 'trade';
+    price: string;
+    size: string;
+    side: string;
+    status: string;
+    maker_orders?: any[];
+    timestamp?: string;
+}
+export interface UserOrderEvent {
+    asset_id: string;
+    event_type: 'order';
+    order_id: string;
+    price: string;
+    original_size: string;
+    matched_size?: string;
+    side: string;
+    type: string;
+    timestamp?: string;
+}
+export type UserChannelEvent = UserTradeEvent | UserOrderEvent;
+export type UserChannelCallback = (event: UserChannelEvent) => void;
 export interface PolymarketWebSocketConfig {
     /** Reconnection check interval in milliseconds (default: 5000) */
     reconnectIntervalMs?: number;
@@ -17,6 +45,8 @@ export interface PolymarketWebSocketConfig {
     watcherConfig?: WatcherConfig;
     /** Timeout in ms for watch methods to receive data (default: 30000). 0 = no timeout. */
     watchTimeoutMs?: number;
+    /** API credentials for the authenticated user channel (fills/orders). */
+    userChannelCreds?: PolymarketUserChannelCreds;
 }
 /**
  * Wrapper around @nevuamarkets/poly-websockets that provides CCXT Pro-style
@@ -31,11 +61,32 @@ 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>;
+    private userWs;
+    private userCallbacks;
+    private userPingInterval;
+    private userReconnectTimer;
+    private userConditionIds;
+    /**
+     * Subscribe to authenticated fill/order events via Polymarket's user channel.
+     * Requires `userChannelCreds` in the config.
+     *
+     * @param conditionIds - Market condition IDs to monitor
+     * @param callback     - Called for each trade or order event
+     */
+    watchUserFills(conditionIds: string[], callback: UserChannelCallback): Promise<void>;
+    /**
+     * Stop watching user fills and close the user channel WebSocket.
+     */
+    unwatchUserFills(): Promise<void>;
+    private connectUserChannel;
+    private sendUserSubscription;
+    private scheduleUserReconnect;
+    private closeUserChannel;
     close(): Promise<void>;
     private ensureInitialized;
     private handleBookSnapshot;

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);
@@ -124,10 +124,135 @@ class PolymarketWebSocket {
     async unwatchAddress(address) {
         return this.watcher.unwatch(address);
     }
+    // -----------------------------------------------------------------
+    // Authenticated User Channel (fills + order updates)
+    // -----------------------------------------------------------------
+    userWs = null;
+    userCallbacks = [];
+    userPingInterval = null;
+    userReconnectTimer = null;
+    userConditionIds = [];
+    /**
+     * Subscribe to authenticated fill/order events via Polymarket's user channel.
+     * Requires `userChannelCreds` in the config.
+     *
+     * @param conditionIds - Market condition IDs to monitor
+     * @param callback     - Called for each trade or order event
+     */
+    async watchUserFills(conditionIds, callback) {
+        const creds = this.config.userChannelCreds;
+        if (!creds) {
+            throw new Error('User channel requires API credentials. Pass userChannelCreds in PolymarketWebSocketConfig.');
+        }
+        this.userCallbacks.push(callback);
+        this.userConditionIds = [...new Set([...this.userConditionIds, ...conditionIds])];
+        if (this.userWs) {
+            // Already connected — just re-subscribe with updated condition IDs.
+            this.sendUserSubscription(creds);
+            return;
+        }
+        await this.connectUserChannel(creds);
+    }
+    /**
+     * Stop watching user fills and close the user channel WebSocket.
+     */
+    async unwatchUserFills() {
+        this.userCallbacks = [];
+        this.userConditionIds = [];
+        this.closeUserChannel();
+    }
+    async connectUserChannel(creds) {
+        const WebSocket = (await Promise.resolve().then(() => __importStar(require('ws')))).default;
+        const url = 'wss://ws-subscriptions-clob.polymarket.com/ws/user';
+        this.userWs = new WebSocket(url);
+        this.userWs.on('open', () => {
+            console.log('[polymarket-ws] user channel connected');
+            this.sendUserSubscription(creds);
+            // Ping every 10 seconds to keep the connection alive.
+            if (this.userPingInterval)
+                clearInterval(this.userPingInterval);
+            this.userPingInterval = setInterval(() => {
+                if (this.userWs?.readyState === WebSocket.OPEN) {
+                    this.userWs.ping();
+                }
+            }, 10_000);
+        });
+        this.userWs.on('message', (raw) => {
+            try {
+                const events = JSON.parse(raw.toString());
+                const arr = Array.isArray(events) ? events : [events];
+                for (const event of arr) {
+                    for (const cb of this.userCallbacks) {
+                        try {
+                            cb(event);
+                        }
+                        catch (e) {
+                            console.error('[polymarket-ws] user callback error:', e);
+                        }
+                    }
+                }
+            }
+            catch {
+                // Non-JSON control message (pong, etc.) — ignore.
+            }
+        });
+        this.userWs.on('close', () => {
+            console.warn('[polymarket-ws] user channel disconnected, reconnecting in 5s');
+            this.scheduleUserReconnect(creds);
+        });
+        this.userWs.on('error', (err) => {
+            console.error('[polymarket-ws] user channel error:', err.message);
+        });
+    }
+    sendUserSubscription(creds) {
+        if (!this.userWs || this.userWs.readyState !== 1)
+            return;
+        const msg = JSON.stringify({
+            auth: {
+                apiKey: creds.apiKey,
+                secret: creds.secret,
+                passphrase: creds.passphrase,
+            },
+            markets: this.userConditionIds,
+            type: 'user',
+        });
+        this.userWs.send(msg);
+    }
+    scheduleUserReconnect(creds) {
+        if (this.userReconnectTimer)
+            return;
+        this.userReconnectTimer = setTimeout(async () => {
+            this.userReconnectTimer = null;
+            if (this.userCallbacks.length > 0) {
+                try {
+                    await this.connectUserChannel(creds);
+                }
+                catch (e) {
+                    console.error('[polymarket-ws] reconnect failed:', e.message);
+                    this.scheduleUserReconnect(creds);
+                }
+            }
+        }, 5000);
+    }
+    closeUserChannel() {
+        if (this.userPingInterval) {
+            clearInterval(this.userPingInterval);
+            this.userPingInterval = null;
+        }
+        if (this.userReconnectTimer) {
+            clearTimeout(this.userReconnectTimer);
+            this.userReconnectTimer = null;
+        }
+        if (this.userWs) {
+            this.userWs.close();
+            this.userWs = null;
+        }
+    }
     async close() {
         if (this.manager) {
             await this.manager.clearState();
         }
+        this.closeUserChannel();
         this.watcher.close();
     }
     async ensureInitialized() {

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;

package/dist/exchanges/polymarket_us/websocket.js

@@ -57,8 +57,8 @@ class PolymarketUSWebSocket {
         this.normalizer = normalizer;
         this.config = config;
     }
-    async watchOrderBook(id) {
-        const slug = slugFromId(id);
+    async watchOrderBook(outcomeId) {
+        const slug = slugFromId(outcomeId);
         await this.ensureInitialized();
         if (!this.bookSubscriptions.has(slug)) {
             this.bookSubscriptions.add(slug);
@@ -69,10 +69,10 @@ class PolymarketUSWebSocket {
             queue.push({ resolve, reject });
             this.orderBookResolvers.set(slug, queue);
         });
-        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 watchTrades(id) {
-        const slug = slugFromId(id);
+    async watchTrades(outcomeId) {
+        const slug = slugFromId(outcomeId);
         await this.ensureInitialized();
         if (!this.tradeSubscriptions.has(slug)) {
             this.tradeSubscriptions.add(slug);
@@ -83,7 +83,7 @@ class PolymarketUSWebSocket {
             queue.push({ resolve, reject });
             this.tradeResolvers.set(slug, queue);
         });
-        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 close() {
         if (this.socket) {

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

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

package/dist/exchanges/probable/api.js

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