@rainprotocolsdk/sdk 1.3.0 → 2.1.0

package/dist/tx/CloseMarket/helpers.js

@@ -0,0 +1,16 @@
+import { Contract, JsonRpcProvider } from "ethers";
+import { TradePoolAbi } from "../../abi/TradeMarketsAbi.js";
+import { ERC20Abi } from "../../abi/ERC20Abi.js";
+import { GET_RESOLVER_BOND_AMOUNT } from "../../constants/contractmethods.js";
+export async function getResolverBondAmount(contractAddress, rpcUrl) {
+    const provider = new JsonRpcProvider(rpcUrl);
+    const contract = new Contract(contractAddress, TradePoolAbi, provider);
+    const bondAmount = await contract[GET_RESOLVER_BOND_AMOUNT]();
+    return BigInt(bondAmount);
+}
+export async function getTokenAllowance(tokenAddress, owner, spender, rpcUrl) {
+    const provider = new JsonRpcProvider(rpcUrl);
+    const contract = new Contract(tokenAddress, ERC20Abi, provider);
+    const allowance = await contract.allowance(owner, spender);
+    return BigInt(allowance);
+}

package/dist/tx/CreateMarket/buildCreateMarketRawTx.d.ts

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

package/dist/tx/CreateMarket/buildCreateMarketRawTx.js

@@ -2,14 +2,23 @@ import { encodeFunctionData } from "viem";
 import { CreateMarketAbi } from "../../abi/CreateMarketAbi.js";
 import { CREATE_MARKET } from "../../constants/contractmethods.js";
 import { validateCreateMarketParams } from "./createMarketValidation.js";
-import { normalizeBarValues } from "./helpers.js";
+import { normalizeBarValues, uploadMetaData } from "./helpers.js";
+import { getUserAllownace } from "../../utils/helpers.js";
+import { buildApproveRawTx } from "../buildApprovalRawTx.js";
 const ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";
-export function buildCreateMarketRawTx(params) {
-    const { isPublic, isPublicPoolResolverAi, creator, startTime, endTime, options, disputeTimer, ipfsUrl, inputAmountWei, barValues, baseToken, factoryContractAddress, } = params;
+export async function buildCreateMarketRawTx(params) {
+    const { isPublic, isPublicPoolResolverAi, creator, startTime, endTime, no_of_options, disputeTimer, inputAmountWei, barValues, baseToken, factoryContractAddress, } = params;
     if (!factoryContractAddress)
         throw new Error("environment is not set correctly, factory contract address is missing");
     validateCreateMarketParams(params);
+    const allowance = await getUserAllownace(params);
+    const createMarketTransactions = [];
+    if (BigInt(allowance) < BigInt(inputAmountWei)) {
+        const approveTx = buildApproveRawTx({ spender: factoryContractAddress, tokenAddress: baseToken });
+        createMarketTransactions.push(approveTx);
+    }
     const normalizeBarValue = normalizeBarValues(barValues);
+    const ipfsUrl = await uploadMetaData(params);
     const createMarketParams = [
         isPublic,
         isPublicPoolResolverAi,
@@ -17,7 +26,7 @@ export function buildCreateMarketRawTx(params) {
         ZERO_ADDRESS,
         startTime,
         endTime,
-        options,
+        no_of_options,
         disputeTimer,
         ipfsUrl,
         inputAmountWei,
@@ -25,12 +34,14 @@ export function buildCreateMarketRawTx(params) {
         creator,
         baseToken,
     ];
-    return {
+    createMarketTransactions.push({
         to: factoryContractAddress,
         data: encodeFunctionData({
             abi: CreateMarketAbi,
             functionName: CREATE_MARKET,
             args: [createMarketParams],
         }),
-    };
+        value: 0n,
+    });
+    return createMarketTransactions;
 }

package/dist/tx/CreateMarket/createMarketValidation.js

@@ -1,5 +1,5 @@
 export function validateCreateMarketParams(params) {
-    const { isPublic, isPublicPoolResolverAi, creator, startTime, endTime, options, ipfsUrl, inputAmountWei, barValues, baseToken, factoryContractAddress, tokenDecimals, } = params;
+    const { marketQuestion, marketOptions, marketTags, marketDescription, isPublic, isPublicPoolResolverAi, creator, startTime, endTime, no_of_options, inputAmountWei, barValues, baseToken, factoryContractAddress, tokenDecimals, } = params;
     // Required field validations
     if (typeof isPublic !== "boolean")
         throw new Error("isPublic is required and must be a boolean");
@@ -7,14 +7,28 @@ export function validateCreateMarketParams(params) {
         throw new Error("isPublicPoolResolverAi is required and must be a boolean");
     if (!creator)
         throw new Error("creator address is required");
+    if (!marketQuestion)
+        throw new Error("question is required");
+    if (!marketDescription)
+        throw new Error("description is required");
+    if (!Array.isArray(marketOptions) || marketOptions.length < 2 || marketOptions.length > 26) {
+        throw new Error("options must be between 2 and 26");
+    }
+    if (marketOptions.some(opt => !opt?.toString().trim())) {
+        throw new Error("options cannot contain empty values");
+    }
+    if (!Array.isArray(marketTags) || marketTags.length < 1 || marketTags.length > 3) {
+        throw new Error("tags must be between 1 and 3");
+    }
+    if (marketTags.some(tag => !tag?.toString().trim())) {
+        throw new Error("tags cannot contain empty values");
+    }
     if (!startTime)
         throw new Error("startTime is required");
     if (!endTime)
         throw new Error("endTime is required");
-    if (!options)
+    if (!no_of_options)
         throw new Error("number of options is required and cannot be empty");
-    if (!ipfsUrl || typeof ipfsUrl !== "string")
-        throw new Error("ipfsUrl is required");
     if (!inputAmountWei)
         throw new Error("inputAmountWei is required");
     if (!barValues || !Array.isArray(barValues) || barValues.length === 0)

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

@@ -1 +1,3 @@
+import { CreateMarketTxParams } from "../types.js";
 export declare function normalizeBarValues(values: (number)[]): number[];
+export declare function uploadMetaData(params: CreateMarketTxParams): Promise<string>;

package/dist/tx/CreateMarket/helpers.js

@@ -9,3 +9,36 @@ export function normalizeBarValues(values) {
     }
     return transformedBarValues;
 }
+export async function uploadMetaData(params) {
+    const { marketQuestion, marketOptions, marketTags, marketDescription, isPublic, isPublicPoolResolverAi, startTime, endTime, no_of_options, creator, apiUrl, } = params;
+    const formattedStartDate = new Date(Number(startTime) * 1000).toISOString();
+    const formattedEndDate = new Date(Number(endTime) * 1000).toISOString();
+    const metadata = {
+        question: marketQuestion,
+        options: Array.isArray(marketOptions) ? marketOptions : [],
+        tags: marketTags,
+        isPrivate: !isPublic,
+        startDate: formattedStartDate,
+        endDate: formattedEndDate,
+        poolDescription: marketDescription,
+        isAiResolver: isPublicPoolResolverAi,
+        contractData: {
+            pool_owner: creator,
+            start_time: startTime.toString(),
+            end_time: endTime.toString(),
+            no_of_options: no_of_options.toString(),
+        },
+    };
+    const res = await fetch(`${apiUrl}/ipfs/upload`, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+        },
+        body: JSON.stringify(metadata),
+    });
+    if (!res.ok) {
+        throw new Error(`Failed to upload metadata: ${res.status}`);
+    }
+    const data = await res.json();
+    return data?.data?.ipfsHash;
+}

package/dist/tx/Dispute/buildDisputeRawTx.d.ts

@@ -0,0 +1,3 @@
+import { CreateDisputeTxParams, CreateAppealTxParams, RawTransaction } from "../types.js";
+export declare function buildCreateDisputeRawTx(params: CreateDisputeTxParams): Promise<RawTransaction[]>;
+export declare function buildCreateAppealRawTx(params: CreateAppealTxParams): Promise<RawTransaction[]>;

package/dist/tx/Dispute/buildDisputeRawTx.js

@@ -0,0 +1,59 @@
+import { encodeFunctionData } from "viem";
+import { TradePoolAbi } from "../../abi/TradeMarketsAbi.js";
+import { getMarket, isRpcValid } from "../ClaimFunds/helpers.js";
+import { getTokenAllowance } from "../CloseMarket/helpers.js";
+import { buildApproveRawTx } from "../buildApprovalRawTx.js";
+import { OPEN_DISPUTE } from "../../constants/contractmethods.js";
+import { getDisputeAppealFee } from "./helpers.js";
+async function buildOpenDisputeTxs(params) {
+    const { marketId, walletAddress, usdtTokenAddress, rainTokenAddress, usdtSymbol, apiUrl, rpcUrl, } = params;
+    if (!apiUrl)
+        throw new Error("Environment is not set properly, api url is missing");
+    if (!rpcUrl)
+        throw new Error("rpcUrl is required");
+    const isRpcWorking = await isRpcValid(rpcUrl);
+    if (!isRpcWorking)
+        throw new Error("Provided RPC URL is not valid or not working");
+    if (!marketId)
+        throw new Error("marketId is required");
+    if (!walletAddress)
+        throw new Error("walletAddress is required");
+    const { data } = await getMarket({ marketId, apiUrl });
+    const contractAddress = data?.contractAddress;
+    const marketTokenSymbol = data?.token?.tokenSymbol ?? "";
+    if (!contractAddress)
+        throw new Error("Market contract address not found");
+    const feeAmount = await getDisputeAppealFee(contractAddress, rpcUrl);
+    const isUsdtMarket = usdtSymbol ? marketTokenSymbol === usdtSymbol : false;
+    const txs = [];
+    if (isUsdtMarket) {
+        if (!usdtTokenAddress)
+            throw new Error("usdtTokenAddress is required for USDT markets");
+        const usdtAllowance = await getTokenAllowance(usdtTokenAddress, walletAddress, contractAddress, rpcUrl);
+        if (usdtAllowance < feeAmount) {
+            txs.push(buildApproveRawTx({ tokenAddress: usdtTokenAddress, spender: contractAddress }));
+        }
+    }
+    else {
+        if (!rainTokenAddress)
+            throw new Error("rainTokenAddress is required for RAIN markets");
+        const rainAllowance = await getTokenAllowance(rainTokenAddress, walletAddress, contractAddress, rpcUrl);
+        if (rainAllowance < feeAmount) {
+            txs.push(buildApproveRawTx({ tokenAddress: rainTokenAddress, spender: contractAddress }));
+        }
+    }
+    txs.push({
+        to: contractAddress,
+        data: encodeFunctionData({
+            abi: TradePoolAbi,
+            functionName: OPEN_DISPUTE,
+        }),
+    });
+    return txs;
+}
+export async function buildCreateDisputeRawTx(params) {
+    return buildOpenDisputeTxs(params);
+}
+export async function buildCreateAppealRawTx(params) {
+    return buildOpenDisputeTxs(params);
+}

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

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

package/dist/tx/Dispute/helpers.js

@@ -0,0 +1,9 @@
+import { Contract, JsonRpcProvider } from "ethers";
+import { TradePoolAbi } from "../../abi/TradeMarketsAbi.js";
+import { GET_DISPUTE_APPEAL_FEE } from "../../constants/contractmethods.js";
+export async function getDisputeAppealFee(contractAddress, rpcUrl) {
+    const provider = new JsonRpcProvider(rpcUrl);
+    const contract = new Contract(contractAddress, TradePoolAbi, provider);
+    const fee = await contract[GET_DISPUTE_APPEAL_FEE]();
+    return BigInt(fee);
+}

package/dist/tx/ExtendTime/buildExtendTimeRawTx.d.ts

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

package/dist/tx/ExtendTime/buildExtendTimeRawTx.js

@@ -0,0 +1,46 @@
+import { encodeFunctionData } from "viem";
+import { Contract, JsonRpcProvider } from "ethers";
+import { OracleAbi } from "../../abi/OracleAbi.js";
+import { TradePoolAbi } from "../../abi/TradeMarketsAbi.js";
+async function getOracleAddress(marketContractAddress, rpcUrl) {
+    const provider = new JsonRpcProvider(rpcUrl);
+    const contract = new Contract(marketContractAddress, TradePoolAbi, provider);
+    const resolver = await contract.resolver();
+    return resolver;
+}
+async function fetchExtendTimeSignature(oracleContractAddress, walletAddress, accessToken, apiUrl) {
+    const res = await fetch(`${apiUrl}/pools/sign-oracles-extend-time?contractAddress=${oracleContractAddress}&walletAddress=${walletAddress}`, { headers: { Authorization: `Bearer ${accessToken}` } });
+    if (!res.ok)
+        throw new Error(`Failed to fetch extend time signature: ${res.status}`);
+    const data = await res.json();
+    if (!data?.epoch || !data?.signature)
+        throw new Error("Invalid response from extend time signature endpoint");
+    return {
+        epoch: BigInt(data.epoch),
+        signature: data.signature,
+    };
+}
+export async function buildExtendTimeRawTx(params) {
+    const { marketContractAddress, walletAddress, accessToken, apiUrl, rpcUrl } = params;
+    if (!apiUrl)
+        throw new Error("Environment is not set properly, api url is missing");
+    if (!rpcUrl)
+        throw new Error("rpcUrl is required");
+    if (!marketContractAddress)
+        throw new Error("marketContractAddress is required");
+    if (!walletAddress)
+        throw new Error("walletAddress is required");
+    if (!accessToken)
+        throw new Error("accessToken is required");
+    const oracleContractAddress = await getOracleAddress(marketContractAddress, rpcUrl);
+    const { epoch, signature } = await fetchExtendTimeSignature(oracleContractAddress, walletAddress, accessToken, apiUrl);
+    return {
+        to: oracleContractAddress,
+        data: encodeFunctionData({
+            abi: OracleAbi,
+            functionName: "extendTime",
+            args: [epoch, signature],
+        }),
+        value: 0n,
+    };
+}

package/dist/tx/buildApprovalRawTx.d.ts

@@ -1,2 +1,2 @@
 import { ApproveTxParams, RawTransaction } from "./types.js";
-export declare function buildApproveRawTx(params: ApproveTxParams): RawTransaction | Error;
+export declare function buildApproveRawTx(params: ApproveTxParams): RawTransaction;

package/dist/tx/buildCancelAllOpenOrdersRawTx.d.ts

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

package/dist/tx/buildCancelAllOpenOrdersRawTx.js

@@ -0,0 +1,35 @@
+import { ethers } from "ethers";
+import { buildCancelOrdersRawTx } from "./buildCancelOrdersRawTx.js";
+const PRICE_DECIMALS = 18;
+async function fetchOpenOrders(marketId, walletAddress, accessToken, apiUrl) {
+    const res = await fetch(`${apiUrl}/orders/get-user-order-by-poolId/${marketId}?filter=open`, { headers: { Authorization: `Bearer ${accessToken}` } });
+    if (!res.ok)
+        throw new Error(`Failed to fetch open orders: ${res.status}`);
+    const data = await res.json();
+    return data?.data ?? data ?? [];
+}
+export async function buildCancelAllOpenOrdersRawTx(params) {
+    const { marketId, marketContractAddress, walletAddress, accessToken, apiUrl } = params;
+    if (!apiUrl)
+        throw new Error("Environment is not set properly, api url is missing");
+    if (!marketId)
+        throw new Error("marketId is required");
+    if (!marketContractAddress)
+        throw new Error("marketContractAddress is required");
+    if (!walletAddress)
+        throw new Error("walletAddress is required");
+    if (!accessToken)
+        throw new Error("accessToken is required");
+    const orders = await fetchOpenOrders(marketId, walletAddress, accessToken, apiUrl);
+    // Filter to only this wallet's orders in case the API returns all
+    const userOrders = orders.filter((o) => !o.user || o.user?.toLowerCase() === walletAddress.toLowerCase());
+    if (userOrders.length === 0)
+        return [];
+    const mapped = userOrders.map((o) => ({
+        orderType: o.orderType,
+        option: BigInt(o.orderOption),
+        pricePerShare: ethers.parseUnits(String(o.pricePerShare), PRICE_DECIMALS),
+        orderId: BigInt(o.externalID),
+    }));
+    return buildCancelOrdersRawTx({ marketContractAddress, orders: mapped });
+}

package/dist/tx/buildCancelOrdersRawTx.d.ts

@@ -0,0 +1,2 @@
+import { CancelOrdersTxParams, RawTransaction } from "./types.js";
+export declare function buildCancelOrdersRawTx(params: CancelOrdersTxParams): RawTransaction[];

package/dist/tx/buildCancelOrdersRawTx.js

@@ -0,0 +1,42 @@
+import { encodeFunctionData } from "viem";
+import { TradePoolAbi } from "../abi/TradeMarketsAbi.js";
+import { CANCEL_BUY_ORDERS, CANCEL_SELL_ORDERS } from "../constants/contractmethods.js";
+export function buildCancelOrdersRawTx(params) {
+    const { marketContractAddress, orders } = params;
+    if (!marketContractAddress)
+        throw new Error("marketContractAddress is required");
+    if (!orders || orders.length === 0)
+        throw new Error("orders array must not be empty");
+    const sellOrders = orders.filter(o => o.orderType === 'sell');
+    const buyOrders = orders.filter(o => o.orderType === 'buy');
+    const txs = [];
+    if (sellOrders.length > 0) {
+        txs.push({
+            to: marketContractAddress,
+            data: encodeFunctionData({
+                abi: TradePoolAbi,
+                functionName: CANCEL_SELL_ORDERS,
+                args: [
+                    sellOrders.map(o => o.option),
+                    sellOrders.map(o => o.pricePerShare),
+                    sellOrders.map(o => o.orderId),
+                ],
+            }),
+        });
+    }
+    if (buyOrders.length > 0) {
+        txs.push({
+            to: marketContractAddress,
+            data: encodeFunctionData({
+                abi: TradePoolAbi,
+                functionName: CANCEL_BUY_ORDERS,
+                args: [
+                    buyOrders.map(o => o.option),
+                    buyOrders.map(o => o.pricePerShare),
+                    buyOrders.map(o => o.orderId),
+                ],
+            }),
+        });
+    }
+    return txs;
+}

package/dist/tx/buildRawTransactions.d.ts

@@ -1,3 +1,4 @@
-import { EnterLimitOptionTxParams, EnterOptionTxParams, RawTransaction } from './types.js';
+import { EnterLimitOptionTxParams, EnterOptionTxParams, LimitSellOptionTxParams, RawTransaction } from './types.js';
 export declare function buildEnterOptionRawTx(params: EnterOptionTxParams): RawTransaction;
 export declare function buildLimitBuyOrderRawTx(params: EnterLimitOptionTxParams): RawTransaction;
+export declare function buildLimitSellOrderRawTx(params: LimitSellOptionTxParams): RawTransaction;

package/dist/tx/buildRawTransactions.js

@@ -1,7 +1,7 @@
 import { encodeFunctionData } from 'viem';
 import { TradePoolAbi } from '../abi/TradeMarketsAbi.js';
 import { convertToWeiEthers } from '../utils/helpers.js';
-import { ENTER_OPTION, PLACE_BUY_ORDER } from '../constants/contractmethods.js';
+import { ENTER_OPTION, PLACE_BUY_ORDER, PLACE_SELL_ORDER } from '../constants/contractmethods.js';
 export function buildEnterOptionRawTx(params) {
     const { marketContractAddress, selectedOption, buyAmountInWei } = params;
     if (!marketContractAddress)
@@ -55,3 +55,37 @@ export function buildLimitBuyOrderRawTx(params) {
         }),
     };
 }
+export function buildLimitSellOrderRawTx(params) {
+    const { marketContractAddress, selectedOption, pricePerShare, sharesAmountWei } = params;
+    if (!marketContractAddress) {
+        throw new Error("market address is required");
+    }
+    if (selectedOption === undefined) {
+        throw new Error("selectedOption is required");
+    }
+    if (!pricePerShare) {
+        throw new Error("price per share is required");
+    }
+    if (pricePerShare <= 0 || pricePerShare >= 1) {
+        throw new Error("price per share should be in between 0 to 1, make sure to convert to correct decimals");
+    }
+    if (!sharesAmountWei) {
+        throw new Error("shares amount is required");
+    }
+    if (sharesAmountWei <= 0n) {
+        throw new Error("shares amount must be greater than 0");
+    }
+    const pricePerShareInEther = convertToWeiEthers(pricePerShare, 18);
+    return {
+        to: marketContractAddress,
+        data: encodeFunctionData({
+            abi: TradePoolAbi,
+            functionName: PLACE_SELL_ORDER,
+            args: [
+                BigInt(selectedOption),
+                pricePerShareInEther,
+                sharesAmountWei,
+            ],
+        }),
+    };
+}

package/dist/tx/types.d.ts

@@ -20,20 +20,32 @@ export interface EnterLimitOptionTxParams {
     buyAmountInWei: bigint;
     tokenDecimals?: number;
 }
+export interface LimitSellOptionTxParams {
+    marketContractAddress: `0x${string}`;
+    selectedOption: number;
+    pricePerShare: bigint;
+    sharesAmountWei: bigint;
+    tokenDecimals?: number;
+}
 export interface CreateMarketTxParams {
+    marketQuestion: string;
+    marketOptions: string[];
+    marketTags: string[];
+    marketDescription: string;
     isPublic: boolean;
     isPublicPoolResolverAi: boolean;
     creator: `0x${string}`;
     startTime: bigint;
     endTime: bigint;
-    options: bigint;
+    no_of_options: bigint;
     disputeTimer: number;
-    ipfsUrl: string;
     inputAmountWei: bigint;
     barValues: number[];
     baseToken: `0x${string}`;
     tokenDecimals?: number;
     factoryContractAddress?: `0x${string}`;
+    apiUrl?: string;
+    rpcUrl?: string;
 }
 export interface ClaimTxParams {
     marketId: string;
@@ -41,6 +53,59 @@ export interface ClaimTxParams {
     apiUrl?: string;
     rpcUrl?: string;
 }
+export interface CreateDisputeTxParams {
+    marketId: string;
+    walletAddress: `0x${string}`;
+    usdtTokenAddress?: `0x${string}`;
+    rainTokenAddress?: `0x${string}`;
+    usdtSymbol?: string;
+    apiUrl?: string;
+    rpcUrl?: string;
+}
+export interface CreateAppealTxParams {
+    marketId: string;
+    walletAddress: `0x${string}`;
+    usdtTokenAddress?: `0x${string}`;
+    rainTokenAddress?: `0x${string}`;
+    usdtSymbol?: string;
+    apiUrl?: string;
+    rpcUrl?: string;
+}
+export interface CloseMarketTxParams {
+    marketId: string;
+    walletAddress: `0x${string}`;
+    proposedOutcome?: number;
+    usdtTokenAddress?: `0x${string}`;
+    rainTokenAddress?: `0x${string}`;
+    usdtSymbol?: string;
+    tokenDecimals?: number;
+    apiUrl?: string;
+    rpcUrl?: string;
+}
+export interface OrderToCancel {
+    orderType: 'buy' | 'sell';
+    option: bigint;
+    pricePerShare: bigint;
+    orderId: bigint;
+}
+export interface CancelOrdersTxParams {
+    marketContractAddress: `0x${string}`;
+    orders: OrderToCancel[];
+}
+export interface CancelAllOpenOrdersTxParams {
+    marketId: string;
+    marketContractAddress: `0x${string}`;
+    walletAddress: `0x${string}`;
+    accessToken: string;
+    apiUrl?: string;
+}
+export interface ExtendTimeTxParams {
+    marketContractAddress: `0x${string}`;
+    walletAddress: `0x${string}`;
+    accessToken: string;
+    apiUrl?: string;
+    rpcUrl?: string;
+}
 export interface GetUserOptionSharesParams {
     options: [{
         choiceIndex: number;

package/dist/utils/helpers.d.ts

@@ -1 +1,3 @@
+import { CreateMarketTxParams } from "../tx/types.js";
 export declare const convertToWeiEthers: (value: string | bigint, decimals: number) => bigint;
+export declare function getUserAllownace(params: CreateMarketTxParams): Promise<number>;

package/dist/utils/helpers.js

@@ -1,4 +1,17 @@
-import { ethers } from "ethers";
+import { ethers, JsonRpcProvider, Contract } from "ethers";
+import { ERC20Abi } from "../abi/ERC20Abi.js";
+import { isRpcValid } from "../tx/ClaimFunds/helpers.js";
 export const convertToWeiEthers = (value, decimals) => {
     return ethers.parseUnits(value.toString(), decimals);
 };
+export async function getUserAllownace(params) {
+    const { factoryContractAddress, baseToken, creator, rpcUrl } = params;
+    const isRpcWorking = await isRpcValid(rpcUrl);
+    if (!rpcUrl || !isRpcWorking) {
+        throw new Error("Provided RPC URL is not valid or not working");
+    }
+    const provider = new JsonRpcProvider(rpcUrl);
+    const ERC20ApprovalContract = new Contract(baseToken, ERC20Abi, provider);
+    const userAllowance = await ERC20ApprovalContract.allowance(creator, factoryContractAddress);
+    return userAllowance;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@rainprotocolsdk/sdk",
-    "version": "1.3.0",
+    "version": "2.1.0",
     "type": "module",
     "description": "Rain SDK",
     "main": "dist/index.js",
@@ -43,4 +43,4 @@
     "devDependencies": {
         "typescript": "^5.9.3"
     }
-}
+}