rain-sdk-v2 1.0.0

package/dist/api/users.js

@@ -0,0 +1,60 @@
+import { buildHeaders, buildQuery, handleResponse } from './helpers.js';
+export async function findUserByWalletAddress(params, config) {
+    const qs = buildQuery({ walletAddress: params.walletAddress });
+    const res = await fetch(`${config.apiUrl}/users/find-user-by-wallet-address${qs}`, {
+        method: 'GET',
+        headers: buildHeaders(config),
+    });
+    return handleResponse(res);
+}
+export async function updateUserProfile(params, config) {
+    const res = await fetch(`${config.apiUrl}/users/user-profile-update`, {
+        method: 'PATCH',
+        headers: buildHeaders(config, 'application/json'),
+        body: JSON.stringify(params),
+    });
+    return handleResponse(res);
+}
+export async function getUserProfile(config) {
+    const res = await fetch(`${config.apiUrl}/users/user-profile`, {
+        method: 'GET',
+        headers: buildHeaders(config),
+    });
+    return handleResponse(res);
+}
+export async function getUsersTotalCount(config) {
+    const res = await fetch(`${config.apiUrl}/users/users-total-count`, {
+        method: 'GET',
+        headers: buildHeaders(config),
+    });
+    return handleResponse(res);
+}
+export async function removeUserProfilePic(config) {
+    const res = await fetch(`${config.apiUrl}/users/remove-user-profile-pic`, {
+        method: 'PATCH',
+        headers: buildHeaders(config),
+    });
+    return handleResponse(res);
+}
+export async function getUserHistory(params, config) {
+    const qs = buildQuery({ limit: params.limit, offset: params.offset });
+    const res = await fetch(`${config.apiUrl}/users/get-user-history${qs}`, {
+        method: 'GET',
+        headers: buildHeaders(config),
+    });
+    return handleResponse(res);
+}
+export async function viewUserProfile(params, config) {
+    const res = await fetch(`${config.apiUrl}/users/view-user-profile/${encodeURIComponent(params.userId)}`, {
+        method: 'GET',
+        headers: buildHeaders(config),
+    });
+    return handleResponse(res);
+}
+export async function checkTokenExpiration(config) {
+    const res = await fetch(`${config.apiUrl}/users/check-token-expiration`, {
+        method: 'GET',
+        headers: buildHeaders(config),
+    });
+    return handleResponse(res);
+}

package/dist/auth/login.d.ts

@@ -0,0 +1,4 @@
+import { LoginParams, LoginResult } from './types.js';
+export declare function loginUser(params: LoginParams & {
+    apiUrl: string;
+}): Promise<LoginResult>;

package/dist/auth/login.js

@@ -0,0 +1,27 @@
+export async function loginUser(params) {
+    const { signature, walletAddress, smartWalletAddress, referredBy, apiUrl } = params;
+    const res = await fetch(`${apiUrl}/auth/login-or-register-with-walletAddress`, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            ...(apiUrl.includes('ngrok') ? { 'ngrok-skip-browser-warning': 'true' } : {}),
+        },
+        body: JSON.stringify({
+            sign: signature,
+            walletAddress,
+            userSmartAddress: smartWalletAddress,
+            ...(referredBy ? { referredBy } : {}),
+        }),
+    });
+    if (!res.ok) {
+        const text = await res.text().catch(() => res.statusText);
+        throw new Error(`Login failed (${res.status}): ${text}`);
+    }
+    const data = await res.json();
+    const accessToken = data?.token;
+    const userId = data?.user?._id;
+    if (!accessToken || !userId) {
+        throw new Error('Login response missing token or user id');
+    }
+    return { accessToken, userId };
+}

package/dist/auth/types.d.ts

@@ -0,0 +1,16 @@
+export interface LoginParams {
+    /** Signed message (personal_sign of the lowercased wallet address) */
+    signature: string;
+    /** EOA wallet address */
+    walletAddress: string;
+    /** Smart account / AA wallet address */
+    smartWalletAddress: string;
+    /** Optional referral code */
+    referredBy?: string;
+}
+export interface LoginResult {
+    /** JWT access token */
+    accessToken: string;
+    /** Backend user ID */
+    userId: string;
+}

package/dist/auth/types.js

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

package/dist/config/environments.d.ts

@@ -0,0 +1,15 @@
+export declare const ALLOWED_ENVIRONMENTS: readonly ["development"];
+export declare const DEFAULT_RPCS: string[];
+export declare function getRandomRpc(): string;
+export declare const USDT_SYMBOL_DEV = "USDTm";
+export declare const ENV_CONFIG: {
+    readonly development: {
+        readonly apiUrl: "https://dev2-api.rain.one";
+        readonly market_factory_address: `0x${string}`;
+        readonly dispute_initial_timer: number;
+        readonly oracle_fixed_fee_per_option: 1000000n;
+        readonly usdt_symbol: "USDTm";
+        readonly usdt_token: `0x${string}`;
+        readonly rain_token: `0x${string}`;
+    };
+};

package/dist/config/environments.js

@@ -0,0 +1,41 @@
+export const ALLOWED_ENVIRONMENTS = ["development"];
+export const DEFAULT_RPCS = [
+    "https://arb1.arbitrum.io/rpc",
+    "https://arbitrum-one.publicnode.com",
+    "https://rpc.sentio.xyz/arbitrum-one"
+];
+export function getRandomRpc() {
+    const index = Math.floor(Math.random() * DEFAULT_RPCS.length);
+    return DEFAULT_RPCS[index];
+}
+export const USDT_SYMBOL_DEV = "USDTm";
+// export const USDT_SYMBOL_PROD = "USD₮0";
+export const ENV_CONFIG = {
+    development: {
+        apiUrl: "https://dev2-api.rain.one",
+        market_factory_address: "0xBD99441C4116b85dFecA2d6521EC0e2Eb62F0adE",
+        dispute_initial_timer: 1 * 60,
+        oracle_fixed_fee_per_option: 1000000n, // $1 per option (6 decimals)
+        usdt_symbol: USDT_SYMBOL_DEV,
+        usdt_token: "0xCa4f77A38d8552Dd1D5E44e890173921B67725F4",
+        rain_token: "0x25118290e6A5f4139381D072181157035864099d",
+    },
+    // stage: {
+    //     apiUrl: "https://stg-api.rain.one",
+    //     market_factory_address: "0xD4900CA167228365806FBA4cB21f7EAe8b6d96BE" as `0x${string}`,
+    //     dispute_initial_timer: 1 * 60,
+    //     oracle_fixed_fee_per_option: 1_000_000n, // $1 per option (6 decimals)
+    //     usdt_symbol: USDT_SYMBOL_PROD,
+    //     usdt_token: "0xFd086bC7CD5C481DCC9C85ebE478A1C0b69FCbb9" as `0x${string}`,
+    //     rain_token: "0x43976a124e6834b541840Ce741243dAD3dd538DA" as `0x${string}`,
+    // },
+    // production: {
+    //     apiUrl: "https://prod-api.rain.one",
+    //     market_factory_address: "0xA8640B62D755e42C9ed6A86d0fc65CE09e31F264" as `0x${string}`,
+    //     dispute_initial_timer: 120 * 60,
+    //     oracle_fixed_fee_per_option: 1_000_000n, // $1 per option (6 decimals)
+    //     usdt_symbol: USDT_SYMBOL_PROD,
+    //     usdt_token: "0xFd086bC7CD5C481DCC9C85ebE478A1C0b69FCbb9" as `0x${string}`,
+    //     rain_token: "0x43976a124e6834b541840Ce741243dAD3dd538DA" as `0x${string}`,
+    // },
+};

package/dist/constants/contractmethods.d.ts

@@ -0,0 +1,15 @@
+export declare const APPROVE_TOKEN = "approve";
+export declare const CREATE_MARKET = "createPool";
+export declare const ENTER_OPTION = "enterOption";
+export declare const ENTER_LIQUIDITY = "enterLiquidity";
+export declare const REMOVE_LIQUIDITY = "removeLiquidity";
+export declare const SPLIT = "split";
+export declare const MERGE = "merge";
+export declare const CLOSE_POOL = "closePool";
+export declare const CHOOSE_WINNER = "chooseWinner";
+export declare const PLACE_BUY_ORDER = "placeBuyOrder";
+export declare const PLACE_SELL_ORDER = "placeSellOrder";
+export declare const OPEN_DISPUTE = "openDispute";
+export declare const CLAIM = "claim";
+export declare const CANCEL_BUY_ORDERS = "cancelBuyOrders";
+export declare const CANCEL_SELL_ORDERS = "cancelSellOrders";

package/dist/constants/contractmethods.js

@@ -0,0 +1,15 @@
+export const APPROVE_TOKEN = 'approve';
+export const CREATE_MARKET = 'createPool';
+export const ENTER_OPTION = 'enterOption';
+export const ENTER_LIQUIDITY = 'enterLiquidity';
+export const REMOVE_LIQUIDITY = 'removeLiquidity';
+export const SPLIT = 'split';
+export const MERGE = 'merge';
+export const CLOSE_POOL = 'closePool';
+export const CHOOSE_WINNER = 'chooseWinner';
+export const PLACE_BUY_ORDER = 'placeBuyOrder';
+export const PLACE_SELL_ORDER = 'placeSellOrder';
+export const OPEN_DISPUTE = 'openDispute';
+export const CLAIM = 'claim';
+export const CANCEL_BUY_ORDERS = 'cancelBuyOrders';
+export const CANCEL_SELL_ORDERS = 'cancelSellOrders';

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+export { Rain } from './Rain.js';
+export { RainAA } from './RainAA.js';
+export * from './types.js';
+export { TradingModel, OptionSide } from './tx/types.js';
+export type { CreateMarketTxParams, EnterOptionTxParams, AddLiquidityTxParams, RemoveLiquidityTxParams, SplitTxParams, MergeTxParams, ClosePoolAITxParams, ClosePoolManualTxParams, ChooseWinnerTxParams, PlaceBuyOrderTxParams, PlaceSellOrderTxParams, OpenDisputeTxParams, ClaimTxParams, CancelBuyOrdersTxParams, CancelSellOrdersTxParams, RawTransaction, ApproveTxParams } from './tx/types.js';
+export type { LoginParams, LoginResult } from './auth/types.js';
+export * from './api/index.js';
+export { RainSocket } from './socket/RainSocket.js';
+export type { RainSocketEvent, EnterOptionEventData, ExitOptionEventData, LiquidityEventData, SplitEventData, MergeEventData, RemoveLiquidityEventData, SyncPriceEventData, OrderCreatedEventData, OrderCancelledEventData, OrderFilledEventData, PoolClosedEventData, PoolEventData, WinnerEventData, DisputeOpenedEventData, OracleCreatedEventData, AppealOpenedEventData, DisputeWinnerEventData, AppealWinnerEventData, ClaimRewardEventData, DisputeRefundEventData } from './socket/RainSocket.js';

package/dist/index.js

@@ -0,0 +1,6 @@
+export { Rain } from './Rain.js';
+export { RainAA } from './RainAA.js';
+export * from './types.js';
+export { TradingModel, OptionSide } from './tx/types.js';
+export * from './api/index.js';
+export { RainSocket } from './socket/RainSocket.js';

package/dist/markets/getDisputeFee.d.ts

@@ -0,0 +1,5 @@
+export declare function getDisputeAppealFee(params: {
+    marketContractAddress: `0x${string}`;
+    option: bigint;
+    rpcUrl: string;
+}): Promise<bigint>;

package/dist/markets/getDisputeFee.js

@@ -0,0 +1,19 @@
+import { createPublicClient, http, parseAbi } from 'viem';
+import { arbitrum } from 'viem/chains';
+const disputeFeeAbi = parseAbi([
+    'function getDisputeAppealFee(uint256 option) view returns (uint256 disputeFee)',
+]);
+export async function getDisputeAppealFee(params) {
+    const { marketContractAddress, option, rpcUrl } = params;
+    const client = createPublicClient({
+        chain: arbitrum,
+        transport: http(rpcUrl),
+    });
+    const fee = await client.readContract({
+        address: marketContractAddress,
+        abi: disputeFeeAbi,
+        functionName: 'getDisputeAppealFee',
+        args: [option],
+    });
+    return fee;
+}

package/dist/markets/getOrderInfo.d.ts

@@ -0,0 +1,53 @@
+export declare function getUserActiveBuyOrders(params: {
+    marketContractAddress: `0x${string}`;
+    userAddress: `0x${string}`;
+    rpcUrl: string;
+}): Promise<bigint>;
+export declare function getUserActiveSellOrders(params: {
+    marketContractAddress: `0x${string}`;
+    userAddress: `0x${string}`;
+    rpcUrl: string;
+}): Promise<bigint>;
+export declare function getFirstBuyOrderPrice(params: {
+    marketContractAddress: `0x${string}`;
+    option: bigint;
+    optionSide: number;
+    rpcUrl: string;
+}): Promise<bigint>;
+export declare function getFirstSellOrderPrice(params: {
+    marketContractAddress: `0x${string}`;
+    option: bigint;
+    optionSide: number;
+    rpcUrl: string;
+}): Promise<bigint>;
+export interface OrderLevelInfo {
+    headIndex: bigint;
+    tailIndex: bigint;
+    count: bigint;
+    isInitialized: boolean;
+}
+export declare function getBuyOrdersAtPrice(params: {
+    marketContractAddress: `0x${string}`;
+    option: bigint;
+    optionSide: number;
+    price: bigint;
+    rpcUrl: string;
+}): Promise<OrderLevelInfo>;
+export declare function getSellOrdersAtPrice(params: {
+    marketContractAddress: `0x${string}`;
+    option: bigint;
+    optionSide: number;
+    price: bigint;
+    rpcUrl: string;
+}): Promise<OrderLevelInfo>;
+export declare function checkOrderExists(params: {
+    marketContractAddress: `0x${string}`;
+    option: bigint;
+    optionSide: number;
+    price: bigint;
+    orderID: bigint;
+    rpcUrl: string;
+}): Promise<{
+    exists: boolean;
+    index: bigint;
+}>;

package/dist/markets/getOrderInfo.js

@@ -0,0 +1,80 @@
+import { createPublicClient, http, parseAbi } from 'viem';
+import { arbitrum } from 'viem/chains';
+const orderInfoAbi = parseAbi([
+    'function userActiveBuyOrders(address user) view returns (uint256)',
+    'function userActiveSellOrders(address user) view returns (uint256)',
+    'function firstBuyOrderPrice(uint256 option, uint8 optionSide) view returns (uint256)',
+    'function firstSellOrderPrice(uint256 option, uint8 optionSide) view returns (uint256)',
+    'function buyOrders(uint256 option, uint8 optionSide, uint256 price) view returns (int256 headIndex, int256 tailIndex, int256 count, bool isInitialized)',
+    'function sellOrders(uint256 option, uint8 optionSide, uint256 price) view returns (int256 headIndex, int256 tailIndex, int256 count, bool isInitialized)',
+    'function orderBook(uint256 option, uint8 optionSide, uint256 price, uint256 orderID) view returns (bool exists, int256 index)',
+]);
+function getClient(rpcUrl) {
+    return createPublicClient({ chain: arbitrum, transport: http(rpcUrl) });
+}
+export async function getUserActiveBuyOrders(params) {
+    const client = getClient(params.rpcUrl);
+    return await client.readContract({
+        address: params.marketContractAddress,
+        abi: orderInfoAbi,
+        functionName: 'userActiveBuyOrders',
+        args: [params.userAddress],
+    });
+}
+export async function getUserActiveSellOrders(params) {
+    const client = getClient(params.rpcUrl);
+    return await client.readContract({
+        address: params.marketContractAddress,
+        abi: orderInfoAbi,
+        functionName: 'userActiveSellOrders',
+        args: [params.userAddress],
+    });
+}
+export async function getFirstBuyOrderPrice(params) {
+    const client = getClient(params.rpcUrl);
+    return await client.readContract({
+        address: params.marketContractAddress,
+        abi: orderInfoAbi,
+        functionName: 'firstBuyOrderPrice',
+        args: [params.option, params.optionSide],
+    });
+}
+export async function getFirstSellOrderPrice(params) {
+    const client = getClient(params.rpcUrl);
+    return await client.readContract({
+        address: params.marketContractAddress,
+        abi: orderInfoAbi,
+        functionName: 'firstSellOrderPrice',
+        args: [params.option, params.optionSide],
+    });
+}
+export async function getBuyOrdersAtPrice(params) {
+    const client = getClient(params.rpcUrl);
+    const [headIndex, tailIndex, count, isInitialized] = await client.readContract({
+        address: params.marketContractAddress,
+        abi: orderInfoAbi,
+        functionName: 'buyOrders',
+        args: [params.option, params.optionSide, params.price],
+    });
+    return { headIndex, tailIndex, count, isInitialized };
+}
+export async function getSellOrdersAtPrice(params) {
+    const client = getClient(params.rpcUrl);
+    const [headIndex, tailIndex, count, isInitialized] = await client.readContract({
+        address: params.marketContractAddress,
+        abi: orderInfoAbi,
+        functionName: 'sellOrders',
+        args: [params.option, params.optionSide, params.price],
+    });
+    return { headIndex, tailIndex, count, isInitialized };
+}
+export async function checkOrderExists(params) {
+    const client = getClient(params.rpcUrl);
+    const [exists, index] = await client.readContract({
+        address: params.marketContractAddress,
+        abi: orderInfoAbi,
+        functionName: 'orderBook',
+        args: [params.option, params.optionSide, params.price, params.orderID],
+    });
+    return { exists, index };
+}

package/dist/markets/getResolverBondAmount.d.ts

@@ -0,0 +1,9 @@
+export declare function getResolverBondAmount(params: {
+    marketContractAddress: `0x${string}`;
+    option: bigint;
+    rpcUrl: string;
+}): Promise<bigint>;
+export declare function getMarketBaseToken(params: {
+    marketContractAddress: `0x${string}`;
+    rpcUrl: string;
+}): Promise<`0x${string}`>;

package/dist/markets/getResolverBondAmount.js

@@ -0,0 +1,35 @@
+import { createPublicClient, http, parseAbi } from 'viem';
+import { arbitrum } from 'viem/chains';
+const resolverBondAbi = parseAbi([
+    'function getResolverBondAmount(uint256 option) view returns (uint256 resolverBondAmount)',
+]);
+const baseTokenAbi = parseAbi([
+    'function baseToken() view returns (address)',
+]);
+export async function getResolverBondAmount(params) {
+    const { marketContractAddress, option, rpcUrl } = params;
+    const client = createPublicClient({
+        chain: arbitrum,
+        transport: http(rpcUrl),
+    });
+    const bond = await client.readContract({
+        address: marketContractAddress,
+        abi: resolverBondAbi,
+        functionName: 'getResolverBondAmount',
+        args: [option],
+    });
+    return bond;
+}
+export async function getMarketBaseToken(params) {
+    const { marketContractAddress, rpcUrl } = params;
+    const client = createPublicClient({
+        chain: arbitrum,
+        transport: http(rpcUrl),
+    });
+    const token = await client.readContract({
+        address: marketContractAddress,
+        abi: baseTokenAbi,
+        functionName: 'baseToken',
+    });
+    return token;
+}

package/dist/markets/getUserOptionLPShares.d.ts

@@ -0,0 +1,7 @@
+export interface GetUserOptionLPSharesParams {
+    marketContractAddress: `0x${string}`;
+    option: bigint;
+    userAddress: `0x${string}`;
+    rpcUrl: string;
+}
+export declare function getUserOptionLPShares(params: GetUserOptionLPSharesParams): Promise<bigint>;

package/dist/markets/getUserOptionLPShares.js

@@ -0,0 +1,17 @@
+import { createPublicClient, http } from 'viem';
+import { arbitrum } from 'viem/chains';
+import { MarketsAbi } from '../abi/MarketsAbi.js';
+export async function getUserOptionLPShares(params) {
+    const { marketContractAddress, option, userAddress, rpcUrl } = params;
+    const client = createPublicClient({
+        chain: arbitrum,
+        transport: http(rpcUrl),
+    });
+    const shares = await client.readContract({
+        address: marketContractAddress,
+        abi: MarketsAbi,
+        functionName: 'userOptionLPShares',
+        args: [option, userAddress],
+    });
+    return shares;
+}

package/dist/markets/getUserOptionShares.d.ts

@@ -0,0 +1,8 @@
+export interface GetUserOptionSharesParams {
+    marketContractAddress: `0x${string}`;
+    option: bigint;
+    optionSide: number;
+    userAddress: `0x${string}`;
+    rpcUrl: string;
+}
+export declare function getUserOptionShares(params: GetUserOptionSharesParams): Promise<bigint>;

package/dist/markets/getUserOptionShares.js

@@ -0,0 +1,17 @@
+import { createPublicClient, http } from 'viem';
+import { arbitrum } from 'viem/chains';
+import { MarketsAbi } from '../abi/MarketsAbi.js';
+export async function getUserOptionShares(params) {
+    const { marketContractAddress, option, optionSide, userAddress, rpcUrl } = params;
+    const client = createPublicClient({
+        chain: arbitrum,
+        transport: http(rpcUrl),
+    });
+    const shares = await client.readContract({
+        address: marketContractAddress,
+        abi: MarketsAbi,
+        functionName: 'userOptionPerSideShares',
+        args: [option, optionSide, userAddress],
+    });
+    return shares;
+}

package/dist/socket/RainSocket.d.ts

@@ -0,0 +1,175 @@
+export type RainSocketEvent = 'enter-option' | 'exit-option' | 'liquidity' | 'split' | 'merge' | 'remove-liquidity' | 'sync-price' | 'order-created' | 'order-cancelled' | 'order-filled' | 'pool-closed' | 'pool-reverted' | 'pool-token-set' | 'streamingStatusChanged' | 'winner' | 'winner-proposer' | 'reveal-winner-available' | 'dispute-opened' | 'oracle-created' | 'dispute-time-extented' | 'appeal-opened' | 'appeal-winner-calculated' | 'dispute-winner' | 'appeal-winner' | 'claim-reward' | 'dispute-refund' | 'appeal-refund' | 'resolution-refund' | 'resolver-reward' | 'notifications' | 'pool';
+export interface EnterOptionEventData {
+    enterOption: Record<string, any>;
+    pool: Record<string, any>;
+    subPool: Record<string, any>;
+}
+export interface ExitOptionEventData {
+    exitOption: Record<string, any>;
+    pool: Record<string, any>;
+    subPool: Record<string, any>;
+}
+export interface LiquidityEventData {
+    enterLiquidity: Record<string, any>;
+    pool: Record<string, any>;
+    subPool: Record<string, any>;
+}
+export interface SplitEventData {
+    split: Record<string, any>;
+    pool: Record<string, any>;
+    subPool: Record<string, any>;
+}
+export interface MergeEventData {
+    merge: Record<string, any>;
+    pool: Record<string, any>;
+    subPool: Record<string, any>;
+}
+export interface RemoveLiquidityEventData {
+    removeLiquidity: Record<string, any>;
+    pool: Record<string, any>;
+    subPool: Record<string, any>;
+}
+export interface SyncPriceEventData {
+    prices: Array<{
+        side: number;
+        price: number;
+        percentage: number;
+        subPoolIndex: number;
+    }>;
+    pool: Record<string, any>;
+    subPool: Record<string, any>;
+}
+export interface OrderCreatedEventData {
+    order: Record<string, any>;
+    pool: Record<string, any>;
+    subPool: Record<string, any>;
+}
+export interface OrderCancelledEventData {
+    order: Record<string, any>;
+    pool: Record<string, any>;
+    subPool: Record<string, any>;
+}
+export interface OrderFilledEventData {
+    filledOrder: Record<string, any>;
+    pendingOrder?: Record<string, any>;
+    pool: Record<string, any>;
+    subPool: Record<string, any>;
+}
+export interface PoolClosedEventData {
+    pool: Record<string, any>;
+    subPool?: Record<string, any>;
+}
+export interface PoolEventData {
+    pool: Record<string, any>;
+    subMarkets?: Record<string, any>[];
+}
+export interface WinnerEventData {
+    pool: Record<string, any>;
+    subPool: Record<string, any>;
+}
+export interface DisputeOpenedEventData {
+    subPool: Record<string, any>;
+    eventType: string;
+}
+export interface OracleCreatedEventData {
+    pool: Record<string, any>;
+    subPool: Record<string, any>;
+}
+export interface AppealOpenedEventData {
+    pool: Record<string, any>;
+    subPool: Record<string, any>;
+}
+export interface DisputeWinnerEventData {
+    subPool: Record<string, any>;
+    eventType: string;
+}
+export interface AppealWinnerEventData {
+    subPool: Record<string, any>;
+    eventType: string;
+    winnerFinalized: boolean;
+}
+export interface ClaimRewardEventData {
+    claimReward: Record<string, any>;
+    pool: Record<string, any>;
+    subPool: Record<string, any>;
+}
+export interface DisputeRefundEventData {
+    claimReward: Record<string, any>;
+    pool: Record<string, any>;
+    subPool: Record<string, any>;
+}
+export declare class RainSocket {
+    private socket;
+    private url;
+    private listeners;
+    constructor(url: string);
+    /**
+     * Connect to the Socket.IO server
+     */
+    connect(): void;
+    /**
+     * Disconnect from the server
+     */
+    disconnect(): void;
+    /**
+     * Check if connected
+     */
+    get isConnected(): boolean;
+    /**
+     * Subscribe to an event for a specific pool
+     * @returns unsubscribe function
+     */
+    on(event: RainSocketEvent, poolId: string, callback: (data: any) => void): () => void;
+    /**
+     * Subscribe to a global event (no poolId)
+     * @returns unsubscribe function
+     */
+    onGlobal(event: 'pool', callback: (data: PoolEventData) => void): () => void;
+    /**
+     * Subscribe to a raw channel name
+     * @returns unsubscribe function
+     */
+    onChannel(channel: string, callback: (data: any) => void): () => void;
+    onEnterOption(poolId: string, callback: (data: EnterOptionEventData) => void): () => void;
+    onExitOption(poolId: string, callback: (data: ExitOptionEventData) => void): () => void;
+    onLiquidity(poolId: string, callback: (data: LiquidityEventData) => void): () => void;
+    onSplit(poolId: string, callback: (data: SplitEventData) => void): () => void;
+    onMerge(poolId: string, callback: (data: MergeEventData) => void): () => void;
+    onRemoveLiquidity(poolId: string, callback: (data: RemoveLiquidityEventData) => void): () => void;
+    onSyncPrice(poolId: string, callback: (data: SyncPriceEventData) => void): () => void;
+    onOrderCreated(poolId: string, callback: (data: OrderCreatedEventData) => void): () => void;
+    onOrderCancelled(poolId: string, callback: (data: OrderCancelledEventData) => void): () => void;
+    onOrderFilled(poolId: string, callback: (data: OrderFilledEventData) => void): () => void;
+    onPoolClosed(poolId: string, callback: (data: PoolClosedEventData) => void): () => void;
+    onPoolReverted(poolId: string, callback: (data: any) => void): () => void;
+    onPoolTokenSet(poolId: string, callback: (data: any) => void): () => void;
+    onStreamingStatusChanged(poolId: string, callback: (data: any) => void): () => void;
+    onNewPool(callback: (data: PoolEventData) => void): () => void;
+    onWinner(poolId: string, callback: (data: WinnerEventData) => void): () => void;
+    onWinnerProposer(poolId: string, callback: (data: WinnerEventData) => void): () => void;
+    onRevealWinnerAvailable(poolId: string, callback: (data: {
+        subPoolId: string;
+    }) => void): () => void;
+    onDisputeOpened(poolId: string, callback: (data: DisputeOpenedEventData) => void): () => void;
+    onOracleCreated(poolId: string, callback: (data: OracleCreatedEventData) => void): () => void;
+    onDisputeTimeExtended(poolId: string, callback: (data: {
+        pool: Record<string, any>;
+        subPool: Record<string, any>;
+    }) => void): () => void;
+    onAppealOpened(poolId: string, callback: (data: AppealOpenedEventData) => void): () => void;
+    onAppealWinnerCalculated(poolId: string, callback: (data: {
+        subPool: Record<string, any>;
+    }) => void): () => void;
+    onDisputeWinner(poolId: string, callback: (data: DisputeWinnerEventData) => void): () => void;
+    onAppealWinner(poolId: string, callback: (data: AppealWinnerEventData) => void): () => void;
+    onClaimReward(poolId: string, callback: (data: ClaimRewardEventData) => void): () => void;
+    /**
+     * User-scoped claim reward event: claim-reward/{poolId}/{userId}
+     */
+    onUserClaimReward(poolId: string, userId: string, callback: (data: ClaimRewardEventData) => void): () => void;
+    onDisputeRefund(poolId: string, userId: string, callback: (data: DisputeRefundEventData) => void): () => void;
+    onAppealRefund(poolId: string, userId: string, callback: (data: DisputeRefundEventData) => void): () => void;
+    onResolutionRefund(poolId: string, userId: string, callback: (data: ClaimRewardEventData) => void): () => void;
+    onResolverReward(poolId: string, userId: string, callback: (data: ClaimRewardEventData) => void): () => void;
+    onNotifications(userId: string, callback: (data: any) => void): () => void;
+}