pmxt-core 2.19.6 → 2.20.1

package/dist/exchanges/limitless/index.js

@@ -1,21 +1,24 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.LimitlessExchange = void 0;
+exports.LimitlessExchange = exports.buildLimitlessBalanceActivity = exports.LIMITLESS_DEFAULT_SUBSCRIPTION = void 0;
+const sdk_1 = require("@limitless-exchange/sdk");
+const ethers_1 = require("ethers");
 const BaseExchange_1 = require("../../BaseExchange");
-const fetchMarkets_1 = require("./fetchMarkets");
+const errors_1 = require("../../errors");
+const goldsky_1 = require("../../subscriber/external/goldsky");
+Object.defineProperty(exports, "buildLimitlessBalanceActivity", { enumerable: true, get: function () { return goldsky_1.buildLimitlessBalanceActivity; } });
+Object.defineProperty(exports, "LIMITLESS_DEFAULT_SUBSCRIPTION", { enumerable: true, get: function () { return goldsky_1.LIMITLESS_DEFAULT_SUBSCRIPTION; } });
+const openapi_1 = require("../../utils/openapi");
+const api_1 = require("./api");
+const auth_1 = require("./auth");
+const client_1 = require("./client");
+const errors_2 = require("./errors");
 const fetchEvents_1 = require("./fetchEvents");
+const fetchMarkets_1 = require("./fetchMarkets");
 const fetchOHLCV_1 = require("./fetchOHLCV");
 const fetchOrderBook_1 = require("./fetchOrderBook");
 const fetchTrades_1 = require("./fetchTrades");
-const auth_1 = require("./auth");
-const client_1 = require("./client");
 const websocket_1 = require("./websocket");
-const errors_1 = require("./errors");
-const errors_2 = require("../../errors");
-const sdk_1 = require("@limitless-exchange/sdk");
-const ethers_1 = require("ethers");
-const openapi_1 = require("../../utils/openapi");
-const api_1 = require("./api");
 class LimitlessExchange extends BaseExchange_1.PredictionMarketExchange {
     has = {
         fetchMarkets: true,
@@ -29,6 +32,8 @@ class LimitlessExchange extends BaseExchange_1.PredictionMarketExchange {
         fetchOpenOrders: true,
         fetchPositions: true,
         fetchBalance: true,
+        watchAddress: true,
+        unwatchAddress: true,
         watchOrderBook: true,
         watchTrades: true,
         fetchMyTrades: true,
@@ -40,6 +45,7 @@ class LimitlessExchange extends BaseExchange_1.PredictionMarketExchange {
     auth;
     client;
     wsConfig;
+    ws;
     constructor(options) {
         // Support both old signature (credentials only) and new signature (options object)
         let credentials;
@@ -85,22 +91,8 @@ class LimitlessExchange extends BaseExchange_1.PredictionMarketExchange {
         return 'Limitless';
     }
     // ----------------------------------------------------------------------------
-    // Implicit API Error Mapping
-    // ----------------------------------------------------------------------------
-    mapImplicitApiError(error) {
-        throw errors_1.limitlessErrorMapper.mapError(error);
-    }
-    // ----------------------------------------------------------------------------
     // Implementation methods for CCXT-style API
     // ----------------------------------------------------------------------------
-    async fetchMarketsImpl(params) {
-        // Pass API key if available for authenticated requests
-        const apiKey = this.auth?.getApiKey();
-        return (0, fetchMarkets_1.fetchMarkets)(params, apiKey, this.callApi.bind(this));
-    }
-    async fetchEventsImpl(params) {
-        return (0, fetchEvents_1.fetchEvents)(params, this.callApi.bind(this), this.http);
-    }
     async fetchOHLCV(id, params) {
         return (0, fetchOHLCV_1.fetchOHLCV)(id, params, this.callApi.bind(this));
     }
@@ -115,26 +107,6 @@ class LimitlessExchange extends BaseExchange_1.PredictionMarketExchange {
         }
         return (0, fetchTrades_1.fetchTrades)(id, params, this.http);
     }
-    // ----------------------------------------------------------------------------
-    // Trading Methods
-    // ----------------------------------------------------------------------------
-    ensureClient() {
-        if (!this.client) {
-            throw new Error('Trading operations require authentication. ' +
-                'Initialize LimitlessExchange with credentials: new LimitlessExchange({ privateKey: "0x...", apiKey: "lmts_..." })');
-        }
-        return this.client;
-    }
-    /**
-     * Ensure authentication is initialized before trading operations.
-     */
-    ensureAuth() {
-        if (!this.auth) {
-            throw new errors_2.AuthenticationError('Trading operations require authentication. ' +
-                'Initialize LimitlessExchange with credentials: new LimitlessExchange({ privateKey: "0x...", apiKey: "lmts_..." })', 'Limitless');
-        }
-        return this.auth;
-    }
     async createOrder(params) {
         const client = this.ensureClient();
         try {
@@ -172,9 +144,12 @@ class LimitlessExchange extends BaseExchange_1.PredictionMarketExchange {
             };
         }
         catch (error) {
-            throw errors_1.limitlessErrorMapper.mapError(error);
+            throw errors_2.limitlessErrorMapper.mapError(error);
         }
     }
+    // ----------------------------------------------------------------------------
+    // Trading Methods
+    // ----------------------------------------------------------------------------
     async cancelOrder(orderId) {
         const client = this.ensureClient();
         try {
@@ -193,7 +168,7 @@ class LimitlessExchange extends BaseExchange_1.PredictionMarketExchange {
             };
         }
         catch (error) {
-            throw errors_1.limitlessErrorMapper.mapError(error);
+            throw errors_2.limitlessErrorMapper.mapError(error);
         }
     }
     async fetchOrder(orderId) {
@@ -228,7 +203,7 @@ class LimitlessExchange extends BaseExchange_1.PredictionMarketExchange {
             }));
         }
         catch (error) {
-            throw errors_1.limitlessErrorMapper.mapError(error);
+            throw errors_2.limitlessErrorMapper.mapError(error);
         }
     }
     async fetchMyTrades(params) {
@@ -248,7 +223,7 @@ class LimitlessExchange extends BaseExchange_1.PredictionMarketExchange {
             }));
         }
         catch (error) {
-            throw errors_1.limitlessErrorMapper.mapError(error);
+            throw errors_2.limitlessErrorMapper.mapError(error);
         }
     }
     async fetchClosedOrders(params) {
@@ -293,10 +268,10 @@ class LimitlessExchange extends BaseExchange_1.PredictionMarketExchange {
             timestamp: o.createdAt ? new Date(o.createdAt).getTime() : Date.now(),
         }));
     }
-    async fetchPositions() {
-        const auth = this.ensureAuth();
-        const address = auth.getAddress();
-        const result = await this.callApi('PublicPortfolioController_getPositions', { account: address });
+    async fetchPositions(address) {
+        // Public endpoint — no auth needed when an address is explicitly supplied.
+        const account = address ?? this.ensureAuth().getAddress();
+        const result = await this.callApi('PublicPortfolioController_getPositions', { account });
         const data = result?.data || result || [];
         return data.map((p) => ({
             marketId: p.market?.slug || p.conditionId,
@@ -309,61 +284,25 @@ class LimitlessExchange extends BaseExchange_1.PredictionMarketExchange {
             realizedPnL: parseFloat(p.realizedPnl || '0'),
         }));
     }
-    async fetchBalance() {
-        const auth = this.ensureAuth();
+    async fetchBalance(address) {
         try {
-            // Query USDC balance directly from the blockchain
-            // Base chain RPC (not Polygon)
-            const provider = new ethers_1.providers.JsonRpcProvider('https://mainnet.base.org');
-            const address = auth.getAddress();
-            // Get USDC contract address for Base
-            const usdcAddress = (0, sdk_1.getContractAddress)('USDC');
-            // USDC ERC20 ABI (balanceOf only)
-            const usdcContract = new ethers_1.Contract(usdcAddress, ['function balanceOf(address) view returns (uint256)'], provider);
-            // Query balance
-            const rawBalance = await usdcContract.balanceOf(address);
-            // USDC has 6 decimals
-            const USDC_DECIMALS = 6;
-            const total = parseFloat(rawBalance.toString()) / Math.pow(10, USDC_DECIMALS);
-            return [
-                {
-                    currency: 'USDC',
-                    total: total,
-                    available: total, // On-chain balance is all available
-                    locked: 0,
-                },
-            ];
+            // When an external address is provided use on-chain RPC only — no auth required.
+            const targetAddress = address ?? this.ensureAuth().getAddress();
+            return await this.getAddressOnChainBalance(targetAddress);
         }
         catch (error) {
-            throw errors_1.limitlessErrorMapper.mapError(error);
-        }
-    }
-    // ----------------------------------------------------------------------------
-    // WebSocket Methods
-    // ----------------------------------------------------------------------------
-    ws;
-    /**
-     * Initialize WebSocket with API key if available.
-     */
-    initWebSocket() {
-        if (!this.ws) {
-            const wsConfig = {
-                ...this.wsConfig,
-                apiKey: this.auth?.getApiKey(),
-            };
-            this.ws = new websocket_1.LimitlessWebSocket(this.callApi.bind(this), wsConfig);
+            throw errors_2.limitlessErrorMapper.mapError(error);
         }
-        return this.ws;
     }
     async watchOrderBook(id, limit) {
-        const ws = this.initWebSocket();
+        const ws = this.ensureWs();
         // Return the snapshot immediately (this allows the script to proceed)
         // Future versions could implement a more sophisticated queueing system
         return ws.watchOrderBook(id);
     }
-    async watchTrades(id, since, limit) {
-        const ws = this.initWebSocket();
-        return ws.watchTrades(id);
+    async watchTrades(id, address, since, limit) {
+        const ws = this.ensureWs();
+        return ws.watchTrades(id, address);
     }
     /**
      * Watch AMM price updates for a market address (Limitless only).
@@ -381,7 +320,7 @@ class LimitlessExchange extends BaseExchange_1.PredictionMarketExchange {
      * exchange.watch_prices(market_address, callback=lambda data: print('Price update:', data))
      */
     async watchPrices(marketAddress, callback) {
-        const ws = this.initWebSocket();
+        const ws = this.ensureWs();
         return ws.watchPrices(marketAddress, callback);
     }
     /**
@@ -400,9 +339,12 @@ class LimitlessExchange extends BaseExchange_1.PredictionMarketExchange {
      */
     async watchUserPositions(callback) {
         this.ensureAuth(); // Ensure API key is available
-        const ws = this.initWebSocket();
+        const ws = this.ensureWs();
         return ws.watchUserPositions(callback);
     }
+    // ----------------------------------------------------------------------------
+    // WebSocket Methods
+    // ----------------------------------------------------------------------------
     /**
      * Watch user transactions in real-time (Limitless only).
      * Requires API key authentication.
@@ -419,14 +361,140 @@ class LimitlessExchange extends BaseExchange_1.PredictionMarketExchange {
      */
     async watchUserTransactions(callback) {
         this.ensureAuth(); // Ensure API key is available
-        const ws = this.initWebSocket();
+        const ws = this.ensureWs();
         return ws.watchUserTransactions(callback);
     }
+    /**
+     * Stream activity (positions, balances) for any public Base-chain wallet address.
+     *
+     * Uses polling of the Limitless public portfolio API (positions) and on-chain Base
+     * RPC calls (USDC balance). No credentials are required.
+     *
+     * Note: Limitless does not expose a public per-address trades endpoint, so the
+     * `'trades'` type returns an empty array when watching a public address.
+     *
+     * Follows the CCXT Pro streaming pattern: the first call returns the initial snapshot
+     * immediately; subsequent calls block until a change is detected.
+     *
+     * @param address - Any public Base-chain wallet address
+     * @param types   - Activity types to watch (default: all)
+     *
+     * @example-ts
+     * while (true) {
+     *   const activity = await exchange.watchAddress('0xabc...', ['positions', 'balances']);
+     *   console.log(activity.positions, activity.balances);
+     * }
+     */
+    async watchAddress(address, types = ['trades', 'positions', 'balances']) {
+        return this.ensureWs().watchAddress(address, types);
+    }
+    /**
+     * Stop watching an address and release polling resources.
+     * Any pending `watchAddress` promises for that address will be rejected.
+     */
+    async unwatchAddress(address) {
+        return this.ensureWs().unwatchAddress(address);
+    }
     async close() {
         if (this.ws) {
-            this.ws.close();
+            await this.ws.close();
             this.ws = undefined;
         }
     }
+    mapImplicitApiError(error) {
+        throw errors_2.limitlessErrorMapper.mapError(error);
+    }
+    // ----------------------------------------------------------------------------
+    // Implicit API Error Mapping
+    // ----------------------------------------------------------------------------
+    async fetchMarketsImpl(params) {
+        // Pass API key if available for authenticated requests
+        const apiKey = this.auth?.getApiKey();
+        return (0, fetchMarkets_1.fetchMarkets)(params, apiKey, this.callApi.bind(this));
+    }
+    async fetchEventsImpl(params) {
+        return (0, fetchEvents_1.fetchEvents)(params, this.callApi.bind(this), this.http);
+    }
+    async getAddressOnChainBalance(targetAddress) {
+        // Query USDC balance directly from Base chain
+        const provider = new ethers_1.providers.JsonRpcProvider('https://mainnet.base.org');
+        // Get USDC contract address for Base
+        const usdcAddress = (0, sdk_1.getContractAddress)('USDC');
+        // USDC ERC20 ABI (balanceOf only)
+        const usdcContract = new ethers_1.Contract(usdcAddress, ['function balanceOf(address) view returns (uint256)'], provider);
+        const rawBalance = await usdcContract.balanceOf(targetAddress);
+        const USDC_DECIMALS = 6;
+        const total = parseFloat(rawBalance.toString()) / Math.pow(10, USDC_DECIMALS);
+        return [{
+                currency: 'USDC',
+                total,
+                available: total, // On-chain balance is all available
+                locked: 0,
+            }];
+    }
+    ensureClient() {
+        if (!this.client) {
+            throw new Error('Trading operations require authentication. ' +
+                'Initialize LimitlessExchange with credentials: new LimitlessExchange({ privateKey: "0x...", apiKey: "lmts_..." })');
+        }
+        return this.client;
+    }
+    /**
+     * Ensure authentication is initialized before trading operations.
+     */
+    ensureAuth() {
+        if (!this.auth) {
+            throw new errors_1.AuthenticationError('Trading operations require authentication. ' +
+                'Initialize LimitlessExchange with credentials: new LimitlessExchange({ privateKey: "0x...", apiKey: "lmts_..." })', 'Limitless');
+        }
+        return this.auth;
+    }
+    /**
+     * Initialize WebSocket with API key if available.
+     */
+    ensureWs() {
+        if (!this.ws) {
+            const wsConfig = {
+                ...this.wsConfig,
+                apiKey: this.auth?.getApiKey(),
+            };
+            this.ws = new websocket_1.LimitlessWebSocket(this.callApi.bind(this), wsConfig);
+        }
+        return this.ws;
+    }
+    /**
+     * Fetch a composite activity snapshot for a Base-chain address from the Limitless
+     * public portfolio API and Base RPC. Used internally by the BaseSubscriber polling loop.
+     */
+    async fetchWatchedAddressActivity(params) {
+        const address = params.address;
+        const types = params.types;
+        const result = { address, timestamp: Date.now() };
+        const fetches = [];
+        // Limitless has no public per-address trades endpoint; return empty.
+        if (types.includes('trades')) {
+            result.trades = [];
+        }
+        if (types.includes('positions')) {
+            fetches.push(this.fetchPositions(address)
+                .then((positions) => {
+                result.positions = positions;
+            })
+                .catch(() => {
+                result.positions = [];
+            }));
+        }
+        if (types.includes('balances')) {
+            fetches.push(this.getAddressOnChainBalance(address)
+                .then((balances) => {
+                result.balances = balances;
+            })
+                .catch(() => {
+                result.balances = [];
+            }));
+        }
+        await Promise.all(fetches);
+        return result;
+    }
 }
 exports.LimitlessExchange = LimitlessExchange;

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

@@ -1,4 +1,6 @@
-import { WebSocketClient, WebSocketConfig, ILogger } from '@limitless-exchange/sdk';
+import { ILogger, WebSocketClient, WebSocketConfig } from '@limitless-exchange/sdk';
+import { SubscribedAddressSnapshot, SubscriptionOption } from "../../subscriber/base";
+import { WatcherConfig } from "../../subscriber/watcher";
 import { OrderBook, Trade } from '../../types';
 export interface LimitlessWebSocketConfig extends Partial<WebSocketConfig> {
     apiKey?: string;
@@ -7,6 +9,8 @@ export interface LimitlessWebSocketConfig extends Partial<WebSocketConfig> {
     logger?: ILogger;
     autoReconnect?: boolean;
     reconnectDelay?: number;
+    /** Watcher subscription configurations */
+    watcherConfig?: WatcherConfig;
 }
 /**
  * Limitless WebSocket implementation using the official SDK.
@@ -18,6 +22,7 @@ export interface LimitlessWebSocketConfig extends Partial<WebSocketConfig> {
  */
 export declare class LimitlessWebSocket {
     private client;
+    private readonly watcher;
     private config;
     private callApi;
     private orderbookCallbacks;
@@ -26,7 +31,6 @@ export declare class LimitlessWebSocket {
     private orderbookBuffers;
     private lastOrderbookTimestamps;
     constructor(callApi: (operationId: string, params?: Record<string, any>) => Promise<any>, config?: LimitlessWebSocketConfig);
-    private setupEventHandlers;
     /**
      * Watch orderbook updates for a CLOB market.
      *
@@ -58,11 +62,13 @@ export declare class LimitlessWebSocket {
     /**
      * Legacy method - watch trades (not directly supported, falls back to orderbook)
      */
-    watchTrades(marketSlug: string): Promise<Trade[]>;
+    watchTrades(marketSlug: string, address?: string): Promise<Trade[]>;
     /**
      * Unsubscribe from a market.
      */
     unsubscribe(marketSlugOrAddress: string): Promise<void>;
+    watchAddress(address: string, types: SubscriptionOption[]): Promise<SubscribedAddressSnapshot>;
+    unwatchAddress(address: string): Promise<void>;
     /**
      * Close the WebSocket connection.
      */
@@ -75,6 +81,7 @@ export declare class LimitlessWebSocket {
      * Get the underlying SDK WebSocket client for advanced usage.
      */
     getClient(): WebSocketClient;
+    private setupEventHandlers;
     private transformOrderbookData;
     private getEmptyOrderbook;
 }

package/dist/exchanges/limitless/websocket.js

@@ -2,12 +2,14 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LimitlessWebSocket = void 0;
 const sdk_1 = require("@limitless-exchange/sdk");
+const goldsky_1 = require("../../subscriber/external/goldsky");
+const watcher_1 = require("../../subscriber/watcher");
 const fetchOrderBook_1 = require("./fetchOrderBook");
 // Limitless uses USDC with 6 decimals
 const USDC_DECIMALS = 6;
 const USDC_SCALE = Math.pow(10, USDC_DECIMALS);
 /**
- * Convert raw orderbook size from smallest unit to human-readable USDC amount.
+ * Convert raw orderbook size from the smallest unit to human-readable USDC amount.
  */
 function convertSize(rawSize) {
     return rawSize / USDC_SCALE;
@@ -22,6 +24,7 @@ function convertSize(rawSize) {
  */
 class LimitlessWebSocket {
     client;
+    watcher;
     config;
     callApi;
     orderbookCallbacks = new Map();
@@ -42,55 +45,14 @@ class LimitlessWebSocket {
         this.client = new sdk_1.WebSocketClient(wsConfig, config.logger);
         // Set up event handlers
         this.setupEventHandlers();
-    }
-    setupEventHandlers() {
-        // Handle orderbook updates
-        this.client.on('orderbookUpdate', (data) => {
-            const { marketSlug, orderbook } = data;
-            const pmxtOrderbook = this.transformOrderbookData(orderbook);
-            // Update timestamp for this market
-            this.lastOrderbookTimestamps.set(marketSlug, Date.now());
-            // Execute callback if registered
-            const callback = this.orderbookCallbacks.get(marketSlug);
-            if (callback) {
-                callback(pmxtOrderbook);
-            }
-            // Handle resolvers and buffers
-            const resolvers = this.orderbookResolvers.get(marketSlug) || [];
-            if (resolvers.length > 0) {
-                // If someone is waiting, give it to them immediately
-                const resolver = resolvers.shift();
-                resolver.resolve(pmxtOrderbook);
-            }
-            else {
-                // Otherwise, buffer it for the next call
-                if (!this.orderbookBuffers.has(marketSlug)) {
-                    this.orderbookBuffers.set(marketSlug, []);
-                }
-                const buffer = this.orderbookBuffers.get(marketSlug);
-                buffer.push(pmxtOrderbook);
-                // Keep buffer size reasonable
-                if (buffer.length > 100)
-                    buffer.shift();
-            }
+        const watcherConfig = this.config.watcherConfig;
+        const subscriber = new goldsky_1.GoldSkySubscriber({
+            ...watcherConfig,
+            buildSubscription: goldsky_1.LIMITLESS_DEFAULT_SUBSCRIPTION,
         });
-        // Handle AMM price updates
-        this.client.on('newPriceData', (data) => {
-            const { marketAddress } = data;
-            const callback = this.priceCallbacks.get(marketAddress);
-            if (callback) {
-                callback(data);
-            }
-        });
-        // Handle connection events
-        this.client.on('connect', () => {
-            console.log('[LimitlessWS] Connected to WebSocket');
-        });
-        this.client.on('disconnect', (reason) => {
-            console.log(`[LimitlessWS] Disconnected from WebSocket: ${reason}`);
-        });
-        this.client.on('error', (error) => {
-            console.error('[LimitlessWS] WebSocket error:', error);
+        this.watcher = new watcher_1.AddressWatcher((address, types) => this.callApi("fetchWatchedAddressActivity", { address, types }), {
+            subscriber,
+            buildActivity: goldsky_1.buildLimitlessBalanceActivity,
         });
     }
     /**
@@ -202,7 +164,7 @@ class LimitlessWebSocket {
         if (!this.client.isConnected()) {
             await this.client.connect();
         }
-        await this.client.subscribe('orders'); // SDK uses 'orders' channel for user positional updates too? 
+        await this.client.subscribe('orders'); // SDK uses 'orders' channel for user positional updates too?
         // Actually, the channel type has 'subscribe_positions'. Let's check.
         // Wait, I saw 'orders' in SubscriptionChannel.
         // Let's use 'orders' as it's common for user data.
@@ -227,7 +189,7 @@ class LimitlessWebSocket {
     /**
      * Legacy method - watch trades (not directly supported, falls back to orderbook)
      */
-    async watchTrades(marketSlug) {
+    async watchTrades(marketSlug, address) {
         console.warn('[LimitlessWS] watchTrades is not directly supported. ' +
             'Use watchOrderBook() for real-time orderbook updates or fetchOHLCV() for historical data.');
         return [];
@@ -246,13 +208,20 @@ class LimitlessWebSocket {
             marketAddresses: [marketSlugOrAddress],
         });
     }
+    async watchAddress(address, types) {
+        return this.watcher.watch(address, types);
+    }
+    async unwatchAddress(address) {
+        return this.watcher.unwatch(address);
+    }
     /**
      * Close the WebSocket connection.
      */
     async close() {
         this.orderbookCallbacks.clear();
         this.priceCallbacks.clear();
-        this.client.disconnect();
+        await this.client.disconnect();
+        this.watcher.close();
     }
     /**
      * Check if connected.
@@ -266,6 +235,56 @@ class LimitlessWebSocket {
     getClient() {
         return this.client;
     }
+    setupEventHandlers() {
+        // Handle orderbook updates
+        this.client.on('orderbookUpdate', (data) => {
+            const { marketSlug, orderbook } = data;
+            const pmxtOrderbook = this.transformOrderbookData(orderbook);
+            // Update timestamp for this market
+            this.lastOrderbookTimestamps.set(marketSlug, Date.now());
+            // Execute callback if registered
+            const callback = this.orderbookCallbacks.get(marketSlug);
+            if (callback) {
+                callback(pmxtOrderbook);
+            }
+            // Handle resolvers and buffers
+            const resolvers = this.orderbookResolvers.get(marketSlug) || [];
+            if (resolvers.length > 0) {
+                // If someone is waiting, give it to them immediately
+                const resolver = resolvers.shift();
+                resolver.resolve(pmxtOrderbook);
+            }
+            else {
+                // Otherwise, buffer it for the next call
+                if (!this.orderbookBuffers.has(marketSlug)) {
+                    this.orderbookBuffers.set(marketSlug, []);
+                }
+                const buffer = this.orderbookBuffers.get(marketSlug);
+                buffer.push(pmxtOrderbook);
+                // Keep buffer size reasonable
+                if (buffer.length > 100)
+                    buffer.shift();
+            }
+        });
+        // Handle AMM price updates
+        this.client.on('newPriceData', (data) => {
+            const { marketAddress } = data;
+            const callback = this.priceCallbacks.get(marketAddress);
+            if (callback) {
+                callback(data);
+            }
+        });
+        // Handle connection events
+        this.client.on('connect', () => {
+            console.log('[LimitlessWS] Connected to WebSocket');
+        });
+        this.client.on('disconnect', (reason) => {
+            console.log(`[LimitlessWS] Disconnected from WebSocket: ${reason}`);
+        });
+        this.client.on('error', (error) => {
+            console.error('[LimitlessWS] WebSocket error:', error);
+        });
+    }
     transformOrderbookData(orderbook) {
         // Convert sizes from smallest unit to human-readable USDC amounts
         const bids = (orderbook.bids || []).map((level) => ({

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-03-06T09:16:55.607Z
+ * Generated at: 2026-03-14T16:40:09.282Z
  * 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-03-06T09:16:55.607Z
+ * Generated at: 2026-03-14T16:40:09.282Z
  * Do not edit manually -- run "npm run fetch:openapi" to regenerate.
  */
 exports.myriadApiSpec = {

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

@@ -13,6 +13,8 @@ export declare class MyriadExchange extends PredictionMarketExchange {
         fetchOpenOrders: "emulated";
         fetchPositions: true;
         fetchBalance: "emulated";
+        watchAddress: false;
+        unwatchAddress: false;
         watchOrderBook: "emulated";
         watchTrades: "emulated";
         fetchMyTrades: true;
@@ -42,6 +44,6 @@ export declare class MyriadExchange extends PredictionMarketExchange {
     fetchPositions(): Promise<Position[]>;
     fetchBalance(): Promise<Balance[]>;
     watchOrderBook(id: string, _limit?: number): Promise<OrderBook>;
-    watchTrades(id: string, _since?: number, _limit?: number): Promise<Trade[]>;
+    watchTrades(id: string, address?: string, _since?: number, _limit?: number): Promise<Trade[]>;
     close(): Promise<void>;
 }