pmxt-core 2.24.0 → 2.25.1

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

@@ -0,0 +1,94 @@
+import type { OrderIntent, Amount } from 'polymarket-us';
+/**
+ * Polymarket US price/quantity conversion utilities.
+ *
+ * CRITICAL CONVENTION: Polymarket US uses a LONG-SIDE PRICE convention.
+ * The `price.value` field on every order is ALWAYS the YES-side (long)
+ * price between $0.01 and $0.99 - even for orders on the NO side.
+ *
+ * To express "I want NO at $0.40", you submit a long-side price of
+ * `1.00 - 0.40 = $0.60`.
+ *
+ * This module exposes pure helpers to convert between user-facing
+ * side prices and the long-side prices the API expects.
+ */
+export declare const POLYMARKET_US_MIN_PRICE = 0.01;
+export declare const POLYMARKET_US_MAX_PRICE = 0.99;
+/**
+ * Default minimum price increment for Polymarket US markets. Observed live
+ * markets report `orderPriceMinTickSize: 0.001`, so we default to that.
+ * Per-market overrides (surfaced on `UnifiedMarket.tickSize`) should be
+ * preferred when available.
+ */
+export declare const POLYMARKET_US_TICK_SIZE = 0.001;
+/**
+ * Number of decimal places used when serializing `Amount.value` strings.
+ * Matches the 0.001 tick-size precision observed on the live gateway
+ * (e.g. `"0.864"`, `"0.999"`).
+ */
+export declare const POLYMARKET_US_PRICE_DECIMALS = 3;
+export declare const POLYMARKET_US_CURRENCY: 'USD';
+/**
+ * Round a price to a tick size using Math.round. Defaults to the
+ * Polymarket US tick size (0.001) but accepts a per-market override.
+ * Re-rounds to `POLYMARKET_US_PRICE_DECIMALS` afterwards to avoid
+ * floating-point drift.
+ *
+ * Note: this is a pure rounding helper - it does NOT validate bounds.
+ * Out-of-range inputs (e.g. 0.9999 -> 1.000) will pass through unchanged.
+ */
+export declare function roundToTickSize(price: number, tickSize?: number): number;
+/**
+ * Validate a price is finite and within [POLYMARKET_US_MIN_PRICE, POLYMARKET_US_MAX_PRICE].
+ *
+ * @throws RangeError if price is not finite or out of bounds.
+ */
+export declare function validatePriceBounds(price: number): void;
+/**
+ * Convert a user-supplied price (in their natural side, 0.01-0.99) to the
+ * long-side price required by the Polymarket US API.
+ *
+ * For LONG intents (BUY_LONG, SELL_LONG) the user price is already the
+ * long-side price and is returned unchanged.
+ *
+ * For SHORT intents (BUY_SHORT, SELL_SHORT) the long-side price is
+ * `1 - userPrice`.
+ *
+ * Both the input and the resulting long-side output are validated against
+ * the Polymarket US price bounds.
+ *
+ * @throws RangeError if userPrice (or the derived long-side price) is not
+ *   finite or outside [0.01, 0.99].
+ */
+export declare function toLongSidePrice(intent: OrderIntent, userPrice: number): number;
+/**
+ * Inverse of `toLongSidePrice`. Given a long-side price returned by the API
+ * and the order's intent, recover the user-facing side price.
+ *
+ * For LONG intents the long-side price IS the user price.
+ * For SHORT intents the user price is `1 - longPrice`.
+ *
+ * @throws RangeError if longPrice (or the derived user price) is not finite
+ *   or outside [0.01, 0.99].
+ */
+export declare function fromLongSidePrice(intent: OrderIntent, longPrice: number): number;
+/**
+ * Build an SDK `Amount` object from a numeric USD price.
+ *
+ * The price is first rounded to tick size and then validated against the
+ * Polymarket US bounds. The resulting value is formatted as a fixed
+ * `POLYMARKET_US_PRICE_DECIMALS`-decimal string (e.g. "0.550"), matching
+ * the precision the live gateway reports.
+ *
+ * An optional `tickSize` override allows per-market tick sizes (as
+ * surfaced on `UnifiedMarket.tickSize`) to be honoured instead of the
+ * default `POLYMARKET_US_TICK_SIZE`.
+ *
+ * @throws RangeError if the rounded price is out of bounds.
+ */
+export declare function toAmount(price: number, tickSize?: number): Amount;
+/**
+ * Parse an SDK `Amount` back to a number. Returns 0 for undefined or empty
+ * values; otherwise delegates to `parseFloat`.
+ */
+export declare function fromAmount(amount: Amount | undefined): number;

package/dist/exchanges/polymarket_us/price.js

@@ -0,0 +1,149 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.POLYMARKET_US_CURRENCY = exports.POLYMARKET_US_PRICE_DECIMALS = exports.POLYMARKET_US_TICK_SIZE = exports.POLYMARKET_US_MAX_PRICE = exports.POLYMARKET_US_MIN_PRICE = void 0;
+exports.roundToTickSize = roundToTickSize;
+exports.validatePriceBounds = validatePriceBounds;
+exports.toLongSidePrice = toLongSidePrice;
+exports.fromLongSidePrice = fromLongSidePrice;
+exports.toAmount = toAmount;
+exports.fromAmount = fromAmount;
+/**
+ * Polymarket US price/quantity conversion utilities.
+ *
+ * CRITICAL CONVENTION: Polymarket US uses a LONG-SIDE PRICE convention.
+ * The `price.value` field on every order is ALWAYS the YES-side (long)
+ * price between $0.01 and $0.99 - even for orders on the NO side.
+ *
+ * To express "I want NO at $0.40", you submit a long-side price of
+ * `1.00 - 0.40 = $0.60`.
+ *
+ * This module exposes pure helpers to convert between user-facing
+ * side prices and the long-side prices the API expects.
+ */
+exports.POLYMARKET_US_MIN_PRICE = 0.01;
+exports.POLYMARKET_US_MAX_PRICE = 0.99;
+/**
+ * Default minimum price increment for Polymarket US markets. Observed live
+ * markets report `orderPriceMinTickSize: 0.001`, so we default to that.
+ * Per-market overrides (surfaced on `UnifiedMarket.tickSize`) should be
+ * preferred when available.
+ */
+exports.POLYMARKET_US_TICK_SIZE = 0.001;
+/**
+ * Number of decimal places used when serializing `Amount.value` strings.
+ * Matches the 0.001 tick-size precision observed on the live gateway
+ * (e.g. `"0.864"`, `"0.999"`).
+ */
+exports.POLYMARKET_US_PRICE_DECIMALS = 3;
+exports.POLYMARKET_US_CURRENCY = 'USD';
+const LONG_INTENTS = new Set([
+    'ORDER_INTENT_BUY_LONG',
+    'ORDER_INTENT_SELL_LONG',
+]);
+/**
+ * Round a price to a tick size using Math.round. Defaults to the
+ * Polymarket US tick size (0.001) but accepts a per-market override.
+ * Re-rounds to `POLYMARKET_US_PRICE_DECIMALS` afterwards to avoid
+ * floating-point drift.
+ *
+ * Note: this is a pure rounding helper - it does NOT validate bounds.
+ * Out-of-range inputs (e.g. 0.9999 -> 1.000) will pass through unchanged.
+ */
+function roundToTickSize(price, tickSize = exports.POLYMARKET_US_TICK_SIZE) {
+    const ticks = Math.round(price / tickSize);
+    const rounded = ticks * tickSize;
+    const scale = Math.pow(10, exports.POLYMARKET_US_PRICE_DECIMALS);
+    return Math.round(rounded * scale) / scale;
+}
+/**
+ * Validate a price is finite and within [POLYMARKET_US_MIN_PRICE, POLYMARKET_US_MAX_PRICE].
+ *
+ * @throws RangeError if price is not finite or out of bounds.
+ */
+function validatePriceBounds(price) {
+    if (!Number.isFinite(price)) {
+        throw new RangeError(`Polymarket US price must be a finite number, got: ${price}`);
+    }
+    if (price < exports.POLYMARKET_US_MIN_PRICE || price > exports.POLYMARKET_US_MAX_PRICE) {
+        throw new RangeError(`Polymarket US price ${price} is out of bounds [${exports.POLYMARKET_US_MIN_PRICE}, ${exports.POLYMARKET_US_MAX_PRICE}]`);
+    }
+}
+/**
+ * Convert a user-supplied price (in their natural side, 0.01-0.99) to the
+ * long-side price required by the Polymarket US API.
+ *
+ * For LONG intents (BUY_LONG, SELL_LONG) the user price is already the
+ * long-side price and is returned unchanged.
+ *
+ * For SHORT intents (BUY_SHORT, SELL_SHORT) the long-side price is
+ * `1 - userPrice`.
+ *
+ * Both the input and the resulting long-side output are validated against
+ * the Polymarket US price bounds.
+ *
+ * @throws RangeError if userPrice (or the derived long-side price) is not
+ *   finite or outside [0.01, 0.99].
+ */
+function toLongSidePrice(intent, userPrice) {
+    validatePriceBounds(userPrice);
+    if (LONG_INTENTS.has(intent)) {
+        return userPrice;
+    }
+    const longPrice = 1 - userPrice;
+    validatePriceBounds(longPrice);
+    return longPrice;
+}
+/**
+ * Inverse of `toLongSidePrice`. Given a long-side price returned by the API
+ * and the order's intent, recover the user-facing side price.
+ *
+ * For LONG intents the long-side price IS the user price.
+ * For SHORT intents the user price is `1 - longPrice`.
+ *
+ * @throws RangeError if longPrice (or the derived user price) is not finite
+ *   or outside [0.01, 0.99].
+ */
+function fromLongSidePrice(intent, longPrice) {
+    validatePriceBounds(longPrice);
+    if (LONG_INTENTS.has(intent)) {
+        return longPrice;
+    }
+    const userPrice = 1 - longPrice;
+    validatePriceBounds(userPrice);
+    return userPrice;
+}
+/**
+ * Build an SDK `Amount` object from a numeric USD price.
+ *
+ * The price is first rounded to tick size and then validated against the
+ * Polymarket US bounds. The resulting value is formatted as a fixed
+ * `POLYMARKET_US_PRICE_DECIMALS`-decimal string (e.g. "0.550"), matching
+ * the precision the live gateway reports.
+ *
+ * An optional `tickSize` override allows per-market tick sizes (as
+ * surfaced on `UnifiedMarket.tickSize`) to be honoured instead of the
+ * default `POLYMARKET_US_TICK_SIZE`.
+ *
+ * @throws RangeError if the rounded price is out of bounds.
+ */
+function toAmount(price, tickSize = exports.POLYMARKET_US_TICK_SIZE) {
+    if (!Number.isFinite(price)) {
+        throw new RangeError(`Polymarket US price must be a finite number, got: ${price}`);
+    }
+    const rounded = roundToTickSize(price, tickSize);
+    validatePriceBounds(rounded);
+    return {
+        value: rounded.toFixed(exports.POLYMARKET_US_PRICE_DECIMALS),
+        currency: exports.POLYMARKET_US_CURRENCY,
+    };
+}
+/**
+ * Parse an SDK `Amount` back to a number. Returns 0 for undefined or empty
+ * values; otherwise delegates to `parseFloat`.
+ */
+function fromAmount(amount) {
+    if (!amount || !amount.value) {
+        return 0;
+    }
+    return parseFloat(amount.value);
+}

package/dist/exchanges/polymarket_us/price.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/exchanges/polymarket_us/price.test.js

@@ -0,0 +1,131 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const price_1 = require("./price");
+describe('roundToTickSize', () => {
+    it('is idempotent for 0.123 at the default 0.001 tick', () => {
+        expect((0, price_1.roundToTickSize)(0.123)).toBe(0.123);
+    });
+    it('rounds 0.1234 down to 0.123 at default tick', () => {
+        expect((0, price_1.roundToTickSize)(0.1234)).toBe(0.123);
+    });
+    it('rounds 0.1235 up to 0.124 (Math.round half-away-from-zero)', () => {
+        expect((0, price_1.roundToTickSize)(0.1235)).toBe(0.124);
+    });
+    it('rounds 0.9999 up to 1.000 (out of bounds, validation is separate)', () => {
+        expect((0, price_1.roundToTickSize)(0.9999)).toBe(1.0);
+    });
+    it('is idempotent for 0.55', () => {
+        expect((0, price_1.roundToTickSize)(0.55)).toBe(0.55);
+    });
+    it('handles floating-point drift cleanly', () => {
+        // 0.1 + 0.2 = 0.30000000000000004
+        expect((0, price_1.roundToTickSize)(0.1 + 0.2)).toBe(0.3);
+    });
+    it('honours an explicit tick-size override (0.01)', () => {
+        expect((0, price_1.roundToTickSize)(0.123, 0.01)).toBe(0.12);
+        expect((0, price_1.roundToTickSize)(0.125, 0.01)).toBe(0.13);
+    });
+});
+describe('validatePriceBounds', () => {
+    it.each([
+        price_1.POLYMARKET_US_MIN_PRICE,
+        0.5,
+        price_1.POLYMARKET_US_MAX_PRICE,
+    ])('accepts %s', (price) => {
+        expect(() => (0, price_1.validatePriceBounds)(price)).not.toThrow();
+    });
+    it.each([
+        0.0,
+        0.001,
+        1.0,
+        1.5,
+        Number.NaN,
+        Number.POSITIVE_INFINITY,
+        Number.NEGATIVE_INFINITY,
+    ])('throws RangeError for %s', (price) => {
+        expect(() => (0, price_1.validatePriceBounds)(price)).toThrow(RangeError);
+    });
+});
+describe('toLongSidePrice', () => {
+    it('returns user price unchanged for BUY_LONG', () => {
+        expect((0, price_1.toLongSidePrice)('ORDER_INTENT_BUY_LONG', 0.55)).toBe(0.55);
+    });
+    it('returns user price unchanged for SELL_LONG', () => {
+        expect((0, price_1.toLongSidePrice)('ORDER_INTENT_SELL_LONG', 0.55)).toBe(0.55);
+    });
+    it('inverts user price for BUY_SHORT', () => {
+        expect((0, price_1.toLongSidePrice)('ORDER_INTENT_BUY_SHORT', 0.4)).toBeCloseTo(0.6, 10);
+    });
+    it('inverts user price for SELL_SHORT', () => {
+        expect((0, price_1.toLongSidePrice)('ORDER_INTENT_SELL_SHORT', 0.4)).toBeCloseTo(0.6, 10);
+    });
+    it('throws on out-of-bounds input (LONG)', () => {
+        expect(() => (0, price_1.toLongSidePrice)('ORDER_INTENT_BUY_LONG', 1.5)).toThrow(RangeError);
+        expect(() => (0, price_1.toLongSidePrice)('ORDER_INTENT_BUY_LONG', 0)).toThrow(RangeError);
+    });
+    it('throws on out-of-bounds input (SHORT)', () => {
+        expect(() => (0, price_1.toLongSidePrice)('ORDER_INTENT_BUY_SHORT', 1.5)).toThrow(RangeError);
+        expect(() => (0, price_1.toLongSidePrice)('ORDER_INTENT_SELL_SHORT', 0)).toThrow(RangeError);
+    });
+    it('throws on NaN', () => {
+        expect(() => (0, price_1.toLongSidePrice)('ORDER_INTENT_BUY_LONG', Number.NaN)).toThrow(RangeError);
+    });
+});
+describe('fromLongSidePrice (round trip)', () => {
+    const intents = [
+        'ORDER_INTENT_BUY_LONG',
+        'ORDER_INTENT_SELL_LONG',
+        'ORDER_INTENT_BUY_SHORT',
+        'ORDER_INTENT_SELL_SHORT',
+    ];
+    const prices = [0.01, 0.25, 0.5, 0.75, 0.99];
+    for (const intent of intents) {
+        for (const price of prices) {
+            it(`round-trips ${price} for ${intent}`, () => {
+                const longPrice = (0, price_1.toLongSidePrice)(intent, price);
+                const userPrice = (0, price_1.fromLongSidePrice)(intent, longPrice);
+                expect(userPrice).toBeCloseTo(price, 10);
+            });
+        }
+    }
+    it('throws on out-of-bounds input', () => {
+        expect(() => (0, price_1.fromLongSidePrice)('ORDER_INTENT_BUY_LONG', 1.5)).toThrow(RangeError);
+    });
+});
+describe('toAmount', () => {
+    it('formats 0.55 to { value: "0.550", currency: "USD" } at 3-decimal precision', () => {
+        expect((0, price_1.toAmount)(0.55)).toEqual({ value: '0.550', currency: 'USD' });
+    });
+    it('keeps 0.123 as "0.123" at the default 0.001 tick', () => {
+        expect((0, price_1.toAmount)(0.123)).toEqual({ value: '0.123', currency: 'USD' });
+    });
+    it('rounds 0.1234 down to "0.123"', () => {
+        expect((0, price_1.toAmount)(0.1234)).toEqual({ value: '0.123', currency: 'USD' });
+    });
+    it('honours an explicit 0.01 tick override', () => {
+        expect((0, price_1.toAmount)(0.123, 0.01)).toEqual({ value: '0.120', currency: 'USD' });
+    });
+    it('throws for 0.0 (below min)', () => {
+        expect(() => (0, price_1.toAmount)(0.0)).toThrow(RangeError);
+    });
+    it('throws for 1.0 (above max)', () => {
+        expect(() => (0, price_1.toAmount)(1.0)).toThrow(RangeError);
+    });
+    it('throws for NaN', () => {
+        expect(() => (0, price_1.toAmount)(Number.NaN)).toThrow(RangeError);
+    });
+    it('throws for Infinity', () => {
+        expect(() => (0, price_1.toAmount)(Number.POSITIVE_INFINITY)).toThrow(RangeError);
+    });
+});
+describe('fromAmount', () => {
+    it('parses { value: "0.550" } to 0.55', () => {
+        expect((0, price_1.fromAmount)({ value: '0.550', currency: 'USD' })).toBe(0.55);
+    });
+    it('returns 0 for undefined', () => {
+        expect((0, price_1.fromAmount)(undefined)).toBe(0);
+    });
+    it('returns 0 for empty string value', () => {
+        expect((0, price_1.fromAmount)({ value: '', currency: 'USD' })).toBe(0);
+    });
+});

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

@@ -0,0 +1,39 @@
+/**
+ * Polymarket US WebSocket wrapper.
+ *
+ * Provides CCXT Pro-style `watchOrderBook()` and `watchTrades()` on top of
+ * the `polymarket-us` SDK's `MarketsWebSocket` class. Each call awaits the
+ * next matching event for the requested market slug (the last segment of a
+ * PMXT outcomeId is stripped before subscribing).
+ *
+ * Notes:
+ *   - The SDK's WebSocket factory requires `keyId` + `secretKey` even for
+ *     the public `markets()` socket, so callers must instantiate the exchange
+ *     with credentials before calling any watch method.
+ *   - Order book and trade prices are reported as LONG-SIDE prices, matching
+ *     the convention used by `normalizeOrderBook` and `normalizeOrder`.
+ */
+import type { PolymarketUS as PolymarketUSClient } from 'polymarket-us';
+import { OrderBook, Trade } from '../../types';
+import { PolymarketUSNormalizer } from './normalizer';
+export declare class PolymarketUSWebSocket {
+    private readonly client;
+    private readonly normalizer;
+    private socket;
+    private initializationPromise?;
+    private readonly bookSubscriptions;
+    private readonly tradeSubscriptions;
+    private readonly orderBookResolvers;
+    private readonly tradeResolvers;
+    constructor(client: PolymarketUSClient, normalizer: PolymarketUSNormalizer);
+    watchOrderBook(id: string): Promise<OrderBook>;
+    watchTrades(id: string): Promise<Trade[]>;
+    close(): Promise<void>;
+    private ensureInitialized;
+    private handleMarketData;
+    private handleTrade;
+    private handleError;
+    private handleClose;
+    private resolveOrderBook;
+    private rejectAllPending;
+}

package/dist/exchanges/polymarket_us/websocket.js

@@ -0,0 +1,181 @@
+"use strict";
+/**
+ * Polymarket US WebSocket wrapper.
+ *
+ * Provides CCXT Pro-style `watchOrderBook()` and `watchTrades()` on top of
+ * the `polymarket-us` SDK's `MarketsWebSocket` class. Each call awaits the
+ * next matching event for the requested market slug (the last segment of a
+ * PMXT outcomeId is stripped before subscribing).
+ *
+ * Notes:
+ *   - The SDK's WebSocket factory requires `keyId` + `secretKey` even for
+ *     the public `markets()` socket, so callers must instantiate the exchange
+ *     with credentials before calling any watch method.
+ *   - Order book and trade prices are reported as LONG-SIDE prices, matching
+ *     the convention used by `normalizeOrderBook` and `normalizeOrder`.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PolymarketUSWebSocket = void 0;
+const price_1 = require("./price");
+function sideFromOrderSide(raw) {
+    if (raw === 'ORDER_SIDE_BUY')
+        return 'buy';
+    if (raw === 'ORDER_SIDE_SELL')
+        return 'sell';
+    return 'unknown';
+}
+function parseTradeTimeMs(value) {
+    if (!value)
+        return Date.now();
+    const ms = new Date(value).getTime();
+    return Number.isFinite(ms) ? ms : Date.now();
+}
+/**
+ * Strip a trailing `:long` or `:short` from a PMXT identifier to recover
+ * the bare Polymarket US market slug.
+ */
+function slugFromId(id) {
+    if (id.endsWith(':long'))
+        return id.slice(0, -':long'.length);
+    if (id.endsWith(':short'))
+        return id.slice(0, -':short'.length);
+    return id;
+}
+class PolymarketUSWebSocket {
+    client;
+    normalizer;
+    socket = null;
+    initializationPromise;
+    bookSubscriptions = new Set();
+    tradeSubscriptions = new Set();
+    orderBookResolvers = new Map();
+    tradeResolvers = new Map();
+    constructor(client, normalizer) {
+        this.client = client;
+        this.normalizer = normalizer;
+    }
+    async watchOrderBook(id) {
+        const slug = slugFromId(id);
+        await this.ensureInitialized();
+        if (!this.bookSubscriptions.has(slug)) {
+            this.bookSubscriptions.add(slug);
+            this.socket.subscribeMarketData(`book:${slug}`, [slug]);
+        }
+        return new Promise((resolve, reject) => {
+            const queue = this.orderBookResolvers.get(slug) ?? [];
+            queue.push({ resolve, reject });
+            this.orderBookResolvers.set(slug, queue);
+        });
+    }
+    async watchTrades(id) {
+        const slug = slugFromId(id);
+        await this.ensureInitialized();
+        if (!this.tradeSubscriptions.has(slug)) {
+            this.tradeSubscriptions.add(slug);
+            this.socket.subscribeTrades(`trade:${slug}`, [slug]);
+        }
+        return new Promise((resolve, reject) => {
+            const queue = this.tradeResolvers.get(slug) ?? [];
+            queue.push({ resolve, reject });
+            this.tradeResolvers.set(slug, queue);
+        });
+    }
+    async close() {
+        if (this.socket) {
+            try {
+                this.socket.close();
+            }
+            catch {
+                // Ignore close errors.
+            }
+            this.socket = null;
+        }
+        this.bookSubscriptions.clear();
+        this.tradeSubscriptions.clear();
+        this.rejectAllPending(new Error('PolymarketUS WebSocket closed'));
+        this.initializationPromise = undefined;
+    }
+    async ensureInitialized() {
+        if (this.initializationPromise)
+            return this.initializationPromise;
+        this.initializationPromise = (async () => {
+            const socket = this.client.ws.markets();
+            socket.on('marketData', (msg) => this.handleMarketData(msg));
+            socket.on('trade', (msg) => this.handleTrade(msg));
+            socket.on('error', (err) => this.handleError(err));
+            socket.on('close', () => this.handleClose());
+            await socket.connect();
+            this.socket = socket;
+        })();
+        try {
+            await this.initializationPromise;
+        }
+        catch (err) {
+            this.initializationPromise = undefined;
+            throw err;
+        }
+    }
+    handleMarketData(msg) {
+        const payload = msg.marketData;
+        if (!payload)
+            return;
+        const slug = payload.marketSlug;
+        // The WS MarketData payload shape is structurally compatible with
+        // the REST MarketBook shape used by normalizeOrderBook.
+        const book = this.normalizer.normalizeOrderBook(payload, slug);
+        this.resolveOrderBook(slug, book);
+    }
+    handleTrade(msg) {
+        const payload = msg.trade;
+        if (!payload)
+            return;
+        const slug = payload.marketSlug;
+        const timestamp = parseTradeTimeMs(payload.tradeTime);
+        const priceValue = payload.price?.value ?? '0';
+        const trade = {
+            id: `${slug}-${timestamp}-${priceValue}`,
+            timestamp,
+            price: (0, price_1.fromAmount)(payload.price),
+            amount: (0, price_1.fromAmount)(payload.quantity),
+            side: sideFromOrderSide(payload.taker?.side),
+        };
+        const queue = this.tradeResolvers.get(slug);
+        if (queue && queue.length > 0) {
+            for (const { resolve } of queue)
+                resolve([trade]);
+            this.tradeResolvers.set(slug, []);
+        }
+    }
+    handleError(err) {
+        // Surface the error to any waiting callers rather than losing it.
+        this.rejectAllPending(err);
+    }
+    handleClose() {
+        this.rejectAllPending(new Error('PolymarketUS WebSocket closed'));
+        this.socket = null;
+        this.initializationPromise = undefined;
+        this.bookSubscriptions.clear();
+        this.tradeSubscriptions.clear();
+    }
+    resolveOrderBook(slug, book) {
+        const queue = this.orderBookResolvers.get(slug);
+        if (queue && queue.length > 0) {
+            for (const { resolve } of queue)
+                resolve(book);
+            this.orderBookResolvers.set(slug, []);
+        }
+    }
+    rejectAllPending(err) {
+        for (const queue of this.orderBookResolvers.values()) {
+            for (const { reject } of queue)
+                reject(err);
+        }
+        this.orderBookResolvers.clear();
+        for (const queue of this.tradeResolvers.values()) {
+            for (const { reject } of queue)
+                reject(err);
+        }
+        this.tradeResolvers.clear();
+    }
+}
+exports.PolymarketUSWebSocket = PolymarketUSWebSocket;

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

@@ -0,0 +1,8 @@
+/**
+ * Unit tests for PolymarketUSWebSocket.
+ *
+ * The polymarket-us SDK is fully stubbed here so the tests run without
+ * touching the network. A fake MarketsWebSocket captures subscriptions
+ * and lets each test fire synthetic messages through a listener map.
+ */
+export {};