@rainprotocolsdk/sdk 2.1.1 → 2.2.0

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/CloseMarket/buildCloseMarketRawTx.js

@@ -30,21 +30,33 @@ export async function buildCloseMarketRawTx(params) {
         if (proposedOutcome === undefined) {
             throw new Error("proposedOutcome is required for V2 markets");
         }
-        txs.push({
-            to: contractAddress,
-            data: encodeFunctionData({
-                abi: TradePoolAbi,
-                functionName: CLOSE_POOL,
-            }),
-        });
-        txs.push({
-            to: contractAddress,
-            data: encodeFunctionData({
-                abi: TradePoolAbi,
-                functionName: CHOOSE_WINNER,
-                args: [BigInt(proposedOutcome)],
-            }),
-        });
+        if (isAiResolver) {
+            // AI resolver: closePool() with no args
+            txs.push({
+                to: contractAddress,
+                data: encodeFunctionData({
+                    abi: TradePoolAbi,
+                    functionName: CLOSE_POOL,
+                }),
+            });
+        }
+        else {
+            txs.push({
+                to: contractAddress,
+                data: encodeFunctionData({
+                    abi: TradePoolAbi,
+                    functionName: CLOSE_POOL,
+                }),
+            });
+            txs.push({
+                to: contractAddress,
+                data: encodeFunctionData({
+                    abi: TradePoolAbi,
+                    functionName: CHOOSE_WINNER,
+                    args: [BigInt(proposedOutcome)],
+                }),
+            });
+        }
     }
     else {
         // V3 flow: optional approvals → closePool() or closePool(proposedOutcome)

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@rainprotocolsdk/sdk",
-    "version": "2.1.1",
+    "version": "2.2.0",
     "type": "module",
     "description": "Rain SDK",
     "main": "dist/index.js",
@@ -38,7 +38,8 @@
         "@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"
+        "ethers": "^6.16.0",
+    "socket.io-client": "^4.8.3"
     },
     "devDependencies": {
         "typescript": "^5.9.3"