@rainprotocolsdk/sdk 1.3.0 → 2.0.0

package/dist/Rain.d.ts

@@ -1,17 +1,28 @@
-import { GetMarketsParams, Market } from './markets/types.js';
-import { ApproveTxParams, ClaimTxParams, 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,23 @@
 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, 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", rpcUrl } = config;
         function isValidEnvironment(env) {
@@ -24,10 +32,17 @@ export class Rain {
         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);
     }
@@ -37,10 +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,20 +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

@@ -8,20 +8,25 @@ 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,5 +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,5 +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/CloseMarket/buildCloseMarketRawTx.d.ts

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

package/dist/tx/CloseMarket/buildCloseMarketRawTx.js

@@ -0,0 +1,97 @@
+import { encodeFunctionData } from "viem";
+import { TradePoolAbi } from "../../abi/TradeMarketsAbi.js";
+import { getMarket, isRpcValid } from "../ClaimFunds/helpers.js";
+import { buildApproveRawTx } from "../buildApprovalRawTx.js";
+import { CLOSE_POOL, CHOOSE_WINNER } from "../../constants/contractmethods.js";
+import { getResolverBondAmount, getTokenAllowance } from "./helpers.js";
+export async function buildCloseMarketRawTx(params) {
+    const { marketId, walletAddress, proposedOutcome, 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 version = data?.version ?? 2;
+    const isAiResolver = data?.isAiResolver ?? false;
+    const marketTokenSymbol = data?.token?.tokenSymbol ?? "";
+    if (!contractAddress)
+        throw new Error("Market contract address not found");
+    const txs = [];
+    if (version <= 2) {
+        // V2 flow: closePool() (no args) → chooseWinner(proposedOutcome)
+        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)],
+            }),
+        });
+    }
+    else {
+        // V3 flow: optional approvals → closePool() or closePool(proposedOutcome)
+        const isUsdtMarket = usdtSymbol ? marketTokenSymbol === usdtSymbol : false;
+        const bondAmount = await getResolverBondAmount(contractAddress, rpcUrl);
+        if (isUsdtMarket) {
+            // Market uses USDT — only check and approve USDT
+            if (!usdtTokenAddress)
+                throw new Error("usdtTokenAddress is required for V3 USDT markets");
+            const usdtAllowance = await getTokenAllowance(usdtTokenAddress, walletAddress, contractAddress, rpcUrl);
+            if (usdtAllowance < bondAmount) {
+                txs.push(buildApproveRawTx({ tokenAddress: usdtTokenAddress, spender: contractAddress }));
+            }
+        }
+        else {
+            // Market uses RAIN — only check and approve RAIN
+            if (!rainTokenAddress)
+                throw new Error("rainTokenAddress is required for V3 RAIN markets");
+            const rainAllowance = await getTokenAllowance(rainTokenAddress, walletAddress, contractAddress, rpcUrl);
+            if (rainAllowance < bondAmount) {
+                txs.push(buildApproveRawTx({ tokenAddress: rainTokenAddress, spender: contractAddress }));
+            }
+        }
+        if (isAiResolver) {
+            // AI resolver: closePool() with no args
+            txs.push({
+                to: contractAddress,
+                data: encodeFunctionData({
+                    abi: TradePoolAbi,
+                    functionName: CLOSE_POOL,
+                }),
+            });
+        }
+        else {
+            // Manual resolver: closePool(proposedOutcome)
+            if (proposedOutcome === undefined) {
+                throw new Error("proposedOutcome is required for V3 manual resolver markets");
+            }
+            txs.push({
+                to: contractAddress,
+                data: encodeFunctionData({
+                    abi: TradePoolAbi,
+                    functionName: CLOSE_POOL,
+                    args: [BigInt(proposedOutcome)],
+                }),
+            });
+        }
+    }
+    return txs;
+}

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

@@ -0,0 +1,2 @@
+export declare function getResolverBondAmount(contractAddress: `0x${string}`, rpcUrl: string): Promise<bigint>;
+export declare function getTokenAllowance(tokenAddress: `0x${string}`, owner: `0x${string}`, spender: `0x${string}`, rpcUrl: string): Promise<bigint>;

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[]>;