@rainprotocolsdk/sdk 1.2.0 → 2.0.0

package/dist/Rain.d.ts

@@ -1,15 +1,28 @@
-import { GetMarketsParams, Market } from './markets/types.js';
-import { ApproveTxParams, CreateMarketTxParams, EnterLimitOptionTxParams, EnterOptionTxParams, RawTransaction } from './tx/types.js';
+import { GetMarketByIdParams, GetMarketsParams, GetUserInvestmentsParams, Market, UserInvestment } from './markets/types.js';
+import { ApproveTxParams, CancelAllOpenOrdersTxParams, CancelOrdersTxParams, ClaimTxParams, CloseMarketTxParams, CreateDisputeTxParams, CreateAppealTxParams, CreateMarketTxParams, EnterLimitOptionTxParams, EnterOptionTxParams, LimitSellOptionTxParams, RawTransaction } from './tx/types.js';
 import { RainCoreConfig, RainEnvironment } from './types.js';
+import { LoginParams, LoginResult } from './auth/types.js';
 export declare class Rain {
     readonly environment: RainEnvironment;
     private readonly marketFactory;
     private readonly apiUrl;
     private readonly distute_initial_timer;
+    private readonly rpcUrl?;
+    private readonly usdtSymbol;
     constructor(config?: RainCoreConfig);
     getPublicMarkets(params: GetMarketsParams): Promise<Market[]>;
+    getMarketById(params: GetMarketByIdParams): Promise<Market>;
+    getUserInvestments(params: GetUserInvestmentsParams): Promise<UserInvestment[]>;
     buildApprovalTx(params: ApproveTxParams): RawTransaction | Error;
     buildBuyOptionRawTx(params: EnterOptionTxParams): RawTransaction;
     buildLimitBuyOptionTx(params: EnterLimitOptionTxParams): RawTransaction;
-    buildCreateMarketTx(params: CreateMarketTxParams): RawTransaction;
+    buildLimitSellOptionTx(params: LimitSellOptionTxParams): RawTransaction;
+    buildCancelOrdersTx(params: CancelOrdersTxParams): RawTransaction[];
+    buildCancelAllOpenOrdersTx(params: CancelAllOpenOrdersTxParams): Promise<RawTransaction[]>;
+    buildCreateMarketTx(params: CreateMarketTxParams): Promise<RawTransaction[]>;
+    buildClaimTx(params: ClaimTxParams): Promise<RawTransaction>;
+    buildCloseMarketTx(params: CloseMarketTxParams): Promise<RawTransaction[]>;
+    buildCreateDisputeTx(params: CreateDisputeTxParams): Promise<RawTransaction[]>;
+    buildCreateAppealTx(params: CreateAppealTxParams): Promise<RawTransaction[]>;
+    login(params: LoginParams): Promise<LoginResult>;
 }

package/dist/Rain.js

@@ -1,15 +1,25 @@
 import { getMarkets } from './markets/getMarkets.js';
-import { buildEnterOptionRawTx, buildLimitBuyOrderRawTx } from './tx/buildRawTransactions.js';
+import { getMarketById } from './markets/getMarketById.js';
+import { getUserInvestments } from './markets/getUserInvestments.js';
+import { buildEnterOptionRawTx, buildLimitBuyOrderRawTx, buildLimitSellOrderRawTx } from './tx/buildRawTransactions.js';
+import { buildCancelOrdersRawTx } from './tx/buildCancelOrdersRawTx.js';
+import { buildCancelAllOpenOrdersRawTx } from './tx/buildCancelAllOpenOrdersRawTx.js';
+import { buildCloseMarketRawTx } from './tx/CloseMarket/buildCloseMarketRawTx.js';
+import { buildCreateDisputeRawTx, buildCreateAppealRawTx } from './tx/Dispute/buildDisputeRawTx.js';
 import { buildApproveRawTx } from './tx/buildApprovalRawTx.js';
 import { buildCreateMarketRawTx } from './tx/CreateMarket/buildCreateMarketRawTx.js';
-import { ALLOWED_ENVIRONMENTS, ENV_CONFIG } from './config/environments.js';
+import { ALLOWED_ENVIRONMENTS, ENV_CONFIG, getRandomRpc } from './config/environments.js';
+import { buildClaimRawTx } from './tx/ClaimFunds/buildClaimFundsRawTx.js';
+import { loginUser } from './auth/login.js';
 export class Rain {
     environment;
     marketFactory;
     apiUrl;
     distute_initial_timer;
+    rpcUrl;
+    usdtSymbol;
     constructor(config = {}) {
-        const { environment = "development" } = config;
+        const { environment = "development", rpcUrl } = config;
         function isValidEnvironment(env) {
             return ALLOWED_ENVIRONMENTS.includes(env);
         }
@@ -17,14 +27,22 @@ export class Rain {
             throw new Error(`Invalid environment "${environment}". Allowed values: ${ALLOWED_ENVIRONMENTS.join(", ")}`);
         }
         this.environment = environment;
+        this.rpcUrl = rpcUrl ?? getRandomRpc();
         const envConfig = ENV_CONFIG[this.environment];
         this.marketFactory = envConfig.market_factory_address;
         this.apiUrl = envConfig.apiUrl;
         this.distute_initial_timer = envConfig.dispute_initial_timer;
+        this.usdtSymbol = envConfig.usdt_symbol;
     }
     async getPublicMarkets(params) {
         return getMarkets({ ...params, apiUrl: this.apiUrl });
     }
+    async getMarketById(params) {
+        return getMarketById({ ...params, apiUrl: this.apiUrl });
+    }
+    async getUserInvestments(params) {
+        return getUserInvestments({ ...params, apiUrl: this.apiUrl });
+    }
     buildApprovalTx(params) {
         return buildApproveRawTx(params);
     }
@@ -34,7 +52,31 @@ export class Rain {
     buildLimitBuyOptionTx(params) {
         return buildLimitBuyOrderRawTx(params);
     }
+    buildLimitSellOptionTx(params) {
+        return buildLimitSellOrderRawTx(params);
+    }
+    buildCancelOrdersTx(params) {
+        return buildCancelOrdersRawTx(params);
+    }
+    async buildCancelAllOpenOrdersTx(params) {
+        return buildCancelAllOpenOrdersRawTx({ ...params, apiUrl: this.apiUrl });
+    }
     buildCreateMarketTx(params) {
-        return buildCreateMarketRawTx({ ...params, factoryContractAddress: this.marketFactory, disputeTimer: this.distute_initial_timer });
+        return buildCreateMarketRawTx({ ...params, factoryContractAddress: this.marketFactory, apiUrl: this.apiUrl, rpcUrl: this.rpcUrl, disputeTimer: this.distute_initial_timer });
+    }
+    async buildClaimTx(params) {
+        return buildClaimRawTx({ ...params, apiUrl: this.apiUrl, rpcUrl: this.rpcUrl });
+    }
+    async buildCloseMarketTx(params) {
+        return buildCloseMarketRawTx({ ...params, apiUrl: this.apiUrl, rpcUrl: this.rpcUrl, usdtSymbol: this.usdtSymbol });
+    }
+    async buildCreateDisputeTx(params) {
+        return buildCreateDisputeRawTx({ ...params, apiUrl: this.apiUrl, rpcUrl: this.rpcUrl, usdtSymbol: this.usdtSymbol });
+    }
+    async buildCreateAppealTx(params) {
+        return buildCreateAppealRawTx({ ...params, apiUrl: this.apiUrl, rpcUrl: this.rpcUrl, usdtSymbol: this.usdtSymbol });
+    }
+    async login(params) {
+        return loginUser({ ...params, apiUrl: this.apiUrl });
     }
 }

package/dist/abi/TradeMarketsAbi.d.ts

@@ -267,12 +267,78 @@ export declare const TradePoolAbi: readonly [{
         readonly internalType: "bool";
     }];
     readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "openDispute";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly type: "function";
+    readonly name: "getDisputeAppealFee";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "disputeFee";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "DISPUTE_FEE_MIN";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "DISPUTE_FEE_MAX";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "APPEAL_FEE_MIN";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }];
+    readonly stateMutability: "view";
 }, {
     readonly type: "function";
     readonly name: "closePool";
     readonly inputs: readonly [];
     readonly outputs: readonly [];
     readonly stateMutability: "nonpayable";
+}, {
+    readonly type: "function";
+    readonly name: "closePool";
+    readonly inputs: readonly [{
+        readonly name: "proposedWinner";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }];
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly type: "function";
+    readonly name: "getResolverBondAmount";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "resolverBondAmount";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }];
+    readonly stateMutability: "view";
 }, {
     readonly type: "function";
     readonly name: "creatorFee";

package/dist/abi/TradeMarketsAbi.js

@@ -347,6 +347,65 @@ export const TradePoolAbi = [
         ],
         "stateMutability": "view"
     },
+    {
+        "type": "function",
+        "name": "openDispute",
+        "inputs": [],
+        "outputs": [],
+        "stateMutability": "nonpayable"
+    },
+    {
+        "type": "function",
+        "name": "getDisputeAppealFee",
+        "inputs": [],
+        "outputs": [
+            {
+                "name": "disputeFee",
+                "type": "uint256",
+                "internalType": "uint256"
+            }
+        ],
+        "stateMutability": "view"
+    },
+    {
+        "type": "function",
+        "name": "DISPUTE_FEE_MIN",
+        "inputs": [],
+        "outputs": [
+            {
+                "name": "",
+                "type": "uint256",
+                "internalType": "uint256"
+            }
+        ],
+        "stateMutability": "view"
+    },
+    {
+        "type": "function",
+        "name": "DISPUTE_FEE_MAX",
+        "inputs": [],
+        "outputs": [
+            {
+                "name": "",
+                "type": "uint256",
+                "internalType": "uint256"
+            }
+        ],
+        "stateMutability": "view"
+    },
+    {
+        "type": "function",
+        "name": "APPEAL_FEE_MIN",
+        "inputs": [],
+        "outputs": [
+            {
+                "name": "",
+                "type": "uint256",
+                "internalType": "uint256"
+            }
+        ],
+        "stateMutability": "view"
+    },
     {
         "type": "function",
         "name": "closePool",
@@ -354,6 +413,32 @@ export const TradePoolAbi = [
         "outputs": [],
         "stateMutability": "nonpayable"
     },
+    {
+        "type": "function",
+        "name": "closePool",
+        "inputs": [
+            {
+                "name": "proposedWinner",
+                "type": "uint256",
+                "internalType": "uint256"
+            }
+        ],
+        "outputs": [],
+        "stateMutability": "nonpayable"
+    },
+    {
+        "type": "function",
+        "name": "getResolverBondAmount",
+        "inputs": [],
+        "outputs": [
+            {
+                "name": "resolverBondAmount",
+                "type": "uint256",
+                "internalType": "uint256"
+            }
+        ],
+        "stateMutability": "view"
+    },
     {
         "type": "function",
         "name": "creatorFee",

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,24 @@
+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' },
+        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

@@ -1,18 +1,25 @@
 export declare const ALLOWED_ENVIRONMENTS: readonly ["development", "stage", "production"];
+export declare const DEFAULT_RPCS: string[];
+export declare function getRandomRpc(): string;
+export declare const USDT_SYMBOL_DEV = "USDTm";
+export declare const USDT_SYMBOL_PROD = "USD\u20AE0";
 export declare const ENV_CONFIG: {
     readonly development: {
         readonly apiUrl: "https://dev-api.rain.one";
         readonly market_factory_address: "0x148DA7F2039B2B00633AC2ab566f59C8a4C86313";
         readonly dispute_initial_timer: number;
+        readonly usdt_symbol: "USDTm";
     };
     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 production: {
         readonly apiUrl: "https://prod-api.rain.one";
         readonly market_factory_address: "0xccCB3C03D9355B01883779EF15C1Be09cf3623F1";
         readonly dispute_initial_timer: number;
+        readonly usdt_symbol: "USD₮0";
     };
 };

package/dist/config/environments.js

@@ -1,18 +1,32 @@
 export const ALLOWED_ENVIRONMENTS = ["development", "stage", "production"];
+export const DEFAULT_RPCS = [
+    "https://arbitrum.meowrpc.com",
+    "https://rpc.sentio.xyz/arbitrum-one",
+    "https://rpc.owlracle.info/arb/70d38ce1826c4a60bb2a8e05a6c8b20f"
+];
+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://dev-api.rain.one",
         market_factory_address: "0x148DA7F2039B2B00633AC2ab566f59C8a4C86313",
-        dispute_initial_timer: 1 * 60
+        dispute_initial_timer: 1 * 60,
+        usdt_symbol: USDT_SYMBOL_DEV,
     },
     stage: {
         apiUrl: "https://stg-api.rain.one",
         market_factory_address: "0x6109c9f28FE3Ad84c51368f7Ef2d487ca020c561",
-        dispute_initial_timer: 1 * 60
+        dispute_initial_timer: 1 * 60,
+        usdt_symbol: USDT_SYMBOL_PROD,
     },
     production: {
         apiUrl: "https://prod-api.rain.one",
         market_factory_address: "0xccCB3C03D9355B01883779EF15C1Be09cf3623F1",
-        dispute_initial_timer: 120 * 60
+        dispute_initial_timer: 120 * 60,
+        usdt_symbol: USDT_SYMBOL_PROD,
     },
 };

package/dist/constants/contractmethods.d.ts

@@ -1,4 +1,13 @@
 export declare const ENTER_OPTION = "enterOption";
 export declare const PLACE_BUY_ORDER = "placeBuyOrder";
+export declare const PLACE_SELL_ORDER = "placeSellOrder";
 export declare const APPROVE_TOKEN = "approve";
 export declare const CREATE_MARKET = "createPool";
+export declare const CLAIM = "claim";
+export declare const CLOSE_POOL = "closePool";
+export declare const CHOOSE_WINNER = "chooseWinner";
+export declare const GET_RESOLVER_BOND_AMOUNT = "getResolverBondAmount";
+export declare const OPEN_DISPUTE = "openDispute";
+export declare const GET_DISPUTE_APPEAL_FEE = "getDisputeAppealFee";
+export declare const CANCEL_BUY_ORDERS = "cancelBuyOrders";
+export declare const CANCEL_SELL_ORDERS = "cancelSellOrders";

package/dist/constants/contractmethods.js

@@ -1,4 +1,13 @@
 export const ENTER_OPTION = 'enterOption';
 export const PLACE_BUY_ORDER = 'placeBuyOrder';
+export const PLACE_SELL_ORDER = 'placeSellOrder';
 export const APPROVE_TOKEN = 'approve';
 export const CREATE_MARKET = 'createPool';
+export const CLAIM = "claim";
+export const CLOSE_POOL = 'closePool';
+export const CHOOSE_WINNER = 'chooseWinner';
+export const GET_RESOLVER_BOND_AMOUNT = 'getResolverBondAmount';
+export const OPEN_DISPUTE = 'openDispute';
+export const GET_DISPUTE_APPEAL_FEE = 'getDisputeAppealFee';
+export const CANCEL_BUY_ORDERS = 'cancelBuyOrders';
+export const CANCEL_SELL_ORDERS = 'cancelSellOrders';

package/dist/index.d.ts

@@ -1,3 +1,4 @@
 export { Rain } from './Rain.js';
 export { RainAA } from './RainAA.js';
 export * from './types.js';
+export type { LoginParams, LoginResult } from './auth/types.js';

package/dist/markets/getMarketById.d.ts

@@ -0,0 +1,2 @@
+import { GetMarketByIdParams, Market } from './types.js';
+export declare function getMarketById(params: GetMarketByIdParams): Promise<Market>;

package/dist/markets/getMarketById.js

@@ -0,0 +1,12 @@
+export async function getMarketById(params) {
+    if (!params?.apiUrl)
+        throw new Error("Environment is not set properly, api url is missing");
+    if (!params?.marketId)
+        throw new Error("marketId is required");
+    const res = await fetch(`${params.apiUrl}/pools/pool/${params.marketId}`);
+    if (!res.ok) {
+        throw new Error(`Failed to fetch market: ${res.status}`);
+    }
+    const data = await res.json();
+    return data;
+}

package/dist/markets/getUserInvestments.d.ts

@@ -0,0 +1,2 @@
+import { GetUserInvestmentsParams, UserInvestment } from './types.js';
+export declare function getUserInvestments(params: GetUserInvestmentsParams): Promise<UserInvestment[]>;

package/dist/markets/getUserInvestments.js

@@ -0,0 +1,23 @@
+import { MARKET_STATUS } from './constants.js';
+export async function getUserInvestments(params) {
+    if (!params?.apiUrl)
+        throw new Error("Environment is not set properly, api url is missing");
+    if (!params?.walletAddress)
+        throw new Error("walletAddress is required");
+    if (!params?.accessToken)
+        throw new Error("accessToken is required");
+    const query = new URLSearchParams();
+    query.append('walletAddress', params.walletAddress);
+    if (params?.limit)
+        query.append('limit', params.limit.toString());
+    if (params?.offset)
+        query.append('offset', params.offset.toString());
+    if (params?.status)
+        query.append('status', MARKET_STATUS[params.status]);
+    const res = await fetch(`${params.apiUrl}/investments/user-invested-pools?${query.toString()}`, { headers: { Authorization: `Bearer ${params.accessToken}` } });
+    if (!res.ok) {
+        throw new Error(`Failed to fetch user investments: ${res.status}`);
+    }
+    const data = await res.json();
+    return data?.data ?? data;
+}

package/dist/markets/types.d.ts

@@ -13,3 +13,24 @@ export interface Market {
     totalVolume: string;
     status: MarketStatus;
 }
+export interface GetMarketByIdParams {
+    marketId: string;
+    apiUrl?: string;
+}
+export interface GetUserInvestmentsParams {
+    walletAddress: string;
+    accessToken: string;
+    limit?: number;
+    offset?: number;
+    status?: MarketStatus;
+    apiUrl?: string;
+}
+export interface UserInvestment {
+    _id: string;
+    poolId: string;
+    walletAddress: string;
+    investment: any[];
+    totalInvestment: string;
+    pool: Record<string, any>;
+    [key: string]: any;
+}

package/dist/tx/ClaimFunds/buildClaimFundsRawTx.d.ts

@@ -0,0 +1,2 @@
+import { ClaimTxParams, RawTransaction } from "../types.js";
+export declare function buildClaimRawTx(params: ClaimTxParams): Promise<RawTransaction>;

package/dist/tx/ClaimFunds/buildClaimFundsRawTx.js

@@ -0,0 +1,34 @@
+import { encodeFunctionData } from "viem";
+import { TradePoolAbi } from "../../abi/TradeMarketsAbi.js";
+import { getMarket, getUserOptionShares, isRpcValid } from "./helpers.js";
+import { MARKET_STATUS } from "../../markets/constants.js";
+import { CLAIM } from "../../constants/contractmethods.js";
+export async function buildClaimRawTx(params) {
+    const { marketId, walletAddress, apiUrl, rpcUrl } = params;
+    if (!apiUrl) {
+        throw new Error("Environemnt is not set properly, api url is missing");
+    }
+    const isRpcWorking = await isRpcValid(rpcUrl);
+    if (!rpcUrl || !isRpcWorking) {
+        throw new Error("Provided RPC URL is not valid or not working");
+    }
+    if (!marketId)
+        throw new Error("marketContractAddress is required");
+    if (!walletAddress)
+        throw new Error("walletAddress is required");
+    const { data } = await getMarket({ marketId, apiUrl });
+    if (data?.status !== MARKET_STATUS.Closed)
+        throw new Error("Market is not closed yet. Please wait until the market is closed to claim your funds.");
+    const marketContractAddress = data?.contractAddress;
+    const options = data?.options || 0;
+    const userShares = await getUserOptionShares({ marketContractAddress: marketContractAddress, walletAddress: walletAddress, options: options, rpcUrl: rpcUrl });
+    if (userShares?.length <= 0)
+        throw new Error("No shares to claim for this market");
+    return {
+        to: marketContractAddress,
+        data: encodeFunctionData({
+            abi: TradePoolAbi,
+            functionName: CLAIM,
+        }),
+    };
+}

package/dist/tx/ClaimFunds/helpers.d.ts

@@ -0,0 +1,8 @@
+import { Market } from "../../markets/types.js";
+import { GetUserOptionSharesParams } from "../types.js";
+export declare function getMarket(params: {
+    marketId: string;
+    apiUrl: string;
+}): Promise<Market>;
+export declare function isRpcValid(rpcUrl: string | undefined): Promise<boolean>;
+export declare function getUserOptionShares(params: GetUserOptionSharesParams): Promise<number[]>;

package/dist/tx/ClaimFunds/helpers.js

@@ -0,0 +1,37 @@
+import { Contract, JsonRpcProvider } from "ethers";
+import { TradePoolAbi } from "../../abi/TradeMarketsAbi.js";
+export async function getMarket(params) {
+    if (!params?.apiUrl) {
+        throw new Error("Environemnt is not set properly, api url is missing");
+    }
+    const res = await fetch(`${params.apiUrl}/pools/pool/${params.marketId}`);
+    if (!res.ok) {
+        throw new Error(`Failed to fetch markets: ${res.status}`);
+    }
+    const data = await res.json();
+    return data;
+}
+export async function isRpcValid(rpcUrl) {
+    if (!rpcUrl)
+        return false;
+    const provider = new JsonRpcProvider(rpcUrl);
+    try {
+        await provider.getNetwork();
+        return true;
+    }
+    catch (error) {
+        return false;
+    }
+}
+export async function getUserOptionShares(params) {
+    const { marketContractAddress, options, walletAddress, rpcUrl } = params;
+    const provider = new JsonRpcProvider(rpcUrl);
+    const userShares = [];
+    for (let i = 0; i < options.length; i++) {
+        const choiceIndex = options[i].choiceIndex;
+        const contract = new Contract(marketContractAddress, TradePoolAbi, provider);
+        const userVotes = await contract.userVotes(choiceIndex, walletAddress);
+        Number(userVotes) > 0 && userShares.push(Number(userVotes));
+    }
+    return userShares;
+}

package/dist/tx/CloseMarket/buildCloseMarketRawTx.d.ts

@@ -0,0 +1,2 @@
+import { CloseMarketTxParams, RawTransaction } from "../types.js";
+export declare function buildCloseMarketRawTx(params: CloseMarketTxParams): Promise<RawTransaction[]>;