pmxt-core 2.49.11 → 2.50.2

package/dist/exchanges/rain/index.js

@@ -0,0 +1,515 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RainExchange = void 0;
+const BaseExchange_1 = require("../../BaseExchange");
+const errors_1 = require("../../errors");
+const auth_1 = require("./auth");
+const fetcher_1 = require("./fetcher");
+const normalizer_1 = require("./normalizer");
+const websocket_1 = require("./websocket");
+const errors_2 = require("./errors");
+const utils_1 = require("./utils");
+const viem_1 = require("viem");
+const ARBITRUM_CHAIN_ID = 42161;
+const PRICE_SCALE = 10n ** 18n;
+const MAX_UINT256 = (1n << 256n) - 1n;
+const ERC20_ABI = (0, viem_1.parseAbi)([
+    'function allowance(address owner, address spender) view returns (uint256)',
+]);
+function encodeOrderId(ref) {
+    return `rain:${ref.marketContract}:${ref.side}:${ref.option}:${ref.pricePerShare1e18}:${ref.rainOrderId}:${ref.txHash ?? ''}`;
+}
+function decodeOrderId(orderId) {
+    const parts = orderId.split(':');
+    if (parts.length < 7 || parts[0] !== 'rain') {
+        throw new errors_1.BadRequest(`Invalid Rain order id: "${orderId}". Expected "rain:{contract}:{side}:{option}:{price1e18}:{rainOrderId}:{txHash}".`, 'Rain');
+    }
+    return {
+        marketContract: parts[1],
+        side: parts[2],
+        option: Number(parts[3]),
+        pricePerShare1e18: parts[4],
+        rainOrderId: parts[5],
+        txHash: parts[6] || undefined,
+    };
+}
+class RainExchange extends BaseExchange_1.PredictionMarketExchange {
+    capabilityOverrides = {
+        fetchSeries: false,
+        fetchOrderBook: 'emulated',
+        watchOrderBook: 'emulated',
+        watchTrades: 'emulated',
+        // Trading is on-chain via Rain SDK + viem. open/closed orders + fetchOrder
+        // need subgraph; without it, they throw at call-time with a clear message.
+        fetchOpenOrders: 'emulated',
+        fetchClosedOrders: 'emulated',
+        fetchOrder: 'emulated',
+    };
+    auth;
+    fetcher;
+    normalizer;
+    ws;
+    constructor(credentials) {
+        super(credentials);
+        this.rateLimit = 250;
+        this.auth = new auth_1.RainAuth(credentials ?? {});
+        this.fetcher = new fetcher_1.RainFetcher({
+            environment: credentials?.environment,
+            subgraphUrl: credentials?.subgraphUrl,
+            subgraphApiKey: credentials?.subgraphApiKey,
+            wsRpcUrl: credentials?.wsRpcUrl,
+        });
+        this.normalizer = new normalizer_1.RainNormalizer();
+    }
+    get name() {
+        return 'Rain';
+    }
+    // ------------------------------------------------------------------------
+    // Market data
+    // ------------------------------------------------------------------------
+    async fetchMarketsImpl(params) {
+        const limit = params?.limit ?? 25;
+        const status = (params?.status === 'closed' ? 'Closed' : params?.status === 'all' ? undefined : 'Live');
+        const sortBy = params?.sort === 'volume' ? 'Volumn' : params?.sort === 'newest' ? 'latest' : 'Liquidity';
+        const rawMarkets = await this.fetcher.fetchRawMarkets({ limit, status, sortBy });
+        return rawMarkets
+            .map((raw) => this.normalizer.normalizeMarket(raw))
+            .filter((m) => m !== null);
+    }
+    async fetchEventsImpl(params) {
+        if (params.series !== undefined)
+            return []; // Rain has no series concept
+        const limit = params.limit ?? 25;
+        const rawMarkets = await this.fetcher.fetchRawMarkets({
+            limit,
+            status: params.status === 'closed' ? 'Closed' : 'Live',
+        });
+        return rawMarkets
+            .map((raw) => this.normalizer.normalizeEvent(raw))
+            .filter((e) => e !== null);
+    }
+    async fetchOHLCV(outcomeId, params) {
+        const parts = outcomeId.split(':');
+        if (parts.length < 3 || parts[0] !== 'rain') {
+            throw new Error(`Invalid Rain outcomeId format: "${outcomeId}". Expected "rain:{marketId}:{choiceIndex}".`);
+        }
+        const marketId = parts[1];
+        const choiceIndex = Number(parts[2]);
+        const interval = normalizer_1.RainNormalizer.mapInterval(params.resolution);
+        const raw = await this.fetcher.fetchRawOHLCV(marketId, choiceIndex, interval, params.limit);
+        return this.normalizer.normalizeOHLCV(raw, params.limit);
+    }
+    async fetchOrderBook(outcomeId, _limit, _params) {
+        const resolved = await this.resolveOutcomeAlias(outcomeId, _params);
+        outcomeId = resolved.outcomeId;
+        const parts = outcomeId.split(':');
+        if (parts.length < 3) {
+            throw new Error(`Invalid Rain outcomeId format: "${outcomeId}". Expected "rain:{marketId}:{choiceIndex}".`);
+        }
+        const raw = await this.fetcher.fetchRawMarket(parts[1]);
+        if (!raw)
+            return { bids: [], asks: [], timestamp: Date.now() };
+        return this.normalizer.normalizeOrderBook(raw, outcomeId);
+    }
+    async fetchTrades(outcomeId, params) {
+        const parts = outcomeId.split(':');
+        if (parts.length < 2) {
+            throw new Error(`Invalid Rain id format: "${outcomeId}". Expected "rain:{marketId}".`);
+        }
+        const market = await this.fetcher.fetchRawMarket(parts[1]);
+        const contract = market?.details?.contractAddress;
+        if (!contract)
+            return [];
+        const raw = await this.fetcher.fetchRawMarketTrades(contract, params.limit);
+        return this.normalizer.normalizeMarketTrades(raw);
+    }
+    async fetchMyTrades(params) {
+        const wallet = this.auth.requireWalletAddress('fetchMyTrades');
+        const marketParts = params?.marketId ? params.marketId.split(':') : [];
+        const marketId = marketParts.length >= 2 ? marketParts[1] : undefined;
+        let marketAddress;
+        if (marketId) {
+            const m = await this.fetcher.fetchRawMarket(marketId);
+            marketAddress = m?.details?.contractAddress;
+        }
+        const raw = await this.fetcher.fetchRawUserTrades(wallet, marketAddress, params?.limit);
+        return this.normalizer.normalizeUserTrades(raw);
+    }
+    async fetchPositions(address) {
+        const wallet = address ?? this.auth.requireWalletAddress('fetchPositions');
+        const raw = await this.fetcher.fetchRawPositions(wallet);
+        return this.normalizer.normalizePositions(raw);
+    }
+    async fetchBalance(address) {
+        const wallet = address ?? this.auth.requireWalletAddress('fetchBalance');
+        const raw = await this.fetcher.fetchRawBalance(wallet, [utils_1.ARBITRUM_USDT, utils_1.ARBITRUM_USDC]);
+        return this.normalizer.normalizeBalance(raw);
+    }
+    // ------------------------------------------------------------------------
+    // Trading -- on-chain via Rain SDK + viem.
+    // ------------------------------------------------------------------------
+    async buildOrder(params) {
+        try {
+            const { marketContract, baseToken, baseDecimals } = await this.resolveContractFor(params);
+            const choice = this.parseChoiceIndex(params.outcomeId);
+            const sdk = await this.fetcher.sdkClient();
+            let rawTx;
+            let pricePerShare1e18 = '0';
+            if (params.side === 'buy' && params.type === 'market') {
+                rawTx = sdk.buildBuyOptionRawTx({
+                    marketContractAddress: marketContract,
+                    selectedOption: BigInt(choice),
+                    buyAmountInWei: this.toBaseWei(params.amount, baseDecimals),
+                });
+            }
+            else if (params.side === 'buy' && params.type === 'limit') {
+                if (params.price == null) {
+                    throw new errors_1.BadRequest('Limit buy requires a price (0 < price < 1).', 'Rain');
+                }
+                const price1e18 = this.toPrice1e18(params.price);
+                pricePerShare1e18 = price1e18.toString();
+                rawTx = sdk.buildLimitBuyOptionTx({
+                    marketContractAddress: marketContract,
+                    selectedOption: choice,
+                    pricePerShare: price1e18,
+                    buyAmountInWei: this.toBaseWei(params.amount, baseDecimals),
+                    tokenDecimals: baseDecimals,
+                });
+            }
+            else if (params.side === 'sell' && params.type === 'limit') {
+                if (params.price == null) {
+                    throw new errors_1.BadRequest('Limit sell requires a price (0 < price < 1).', 'Rain');
+                }
+                pricePerShare1e18 = this.toPrice1e18(params.price).toString();
+                rawTx = sdk.buildSellOptionTx({
+                    marketContractAddress: marketContract,
+                    selectedOption: choice,
+                    pricePerShare: params.price,
+                    shares: this.toBaseWei(params.amount, baseDecimals),
+                    tokenDecimals: baseDecimals,
+                });
+            }
+            else {
+                // params.side === 'sell' && params.type === 'market'
+                throw new errors_1.NotSupported('Rain has no AMM market-sell. Sells go through the orderbook as limit orders — pass type:"limit" with a price.', 'Rain');
+            }
+            const ref = {
+                marketContract,
+                side: params.side,
+                option: choice,
+                pricePerShare1e18,
+                rainOrderId: '0',
+            };
+            return {
+                exchange: 'Rain',
+                params,
+                tx: {
+                    to: rawTx.to,
+                    data: rawTx.data,
+                    value: (rawTx.value ?? 0n).toString(),
+                    chainId: ARBITRUM_CHAIN_ID,
+                },
+                raw: { rawTx, ref, baseToken, baseDecimals },
+            };
+        }
+        catch (error) {
+            throw errors_2.rainErrorMapper.mapError(error);
+        }
+    }
+    async submitOrder(built) {
+        try {
+            const wallet = this.auth.ensureWalletClient();
+            const account = wallet.account;
+            if (!account)
+                throw new Error('Wallet client has no account.');
+            const raw = built.raw;
+            if (built.params.side === 'buy') {
+                await this.ensureApproval(raw.baseToken, raw.ref.marketContract, this.toBaseWei(built.params.amount, raw.baseDecimals));
+            }
+            const txHash = await wallet.sendTransaction({
+                account,
+                chain: wallet.chain,
+                to: raw.rawTx.to,
+                data: raw.rawTx.data,
+                value: raw.rawTx.value ?? 0n,
+            });
+            const ref = { ...raw.ref, txHash };
+            const isMarket = built.params.type === 'market';
+            return {
+                id: encodeOrderId(ref),
+                marketId: built.params.marketId,
+                outcomeId: built.params.outcomeId,
+                side: built.params.side,
+                type: built.params.type,
+                price: built.params.price ?? (raw.ref.pricePerShare1e18 !== '0'
+                    ? (0, utils_1.priceBigIntToNumber)(BigInt(raw.ref.pricePerShare1e18))
+                    : undefined),
+                amount: built.params.amount,
+                status: isMarket ? 'filled' : 'open',
+                filled: isMarket ? built.params.amount : 0,
+                remaining: isMarket ? 0 : built.params.amount,
+                timestamp: Date.now(),
+                txHash,
+                chain: 'arbitrum',
+            };
+        }
+        catch (error) {
+            throw errors_2.rainErrorMapper.mapError(error);
+        }
+    }
+    async createOrder(params) {
+        const built = await this.buildOrder(params);
+        return this.submitOrder(built);
+    }
+    async cancelOrder(orderId) {
+        try {
+            const ref = decodeOrderId(orderId);
+            if (ref.rainOrderId === '0') {
+                throw new errors_1.BadRequest('Cannot cancel a Rain order without a Rain orderID. Market AMM swaps are atomic; only resting limit orders are cancellable.', 'Rain');
+            }
+            const sdk = await this.fetcher.sdkClient();
+            const builder = ref.side === 'buy' ? sdk.buildCancelBuyOrdersTx : sdk.buildCancelSellOrdersTx;
+            const rawTx = builder({
+                marketContractAddress: ref.marketContract,
+                orders: [{
+                        option: ref.option,
+                        price: (0, utils_1.priceBigIntToNumber)(BigInt(ref.pricePerShare1e18)),
+                        orderID: BigInt(ref.rainOrderId),
+                    }],
+            });
+            const wallet = this.auth.ensureWalletClient();
+            const account = wallet.account;
+            if (!account)
+                throw new Error('Wallet client has no account.');
+            const txHash = await wallet.sendTransaction({
+                account,
+                chain: wallet.chain,
+                to: rawTx.to,
+                data: rawTx.data,
+                value: rawTx.value ?? 0n,
+            });
+            return {
+                id: orderId,
+                marketId: `rain:unknown`,
+                outcomeId: `rain:unknown:${ref.option}`,
+                side: ref.side,
+                type: 'limit',
+                amount: 0,
+                status: 'canceled',
+                filled: 0,
+                remaining: 0,
+                timestamp: Date.now(),
+                txHash,
+                chain: 'arbitrum',
+            };
+        }
+        catch (error) {
+            throw errors_2.rainErrorMapper.mapError(error);
+        }
+    }
+    async fetchOrder(orderId) {
+        const ref = decodeOrderId(orderId);
+        if (!ref.txHash) {
+            throw new errors_1.BadRequest('Rain order id has no tx hash to look up.', 'Rain');
+        }
+        const sdk = await this.fetcher.sdkClient();
+        const details = await sdk.getTransactionDetails({ transactionHash: ref.txHash });
+        return {
+            id: orderId,
+            marketId: 'rain:unknown',
+            outcomeId: `rain:unknown:${ref.option}`,
+            side: ref.side,
+            type: ref.rainOrderId === '0' ? 'market' : 'limit',
+            amount: 0,
+            status: details?.status === 'success' ? 'filled' : 'rejected',
+            filled: 0,
+            remaining: 0,
+            timestamp: details?.timestamp ? Number(details.timestamp) * 1000 : Date.now(),
+            txHash: ref.txHash,
+            chain: 'arbitrum',
+        };
+    }
+    async fetchOpenOrders(marketId) {
+        // Open orders = limit_*_placed transactions whose orderID has not been
+        // cancelled or filled. Needs subgraph; without it we honestly return [].
+        const wallet = this.auth.resolveAddress();
+        if (!wallet)
+            return [];
+        const raw = await this.fetcher.fetchRawUserTrades(wallet, undefined, 200);
+        if (!raw)
+            return [];
+        const open = new Map();
+        for (const tx of raw.transactions ?? []) {
+            const key = `${tx.marketAddress}:${tx.orderId}:${tx.type.startsWith('limit_buy') ? 'buy' : 'sell'}`;
+            if (tx.type === 'limit_buy_placed' || tx.type === 'limit_sell_placed') {
+                open.set(key, {
+                    side: tx.type === 'limit_buy_placed' ? 'buy' : 'sell',
+                    option: tx.option ?? 0,
+                    price: BigInt(tx.price ?? 0),
+                    orderId: BigInt(tx.orderId ?? 0),
+                    market: tx.marketAddress,
+                    ts: Number(tx.timestamp) * 1000,
+                });
+            }
+            else if (tx.type === 'limit_buy_filled' || tx.type === 'limit_sell_filled' ||
+                tx.type === 'cancel_buy' || tx.type === 'cancel_sell') {
+                const side = tx.type.includes('buy') ? 'buy' : 'sell';
+                open.delete(`${tx.marketAddress}:${tx.orderId}:${side}`);
+            }
+        }
+        const want = marketId ? marketId.replace(/^rain:/, '') : undefined;
+        const out = [];
+        for (const o of open.values()) {
+            const ref = {
+                marketContract: o.market,
+                side: o.side,
+                option: o.option,
+                pricePerShare1e18: o.price.toString(),
+                rainOrderId: o.orderId.toString(),
+            };
+            const oMarketId = `rain:${o.market}`;
+            if (want && oMarketId !== `rain:${want}`)
+                continue;
+            out.push({
+                id: encodeOrderId(ref),
+                marketId: oMarketId,
+                outcomeId: `rain:${o.market}:${o.option}`,
+                side: o.side,
+                type: 'limit',
+                price: (0, utils_1.priceBigIntToNumber)(o.price),
+                amount: 0,
+                status: 'open',
+                filled: 0,
+                remaining: 0,
+                timestamp: o.ts,
+                chain: 'arbitrum',
+            });
+        }
+        return out;
+    }
+    // ------------------------------------------------------------------------
+    // Trading helpers
+    // ------------------------------------------------------------------------
+    parseChoiceIndex(outcomeId) {
+        const parts = outcomeId.split(':');
+        if (parts.length < 3) {
+            throw new errors_1.BadRequest(`Invalid Rain outcomeId: "${outcomeId}". Expected "rain:{marketId}:{choiceIndex}".`, 'Rain');
+        }
+        const idx = Number(parts[2]);
+        if (!Number.isInteger(idx) || idx < 0) {
+            throw new errors_1.BadRequest(`Invalid choice index in outcomeId: "${outcomeId}".`, 'Rain');
+        }
+        return idx;
+    }
+    toBaseWei(amount, decimals) {
+        // amount is the user-facing decimal token amount (e.g., 10 USDT). Convert
+        // to base-token wei. For sells (shares) we accept a decimal share count.
+        const scale = 10n ** BigInt(decimals);
+        const PRECISION = 1_000_000;
+        return (BigInt(Math.round(amount * PRECISION)) * scale) / BigInt(PRECISION);
+    }
+    toPrice1e18(price) {
+        if (price <= 0 || price >= 1) {
+            throw new errors_1.BadRequest(`Rain price must satisfy 0 < price < 1, got ${price}.`, 'Rain');
+        }
+        const PRECISION = 1000000n;
+        return (BigInt(Math.round(price * Number(PRECISION))) * PRICE_SCALE) / PRECISION;
+    }
+    async resolveContractFor(params) {
+        const marketParts = params.marketId.split(':');
+        if (marketParts.length < 2 || marketParts[0] !== 'rain') {
+            throw new errors_1.BadRequest(`Invalid Rain marketId: "${params.marketId}". Expected "rain:{marketId}".`, 'Rain');
+        }
+        const m = await this.fetcher.fetchRawMarket(marketParts[1]);
+        if (!m?.details?.contractAddress) {
+            throw new errors_1.BadRequest(`Could not resolve contract address for Rain market ${params.marketId}.`, 'Rain');
+        }
+        return {
+            marketContract: m.details.contractAddress,
+            baseToken: m.details.baseToken ?? utils_1.ARBITRUM_USDT,
+            baseDecimals: (0, utils_1.resolveDecimals)(m.details.baseTokenDecimals, utils_1.USDT_DECIMALS),
+        };
+    }
+    async ensureApproval(token, spender, neededAmount) {
+        const pub = this.auth.ensurePublicClient();
+        const owner = this.auth.resolveAddress();
+        if (!owner) {
+            throw new Error('Cannot check allowance without a wallet address.');
+        }
+        const allowance = await pub.readContract({
+            address: token,
+            abi: ERC20_ABI,
+            functionName: 'allowance',
+            args: [owner, spender],
+        });
+        if (allowance >= neededAmount)
+            return;
+        const sdk = await this.fetcher.sdkClient();
+        const approveTx = sdk.buildApprovalTx({
+            tokenAddress: token,
+            spender,
+            amount: MAX_UINT256,
+        });
+        if (approveTx instanceof Error) {
+            throw approveTx;
+        }
+        const wallet = this.auth.ensureWalletClient();
+        const account = wallet.account;
+        if (!account)
+            throw new Error('Wallet client has no account.');
+        const hash = await wallet.sendTransaction({
+            account,
+            chain: wallet.chain,
+            to: approveTx.to,
+            data: approveTx.data,
+            value: approveTx.value ?? 0n,
+        });
+        await pub.waitForTransactionReceipt({ hash });
+    }
+    // ------------------------------------------------------------------------
+    // WebSocket
+    // ------------------------------------------------------------------------
+    ensureWebSocket() {
+        if (!this.ws) {
+            const wsRpcUrl = this.auth.creds?.wsRpcUrl;
+            if (!wsRpcUrl) {
+                throw new Error('Rain WebSocket requires wsRpcUrl in credentials.');
+            }
+            this.ws = new websocket_1.RainWebSocket({
+                wsRpcUrl,
+                environment: this.auth.creds?.environment,
+            });
+        }
+        return this.ws;
+    }
+    async watchOrderBook(outcomeId, _limit, _params = {}) {
+        const parts = outcomeId.split(':');
+        if (parts.length < 3) {
+            throw new Error(`Invalid Rain outcomeId for watchOrderBook: "${outcomeId}".`);
+        }
+        const market = await this.fetcher.fetchRawMarket(parts[1]);
+        const contract = market?.details?.contractAddress;
+        if (!contract)
+            throw new Error(`No contract address for Rain market ${parts[1]}.`);
+        return this.ensureWebSocket().watchOrderBook(contract, outcomeId);
+    }
+    async watchTrades(outcomeId) {
+        const parts = outcomeId.split(':');
+        if (parts.length < 2) {
+            throw new Error(`Invalid Rain outcomeId for watchTrades: "${outcomeId}".`);
+        }
+        const market = await this.fetcher.fetchRawMarket(parts[1]);
+        const contract = market?.details?.contractAddress;
+        if (!contract)
+            throw new Error(`No contract address for Rain market ${parts[1]}.`);
+        return this.ensureWebSocket().watchTrades(contract);
+    }
+    async close() {
+        if (this.ws) {
+            await this.ws.close();
+            this.ws = undefined;
+        }
+        await this.fetcher.close();
+    }
+}
+exports.RainExchange = RainExchange;

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

@@ -0,0 +1,33 @@
+import { UnifiedMarket, UnifiedEvent, PriceCandle, OrderBook, Trade, UserTrade, Position, Balance, CandleInterval } from '../../types';
+import { RainMarketWithDetails, RainRawMarketDetails, RainRawPositions, RainRawBalance, RainRawPriceHistory, RainRawTransactions, RainRawMarketTransactions } from './fetcher';
+export declare 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: RainMarketWithDetails): UnifiedMarket | null;
+    /**
+     * 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: RainMarketWithDetails): UnifiedEvent | null;
+    /**
+     * 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: RainMarketWithDetails, outcomeId: string): OrderBook;
+    normalizeOHLCV(raw: RainRawPriceHistory | null, limit?: number): PriceCandle[];
+    /** Map Rain SDK price-history intervals onto PMXT CandleInterval strings. */
+    static mapInterval(resolution: CandleInterval): '1m' | '5m' | '15m' | '1h' | '4h' | '1d' | '1w';
+    normalizeMarketTrades(raw: RainRawMarketTransactions | null): Trade[];
+    normalizeUserTrades(raw: RainRawTransactions | null): UserTrade[];
+    normalizePositions(raw: RainRawPositions): Position[];
+    normalizeBalance(raw: RainRawBalance): Balance[];
+    normalizeMarketDetails(details: RainRawMarketDetails): UnifiedMarket | null;
+}