@rainprotocolsdk/sdk 1.1.1 → 1.3.0

package/dist/config/environments.d.ts

@@ -0,0 +1,20 @@
+export declare const ALLOWED_ENVIRONMENTS: readonly ["development", "stage", "production"];
+export declare const DEFAULT_RPCS: string[];
+export declare function getRandomRpc(): string;
+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 stage: {
+        readonly apiUrl: "https://stg-api.rain.one";
+        readonly market_factory_address: "0x6109c9f28FE3Ad84c51368f7Ef2d487ca020c561";
+        readonly dispute_initial_timer: number;
+    };
+    readonly production: {
+        readonly apiUrl: "https://prod-api.rain.one";
+        readonly market_factory_address: "0xccCB3C03D9355B01883779EF15C1Be09cf3623F1";
+        readonly dispute_initial_timer: number;
+    };
+};

package/dist/config/environments.js

@@ -0,0 +1,27 @@
+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 ENV_CONFIG = {
+    development: {
+        apiUrl: "https://dev-api.rain.one",
+        market_factory_address: "0x148DA7F2039B2B00633AC2ab566f59C8a4C86313",
+        dispute_initial_timer: 1 * 60
+    },
+    stage: {
+        apiUrl: "https://stg-api.rain.one",
+        market_factory_address: "0x6109c9f28FE3Ad84c51368f7Ef2d487ca020c561",
+        dispute_initial_timer: 1 * 60
+    },
+    production: {
+        apiUrl: "https://prod-api.rain.one",
+        market_factory_address: "0xccCB3C03D9355B01883779EF15C1Be09cf3623F1",
+        dispute_initial_timer: 120 * 60
+    },
+};

package/dist/constants/contractmethods.d.ts

@@ -1,3 +1,5 @@
 export declare const ENTER_OPTION = "enterOption";
 export declare const PLACE_BUY_ORDER = "placeBuyOrder";
 export declare const APPROVE_TOKEN = "approve";
+export declare const CREATE_MARKET = "createPool";
+export declare const CLAIM = "claim";

package/dist/constants/contractmethods.js

@@ -1,3 +1,5 @@
 export const ENTER_OPTION = 'enterOption';
 export const PLACE_BUY_ORDER = 'placeBuyOrder';
 export const APPROVE_TOKEN = 'approve';
+export const CREATE_MARKET = 'createPool';
+export const CLAIM = "claim";

package/dist/markets/getMarkets.js

@@ -1,7 +1,9 @@
-import { API_BASE_URL } from '../config/api.js';
 import { MARKET_SORT_BY, MARKET_STATUS } from './constants.js';
 export async function getMarkets(params) {
     const query = new URLSearchParams();
+    if (!params?.apiUrl) {
+        throw new Error("Environemnt is not set properly, api url is missing");
+    }
     if (params?.limit)
         query.append('limit', params.limit.toString());
     if (params?.offset)
@@ -10,7 +12,7 @@ export async function getMarkets(params) {
         query.append('sortBy', MARKET_SORT_BY[params.sortBy]);
     if (params?.status)
         query.append('status', MARKET_STATUS[params.status]);
-    const res = await fetch(`${API_BASE_URL}/pools/public-pools?${query.toString()}`);
+    const res = await fetch(`${params.apiUrl}/pools/public-pools?${query.toString()}`);
     if (!res.ok) {
         throw new Error(`Failed to fetch markets: ${res.status}`);
     }

package/dist/markets/types.d.ts

@@ -5,6 +5,7 @@ export interface GetMarketsParams {
     offset?: number;
     sortBy?: MarketSortBy;
     status?: MarketStatus;
+    apiUrl?: string;
 }
 export interface Market {
     id: string;

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/CreateMarket/buildCreateMarketRawTx.d.ts

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

package/dist/tx/CreateMarket/buildCreateMarketRawTx.js

@@ -0,0 +1,36 @@
+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";
+const ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";
+export function buildCreateMarketRawTx(params) {
+    const { isPublic, isPublicPoolResolverAi, creator, startTime, endTime, options, disputeTimer, ipfsUrl, inputAmountWei, barValues, baseToken, factoryContractAddress, } = params;
+    if (!factoryContractAddress)
+        throw new Error("environment is not set correctly, factory contract address is missing");
+    validateCreateMarketParams(params);
+    const normalizeBarValue = normalizeBarValues(barValues);
+    const createMarketParams = [
+        isPublic,
+        isPublicPoolResolverAi,
+        creator,
+        ZERO_ADDRESS,
+        startTime,
+        endTime,
+        options,
+        disputeTimer,
+        ipfsUrl,
+        inputAmountWei,
+        normalizeBarValue,
+        creator,
+        baseToken,
+    ];
+    return {
+        to: factoryContractAddress,
+        data: encodeFunctionData({
+            abi: CreateMarketAbi,
+            functionName: CREATE_MARKET,
+            args: [createMarketParams],
+        }),
+    };
+}

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,34 @@
+export function validateCreateMarketParams(params) {
+    const { isPublic, isPublicPoolResolverAi, creator, startTime, endTime, options, ipfsUrl, 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 (!startTime)
+        throw new Error("startTime is required");
+    if (!endTime)
+        throw new Error("endTime is required");
+    if (!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)
+        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 @@
+export declare function normalizeBarValues(values: (number)[]): number[];

package/dist/tx/CreateMarket/helpers.js

@@ -0,0 +1,11 @@
+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;
+}

package/dist/tx/types.d.ts

@@ -20,3 +20,33 @@ export interface EnterLimitOptionTxParams {
     buyAmountInWei: bigint;
     tokenDecimals?: number;
 }
+export interface CreateMarketTxParams {
+    isPublic: boolean;
+    isPublicPoolResolverAi: boolean;
+    creator: `0x${string}`;
+    startTime: bigint;
+    endTime: bigint;
+    options: bigint;
+    disputeTimer: number;
+    ipfsUrl: string;
+    inputAmountWei: bigint;
+    barValues: number[];
+    baseToken: `0x${string}`;
+    tokenDecimals?: number;
+    factoryContractAddress?: `0x${string}`;
+}
+export interface ClaimTxParams {
+    marketId: string;
+    walletAddress: `0x${string}`;
+    apiUrl?: string;
+    rpcUrl?: string;
+}
+export interface GetUserOptionSharesParams {
+    options: [{
+        choiceIndex: number;
+        optionName: string;
+    }];
+    walletAddress: `0x${string}`;
+    marketContractAddress: `0x${string}`;
+    rpcUrl: string;
+}

package/dist/types.d.ts

@@ -7,3 +7,8 @@ export interface RainConfig {
     chain: Chain;
     rpcUrl?: string;
 }
+export type RainEnvironment = "development" | "stage" | "production";
+export interface RainCoreConfig {
+    environment?: RainEnvironment;
+    rpcUrl?: string;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@rainprotocolsdk/sdk",
-    "version": "1.1.1",
+    "version": "1.3.0",
     "type": "module",
     "description": "Rain SDK",
     "main": "dist/index.js",

package/dist/config/api.d.ts

@@ -1 +0,0 @@
-export declare const API_BASE_URL = "https://dev-api.rain.one";

package/dist/config/api.js

@@ -1 +0,0 @@
-export const API_BASE_URL = "https://dev-api.rain.one";