release: 2.50.2 — Rain works in both SDKs + restore hosted submitOrder

Three fixes that together make Rain usable from pmxtjs and pmxt-py:
1. Function-wrap ESM import() to defeat tsc's commonjs downlevel
2. Stringify bigints in sourceMetadata before HTTP serialisation
3. Restore _hostedSubmitOrder helper that PR #1058 orphaned

(3) was a pre-existing regression on main that broke hosted createOrder
for every venue, not just Rain.

Author: realfishsam

changelog.md

@@ -2,6 +2,16 @@
 
 All notable changes to this project will be documented in this file.
 
+## [2.50.2] - 2026-06-15
+
+Rain now actually works end-to-end through both `pmxtjs` and the Python SDK, and restores hosted-mode `createOrder` for every other venue (`polymarket`, `opinion`, `limitless`) which had been broken on `main` since PR #1058. Verified live: `new pmxt.Rain().fetchMarkets({ limit: 3 })` and `Rain().fetch_markets(limit=3)` both round-trip real markets (Khamenei binary, Bond actor 6-way, FIFA 16-way) through the sidecar.
+
+### Fixed
+
+- **`core/src/exchanges/rain/fetcher.ts` + `core/src/exchanges/rain/websocket.ts`**: `@buidlrrr/rain-sdk` is ESM-only (`"type": "module"`, no CJS export) and `tsc` with `module: "commonjs"` silently rewrites `await import('@buidlrrr/rain-sdk')` into `Promise.resolve().then(() => require('@buidlrrr/rain-sdk'))`, which throws `ERR_PACKAGE_PATH_NOT_EXPORTED` at runtime. Wrapping the loader in `new Function('return import("@buidlrrr/rain-sdk")')` keeps the real ESM `import()` opaque to the downleveller, so Node executes it natively. The same trap applies to the Opinion adapter on paper; its read path appears to escape it via existing bundling, but the Rain path lit it up because the trade-tx builders are called from the cold server start.
+- **`core/src/exchanges/rain/utils.ts` + `core/src/exchanges/rain/normalizer.ts`**: New `bigintsToStrings()` recursive converter is applied to the spread that feeds `buildSourceMetadata`. Rain's `MarketDetails` carries `bigint` for `startTime`, `endTime`, `oracleEndTime`, `allFunds`, `allVotes`, `totalLiquidity`, `numberOfOptions`, `winner`, `baseTokenDecimals`, etc., and the PMXT sidecar `JSON.stringify`s the response over HTTP — the unconverted spread threw "Do not know how to serialize a BigInt" and dropped every Rain market on the floor before it reached the SDKs.
+- **`sdks/typescript/pmxt/client.ts`**: Restored `_hostedSubmitOrder` (typed-data sign + economic validation + `/v0/trade/submit-order` POST) and `_hostedTypedDataRoute` / `_hostedCancelTypedDataRoute` helpers. PR #1058 (Limitless hosted wire-up, commit `e96801b`) removed all three methods but left their call sites and signing imports intact; this made `npx tsc` fail with `TS2551: Property '_hostedSubmitOrder' does not exist on type 'Exchange'` and silently broke hosted-mode `createOrder` on every venue at runtime (it would have thrown "this._hostedSubmitOrder is not a function" the moment a hosted user placed an order). The restored helper now also routes `limitless` through `limitless_buy` / `limitless_sell_polygon` / `limitless_sell_base_pull` / `cancel_limitless_*` schemas, matching the PR's stated scope.
+
 ## [2.50.1] - 2026-06-15
 
 Follow-up to 2.50.0. Rain is now wired through every consumer surface — the openapi enum source, the TS SDK class export, and the Python SDK class export — so `pmxtjs.Rain` and `pmxt.Rain` (Python) actually exist instead of being missing from the published packages. The CI exchange-drift check caught this on the 2.50.0 push; `ADDING_AN_EXCHANGE.md` only documents the core-server registration sites, not these SDK-facing ones.

core/src/exchanges/rain/fetcher.ts

@@ -5,13 +5,21 @@
 import { rainErrorMapper } from './errors';
 import { logger } from '../../utils/logger';
 
-// ESM dynamic import (same pattern as Opinion adapter).
+// @buidlrrr/rain-sdk is ESM-only. TSC with module:"commonjs" rewrites a plain
+// `await import(...)` to `Promise.resolve().then(() => require(...))`, which
+// blows up at runtime on `"type": "module"` packages with no CJS export
+// (`ERR_PACKAGE_PATH_NOT_EXPORTED`). The Function-wrapped string keeps the
+// real ESM `import()` opaque to TSC's downleveller so Node executes it natively.
 type RainSdk = typeof import('@buidlrrr/rain-sdk');
 type RainClient = InstanceType<RainSdk['Rain']>;
 
+const esmImportRainSdk: () => Promise<RainSdk> = new Function(
+    'return import("@buidlrrr/rain-sdk")',
+) as () => Promise<RainSdk>;
+
 let sdkPromise: Promise<RainSdk> | undefined;
 function loadSdk(): Promise<RainSdk> {
-    if (!sdkPromise) sdkPromise = import('@buidlrrr/rain-sdk');
+    if (!sdkPromise) sdkPromise = esmImportRainSdk();
     return sdkPromise;
 }
 

core/src/exchanges/rain/normalizer.ts

@@ -9,7 +9,7 @@ import {
     RainRawBalance, RainRawPriceHistory, RainRawTransactions, RainRawMarketTransactions,
 } from './fetcher';
 import {
-    priceBigIntToNumber, weiToNumber, mapRainStatus, rainMarketUrl, USDT_DECIMALS, resolveDecimals,
+    priceBigIntToNumber, weiToNumber, mapRainStatus, rainMarketUrl, USDT_DECIMALS, resolveDecimals, bigintsToStrings,
 } from './utils';
 
 const PROMOTED_MARKET_KEYS = [
@@ -83,7 +83,7 @@ export class RainNormalizer {
             contractAddress,
             tags,
             sourceMetadata: buildSourceMetadata(
-                { ...(details ?? {}), ...m } as Record<string, unknown>,
+                bigintsToStrings({ ...(details ?? {}), ...m }) as Record<string, unknown>,
                 PROMOTED_MARKET_KEYS,
             ),
         };

core/src/exchanges/rain/utils.ts

@@ -59,3 +59,25 @@ export function mapRainStatus(status?: string): string | undefined {
 export function rainMarketUrl(marketId: string): string {
     return `https://rain.one/markets/${marketId}`;
 }
+
+/**
+ * Recursively convert bigints to strings so the value is JSON-serialisable.
+ * Rain's SDK returns bigints all over (timestamps, fund totals, prices), and
+ * the PMXT server JSON.stringifies sourceMetadata before returning over HTTP.
+ */
+export function bigintsToStrings<T>(value: T): T {
+    if (typeof value === 'bigint') {
+        return value.toString() as unknown as T;
+    }
+    if (Array.isArray(value)) {
+        return value.map(bigintsToStrings) as unknown as T;
+    }
+    if (value && typeof value === 'object') {
+        const out: Record<string, unknown> = {};
+        for (const [k, v] of Object.entries(value as Record<string, unknown>)) {
+            out[k] = bigintsToStrings(v);
+        }
+        return out as T;
+    }
+    return value;
+}

core/src/exchanges/rain/websocket.ts

@@ -9,6 +9,11 @@ type RainSdk = typeof import('@buidlrrr/rain-sdk');
 type RainClient = InstanceType<RainSdk['Rain']>;
 type Unsubscribe = () => void;
 
+// See note in fetcher.ts on why we Function-wrap the import().
+const esmImportRainSdk: () => Promise<RainSdk> = new Function(
+    'return import("@buidlrrr/rain-sdk")',
+) as () => Promise<RainSdk>;
+
 export interface RainWebSocketConfig {
     wsRpcUrl: string;
     environment?: 'development' | 'stage' | 'production';
@@ -26,7 +31,7 @@ export class RainWebSocket {
 
     private async getClient(): Promise<RainClient> {
         if (!this.client) {
-            const sdk = await import('@buidlrrr/rain-sdk');
+            const sdk = await esmImportRainSdk();
             this.client = new sdk.Rain({
                 environment: this.config.environment ?? 'production',
                 wsRpcUrl: this.config.wsRpcUrl,

sdks/typescript/pmxt/client.ts

@@ -2237,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