rain-sdk-v2 1.0.0

package/dist/socket/RainSocket.js

@@ -0,0 +1,186 @@
+import { io } from 'socket.io-client';
+export class RainSocket {
+    socket = null;
+    url;
+    listeners = new Map();
+    constructor(url) {
+        this.url = url;
+    }
+    /**
+     * Connect to the Socket.IO server
+     */
+    connect() {
+        if (this.socket?.connected)
+            return;
+        this.socket = io(this.url, {
+            transports: ['websocket', 'polling'],
+        });
+        this.socket.on('connect', () => {
+            console.log('[RainSocket] Connected:', this.socket?.id);
+            // Re-register all listeners after reconnect
+            for (const [channel, callbacks] of this.listeners.entries()) {
+                for (const cb of callbacks) {
+                    this.socket.on(channel, cb);
+                }
+            }
+        });
+        this.socket.on('disconnect', (reason) => {
+            console.log('[RainSocket] Disconnected:', reason);
+        });
+        this.socket.on('connect_error', (err) => {
+            console.error('[RainSocket] Connection error:', err.message);
+        });
+    }
+    /**
+     * Disconnect from the server
+     */
+    disconnect() {
+        if (this.socket) {
+            this.socket.removeAllListeners();
+            this.socket.disconnect();
+            this.socket = null;
+        }
+        this.listeners.clear();
+    }
+    /**
+     * Check if connected
+     */
+    get isConnected() {
+        return this.socket?.connected ?? false;
+    }
+    /**
+     * Subscribe to an event for a specific pool
+     * @returns unsubscribe function
+     */
+    on(event, poolId, callback) {
+        const channel = `${event}/${poolId}`;
+        return this.onChannel(channel, callback);
+    }
+    /**
+     * Subscribe to a global event (no poolId)
+     * @returns unsubscribe function
+     */
+    onGlobal(event, callback) {
+        return this.onChannel(event, callback);
+    }
+    /**
+     * Subscribe to a raw channel name
+     * @returns unsubscribe function
+     */
+    onChannel(channel, callback) {
+        if (!this.listeners.has(channel)) {
+            this.listeners.set(channel, new Set());
+        }
+        this.listeners.get(channel).add(callback);
+        if (this.socket) {
+            this.socket.on(channel, callback);
+        }
+        return () => {
+            this.listeners.get(channel)?.delete(callback);
+            if (this.socket) {
+                this.socket.off(channel, callback);
+            }
+        };
+    }
+    // ─── Typed helpers ──────────────────────────────────────────────────────────
+    onEnterOption(poolId, callback) {
+        return this.on('enter-option', poolId, callback);
+    }
+    onExitOption(poolId, callback) {
+        return this.on('exit-option', poolId, callback);
+    }
+    onLiquidity(poolId, callback) {
+        return this.on('liquidity', poolId, callback);
+    }
+    onSplit(poolId, callback) {
+        return this.on('split', poolId, callback);
+    }
+    onMerge(poolId, callback) {
+        return this.on('merge', poolId, callback);
+    }
+    onRemoveLiquidity(poolId, callback) {
+        return this.on('remove-liquidity', poolId, callback);
+    }
+    onSyncPrice(poolId, callback) {
+        return this.on('sync-price', poolId, callback);
+    }
+    onOrderCreated(poolId, callback) {
+        return this.on('order-created', poolId, callback);
+    }
+    onOrderCancelled(poolId, callback) {
+        return this.on('order-cancelled', poolId, callback);
+    }
+    onOrderFilled(poolId, callback) {
+        return this.on('order-filled', poolId, callback);
+    }
+    onPoolClosed(poolId, callback) {
+        return this.on('pool-closed', poolId, callback);
+    }
+    onPoolReverted(poolId, callback) {
+        return this.on('pool-reverted', poolId, callback);
+    }
+    onPoolTokenSet(poolId, callback) {
+        return this.on('pool-token-set', poolId, callback);
+    }
+    onStreamingStatusChanged(poolId, callback) {
+        return this.on('streamingStatusChanged', poolId, callback);
+    }
+    onNewPool(callback) {
+        return this.onGlobal('pool', callback);
+    }
+    // ─── Dispute & Appeal events ────────────────────────────────────────────────
+    onWinner(poolId, callback) {
+        return this.on('winner', poolId, callback);
+    }
+    onWinnerProposer(poolId, callback) {
+        return this.on('winner-proposer', poolId, callback);
+    }
+    onRevealWinnerAvailable(poolId, callback) {
+        return this.on('reveal-winner-available', poolId, callback);
+    }
+    onDisputeOpened(poolId, callback) {
+        return this.on('dispute-opened', poolId, callback);
+    }
+    onOracleCreated(poolId, callback) {
+        return this.on('oracle-created', poolId, callback);
+    }
+    onDisputeTimeExtended(poolId, callback) {
+        return this.on('dispute-time-extented', poolId, callback);
+    }
+    onAppealOpened(poolId, callback) {
+        return this.on('appeal-opened', poolId, callback);
+    }
+    onAppealWinnerCalculated(poolId, callback) {
+        return this.on('appeal-winner-calculated', poolId, callback);
+    }
+    onDisputeWinner(poolId, callback) {
+        return this.on('dispute-winner', poolId, callback);
+    }
+    onAppealWinner(poolId, callback) {
+        return this.on('appeal-winner', poolId, callback);
+    }
+    onClaimReward(poolId, callback) {
+        return this.on('claim-reward', poolId, callback);
+    }
+    /**
+     * User-scoped claim reward event: claim-reward/{poolId}/{userId}
+     */
+    onUserClaimReward(poolId, userId, callback) {
+        return this.onChannel(`claim-reward/${poolId}/${userId}`, callback);
+    }
+    onDisputeRefund(poolId, userId, callback) {
+        return this.onChannel(`dispute-refund/${poolId}/${userId}`, callback);
+    }
+    onAppealRefund(poolId, userId, callback) {
+        return this.onChannel(`appeal-refund/${poolId}/${userId}`, callback);
+    }
+    onResolutionRefund(poolId, userId, callback) {
+        return this.onChannel(`resolution-refund/${poolId}/${userId}`, callback);
+    }
+    onResolverReward(poolId, userId, callback) {
+        return this.onChannel(`resolver-reward/${poolId}/${userId}`, callback);
+    }
+    onNotifications(userId, callback) {
+        return this.onChannel(`notifications/${userId}`, callback);
+    }
+}

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

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

package/dist/tx/CreateMarket/buildCreateMarketRawTx.js

@@ -0,0 +1,55 @@
+import { encodeFunctionData } from "viem";
+import { CreateMarketAbi } from "../../abi/CreateMarketAbi.js";
+import { CREATE_MARKET } from "../../constants/contractmethods.js";
+import { validateCreateMarketParams } from "./createMarketValidation.js";
+import { normalizeBarValues, uploadMetaData } from "./helpers.js";
+import { getUserAllowance } from "../../utils/helpers.js";
+import { buildApproveRawTx } from "../buildApprovalRawTx.js";
+const ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";
+export async function buildCreateMarketRawTx(params) {
+    const { isPublic, isPublicPoolResolverAi, creator, startTime, endTime, no_of_options, disputeTimer, inputAmountWei, barValues, baseToken, tradingModel, factoryContractAddress, oracleFixedFeePerOption, } = params;
+    if (!factoryContractAddress)
+        throw new Error("environment is not set correctly, factory contract address is missing");
+    validateCreateMarketParams(params);
+    // Approval = liquidity + oracle fixed fee (fee per option * number of options)
+    const oracleFee = (oracleFixedFeePerOption ?? 0n) * BigInt(no_of_options);
+    const approvalAmount = inputAmountWei + oracleFee;
+    const allowance = await getUserAllowance(params);
+    const createMarketTransactions = [];
+    if (BigInt(allowance) < approvalAmount) {
+        const approveTx = buildApproveRawTx({ spender: factoryContractAddress, tokenAddress: baseToken, amount: approvalAmount });
+        createMarketTransactions.push(approveTx);
+    }
+    const normalizeBarValue = normalizeBarValues(barValues);
+    const liquidityPercentages = normalizeBarValue.map((v) => BigInt(v));
+    const ipfsUrl = await uploadMetaData(params);
+    // oracleEndTime = endTime + disputeTimer (seconds)
+    const oracleEndTime = BigInt(endTime) + BigInt(disputeTimer);
+    const createMarketParams = {
+        isPublic,
+        resolverIsAI: isPublicPoolResolverAi,
+        poolOwner: creator,
+        referrer: ZERO_ADDRESS,
+        startTime,
+        endTime,
+        numberOfOptions: no_of_options,
+        oracleEndTime,
+        ipfsUri: ipfsUrl,
+        initialLiquidity: inputAmountWei,
+        liquidityPercentages,
+        poolResolver: ZERO_ADDRESS,
+        baseToken,
+        tradingModel: tradingModel ?? 0,
+    };
+    console.log('createMarketParams: ', createMarketParams);
+    createMarketTransactions.push({
+        to: factoryContractAddress,
+        data: encodeFunctionData({
+            abi: CreateMarketAbi,
+            functionName: CREATE_MARKET,
+            args: [createMarketParams],
+        }),
+        value: 0n,
+    });
+    return createMarketTransactions;
+}

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

@@ -0,0 +1,2 @@
+import { CreateMarketTxParams } from "../types.js";
+export declare function validateCreateMarketParams(params: CreateMarketTxParams): boolean;

package/dist/tx/CreateMarket/createMarketValidation.js

@@ -0,0 +1,48 @@
+export function validateCreateMarketParams(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");
+    if (typeof isPublicPoolResolverAi !== "boolean")
+        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 < 3 || marketOptions.length > 26) {
+        throw new Error("options must be between 3 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 (!no_of_options)
+        throw new Error("number of options is required and cannot be empty");
+    if (!inputAmountWei)
+        throw new Error("inputAmountWei is required");
+    if (!barValues || !Array.isArray(barValues) || barValues.length === 0)
+        throw new Error("barValues array is required and cannot be empty");
+    if (!baseToken)
+        throw new Error("baseToken address is required");
+    if (!factoryContractAddress)
+        throw new Error("factoryContractAddress is required");
+    const decimals = tokenDecimals ?? 6;
+    const oneTokenInWei = 10n ** BigInt(decimals);
+    if (inputAmountWei < oneTokenInWei * 10n) {
+        throw new Error("Market cannot be opened: inputAmountWei must be at least $10");
+    }
+    if (startTime >= endTime)
+        throw new Error("startTime must be earlier than endTime");
+    return true;
+}

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

@@ -0,0 +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

@@ -0,0 +1,42 @@
+export function normalizeBarValues(values) {
+    const transformedBarValues = [
+        ...values.map((value) => Math.floor(value * 100)),
+    ];
+    const totalRounded = transformedBarValues.reduce((sum, val) => sum + val, 0);
+    const difference = 10000 - totalRounded;
+    if (difference !== 0) {
+        transformedBarValues[transformedBarValues.length - 1] += difference;
+    }
+    return transformedBarValues;
+}
+export async function uploadMetaData(params) {
+    const { marketQuestion, marketOptions, marketTags, marketDescription, isPublic, isPublicPoolResolverAi, startTime, endTime, no_of_options, creator, tradingModel, apiUrl, } = params;
+    const formattedStartDate = new Date(Number(startTime) * 1000).toISOString();
+    const formattedEndDate = new Date(Number(endTime) * 1000).toISOString();
+    const metadata = {
+        question: marketQuestion,
+        isPrivate: !isPublic,
+        options: Array.isArray(marketOptions) ? marketOptions : [],
+        startDate: formattedStartDate,
+        endDate: formattedEndDate,
+        tradingModel: tradingModel ?? 0,
+        questionImage: params.questionImage ?? '',
+        tags: marketTags,
+        poolDescription: marketDescription,
+        isAiResolver: isPublicPoolResolverAi,
+    };
+    const res = await fetch(`${apiUrl}/ipfs/upload`, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+            ...(apiUrl?.includes('ngrok') ? { "ngrok-skip-browser-warning": "true" } : {}),
+        },
+        body: JSON.stringify(metadata),
+    });
+    if (!res.ok) {
+        const errorText = await res.text().catch(() => res.statusText);
+        throw new Error(`Failed to upload metadata: ${res.status} — ${errorText}`);
+    }
+    const data = await res.json();
+    return data?.data?.ipfsHash;
+}

package/dist/tx/buildAddLiquidityRawTx.d.ts

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

package/dist/tx/buildAddLiquidityRawTx.js

@@ -0,0 +1,23 @@
+import { encodeFunctionData } from "viem";
+import { MarketsAbi } from "../abi/MarketsAbi.js";
+import { ENTER_LIQUIDITY } from "../constants/contractmethods.js";
+export function buildAddLiquidityRawTx(params) {
+    const { marketContractAddress, option, totalAmountInWei } = params;
+    if (!marketContractAddress)
+        throw new Error("marketContractAddress is required");
+    if (option === undefined || option === null)
+        throw new Error("option is required");
+    if (!totalAmountInWei)
+        throw new Error("totalAmountInWei is required");
+    if (totalAmountInWei <= 0n)
+        throw new Error("totalAmountInWei must be greater than 0");
+    return {
+        to: marketContractAddress,
+        data: encodeFunctionData({
+            abi: MarketsAbi,
+            functionName: ENTER_LIQUIDITY,
+            args: [option, totalAmountInWei],
+        }),
+        value: 0n,
+    };
+}

package/dist/tx/buildApprovalRawTx.d.ts

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

package/dist/tx/buildApprovalRawTx.js

@@ -0,0 +1,24 @@
+import { encodeFunctionData } from "viem";
+import { ERC20Abi } from "../abi/ERC20Abi.js";
+import { APPROVE_TOKEN } from "../constants/contractmethods.js";
+export function buildApproveRawTx(params) {
+    const { tokenAddress, spender, amount } = params;
+    if (!tokenAddress)
+        throw new Error("token address is required");
+    if (!spender)
+        throw new Error("spender address is required");
+    if (amount === undefined || amount === null) {
+        throw new Error("amount is required; pass a finite bigint (infinite approvals are no longer supported)");
+    }
+    if (amount <= 0n)
+        throw new Error("amount must be greater than 0");
+    return {
+        to: tokenAddress,
+        data: encodeFunctionData({
+            abi: ERC20Abi,
+            functionName: APPROVE_TOKEN,
+            args: [spender, amount],
+        }),
+        value: 0n,
+    };
+}

package/dist/tx/buildCalculateWinnerRawTx.d.ts

@@ -0,0 +1,13 @@
+import { RawTransaction } from "./types.js";
+export interface CalculateWinnerTxParams {
+    marketContractAddress: `0x${string}`;
+    option: bigint;
+}
+/**
+ * Builds calculateWinner TX.
+ * 1. Reads optionResolver(option) from market contract to get the resolver address for that option
+ * 2. Encodes calculateWinner() call to that resolver
+ */
+export declare function buildCalculateWinnerRawTx(params: CalculateWinnerTxParams & {
+    rpcUrl: string;
+}): Promise<RawTransaction>;

package/dist/tx/buildCalculateWinnerRawTx.js

@@ -0,0 +1,37 @@
+import { encodeFunctionData, createPublicClient, http, parseAbi } from "viem";
+import { arbitrum } from "viem/chains";
+import { OracleAbi } from "../abi/OracleAbi.js";
+const optionResolverAbi = parseAbi(['function optionResolver(uint256 option) view returns (address)']);
+/**
+ * Builds calculateWinner TX.
+ * 1. Reads optionResolver(option) from market contract to get the resolver address for that option
+ * 2. Encodes calculateWinner() call to that resolver
+ */
+export async function buildCalculateWinnerRawTx(params) {
+    const { marketContractAddress, option, rpcUrl } = params;
+    if (!marketContractAddress)
+        throw new Error("marketContractAddress is required");
+    if (option === undefined || option === null)
+        throw new Error("option is required");
+    const client = createPublicClient({
+        chain: arbitrum,
+        transport: http(rpcUrl),
+    });
+    const resolverAddress = await client.readContract({
+        address: marketContractAddress,
+        abi: optionResolverAbi,
+        functionName: 'optionResolver',
+        args: [option],
+    });
+    if (!resolverAddress || resolverAddress === '0x0000000000000000000000000000000000000000') {
+        throw new Error("No resolver set for this option");
+    }
+    return {
+        to: resolverAddress,
+        data: encodeFunctionData({
+            abi: OracleAbi,
+            functionName: 'calculateWinner',
+        }),
+        value: 0n,
+    };
+}

package/dist/tx/buildCancelOrdersRawTx.d.ts

@@ -0,0 +1,3 @@
+import { CancelBuyOrdersTxParams, CancelSellOrdersTxParams, RawTransaction } from "./types.js";
+export declare function buildCancelBuyOrdersRawTx(params: CancelBuyOrdersTxParams): RawTransaction;
+export declare function buildCancelSellOrdersRawTx(params: CancelSellOrdersTxParams): RawTransaction;

package/dist/tx/buildCancelOrdersRawTx.js

@@ -0,0 +1,43 @@
+import { encodeFunctionData } from "viem";
+import { MarketsAbi } from "../abi/MarketsAbi.js";
+import { CANCEL_BUY_ORDERS, CANCEL_SELL_ORDERS } from "../constants/contractmethods.js";
+export function buildCancelBuyOrdersRawTx(params) {
+    const { marketContractAddress, option, optionSides, prices, orderIDs } = params;
+    if (!marketContractAddress)
+        throw new Error("marketContractAddress is required");
+    if (option === undefined || option === null)
+        throw new Error("option is required");
+    if (!optionSides.length || !prices.length || !orderIDs.length)
+        throw new Error("optionSides, prices, and orderIDs arrays are required");
+    if (optionSides.length !== prices.length || prices.length !== orderIDs.length)
+        throw new Error("optionSides, prices, and orderIDs must have the same length");
+    return {
+        to: marketContractAddress,
+        data: encodeFunctionData({
+            abi: MarketsAbi,
+            functionName: CANCEL_BUY_ORDERS,
+            args: [option, optionSides, prices, orderIDs],
+        }),
+        value: 0n,
+    };
+}
+export function buildCancelSellOrdersRawTx(params) {
+    const { marketContractAddress, option, optionSides, prices, orderIDs } = params;
+    if (!marketContractAddress)
+        throw new Error("marketContractAddress is required");
+    if (option === undefined || option === null)
+        throw new Error("option is required");
+    if (!optionSides.length || !prices.length || !orderIDs.length)
+        throw new Error("optionSides, prices, and orderIDs arrays are required");
+    if (optionSides.length !== prices.length || prices.length !== orderIDs.length)
+        throw new Error("optionSides, prices, and orderIDs must have the same length");
+    return {
+        to: marketContractAddress,
+        data: encodeFunctionData({
+            abi: MarketsAbi,
+            functionName: CANCEL_SELL_ORDERS,
+            args: [option, optionSides, prices, orderIDs],
+        }),
+        value: 0n,
+    };
+}

package/dist/tx/buildClaimRawTx.d.ts

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

package/dist/tx/buildClaimRawTx.js

@@ -0,0 +1,19 @@
+import { encodeFunctionData } from "viem";
+import { MarketsAbi } from "../abi/MarketsAbi.js";
+import { CLAIM } from "../constants/contractmethods.js";
+export function buildClaimRawTx(params) {
+    const { marketContractAddress, option } = params;
+    if (!marketContractAddress)
+        throw new Error("marketContractAddress is required");
+    if (option === undefined || option === null)
+        throw new Error("option is required");
+    return {
+        to: marketContractAddress,
+        data: encodeFunctionData({
+            abi: MarketsAbi,
+            functionName: CLAIM,
+            args: [option],
+        }),
+        value: 0n,
+    };
+}

package/dist/tx/buildClosePoolRawTx.d.ts

@@ -0,0 +1,20 @@
+import { ClosePoolAITxParams, ClosePoolManualTxParams, ChooseWinnerTxParams, RawTransaction } from "./types.js";
+/**
+ * Close pool with AI resolver — no winner proposed, AI decides.
+ * Returns [approval, closePool] transactions.
+ */
+export declare function buildClosePoolAIRawTx(params: ClosePoolAITxParams & {
+    rpcUrl: string;
+}): Promise<RawTransaction[]>;
+/**
+ * Close pool with manual resolver — proposer suggests a winning side.
+ * Returns [approval, closePool] transactions.
+ */
+export declare function buildClosePoolManualRawTx(params: ClosePoolManualTxParams & {
+    rpcUrl: string;
+}): Promise<RawTransaction[]>;
+/**
+ * Choose/finalize the winner after pool is closed.
+ * chooseWinner(option, optionSide)
+ */
+export declare function buildChooseWinnerRawTx(params: ChooseWinnerTxParams): RawTransaction;

package/dist/tx/buildClosePoolRawTx.js

@@ -0,0 +1,95 @@
+import { encodeFunctionData } from "viem";
+import { MarketsAbi } from "../abi/MarketsAbi.js";
+import { CLOSE_POOL, CHOOSE_WINNER } from "../constants/contractmethods.js";
+import { getResolverBondAmount, getMarketBaseToken } from "../markets/getResolverBondAmount.js";
+import { buildApproveRawTx } from "./buildApprovalRawTx.js";
+/**
+ * Close pool with AI resolver — no winner proposed, AI decides.
+ * Returns [approval, closePool] transactions.
+ */
+export async function buildClosePoolAIRawTx(params) {
+    const { marketContractAddress, option, rpcUrl } = params;
+    if (!marketContractAddress)
+        throw new Error("marketContractAddress is required");
+    if (option === undefined || option === null)
+        throw new Error("option is required");
+    const [bondAmount, baseToken] = await Promise.all([
+        getResolverBondAmount({ marketContractAddress, option, rpcUrl }),
+        getMarketBaseToken({ marketContractAddress, rpcUrl }),
+    ]);
+    const txs = [];
+    if (bondAmount > 0n) {
+        txs.push(buildApproveRawTx({
+            tokenAddress: baseToken,
+            spender: marketContractAddress,
+            amount: bondAmount,
+        }));
+    }
+    txs.push({
+        to: marketContractAddress,
+        data: encodeFunctionData({
+            abi: MarketsAbi,
+            functionName: CLOSE_POOL,
+            args: [option],
+        }),
+        value: 0n,
+    });
+    return txs;
+}
+/**
+ * Close pool with manual resolver — proposer suggests a winning side.
+ * Returns [approval, closePool] transactions.
+ */
+export async function buildClosePoolManualRawTx(params) {
+    const { marketContractAddress, option, proposedWinner, rpcUrl } = params;
+    if (!marketContractAddress)
+        throw new Error("marketContractAddress is required");
+    if (option === undefined || option === null)
+        throw new Error("option is required");
+    if (proposedWinner === undefined || proposedWinner === null)
+        throw new Error("proposedWinner is required");
+    const [bondAmount, baseToken] = await Promise.all([
+        getResolverBondAmount({ marketContractAddress, option, rpcUrl }),
+        getMarketBaseToken({ marketContractAddress, rpcUrl }),
+    ]);
+    const txs = [];
+    if (bondAmount > 0n) {
+        txs.push(buildApproveRawTx({
+            tokenAddress: baseToken,
+            spender: marketContractAddress,
+            amount: bondAmount,
+        }));
+    }
+    txs.push({
+        to: marketContractAddress,
+        data: encodeFunctionData({
+            abi: MarketsAbi,
+            functionName: CLOSE_POOL,
+            args: [option, proposedWinner],
+        }),
+        value: 0n,
+    });
+    return txs;
+}
+/**
+ * Choose/finalize the winner after pool is closed.
+ * chooseWinner(option, optionSide)
+ */
+export function buildChooseWinnerRawTx(params) {
+    const { marketContractAddress, option, optionSide } = params;
+    if (!marketContractAddress)
+        throw new Error("marketContractAddress is required");
+    if (option === undefined || option === null)
+        throw new Error("option is required");
+    if (optionSide === undefined || optionSide === null)
+        throw new Error("optionSide is required");
+    return {
+        to: marketContractAddress,
+        data: encodeFunctionData({
+            abi: MarketsAbi,
+            functionName: CHOOSE_WINNER,
+            args: [option, optionSide],
+        }),
+        value: 0n,
+    };
+}

package/dist/tx/buildEnterOptionRawTx.d.ts

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