@rainprotocolsdk/sdk 2.1.2 → 2.3.0

package/dist/Rain.d.ts

@@ -1,5 +1,5 @@
 import { GetMarketByIdParams, GetMarketsParams, GetUserInvestmentsParams, Market, UserInvestment } from './markets/types.js';
-import { ApproveTxParams, CancelAllOpenOrdersTxParams, CancelOrdersTxParams, ClaimTxParams, CloseMarketTxParams, CreateDisputeTxParams, CreateAppealTxParams, CreateMarketTxParams, EnterLimitOptionTxParams, EnterOptionTxParams, ExtendTimeTxParams, LimitSellOptionTxParams, RawTransaction } from './tx/types.js';
+import { AddLiquidityTxParams, ApproveTxParams, CancelAllOpenOrdersTxParams, CancelOrdersTxParams, ClaimTxParams, CloseMarketTxParams, CreateDisputeTxParams, CreateAppealTxParams, CreateMarketTxParams, EnterLimitOptionTxParams, EnterOptionTxParams, ExtendTimeTxParams, LimitSellOptionTxParams, RawTransaction } from './tx/types.js';
 import { RainCoreConfig, RainEnvironment } from './types.js';
 import { LoginParams, LoginResult } from './auth/types.js';
 export declare class Rain {
@@ -25,5 +25,6 @@ export declare class Rain {
     buildCreateDisputeTx(params: CreateDisputeTxParams): Promise<RawTransaction[]>;
     buildCreateAppealTx(params: CreateAppealTxParams): Promise<RawTransaction[]>;
     buildExtendTimeTx(params: ExtendTimeTxParams): Promise<RawTransaction>;
+    buildAddLiquidityTx(params: AddLiquidityTxParams): Promise<RawTransaction[]>;
     login(params: LoginParams): Promise<LoginResult>;
 }

package/dist/Rain.js

@@ -11,6 +11,7 @@ import { buildCreateMarketRawTx } from './tx/CreateMarket/buildCreateMarketRawTx
 import { ALLOWED_ENVIRONMENTS, ENV_CONFIG, getRandomRpc } from './config/environments.js';
 import { buildClaimRawTx } from './tx/ClaimFunds/buildClaimFundsRawTx.js';
 import { buildExtendTimeRawTx } from './tx/ExtendTime/buildExtendTimeRawTx.js';
+import { buildAddLiquidityRawTx } from './tx/AddLiquidity/buildAddLiquidityRawTx.js';
 import { loginUser } from './auth/login.js';
 export class Rain {
     environment;
@@ -80,6 +81,13 @@ export class Rain {
     async buildExtendTimeTx(params) {
         return buildExtendTimeRawTx({ ...params, apiUrl: this.apiUrl, rpcUrl: this.rpcUrl });
     }
+    async buildAddLiquidityTx(params) {
+        return buildAddLiquidityRawTx({
+            ...params,
+            environment: this.environment,
+            rpcUrl: params.rpcUrl ?? this.rpcUrl,
+        });
+    }
     async login(params) {
         return loginUser({ ...params, apiUrl: this.apiUrl });
     }

package/dist/config/environments.d.ts

@@ -9,17 +9,23 @@ export declare const ENV_CONFIG: {
         readonly market_factory_address: "0x148DA7F2039B2B00633AC2ab566f59C8a4C86313";
         readonly dispute_initial_timer: number;
         readonly usdt_symbol: "USDTm";
+        readonly usdt_token: `0x${string}`;
+        readonly rain_token: `0x${string}`;
     };
     readonly stage: {
         readonly apiUrl: "https://stg-api.rain.one";
         readonly market_factory_address: "0x6109c9f28FE3Ad84c51368f7Ef2d487ca020c561";
         readonly dispute_initial_timer: number;
         readonly usdt_symbol: "USD₮0";
+        readonly usdt_token: `0x${string}`;
+        readonly rain_token: `0x${string}`;
     };
     readonly production: {
         readonly apiUrl: "https://prod-api.rain.one";
         readonly market_factory_address: "0xccCB3C03D9355B01883779EF15C1Be09cf3623F1";
         readonly dispute_initial_timer: number;
         readonly usdt_symbol: "USD₮0";
+        readonly usdt_token: `0x${string}`;
+        readonly rain_token: `0x${string}`;
     };
 };

package/dist/config/environments.js

@@ -16,17 +16,23 @@ export const ENV_CONFIG = {
         market_factory_address: "0x148DA7F2039B2B00633AC2ab566f59C8a4C86313",
         dispute_initial_timer: 1 * 60,
         usdt_symbol: USDT_SYMBOL_DEV,
+        usdt_token: "0xCa4f77A38d8552Dd1D5E44e890173921B67725F4",
+        rain_token: "0x25118290e6A5f4139381D072181157035864099d",
     },
     stage: {
         apiUrl: "https://stg-api.rain.one",
         market_factory_address: "0x6109c9f28FE3Ad84c51368f7Ef2d487ca020c561",
         dispute_initial_timer: 1 * 60,
         usdt_symbol: USDT_SYMBOL_PROD,
+        usdt_token: "0xFd086bC7CD5C481DCC9C85ebE478A1C0b69FCbb9",
+        rain_token: "0x43976a124e6834b541840Ce741243dAD3dd538DA",
     },
     production: {
         apiUrl: "https://prod-api.rain.one",
         market_factory_address: "0xccCB3C03D9355B01883779EF15C1Be09cf3623F1",
         dispute_initial_timer: 120 * 60,
         usdt_symbol: USDT_SYMBOL_PROD,
+        usdt_token: "0xFd086bC7CD5C481DCC9C85ebE478A1C0b69FCbb9",
+        rain_token: "0x43976a124e6834b541840Ce741243dAD3dd538DA",
     },
 };

package/dist/index.d.ts

@@ -1,4 +1,6 @@
 export { Rain } from './Rain.js';
 export { RainAA } from './RainAA.js';
+export { RainSocket } from './socket/RainSocket.js';
 export * from './types.js';
 export type { LoginParams, LoginResult } from './auth/types.js';
+export type { EnterOptionEventData, OrderEventData, OrderFilledEventData, DisputeOpenedEventData, AppealOpenedEventData, DisputeTimeExtendedEventData, DisputeWinnerEventData, AppealWinnerEventData, ClaimRewardEventData } from './socket/types.js';

package/dist/index.js

@@ -1,3 +1,4 @@
 export { Rain } from './Rain.js';
 export { RainAA } from './RainAA.js';
+export { RainSocket } from './socket/RainSocket.js';
 export * from './types.js';

package/dist/socket/RainSocket.d.ts

@@ -0,0 +1,59 @@
+import { RainCoreConfig } from '../types.js';
+import { EnterOptionEventData, OrderEventData, OrderFilledEventData, DisputeOpenedEventData, AppealOpenedEventData, DisputeTimeExtendedEventData, DisputeWinnerEventData, AppealWinnerEventData, ClaimRewardEventData } from './types.js';
+export declare class RainSocket {
+    private socket;
+    constructor(config?: RainCoreConfig);
+    get connected(): boolean;
+    onConnect(callback: () => void): void;
+    onDisconnect(callback: () => void): void;
+    /**
+     * Subscribe to the enter-option event for a specific market.
+     * Fires when a user buys into a market option.
+     * Returns an unsubscribe function — call it to stop listening.
+     */
+    onEnterOption(marketId: string, callback: (data: EnterOptionEventData) => void): () => void;
+    /**
+     * Subscribe to the order-created event for a specific market.
+     * Fires when a new limit order is placed.
+     */
+    onOrderCreated(marketId: string, callback: (data: OrderEventData) => void): () => void;
+    /**
+     * Subscribe to the order-cancelled event for a specific market.
+     * Fires when an open order is cancelled.
+     */
+    onOrderCancelled(marketId: string, callback: (data: OrderEventData) => void): () => void;
+    /**
+     * Subscribe to the order-filled event for a specific market.
+     * Fires when an order is partially or fully filled.
+     */
+    onOrderFilled(marketId: string, callback: (data: OrderFilledEventData) => void): () => void;
+    /**
+     * Subscribe to the dispute-opened event for a specific market.
+     */
+    onDisputeOpened(marketId: string, callback: (data: DisputeOpenedEventData) => void): () => void;
+    /**
+     * Subscribe to the appeal-opened event for a specific market.
+     */
+    onAppealOpened(marketId: string, callback: (data: AppealOpenedEventData) => void): () => void;
+    /**
+     * Subscribe to the dispute-time-extented event for a specific market.
+     * Note: event name matches the backend spelling ("extented").
+     */
+    onDisputeTimeExtended(marketId: string, callback: (data: DisputeTimeExtendedEventData) => void): () => void;
+    /**
+     * Subscribe to the dispute-winner event for a specific market.
+     * Fires when a dispute winner is decided.
+     */
+    onDisputeWinner(marketId: string, callback: (data: DisputeWinnerEventData) => void): () => void;
+    /**
+     * Subscribe to the appeal-winner event for a specific market.
+     * Fires when an appeal winner is finalized.
+     */
+    onAppealWinner(marketId: string, callback: (data: AppealWinnerEventData) => void): () => void;
+    /**
+     * Subscribe to the claim-reward event for a specific market and user.
+     * Fires when a user's reward claim is confirmed.
+     */
+    onClaimReward(marketId: string, userId: string, callback: (data: ClaimRewardEventData) => void): () => void;
+    disconnect(): void;
+}

package/dist/socket/RainSocket.js

@@ -0,0 +1,193 @@
+import { io } from 'socket.io-client';
+import { ALLOWED_ENVIRONMENTS, ENV_CONFIG } from '../config/environments.js';
+export class RainSocket {
+    socket;
+    constructor(config = {}) {
+        const { environment = 'development' } = config;
+        function isValidEnvironment(env) {
+            return ALLOWED_ENVIRONMENTS.includes(env);
+        }
+        if (!isValidEnvironment(environment)) {
+            throw new Error(`Invalid environment "${environment}". Allowed values: ${ALLOWED_ENVIRONMENTS.join(', ')}`);
+        }
+        const { apiUrl } = ENV_CONFIG[environment];
+        this.socket = io(apiUrl, { transports: ['websocket', 'polling'] });
+    }
+    get connected() {
+        return this.socket.connected;
+    }
+    onConnect(callback) {
+        this.socket.on('connect', callback);
+    }
+    onDisconnect(callback) {
+        this.socket.on('disconnect', callback);
+    }
+    /**
+     * Subscribe to the enter-option event for a specific market.
+     * Fires when a user buys into a market option.
+     * Returns an unsubscribe function — call it to stop listening.
+     */
+    onEnterOption(marketId, callback) {
+        const event = `enter-option/${marketId}`;
+        const handler = (raw) => {
+            const investments = (raw?.enterOption?.investment ?? []).map((inv) => ({
+                choiceIndex: inv?.choiceIndex ?? inv?.option ?? 0,
+                amount: String(inv?.amount ?? inv?.investment ?? '0'),
+                optionName: inv?.optionName,
+            }));
+            callback({
+                poolId: raw?.pool?._id ?? marketId,
+                investments,
+                totalInvestmentWei: String(raw?.enterOption?.totalInvestment ?? '0'),
+                tokenDecimals: raw?.pool?.token?.tokenDecimals ?? 6,
+            });
+        };
+        this.socket.on(event, handler);
+        return () => this.socket.off(event, handler);
+    }
+    /**
+     * Subscribe to the order-created event for a specific market.
+     * Fires when a new limit order is placed.
+     */
+    onOrderCreated(marketId, callback) {
+        const event = `order-created/${marketId}`;
+        const handler = (raw) => {
+            callback({
+                poolId: raw?.pool?._id ?? marketId,
+                order: raw?.order ?? {},
+                tokenDecimals: raw?.pool?.token?.tokenDecimals ?? 6,
+            });
+        };
+        this.socket.on(event, handler);
+        return () => this.socket.off(event, handler);
+    }
+    /**
+     * Subscribe to the order-cancelled event for a specific market.
+     * Fires when an open order is cancelled.
+     */
+    onOrderCancelled(marketId, callback) {
+        const event = `order-cancelled/${marketId}`;
+        const handler = (raw) => {
+            callback({
+                poolId: raw?.pool?._id ?? marketId,
+                order: raw?.order ?? {},
+                tokenDecimals: raw?.pool?.token?.tokenDecimals ?? 6,
+            });
+        };
+        this.socket.on(event, handler);
+        return () => this.socket.off(event, handler);
+    }
+    /**
+     * Subscribe to the order-filled event for a specific market.
+     * Fires when an order is partially or fully filled.
+     */
+    onOrderFilled(marketId, callback) {
+        const event = `order-filled/${marketId}`;
+        const handler = (raw) => {
+            callback({ poolId: raw?.pool?._id ?? marketId, raw });
+        };
+        this.socket.on(event, handler);
+        return () => this.socket.off(event, handler);
+    }
+    /**
+     * Subscribe to the dispute-opened event for a specific market.
+     */
+    onDisputeOpened(marketId, callback) {
+        const event = `dispute-opened/${marketId}`;
+        const handler = (raw) => {
+            callback({
+                poolId: raw?.pool?._id ?? marketId,
+                isDisputed: raw?.pool?.isDisputed ?? false,
+                isAiResolver: raw?.pool?.isAiResolver ?? false,
+                status: raw?.pool?.status ?? '',
+                disputeData: raw?.pool?.disputeData ?? null,
+                winnerDecidedBy: raw?.pool?.winnerOption?.decidedBy ?? '',
+            });
+        };
+        this.socket.on(event, handler);
+        return () => this.socket.off(event, handler);
+    }
+    /**
+     * Subscribe to the appeal-opened event for a specific market.
+     */
+    onAppealOpened(marketId, callback) {
+        const event = `appeal-opened/${marketId}`;
+        const handler = (raw) => {
+            callback({
+                poolId: raw?.pool?._id ?? marketId,
+                eventType: raw?.eventType ?? '',
+                isAppealed: raw?.pool?.isAppealed ?? false,
+            });
+        };
+        this.socket.on(event, handler);
+        return () => this.socket.off(event, handler);
+    }
+    /**
+     * Subscribe to the dispute-time-extented event for a specific market.
+     * Note: event name matches the backend spelling ("extented").
+     */
+    onDisputeTimeExtended(marketId, callback) {
+        const event = `dispute-time-extented/${marketId}`;
+        const handler = (raw) => {
+            callback({
+                poolId: raw?.pool?._id ?? marketId,
+                eventType: raw?.eventType ?? '',
+                newEndTime: raw?.newEndTime ?? '',
+            });
+        };
+        this.socket.on(event, handler);
+        return () => this.socket.off(event, handler);
+    }
+    /**
+     * Subscribe to the dispute-winner event for a specific market.
+     * Fires when a dispute winner is decided.
+     */
+    onDisputeWinner(marketId, callback) {
+        const event = `dispute-winner/${marketId}`;
+        const handler = (raw) => {
+            callback({
+                poolId: raw?.pool?._id ?? marketId,
+                status: raw?.pool?.status ?? '',
+                winnerOption: {
+                    decidedBy: raw?.pool?.winnerOption?.decidedBy ?? '',
+                    choiceIndex: raw?.pool?.winnerOption?.choiceIndex ?? 0,
+                    createdAt: raw?.pool?.winnerOption?.createdAt ?? '',
+                },
+            });
+        };
+        this.socket.on(event, handler);
+        return () => this.socket.off(event, handler);
+    }
+    /**
+     * Subscribe to the appeal-winner event for a specific market.
+     * Fires when an appeal winner is finalized.
+     */
+    onAppealWinner(marketId, callback) {
+        const event = `appeal-winner/${marketId}`;
+        const handler = (raw) => {
+            callback({
+                poolId: raw?.pool?._id ?? marketId,
+                eventType: raw?.eventType ?? '',
+                winnerFinalized: raw?.winnerFinalized ?? null,
+                winnerOption: raw?.pool?.winnerOption ?? null,
+            });
+        };
+        this.socket.on(event, handler);
+        return () => this.socket.off(event, handler);
+    }
+    /**
+     * Subscribe to the claim-reward event for a specific market and user.
+     * Fires when a user's reward claim is confirmed.
+     */
+    onClaimReward(marketId, userId, callback) {
+        const event = `claim-reward/${marketId}/${userId}`;
+        const handler = (_raw) => {
+            callback({ poolId: marketId, userId });
+        };
+        this.socket.on(event, handler);
+        return () => this.socket.off(event, handler);
+    }
+    disconnect() {
+        this.socket.disconnect();
+    }
+}

package/dist/socket/types.d.ts

@@ -0,0 +1,65 @@
+export interface EnterOptionEventData {
+    poolId: string;
+    investments: {
+        choiceIndex: number;
+        amount: string;
+        optionName?: string;
+    }[];
+    totalInvestmentWei: string;
+    tokenDecimals: number;
+}
+export interface OrderEventData {
+    poolId: string;
+    order: {
+        _id: string;
+        orderType: 'buy' | 'sell';
+        option: number;
+        optionName?: string;
+        pricePerShare: string;
+        quantity: string;
+        createdAt: string;
+        [key: string]: any;
+    };
+    tokenDecimals: number;
+}
+export interface OrderFilledEventData {
+    poolId: string;
+    raw: any;
+}
+export interface DisputeOpenedEventData {
+    poolId: string;
+    isDisputed: boolean;
+    isAiResolver: boolean;
+    status: string;
+    disputeData: any;
+    winnerDecidedBy: string;
+}
+export interface AppealOpenedEventData {
+    poolId: string;
+    eventType: string;
+    isAppealed: boolean;
+}
+export interface DisputeTimeExtendedEventData {
+    poolId: string;
+    eventType: string;
+    newEndTime: string | number;
+}
+export interface DisputeWinnerEventData {
+    poolId: string;
+    status: string;
+    winnerOption: {
+        decidedBy: string;
+        choiceIndex: number;
+        createdAt: string;
+    };
+}
+export interface AppealWinnerEventData {
+    poolId: string;
+    eventType: string;
+    winnerFinalized: any;
+    winnerOption: any;
+}
+export interface ClaimRewardEventData {
+    poolId: string;
+    userId: string;
+}

package/dist/socket/types.js

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

package/dist/tx/AddLiquidity/buildAddLiquidityRawTx.d.ts

@@ -0,0 +1,8 @@
+import { AddLiquidityTxParams, RawTransaction } from "../types.js";
+import { RainEnvironment } from "../../types.js";
+interface AddLiquidityRawTxInternalParams extends AddLiquidityTxParams {
+    environment: RainEnvironment;
+    rpcUrl: string;
+}
+export declare function buildAddLiquidityRawTx(params: AddLiquidityRawTxInternalParams): Promise<RawTransaction[]>;
+export {};

package/dist/tx/AddLiquidity/buildAddLiquidityRawTx.js

@@ -0,0 +1,51 @@
+import { encodeFunctionData } from "viem";
+import { Contract, JsonRpcProvider, ethers } from "ethers";
+import { TradePoolAbi } from "../../abi/TradeMarketsAbi.js";
+import { buildApproveRawTx } from "../buildApprovalRawTx.js";
+import { getTokenAllowance } from "../CloseMarket/helpers.js";
+import { isRpcValid } from "../ClaimFunds/helpers.js";
+import { ENV_CONFIG, ALLOWED_ENVIRONMENTS } from "../../config/environments.js";
+async function getMarketBaseToken(marketContractAddress, rpcUrl) {
+    const provider = new JsonRpcProvider(rpcUrl);
+    const contract = new Contract(marketContractAddress, TradePoolAbi, provider);
+    return (await contract.baseToken()).toLowerCase();
+}
+export async function buildAddLiquidityRawTx(params) {
+    const { marketContractAddress, walletAddress, amount, environment, rpcUrl } = params;
+    if (!marketContractAddress)
+        throw new Error("marketContractAddress is required");
+    if (!walletAddress)
+        throw new Error("walletAddress is required");
+    if (!amount)
+        throw new Error("amount is required");
+    if (!ALLOWED_ENVIRONMENTS.includes(environment))
+        throw new Error(`Invalid environment: ${environment}`);
+    const isRpcWorking = await isRpcValid(rpcUrl);
+    if (!isRpcWorking)
+        throw new Error("Provided RPC URL is not valid or not working");
+    const { usdt_token, rain_token } = ENV_CONFIG[environment];
+    // Read base token from the market contract
+    const baseToken = await getMarketBaseToken(marketContractAddress, rpcUrl);
+    const isUsdtMarket = baseToken === usdt_token.toLowerCase();
+    const tokenAddress = isUsdtMarket ? usdt_token : rain_token;
+    // USDT uses 6 decimals, RAIN uses 18
+    const decimals = isUsdtMarket ? 6 : 18;
+    const amountInWei = ethers.parseUnits(amount.toString(), decimals);
+    const txs = [];
+    // Check allowance for the correct token only
+    const allowance = await getTokenAllowance(tokenAddress, walletAddress, marketContractAddress, rpcUrl);
+    if (BigInt(allowance) < amountInWei) {
+        txs.push(buildApproveRawTx({ tokenAddress, spender: marketContractAddress }));
+    }
+    // enterLiquidity tx on the market contract
+    txs.push({
+        to: marketContractAddress,
+        data: encodeFunctionData({
+            abi: TradePoolAbi,
+            functionName: "enterLiquidity",
+            args: [amountInWei],
+        }),
+        value: 0n,
+    });
+    return txs;
+}

package/dist/tx/types.d.ts

@@ -99,6 +99,12 @@ export interface CancelAllOpenOrdersTxParams {
     accessToken: string;
     apiUrl?: string;
 }
+export interface AddLiquidityTxParams {
+    marketContractAddress: `0x${string}`;
+    walletAddress: `0x${string}`;
+    amount: string | number;
+    rpcUrl?: string;
+}
 export interface ExtendTimeTxParams {
     marketContractAddress: `0x${string}`;
     walletAddress: `0x${string}`;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@rainprotocolsdk/sdk",
-    "version": "2.1.2",
+    "version": "2.3.0",
     "type": "module",
     "description": "Rain SDK",
     "main": "dist/index.js",
@@ -31,14 +31,21 @@
     "author": "Rain Protocol",
     "license": "MIT",
     "peerDependencies": {
-        "viem": "^2.0.0"
-    },
-    "dependencies": {
+        "viem": "^2.0.0",
         "@account-kit/infra": "^4.48.0",
         "@account-kit/wallet-client": "^0.1.0-alpha.10",
         "@alchemy/aa-alchemy": "^3.0.0",
-        "@alchemy/aa-core": "^3.0.0",
-        "ethers": "^6.16.0"
+        "@alchemy/aa-core": "^3.0.0"
+    },
+    "peerDependenciesMeta": {
+        "@account-kit/infra": { "optional": true },
+        "@account-kit/wallet-client": { "optional": true },
+        "@alchemy/aa-alchemy": { "optional": true },
+        "@alchemy/aa-core": { "optional": true }
+    },
+    "dependencies": {
+        "ethers": "^6.16.0",
+        "socket.io-client": "^4.8.3"
     },
     "devDependencies": {
         "typescript": "^5.9.3"