pmxtjs 2.49.10 → 2.50.2

package/pmxt/client.ts

@@ -46,6 +46,7 @@ import {
     UnifiedSeries,
     UserTrade,
     FirehoseEvent,
+    FetchMatchedMarketClustersParams,
 } from "./models.js";
 
 import { ServerManager } from "./server-manager.js";
@@ -1131,9 +1132,6 @@ export abstract class Exchange {
     }
 
     async submitOrder(built: BuiltOrder): Promise<Order> {
-        if (this.isHostedTradingMode()) {
-            return this._hostedSubmitOrder(built);
-        }
         await this.initPromise;
         if (this.isHosted) {
             throw new PmxtError("submitOrder is not available in hosted mode. Use createOrder instead.");
@@ -1162,88 +1160,7 @@ export abstract class Exchange {
         }
     }
 
-    /**
-     * Hosted-mode submitOrder: validate the stored build response, sign the
-     * typed_data (and pull_typed_data for Opinion cross-chain sells), then
-     * POST to `/v0/trade/submit-order`.
-     */
-    private async _hostedSubmitOrder(built: BuiltOrder): Promise<Order> {
-        const signer = this.requireHostedSigner();
-        if (!this.walletAddress) {
-            throw new MissingWalletAddress(
-                "hosted submitOrder requires walletAddress",
-            );
-        }
-        // BuiltOrder is the SDK-side wrapper around the build response —
-        // expect typed_data, optional pull_typed_data, built_order_id, and
-        // the originating build_request to be present.
-        const payload = built as unknown as Record<string, unknown>;
-        const typedData = payload["typed_data"] as TypedData | undefined;
-        if (!typedData) {
-            throw new HostedInvalidSignature(0, "typed_data missing from built order");
-        }
-        const buildRequest = (payload["build_request"] as Record<string, unknown> | undefined)
-            ?? ((payload["params"] as Record<string, unknown> | undefined)?.["build_request"] as Record<string, unknown> | undefined);
-
-        const side = String(buildRequest?.["side"] ?? "buy");
-        const primaryRoute = this._hostedTypedDataRoute(side, false);
-        // Layer 1: schema, Layer 2: economics.
-        validateTypedData(typedData, primaryRoute, this.walletAddress);
-        if (buildRequest) {
-            validateEconomics(typedData, primaryRoute, buildRequest, payload);
-        }
-
-        const signature = await signer.signTypedData(typedData);
-        // Layer 3: post-sign recovery + canonical check.
-        verifySignature(typedData, signature, signer.address);
-
-        const body: Record<string, unknown> = {
-            built_order_id: payload["built_order_id"],
-            signature,
-        };
-
-        const pullTypedData = payload["pull_typed_data"] as TypedData | undefined;
-        if (pullTypedData) {
-            const pullRoute = this._hostedTypedDataRoute(side, true);
-            if (pullRoute) {
-                validateTypedData(pullTypedData, pullRoute, this.walletAddress);
-            }
-            const pullSig = await signer.signTypedData(pullTypedData);
-            verifySignature(pullTypedData, pullSig, signer.address);
-            body["pull_signature"] = pullSig;
-        }
-
-        const route = HOSTED_METHOD_ROUTES.get("submitOrder")!;
-        const data = await _tradingRequest(this, { method: route.method, path: route.path, body });
-        return orderFromV0(data as Record<string, unknown>);
-    }
-
-    /**
-     * Resolve the per-(venue, side, pull) typed-data schema route used by
-     * `validateTypedData` / `validateEconomics`. Returns undefined for the
-     * pull leg when a venue/side combo doesn't have one.
-     */
-    private _hostedTypedDataRoute(side: string, isPull: boolean): string {
-        const venue = this.exchangeName;
-        const sideLower = side.toLowerCase();
-        if (venue === "polymarket") {
-            return sideLower === "sell" ? "polymarket_sell" : "polymarket_buy";
-        }
-        // opinion
-        if (sideLower === "buy") return "opinion_buy";
-        // sell — polygon, or BSC pull leg for cross-chain
-        return isPull ? "opinion_sell_bsc_pull" : "opinion_sell_polygon";
-    }
-
-    private _hostedCancelTypedDataRoute(isPull: boolean): string {
-        if (this.exchangeName === "polymarket") return "cancel_polymarket";
-        return isPull ? "cancel_opinion_bsc_pull" : "cancel_opinion_polygon";
-    }
-
     async cancelOrder(orderId: string): Promise<Order> {
-        if (this.isHostedTradingMode()) {
-            return this._hostedCancelOrder(orderId);
-        }
         await this.initPromise;
         try {
             const args: any[] = [];
@@ -1269,56 +1186,7 @@ export abstract class Exchange {
         }
     }
 
-    /**
-     * Hosted-mode cancelOrder: build the cancel typed_data on the server,
-     * validate + sign (dual-sign for Opinion cross-chain), then submit.
-     */
-    private async _hostedCancelOrder(orderId: string): Promise<Order> {
-        const signer = this.requireHostedSigner();
-        if (!this.walletAddress) {
-            throw new MissingWalletAddress(
-                "hosted cancelOrder requires walletAddress",
-            );
-        }
-
-        const buildRoute = HOSTED_METHOD_ROUTES.get("cancelOrderBuild")!;
-        const buildResp = await _tradingRequest(this, {
-            method: buildRoute.method,
-            path: buildRoute.path,
-            body: { order_id: orderId },
-        }) as Record<string, unknown>;
-
-        const typedData = buildResp["typed_data"] as TypedData | undefined;
-        if (!typedData) {
-            throw new HostedInvalidSignature(0, "typed_data missing from cancel build response");
-        }
-
-        validateTypedData(typedData, this._hostedCancelTypedDataRoute(false), this.walletAddress);
-        const signature = await signer.signTypedData(typedData);
-        verifySignature(typedData, signature, signer.address);
-
-        const body: Record<string, unknown> = {
-            cancel_id: buildResp["cancel_id"],
-            signature,
-        };
-
-        const pullTypedData = buildResp["pull_typed_data"] as TypedData | undefined;
-        if (pullTypedData) {
-            validateTypedData(pullTypedData, this._hostedCancelTypedDataRoute(true), this.walletAddress);
-            const pullSig = await signer.signTypedData(pullTypedData);
-            verifySignature(pullTypedData, pullSig, signer.address);
-            body["pull_signature"] = pullSig;
-        }
-
-        const route = HOSTED_METHOD_ROUTES.get("cancelOrder")!;
-        const data = await _tradingRequest(this, { method: route.method, path: route.path, body });
-        return orderFromV0(data as Record<string, unknown>);
-    }
-
     async fetchOrder(orderId: string): Promise<Order> {
-        if (this.isHostedTradingMode()) {
-            return this._hostedFetchOrder(orderId);
-        }
         await this.initPromise;
         try {
             const args: any[] = [];
@@ -1344,17 +1212,7 @@ export abstract class Exchange {
         }
     }
 
-    private async _hostedFetchOrder(orderId: string): Promise<Order> {
-        const route = HOSTED_METHOD_ROUTES.get("fetchOrder")!;
-        const path = formatRoutePath(route, { order_id: orderId });
-        const data = await _tradingRequest(this, { method: route.method, path });
-        return orderFromV0(data as Record<string, unknown>);
-    }
-
     async fetchOpenOrders(marketId?: string): Promise<Order[]> {
-        if (this.isHostedTradingMode()) {
-            return this._hostedFetchOpenOrders(marketId);
-        }
         await this.initPromise;
         try {
             const args: any[] = [];
@@ -1380,24 +1238,7 @@ export abstract class Exchange {
         }
     }
 
-    private async _hostedFetchOpenOrders(marketId?: string): Promise<Order[]> {
-        const address = resolveWalletAddress(this, undefined);
-        const route = HOSTED_METHOD_ROUTES.get("fetchOpenOrders")!;
-        const params: Record<string, string> = { address };
-        if (marketId !== undefined) params["market_id"] = marketId;
-        const data = await _tradingRequest(this, {
-            method: route.method,
-            path: route.path,
-            params,
-        });
-        const items = (Array.isArray(data) ? data : (data as Record<string, unknown>)?.["orders"] ?? []) as unknown[];
-        return (items as Record<string, unknown>[]).map(orderFromV0);
-    }
-
     async fetchMyTrades(params?: MyTradesParams): Promise<UserTrade[]> {
-        if (this.isHostedTradingMode()) {
-            return this._hostedFetchMyTrades(params);
-        }
         await this.initPromise;
         try {
             const args: any[] = [];
@@ -1423,32 +1264,7 @@ export abstract class Exchange {
         }
     }
 
-    private async _hostedFetchMyTrades(params?: MyTradesParams): Promise<UserTrade[]> {
-        const address = resolveWalletAddress(this, undefined);
-        const route = HOSTED_METHOD_ROUTES.get("fetchMyTrades")!;
-        const path = formatRoutePath(route, { address });
-        const q: Record<string, string> = {};
-        if (params?.marketId) q["market_id"] = params.marketId;
-        if (params?.outcomeId) q["outcome_id"] = params.outcomeId;
-        if (params?.limit !== undefined) q["limit"] = String(params.limit);
-        if (params?.cursor) q["cursor"] = params.cursor;
-        if (params?.since) q["since"] = String(params.since.getTime());
-        if (params?.until) q["until"] = String(params.until.getTime());
-        const data = await _tradingRequest(this, {
-            method: route.method,
-            path,
-            params: Object.keys(q).length ? q : undefined,
-        });
-        const items = (Array.isArray(data) ? data : (data as Record<string, unknown>)?.["trades"] ?? []) as unknown[];
-        return (items as Record<string, unknown>[]).map(userTradeFromV0);
-    }
-
     async fetchClosedOrders(params?: OrderHistoryParams): Promise<Order[]> {
-        if (this.isHostedTradingMode()) {
-            throw new NotSupported(
-                "Settled orders are modeled as trades — use fetchMyTrades().",
-            );
-        }
         await this.initPromise;
         try {
             const args: any[] = [];
@@ -1475,11 +1291,6 @@ export abstract class Exchange {
     }
 
     async fetchAllOrders(params?: OrderHistoryParams): Promise<Order[]> {
-        if (this.isHostedTradingMode()) {
-            throw new NotSupported(
-                "Use fetchOpenOrders() and fetchMyTrades() separately.",
-            );
-        }
         await this.initPromise;
         try {
             const args: any[] = [];
@@ -1506,9 +1317,6 @@ export abstract class Exchange {
     }
 
     async fetchPositions(address?: string): Promise<Position[]> {
-        if (this.isHostedTradingMode()) {
-            return this._hostedFetchPositions(address);
-        }
         await this.initPromise;
         try {
             const args: any[] = [];
@@ -1534,19 +1342,7 @@ export abstract class Exchange {
         }
     }
 
-    private async _hostedFetchPositions(address?: string): Promise<Position[]> {
-        const resolvedAddr = resolveWalletAddress(this, address);
-        const route = HOSTED_METHOD_ROUTES.get("fetchPositions")!;
-        const path = formatRoutePath(route, { address: resolvedAddr });
-        const data = await _tradingRequest(this, { method: route.method, path });
-        const items = (Array.isArray(data) ? data : (data as Record<string, unknown>)?.["positions"] ?? []) as unknown[];
-        return (items as Record<string, unknown>[]).map(positionFromV0);
-    }
-
     async fetchBalance(address?: string): Promise<Balance[]> {
-        if (this.isHostedTradingMode()) {
-            return this._hostedFetchBalance(address);
-        }
         await this.initPromise;
         try {
             const args: any[] = [];
@@ -1572,19 +1368,6 @@ export abstract class Exchange {
         }
     }
 
-    private async _hostedFetchBalance(address?: string): Promise<Balance[]> {
-        const resolvedAddr = resolveWalletAddress(this, address);
-        const route = HOSTED_METHOD_ROUTES.get("fetchBalance")!;
-        const path = formatRoutePath(route, { address: resolvedAddr });
-        const data = await _tradingRequest(this, { method: route.method, path });
-        // Hosted balance is a single USDC escrow record; wrap in an array
-        // to match the existing Balance[] return shape.
-        if (Array.isArray(data)) {
-            return (data as Record<string, unknown>[]).map(balanceFromV0);
-        }
-        return [balanceFromV0(data as Record<string, unknown>)];
-    }
-
     async unwatchOrderBook(outcomeId: string | MarketOutcome): Promise<void> {
         await this.initPromise;
         try {
@@ -1784,7 +1567,7 @@ export abstract class Exchange {
         }
     }
 
-    async fetchMatchedMarkets(params?: any): Promise<any[]> {
+    async fetchMatchedMarkets(params?: FetchMatchedMarketClustersParams): Promise<any[]> {
         await this.initPromise;
         try {
             const args: any[] = [];
@@ -2322,6 +2105,15 @@ export abstract class Exchange {
             if (params.fee !== undefined) {
                 paramsDict.fee = params.fee;
             }
+            if (params.tickSize !== undefined) {
+                paramsDict.tickSize = params.tickSize;
+            }
+            if (params.negRisk !== undefined) {
+                paramsDict.negRisk = params.negRisk;
+            }
+            if (params.onBehalfOf !== undefined) {
+                paramsDict.onBehalfOf = params.onBehalfOf;
+            }
 
             const response = await this.fetchWithRetry(`${this.resolveBaseUrl()}/api/${this.exchangeName}/buildOrder`, {
                 method: 'POST',
@@ -2445,6 +2237,87 @@ export abstract class Exchange {
         return this._hostedSubmitOrder(built);
     }
 
+    /**
+     * Hosted-mode submitOrder: validate the stored build response, sign the
+     * typed_data (and pull_typed_data for cross-chain venue sells), then
+     * POST to `/v0/trade/submit-order`.
+     *
+     * Restored after PR #1058 (Limitless hosted wire-up) accidentally
+     * removed it but left the call site + signing imports intact.
+     */
+    private async _hostedSubmitOrder(built: BuiltOrder): Promise<Order> {
+        const signer = this.requireHostedSigner();
+        if (!this.walletAddress) {
+            throw new MissingWalletAddress(
+                "hosted submitOrder requires walletAddress",
+            );
+        }
+        const payload = built as unknown as Record<string, unknown>;
+        const typedData = payload["typed_data"] as TypedData | undefined;
+        if (!typedData) {
+            throw new HostedInvalidSignature(0, "typed_data missing from built order");
+        }
+        const buildRequest = (payload["build_request"] as Record<string, unknown> | undefined)
+            ?? ((payload["params"] as Record<string, unknown> | undefined)?.["build_request"] as Record<string, unknown> | undefined);
+
+        const side = String(buildRequest?.["side"] ?? "buy");
+        const primaryRoute = this._hostedTypedDataRoute(side, false);
+        validateTypedData(typedData, primaryRoute, this.walletAddress);
+        if (buildRequest) {
+            validateEconomics(typedData, primaryRoute, buildRequest, payload);
+        }
+
+        const signature = await signer.signTypedData(typedData);
+        verifySignature(typedData, signature, signer.address);
+
+        const body: Record<string, unknown> = {
+            built_order_id: payload["built_order_id"],
+            signature,
+        };
+
+        const pullTypedData = payload["pull_typed_data"] as TypedData | undefined;
+        if (pullTypedData) {
+            const pullRoute = this._hostedTypedDataRoute(side, true);
+            if (pullRoute) {
+                validateTypedData(pullTypedData, pullRoute, this.walletAddress);
+            }
+            const pullSig = await signer.signTypedData(pullTypedData);
+            verifySignature(pullTypedData, pullSig, signer.address);
+            body["pull_signature"] = pullSig;
+        }
+
+        const route = HOSTED_METHOD_ROUTES.get("submitOrder")!;
+        const data = await _tradingRequest(this, { method: route.method, path: route.path, body });
+        return orderFromV0(data as Record<string, unknown>);
+    }
+
+    /**
+     * Resolve the per-(venue, side, pull) typed-data schema route used by
+     * `validateTypedData` / `validateEconomics`. Returns the cross-chain
+     * pull-leg route name for Opinion sells and Limitless cross-chain orders.
+     */
+    private _hostedTypedDataRoute(side: string, isPull: boolean): string {
+        const venue = this.exchangeName;
+        const sideLower = side.toLowerCase();
+        if (venue === "polymarket") {
+            return sideLower === "sell" ? "polymarket_sell" : "polymarket_buy";
+        }
+        if (venue === "limitless") {
+            if (sideLower === "buy") return "limitless_buy";
+            return isPull ? "limitless_sell_base_pull" : "limitless_sell_polygon";
+        }
+        // opinion
+        if (sideLower === "buy") return "opinion_buy";
+        return isPull ? "opinion_sell_bsc_pull" : "opinion_sell_polygon";
+    }
+
+    private _hostedCancelTypedDataRoute(isPull: boolean): string {
+        const venue = this.exchangeName;
+        if (venue === "polymarket") return "cancel_polymarket";
+        if (venue === "limitless") return isPull ? "cancel_limitless_base_pull" : "cancel_limitless_polygon";
+        return isPull ? "cancel_opinion_bsc_pull" : "cancel_opinion_polygon";
+    }
+
     /**
      * Construct the hosted build-order request body and validate inputs
      * locally per the v0 contract (denom/side compatibility, > 6-decimal
@@ -2624,6 +2497,15 @@ export abstract class Exchange {
             if (params.fee !== undefined) {
                 paramsDict.fee = params.fee;
             }
+            if (params.tickSize !== undefined) {
+                paramsDict.tickSize = params.tickSize;
+            }
+            if (params.negRisk !== undefined) {
+                paramsDict.negRisk = params.negRisk;
+            }
+            if (params.onBehalfOf !== undefined) {
+                paramsDict.onBehalfOf = params.onBehalfOf;
+            }
 
             const response = await this.fetchWithRetry(`${this.resolveBaseUrl()}/api/${this.exchangeName}/createOrder`, {
                 method: 'POST',
@@ -3373,6 +3255,28 @@ export class SuiBets extends Exchange {
 // Backwards-compatible casing alias matching the Python SDK export.
 export const Suibets = SuiBets;
 
+/**
+ * Rain exchange client.
+ *
+ * Rain is a permissionless AMM-plus-orderbook prediction market on Arbitrum One.
+ * Reads are unauthenticated; trading requires an EVM privateKey.
+ *
+ * @example
+ * ```typescript
+ * const rain = new Rain();
+ * const markets = await rain.fetchMarkets({ limit: 20 });
+ *
+ * // With wallet for trading
+ * const me = new Rain({ privateKey: '0x...' });
+ * await me.createOrder({ marketId, outcomeId, side: 'buy', type: 'market', amount: 10 });
+ * ```
+ */
+export class Rain extends Exchange {
+    constructor(options: ExchangeOptions = {}) {
+        super("rain", options);
+    }
+}
+
 /**
  * Mock exchange client.
  *

package/pmxt/constants.ts

@@ -80,3 +80,10 @@ export const PREFUNDED_ESCROW_ADDRESSES: ReadonlySet<string> = new Set([
  * as venue-owned escrows. Currently empty; populated as venues onboard.
  */
 export const VENUE_ESCROW_ADDRESSES: ReadonlySet<string> = new Set<string>();
+
+/**
+ * Limitless VenueEscrow contract addresses on Base (chain 8453).
+ */
+export const LIMITLESS_VENUE_ESCROW_ADDRESSES: ReadonlySet<string> = new Set([
+    "0x34c42d01aad6ded00f1a6830d90b0e9204db7855",
+]);

package/pmxt/hosted-routing.ts

@@ -24,6 +24,7 @@ export const HOSTED_TRADING_BASE_URL = "https://trade.pmxt.dev";
 export const HOSTED_TRADING_VENUES: ReadonlySet<string> = new Set([
     "polymarket",
     "opinion",
+    "limitless",
 ]);
 
 export interface HostedRoute {

package/pmxt/hosted-typed-data.ts

@@ -11,7 +11,7 @@
 
 import { InvalidSignature } from "./hosted-errors";
 import { to6dec } from "./hosted-mappers";
-import { TypedData } from "./signers";
+import { TypedData, loadEthers } from "./signers";
 
 // The constants module is updated in a parallel-agent change to add these
 // allowlists. We import them at runtime so we don't hard-fail if the change
@@ -123,10 +123,19 @@ const VENUE_DOMAIN: DomainSchema = {
     chainId: 56,
     allowlistKey: "venue",
 };
+const LIMITLESS_VENUE_DOMAIN: DomainSchema = {
+    name: "VenueEscrow",
+    version: "1",
+    chainId: 8453,
+    allowlistKey: "venue",
+};
 
 export type HostedRoute =
     | "polymarket_buy"
     | "polymarket_sell"
+    | "limitless_buy"
+    | "limitless_sell_polygon"
+    | "limitless_sell_base_pull"
     | "opinion_buy"
     | "opinion_sell_polygon"
     | "opinion_sell_bsc_pull"
@@ -142,6 +151,27 @@ const SCHEMAS: Readonly<Record<HostedRoute, TypedDataSchema>> = {
         messageKeys: messageKeysFromFields(ORDER_PARAMS_FIELDS),
         walletField: "user",
     },
+    limitless_buy: {
+        primaryType: "CrossChainOrderParams",
+        domain: PREFUNDED_DOMAIN,
+        fields: CROSS_CHAIN_ORDER_PARAMS_FIELDS,
+        messageKeys: messageKeysFromFields(CROSS_CHAIN_ORDER_PARAMS_FIELDS),
+        walletField: "user",
+    },
+    limitless_sell_polygon: {
+        primaryType: "CrossChainSellPayParams",
+        domain: PREFUNDED_DOMAIN,
+        fields: CROSS_CHAIN_SELL_PAY_PARAMS_FIELDS,
+        messageKeys: messageKeysFromFields(CROSS_CHAIN_SELL_PAY_PARAMS_FIELDS),
+        walletField: "user",
+    },
+    limitless_sell_base_pull: {
+        primaryType: "CrossChainSellPullParams",
+        domain: LIMITLESS_VENUE_DOMAIN,
+        fields: CROSS_CHAIN_SELL_PULL_PARAMS_FIELDS,
+        messageKeys: messageKeysFromFields(CROSS_CHAIN_SELL_PULL_PARAMS_FIELDS),
+        walletField: "user",
+    },
     polymarket_sell: {
         primaryType: "SellOrderParams",
         domain: PREFUNDED_DOMAIN,
@@ -508,7 +538,33 @@ function validateOpinionMarketId(
     message: Record<string, unknown>,
     buildResponse: any,
 ): void {
-    const expected = firstPresent(
+    // The current trading-API Opinion message schema does not embed
+    // opinion_market_id — the signed economic identity is the outcome
+    // tokenId. Validate that against the build response's resolved token.
+    // The legacy opinion_market_id check only applies when the message
+    // actually carries the field (older API versions).
+    const expectedToken = firstPresent(
+        getPath(buildResponse, "resolved", "token_id"),
+        getPath(buildResponse, "resolved", "tokenId"),
+        getField(buildResponse, "token_id"),
+        getField(buildResponse, "tokenId"),
+    );
+    const actualToken = firstPresent(
+        getField(message, "tokenId"),
+        getField(message, "token_id"),
+    );
+    if (actualToken === MISSING) economicFail("message.tokenId missing");
+    if (expectedToken !== MISSING && idValue(actualToken) !== idValue(expectedToken)) {
+        economicFail(`tokenId expected ${expectedToken} got ${actualToken}`);
+    }
+
+    const actualMarketId = firstPresent(
+        getField(message, "opinion_market_id"),
+        getField(message, "opinionMarketId"),
+    );
+    if (actualMarketId === MISSING) return; // current schema: tokenId-only message
+
+    const expectedMarketId = firstPresent(
         getPath(buildResponse, "resolved", "opinion_market_id"),
         getPath(buildResponse, "resolved", "opinionMarketId"),
         getField(buildResponse, "opinion_market_id"),
@@ -516,16 +572,9 @@ function validateOpinionMarketId(
         getPath(buildResponse, "params", "opinion_market_id"),
         getPath(buildResponse, "params", "opinionMarketId"),
     );
-    if (expected === MISSING) economicFail("resolved.opinion_market_id missing");
-
-    const actual = firstPresent(
-        getField(message, "opinion_market_id"),
-        getField(message, "opinionMarketId"),
-    );
-    if (actual === MISSING) economicFail("message.opinion_market_id missing");
-
-    if (idValue(actual) !== idValue(expected)) {
-        economicFail(`opinion_market_id expected ${expected} got ${actual}`);
+    if (expectedMarketId === MISSING) economicFail("resolved.opinion_market_id missing");
+    if (idValue(actualMarketId) !== idValue(expectedMarketId)) {
+        economicFail(`opinion_market_id expected ${expectedMarketId} got ${actualMarketId}`);
     }
 }
 
@@ -575,12 +624,11 @@ export function verifySignature(
 
     let ethers: any;
     try {
-        // eslint-disable-next-line @typescript-eslint/no-require-imports
-        ethers = require("ethers");
-    } catch {
+        ethers = loadEthers("ethers is required for hosted signature verification");
+    } catch (err) {
         throw new InvalidSignature(
             0,
-            "ethers is required for hosted signature verification",
+            err instanceof Error ? err.message : "ethers is required for hosted signature verification",
         );
     }
 
@@ -680,7 +728,9 @@ function allowedAddresses(
     const raw =
         key === "prefunded"
             ? (constants as any).PREFUNDED_ESCROW_ADDRESSES
-            : (constants as any).VENUE_ESCROW_ADDRESSES;
+            : chainId === 8453
+              ? (constants as any).LIMITLESS_VENUE_ESCROW_ADDRESSES
+              : (constants as any).VENUE_ESCROW_ADDRESSES;
     const list: unknown[] = [];
     if (raw == null) {
         // empty

package/pmxt/models.ts

@@ -1048,6 +1048,9 @@ export interface FetchMatchedMarketClustersParams extends MatchedClusterFilterPa
     url?: string;
 }
 
+// Alias for SDK consistency with Python
+export type MatchedMarketClusterParams = FetchMatchedMarketClustersParams;
+
 /** Parameters for fetching matched event clusters. */
 export interface FetchMatchedEventClustersParams extends MatchedClusterFilterParams {
     /** Pass a UnifiedEvent directly instead of eventId/slug/url. */

package/pmxt/router.ts

@@ -13,6 +13,7 @@ import {
     EventMatchResult,
     FetchMatchedEventClustersParams,
     FetchMatchedMarketClustersParams,
+    MatchedMarketClusterParams,
     MatchedEventCluster,
     MatchedMarketCluster,
     PriceComparison,
@@ -21,6 +22,15 @@ import {
     UnifiedEvent,
 } from "./models.js";
 
+function withQuestionAlias<T extends UnifiedMarket>(market: T): T {
+    Object.defineProperty(market, 'question', {
+        get() { return this.title; },
+        enumerable: false,
+        configurable: true,
+    });
+    return market;
+}
+
 function convertMarket(raw: any): UnifiedMarket {
     const outcomes = (raw.outcomes || []).map((o: any) => ({
         outcomeId: o.outcomeId,
@@ -44,7 +54,7 @@ function convertMarket(raw: any): UnifiedMarket {
         metadata: o.metadata,
     }) : undefined;
 
-    return {
+    return withQuestionAlias({
         marketId: raw.marketId,
         title: raw.title,
         slug: raw.slug,
@@ -68,7 +78,7 @@ function convertMarket(raw: any): UnifiedMarket {
         no: convertOutcome(raw.no),
         up: convertOutcome(raw.up),
         down: convertOutcome(raw.down),
-    };
+    });
 }
 
 function convertEvent(raw: any): UnifiedEvent {
@@ -91,7 +101,7 @@ function convertEvent(raw: any): UnifiedEvent {
 function parseMatchResult(raw: any): MatchResult {
     const marketData = raw.market || {};
     const market = convertMarket(marketData);
-    return {
+    const result: MatchResult = {
         ...market,
         market,
         relation: raw.relation || 'identity',
@@ -101,6 +111,7 @@ function parseMatchResult(raw: any): MatchResult {
         bestAsk: raw.bestAsk ?? marketData.bestAsk,
         sourceMarket: raw.sourceMarket ? convertMarket(raw.sourceMarket) : undefined,
     };
+    return withQuestionAlias(result);
 }
 
 function normalizeQueryValue(value: unknown): unknown {