pmxt-core 2.49.11 → 2.50.2

package/dist/exchanges/rain/normalizer.js

@@ -0,0 +1,289 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RainNormalizer = void 0;
+const market_utils_1 = require("../../utils/market-utils");
+const metadata_1 = require("../../utils/metadata");
+const utils_1 = require("./utils");
+const PROMOTED_MARKET_KEYS = [
+    'id', 'title', 'status', 'contractAddress', 'totalVolume', 'options',
+    'totalLiquidity', 'startTime', 'endTime', 'baseToken', 'baseTokenDecimals',
+];
+const PROMOTED_EVENT_KEYS = ['id', 'title', 'options'];
+class RainNormalizer {
+    /**
+     * One Rain market with N options -> one UnifiedMarket when N<=2 (binary),
+     * or one UnifiedEvent with N synthetic binary UnifiedMarkets when N>2.
+     * The list-shape returns UnifiedMarket[]; callers wanting event grouping
+     * should call normalizeEvent.
+     */
+    normalizeMarket(raw) {
+        if (!raw?.market)
+            return null;
+        const { details } = raw;
+        const m = raw.market;
+        const marketId = (m._id ?? m.id);
+        if (!marketId)
+            return null;
+        const decimals = (0, utils_1.resolveDecimals)(details?.baseTokenDecimals ?? m.token?.tokenDecimals, utils_1.USDT_DECIMALS);
+        const contractAddress = (details?.contractAddress ?? m.contractAddress);
+        const title = (m.question ?? m.title ?? details?.title ?? '');
+        const tags = (m.tags ?? []);
+        // Outcomes: prefer on-chain (details.options with 1e18 currentPrice);
+        // fall back to the list-shape options (percentage 0-100).
+        const detailOpts = details?.options ?? [];
+        const listOpts = (m.options ?? []);
+        const outcomes = detailOpts.length
+            ? detailOpts.map((o) => ({
+                outcomeId: `rain:${marketId}:${o.choiceIndex}`,
+                marketId: `rain:${marketId}`,
+                label: o.optionName,
+                price: (0, utils_1.priceBigIntToNumber)(o.currentPrice),
+            }))
+            : listOpts.map((o) => ({
+                outcomeId: `rain:${marketId}:${o.choiceIndex}`,
+                marketId: `rain:${marketId}`,
+                label: o.optionName,
+                price: Math.min(1, Math.max(0, Number(o.percentage ?? 0) / 100)),
+            }));
+        const volume = details?.allFunds != null
+            ? (0, utils_1.weiToNumber)(details.allFunds, decimals)
+            : Number(m.totalVolumeUSD ?? m.totalVolume ?? 0);
+        const liquidity = details?.totalLiquidity != null
+            ? (0, utils_1.weiToNumber)(details.totalLiquidity, decimals)
+            : Number(m.totalLiquidityUSD ?? m.totalLiquidity ?? 0);
+        const endDate = details?.endTime
+            ? new Date(Number(details.endTime) * 1000)
+            : (m.endDate ? new Date(m.endDate) : undefined);
+        const um = {
+            marketId: `rain:${marketId}`,
+            title,
+            description: '',
+            outcomes,
+            resolutionDate: endDate,
+            volume24h: 0,
+            volume,
+            liquidity,
+            url: (0, utils_1.rainMarketUrl)(marketId),
+            status: (0, utils_1.mapRainStatus)((m.status ?? details?.status)),
+            contractAddress,
+            tags,
+            sourceMetadata: (0, metadata_1.buildSourceMetadata)((0, utils_1.bigintsToStrings)({ ...(details ?? {}), ...m }), PROMOTED_MARKET_KEYS),
+        };
+        (0, market_utils_1.addBinaryOutcomes)(um);
+        return um;
+    }
+    /**
+     * Rain market -> UnifiedEvent. Multi-option markets are expanded into
+     * one synthetic binary market per option (matches Myriad/Polymarket pattern
+     * so the matching engine can find cross-venue identity matches).
+     */
+    normalizeEvent(raw) {
+        if (!raw?.market)
+            return null;
+        const { details } = raw;
+        const m = raw.market;
+        const eventId = (m._id ?? m.id);
+        if (!eventId)
+            return null;
+        const eventTitle = (m.question ?? m.title ?? details?.title ?? '');
+        const decimals = (0, utils_1.resolveDecimals)(details?.baseTokenDecimals ?? m.token?.tokenDecimals, utils_1.USDT_DECIMALS);
+        const options = details?.options?.length
+            ? details.options.map((o) => ({
+                choiceIndex: o.choiceIndex,
+                optionName: o.optionName,
+                price: (0, utils_1.priceBigIntToNumber)(o.currentPrice),
+                fundsBase: (0, utils_1.weiToNumber)(o.totalFunds, decimals),
+            }))
+            : (m.options ?? []).map((o) => ({
+                choiceIndex: o.choiceIndex,
+                optionName: o.optionName,
+                price: Math.min(1, Math.max(0, Number(o.percentage ?? 0) / 100)),
+                fundsBase: null,
+            }));
+        const markets = [];
+        const endDate = details?.endTime
+            ? new Date(Number(details.endTime) * 1000)
+            : (m.endDate ? new Date(m.endDate) : undefined);
+        const contractAddress = (details?.contractAddress ?? m.contractAddress);
+        const status = (0, utils_1.mapRainStatus)((m.status ?? details?.status));
+        const tags = (m.tags ?? []);
+        if (options.length <= 2) {
+            const um = this.normalizeMarket(raw);
+            if (um)
+                markets.push(um);
+        }
+        else {
+            for (const opt of options) {
+                const yesPrice = opt.price;
+                const syntheticOutcomes = [
+                    {
+                        outcomeId: `rain:${eventId}:${opt.choiceIndex}`,
+                        marketId: `rain:${eventId}:${opt.choiceIndex}`,
+                        label: opt.optionName,
+                        price: yesPrice,
+                    },
+                    {
+                        outcomeId: `rain:${eventId}:${opt.choiceIndex}:no`,
+                        marketId: `rain:${eventId}:${opt.choiceIndex}`,
+                        label: `Not ${opt.optionName}`,
+                        price: Math.max(0, 1 - yesPrice),
+                    },
+                ];
+                const um = {
+                    marketId: `rain:${eventId}:${opt.choiceIndex}`,
+                    eventId: `rain:${eventId}`,
+                    title: `${eventTitle} - ${opt.optionName}`,
+                    description: '',
+                    outcomes: syntheticOutcomes,
+                    resolutionDate: endDate,
+                    volume24h: 0,
+                    volume: opt.fundsBase ?? 0,
+                    liquidity: opt.fundsBase ?? 0,
+                    url: (0, utils_1.rainMarketUrl)(eventId),
+                    status,
+                    contractAddress,
+                    tags,
+                };
+                (0, market_utils_1.addBinaryOutcomes)(um);
+                markets.push(um);
+            }
+        }
+        return {
+            id: `rain:${eventId}`,
+            title: eventTitle,
+            description: '',
+            slug: eventId,
+            markets,
+            volume24h: 0,
+            volume: markets.reduce((s, mk) => s + (mk.volume ?? 0), 0),
+            url: (0, utils_1.rainMarketUrl)(eventId),
+            tags,
+            sourceMetadata: (0, metadata_1.buildSourceMetadata)({ ...(details ?? {}), ...m }, PROMOTED_EVENT_KEYS),
+        };
+    }
+    /**
+     * Single-level emulated book using AMM spot. The plan was to use
+     * getMarketLiquidity.firstBuyOrderPrice / firstSellOrderPrice for real
+     * top-of-book; left for v2 because it needs an extra on-chain read per
+     * call. ponytail: 1-level AMM book is what Myriad ships and matches the
+     * router's expectations.
+     */
+    normalizeOrderBook(raw, outcomeId) {
+        const parts = outcomeId.split(':');
+        const choiceIndex = parts.length >= 3 ? Number(parts[2]) : NaN;
+        const isSyntheticNo = parts.length >= 4 && parts[3] === 'no';
+        const options = raw.details?.options ?? [];
+        if (!options.length || isNaN(choiceIndex)) {
+            return { bids: [], asks: [], timestamp: Date.now() };
+        }
+        const option = options.find((o) => o.choiceIndex === choiceIndex);
+        if (!option)
+            return { bids: [], asks: [], timestamp: Date.now() };
+        let price = (0, utils_1.priceBigIntToNumber)(option.currentPrice);
+        if (isSyntheticNo)
+            price = Math.max(0, 1 - price);
+        const decimals = (0, utils_1.resolveDecimals)(raw.details?.baseTokenDecimals, utils_1.USDT_DECIMALS);
+        const liquidity = raw.details?.totalLiquidity ? (0, utils_1.weiToNumber)(raw.details.totalLiquidity, decimals) : 0;
+        const size = liquidity > 0 ? liquidity : 1;
+        return {
+            bids: [{ price, size }],
+            asks: [{ price, size }],
+            timestamp: Date.now(),
+        };
+    }
+    normalizeOHLCV(raw, limit) {
+        if (!raw?.candles?.length)
+            return [];
+        const candles = raw.candles.map((c) => ({
+            timestamp: Number(c.timestamp) * 1000,
+            open: (0, utils_1.priceBigIntToNumber)(c.open),
+            high: (0, utils_1.priceBigIntToNumber)(c.high),
+            low: (0, utils_1.priceBigIntToNumber)(c.low),
+            close: (0, utils_1.priceBigIntToNumber)(c.close),
+            volume: (0, utils_1.weiToNumber)(c.volume),
+        }));
+        return limit && candles.length > limit ? candles.slice(-limit) : candles;
+    }
+    /** Map Rain SDK price-history intervals onto PMXT CandleInterval strings. */
+    static mapInterval(resolution) {
+        switch (resolution) {
+            case '1m': return '1m';
+            case '5m': return '5m';
+            case '15m': return '15m';
+            case '1h': return '1h';
+            case '4h': return '4h';
+            case '1d': return '1d';
+            case '1w': return '1w';
+            default: return '1h';
+        }
+    }
+    normalizeMarketTrades(raw) {
+        if (!raw?.transactions?.length)
+            return [];
+        return raw.transactions
+            .filter((t) => t.type === 'buy' || t.type === 'limit_buy_filled' || t.type === 'limit_sell_filled')
+            .map((t, i) => ({
+            id: t.transactionHash ?? `${t.blockNumber}-${i}`,
+            timestamp: Number(t.timestamp) * 1000,
+            price: (0, utils_1.priceBigIntToNumber)(t.price),
+            amount: t.optionAmount ? (0, utils_1.weiToNumber)(t.optionAmount) : 0,
+            side: t.type === 'buy' || t.type === 'limit_buy_filled' ? 'buy' : 'sell',
+        }));
+    }
+    normalizeUserTrades(raw) {
+        if (!raw?.transactions?.length)
+            return [];
+        return raw.transactions
+            .filter((t) => t.type === 'buy' || t.type === 'limit_buy_filled' || t.type === 'limit_sell_filled')
+            .map((t, i) => ({
+            id: t.transactionHash ?? `${t.blockNumber}-${i}`,
+            timestamp: Number(t.timestamp) * 1000,
+            price: (0, utils_1.priceBigIntToNumber)(t.price),
+            amount: t.optionAmount ? (0, utils_1.weiToNumber)(t.optionAmount) : 0,
+            side: t.type === 'buy' || t.type === 'limit_buy_filled' ? 'buy' : 'sell',
+        }));
+    }
+    normalizePositions(raw) {
+        const out = [];
+        for (const m of raw?.markets ?? []) {
+            for (const opt of m.options ?? []) {
+                const shares = (0, utils_1.weiToNumber)(opt.shares);
+                if (shares === 0)
+                    continue;
+                out.push({
+                    marketId: `rain:${m.marketId}`,
+                    outcomeId: `rain:${m.marketId}:${opt.choiceIndex}`,
+                    outcomeLabel: opt.optionName,
+                    size: shares,
+                    entryPrice: undefined,
+                    currentPrice: (0, utils_1.priceBigIntToNumber)(opt.currentPrice),
+                    currentValue: shares * (0, utils_1.priceBigIntToNumber)(opt.currentPrice),
+                });
+            }
+        }
+        return out;
+    }
+    normalizeBalance(raw) {
+        if (!raw?.tokenBalances?.length)
+            return [];
+        return raw.tokenBalances.map((b) => ({
+            currency: b.symbol,
+            total: (0, utils_1.weiToNumber)(b.balance, b.decimals),
+            available: (0, utils_1.weiToNumber)(b.balance, b.decimals),
+            locked: 0,
+        }));
+    }
+    normalizeMarketDetails(details) {
+        return this.normalizeMarket({
+            market: {
+                id: details.id,
+                title: details.title,
+                totalVolume: '0',
+                status: details.status,
+                contractAddress: details.contractAddress,
+            },
+            details,
+        });
+    }
+}
+exports.RainNormalizer = RainNormalizer;

package/dist/exchanges/rain/utils.d.ts

@@ -0,0 +1,20 @@
+export declare const RAIN_DEFAULT_ENVIRONMENT: "production";
+export declare const RAIN_BASE_URL = "https://rain.one";
+export declare const ARBITRUM_USDT = "0xFd086bC7CD5C481DCC9C85ebE478A1C0b69FCbb9";
+export declare const ARBITRUM_USDC = "0xaf88d065e77c8cC2239327C5EDb3A432268e5831";
+export declare const USDT_DECIMALS = 6;
+export declare function priceBigIntToNumber(price: bigint | string | undefined | null): number;
+export declare function weiToNumber(wei: bigint | string | undefined | null, decimals?: number): number;
+/**
+ * Rain SDK returns `baseTokenDecimals` as the scale factor (e.g. 1000000n for
+ * a 6-decimal token), not the decimal count. Detect and normalize to a count.
+ */
+export declare function resolveDecimals(raw: bigint | number | string | undefined | null, fallback?: number): number;
+export declare function mapRainStatus(status?: string): string | undefined;
+export declare function rainMarketUrl(marketId: string): string;
+/**
+ * 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 declare function bigintsToStrings<T>(value: T): T;

package/dist/exchanges/rain/utils.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.USDT_DECIMALS = exports.ARBITRUM_USDC = exports.ARBITRUM_USDT = exports.RAIN_BASE_URL = exports.RAIN_DEFAULT_ENVIRONMENT = void 0;
+exports.priceBigIntToNumber = priceBigIntToNumber;
+exports.weiToNumber = weiToNumber;
+exports.resolveDecimals = resolveDecimals;
+exports.mapRainStatus = mapRainStatus;
+exports.rainMarketUrl = rainMarketUrl;
+exports.bigintsToStrings = bigintsToStrings;
+exports.RAIN_DEFAULT_ENVIRONMENT = 'production';
+exports.RAIN_BASE_URL = 'https://rain.one';
+exports.ARBITRUM_USDT = '0xFd086bC7CD5C481DCC9C85ebE478A1C0b69FCbb9';
+exports.ARBITRUM_USDC = '0xaf88d065e77c8cC2239327C5EDb3A432268e5831';
+exports.USDT_DECIMALS = 6;
+const PRICE_SCALE = 10n ** 18n;
+const PRECISION = 1_000_000;
+function priceBigIntToNumber(price) {
+    if (price == null)
+        return 0;
+    const p = typeof price === 'string' ? BigInt(price) : price;
+    return Number((p * BigInt(PRECISION)) / PRICE_SCALE) / PRECISION;
+}
+function weiToNumber(wei, decimals = exports.USDT_DECIMALS) {
+    if (wei == null)
+        return 0;
+    const w = typeof wei === 'string' ? BigInt(wei) : wei;
+    const scale = 10n ** BigInt(decimals);
+    return Number((w * BigInt(PRECISION)) / scale) / PRECISION;
+}
+/**
+ * Rain SDK returns `baseTokenDecimals` as the scale factor (e.g. 1000000n for
+ * a 6-decimal token), not the decimal count. Detect and normalize to a count.
+ */
+function resolveDecimals(raw, fallback = exports.USDT_DECIMALS) {
+    if (raw == null)
+        return fallback;
+    const n = typeof raw === 'bigint' ? Number(raw) : Number(raw);
+    if (!Number.isFinite(n) || n <= 0)
+        return fallback;
+    // Heuristic: values <=36 are decimal counts; anything larger is a scale.
+    if (n <= 36)
+        return Math.round(n);
+    const log = Math.log10(n);
+    return Math.round(log);
+}
+function mapRainStatus(status) {
+    if (!status)
+        return undefined;
+    switch (status) {
+        case 'Live':
+        case 'New':
+        case 'ClosingSoon':
+        case 'Trading':
+            return 'active';
+        case 'WaitingForResult':
+        case 'InReview':
+        case 'InEvaluation':
+            return 'resolving';
+        case 'UnderDispute':
+        case 'UnderAppeal':
+            return 'disputed';
+        case 'Closed':
+            return 'closed';
+        default:
+            return status.toLowerCase();
+    }
+}
+function rainMarketUrl(marketId) {
+    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.
+ */
+function bigintsToStrings(value) {
+    if (typeof value === 'bigint') {
+        return value.toString();
+    }
+    if (Array.isArray(value)) {
+        return value.map(bigintsToStrings);
+    }
+    if (value && typeof value === 'object') {
+        const out = {};
+        for (const [k, v] of Object.entries(value)) {
+            out[k] = bigintsToStrings(v);
+        }
+        return out;
+    }
+    return value;
+}

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

@@ -0,0 +1,21 @@
+import { OrderBook, Trade } from '../../types';
+export interface RainWebSocketConfig {
+    wsRpcUrl: string;
+    environment?: 'development' | 'stage' | 'production';
+}
+export declare class RainWebSocket {
+    private readonly config;
+    private client?;
+    private readonly subs;
+    private readonly normalizer;
+    constructor(config: RainWebSocketConfig);
+    private getClient;
+    /**
+     * Resolves to the next OrderBook snapshot after a price-affecting event.
+     * Stays subscribed for the connection lifetime; same caller can re-await
+     * to get subsequent snapshots.
+     */
+    watchOrderBook(marketAddress: string, outcomeId: string): Promise<OrderBook>;
+    watchTrades(marketAddress: string): Promise<Trade[]>;
+    close(): Promise<void>;
+}

package/dist/exchanges/rain/websocket.js

@@ -0,0 +1,98 @@
+"use strict";
+// Thin wrapper around Rain SDK's subscribePriceUpdates. Provides the
+// CCXT-Pro-style "next snapshot" promise pattern PMXT expects.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RainWebSocket = void 0;
+const normalizer_1 = require("./normalizer");
+const logger_1 = require("../../utils/logger");
+// See note in fetcher.ts on why we Function-wrap the import().
+const esmImportRainSdk = new Function('return import("@buidlrrr/rain-sdk")');
+class RainWebSocket {
+    config;
+    client;
+    subs = new Map();
+    normalizer = new normalizer_1.RainNormalizer();
+    constructor(config) {
+        this.config = config;
+    }
+    async getClient() {
+        if (!this.client) {
+            const sdk = await esmImportRainSdk();
+            this.client = new sdk.Rain({
+                environment: this.config.environment ?? 'production',
+                wsRpcUrl: this.config.wsRpcUrl,
+            });
+        }
+        return this.client;
+    }
+    /**
+     * Resolves to the next OrderBook snapshot after a price-affecting event.
+     * Stays subscribed for the connection lifetime; same caller can re-await
+     * to get subsequent snapshots.
+     */
+    async watchOrderBook(marketAddress, outcomeId) {
+        const client = await this.getClient();
+        return new Promise((resolve, reject) => {
+            const key = `book:${marketAddress}:${outcomeId}`;
+            const existing = this.subs.get(key);
+            if (existing)
+                existing();
+            const unsubscribe = client.subscribePriceUpdates({
+                marketAddress: marketAddress,
+                onPriceUpdate: () => {
+                    resolve(this.normalizer.normalizeOrderBook({ market: { contractAddress: marketAddress }, details: undefined }, outcomeId));
+                },
+                onError: (err) => {
+                    logger_1.logger.warn('RainWebSocket: price update error', { err: String(err) });
+                    reject(err);
+                },
+            });
+            this.subs.set(key, unsubscribe);
+        });
+    }
+    async watchTrades(marketAddress) {
+        const client = await this.getClient();
+        return new Promise((resolve, reject) => {
+            const key = `trades:${marketAddress}`;
+            const existing = this.subs.get(key);
+            if (existing)
+                existing();
+            const unsubscribe = client.subscribeToMarketEvents({
+                marketAddress: marketAddress,
+                eventNames: ['EnterOption', 'ExecuteBuyOrder', 'ExecuteSellOrder'],
+                onEvent: (event) => {
+                    const isBuy = event.eventName === 'EnterOption' || event.eventName === 'ExecuteBuyOrder';
+                    resolve([{
+                            id: event.transactionHash,
+                            timestamp: Number(event.blockNumber) * 1000,
+                            price: 0,
+                            amount: 0,
+                            side: isBuy ? 'buy' : 'sell',
+                        }]);
+                },
+                onError: (err) => {
+                    logger_1.logger.warn('RainWebSocket: trade subscription error', { err: String(err) });
+                    reject(err);
+                },
+            });
+            this.subs.set(key, unsubscribe);
+        });
+    }
+    async close() {
+        for (const unsub of this.subs.values()) {
+            try {
+                unsub();
+            }
+            catch { /* ignore */ }
+        }
+        this.subs.clear();
+        if (this.client && typeof this.client.destroyWebSocket === 'function') {
+            try {
+                await this.client.destroyWebSocket();
+            }
+            catch { /* ignore */ }
+        }
+        this.client = undefined;
+    }
+}
+exports.RainWebSocket = RainWebSocket;

package/dist/index.d.ts

@@ -18,6 +18,7 @@ export * from './exchanges/polymarket_us';
 export * from './exchanges/hyperliquid';
 export * from './exchanges/gemini-titan';
 export * from './exchanges/suibets';
+export * from './exchanges/rain';
 export * from './router';
 export * from './feeds';
 export * from './server/app';
@@ -38,6 +39,7 @@ import { PolymarketUSExchange } from './exchanges/polymarket_us';
 import { HyperliquidExchange } from './exchanges/hyperliquid';
 import { GeminiTitanExchange } from './exchanges/gemini-titan';
 import { SuiBetsExchange } from './exchanges/suibets';
+import { RainExchange } from './exchanges/rain';
 import { Router } from './router';
 declare const pmxt: {
     Mock: typeof MockExchange;
@@ -55,6 +57,7 @@ declare const pmxt: {
     Hyperliquid: typeof HyperliquidExchange;
     GeminiTitan: typeof GeminiTitanExchange;
     SuiBets: typeof SuiBetsExchange;
+    Rain: typeof RainExchange;
     Router: typeof Router;
 };
 export declare const Mock: typeof MockExchange;
@@ -72,4 +75,5 @@ export declare const PolymarketUS: typeof PolymarketUSExchange;
 export declare const Hyperliquid: typeof HyperliquidExchange;
 export declare const GeminiTitan: typeof GeminiTitanExchange;
 export declare const SuiBets: typeof SuiBetsExchange;
+export declare const Rain: typeof RainExchange;
 export default pmxt;

package/dist/index.js

@@ -14,7 +14,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SuiBets = exports.GeminiTitan = exports.Hyperliquid = exports.PolymarketUS = exports.Smarkets = exports.Metaculus = exports.Opinion = exports.Myriad = exports.Baozi = exports.Probable = exports.KalshiDemo = exports.Kalshi = exports.Limitless = exports.Polymarket = exports.Mock = exports.parseOpenApiSpec = void 0;
+exports.Rain = exports.SuiBets = exports.GeminiTitan = exports.Hyperliquid = exports.PolymarketUS = exports.Smarkets = exports.Metaculus = exports.Opinion = exports.Myriad = exports.Baozi = exports.Probable = exports.KalshiDemo = exports.Kalshi = exports.Limitless = exports.Polymarket = exports.Mock = exports.parseOpenApiSpec = void 0;
 __exportStar(require("./BaseExchange"), exports);
 __exportStar(require("./types"), exports);
 __exportStar(require("./utils/math"), exports);
@@ -36,6 +36,7 @@ __exportStar(require("./exchanges/polymarket_us"), exports);
 __exportStar(require("./exchanges/hyperliquid"), exports);
 __exportStar(require("./exchanges/gemini-titan"), exports);
 __exportStar(require("./exchanges/suibets"), exports);
+__exportStar(require("./exchanges/rain"), exports);
 __exportStar(require("./router"), exports);
 __exportStar(require("./feeds"), exports);
 __exportStar(require("./server/app"), exports);
@@ -56,6 +57,7 @@ const polymarket_us_1 = require("./exchanges/polymarket_us");
 const hyperliquid_1 = require("./exchanges/hyperliquid");
 const gemini_titan_1 = require("./exchanges/gemini-titan");
 const suibets_1 = require("./exchanges/suibets");
+const rain_1 = require("./exchanges/rain");
 const router_1 = require("./router");
 const pmxt = {
     Mock: mock_1.MockExchange,
@@ -73,6 +75,7 @@ const pmxt = {
     Hyperliquid: hyperliquid_1.HyperliquidExchange,
     GeminiTitan: gemini_titan_1.GeminiTitanExchange,
     SuiBets: suibets_1.SuiBetsExchange,
+    Rain: rain_1.RainExchange,
     Router: router_1.Router,
 };
 exports.Mock = mock_1.MockExchange;
@@ -90,4 +93,5 @@ exports.PolymarketUS = polymarket_us_1.PolymarketUSExchange;
 exports.Hyperliquid = hyperliquid_1.HyperliquidExchange;
 exports.GeminiTitan = gemini_titan_1.GeminiTitanExchange;
 exports.SuiBets = suibets_1.SuiBetsExchange;
+exports.Rain = rain_1.RainExchange;
 exports.default = pmxt;

package/dist/server/exchange-factory.js

@@ -15,6 +15,7 @@ const polymarket_us_1 = require("../exchanges/polymarket_us");
 const hyperliquid_1 = require("../exchanges/hyperliquid");
 const gemini_titan_1 = require("../exchanges/gemini-titan");
 const suibets_1 = require("../exchanges/suibets");
+const rain_1 = require("../exchanges/rain");
 const mock_1 = require("../exchanges/mock");
 const router_1 = require("../router");
 function createExchange(name, credentials, bearerToken) {
@@ -109,6 +110,20 @@ function createExchange(name, credentials, bearerToken) {
                 walletAddress: credentials?.walletAddress || process.env.SUIBETS_WALLET_ADDRESS,
                 baseUrl: credentials?.baseUrl || process.env.SUIBETS_BASE_URL,
             });
+        case "rain":
+            return new rain_1.RainExchange({
+                privateKey: credentials?.privateKey || process.env.RAIN_PRIVATE_KEY,
+                walletAddress: credentials?.walletAddress ||
+                    process.env.RAIN_WALLET_ADDRESS,
+                subgraphUrl: credentials?.subgraphUrl ||
+                    process.env.RAIN_SUBGRAPH_URL,
+                subgraphApiKey: credentials?.subgraphApiKey ||
+                    process.env.RAIN_SUBGRAPH_API_KEY,
+                wsRpcUrl: credentials?.wsRpcUrl ||
+                    process.env.RAIN_WS_RPC_URL,
+                environment: (credentials?.environment ||
+                    process.env.RAIN_ENVIRONMENT),
+            });
         case "mock":
             return new mock_1.MockExchange();
         case "router":

package/dist/server/openapi.yaml

@@ -2587,6 +2587,7 @@ components:
           - gemini-titan
           - hyperliquid
           - suibets
+          - rain
           - mock
           - router
       required: true
@@ -4471,6 +4472,17 @@ x-sdk-constructors:
         tsName: pmxtApiKey
         type: string
         description: PMXT API key for hosted access
+  rain:
+    className: Rain
+    params:
+      - name: pmxt_api_key
+        tsName: pmxtApiKey
+        type: string
+        description: PMXT API key for hosted access
+      - name: private_key
+        tsName: privateKey
+        type: string
+        description: Private key for authentication
   mock:
     className: Mock
     params: