rain-sdk-v2 2.1.3 → 2.1.5

package/README.md

@@ -661,6 +661,96 @@ const payouts = await rain.getDynamicPayout({
 // payouts = [yesPayoutWei, noPayoutWei]
 ```
 
+### `getResolverBondAmount(params): Promise<bigint>`
+
+Get the bond amount (in base-token wei) a resolver must post to propose a resolution for an option.
+
+```typescript
+const bond = await rain.getResolverBondAmount({
+  marketContractAddress: '0x...',
+  option: 1n, // 1-based option index
+});
+```
+
+### `getDisputeAppealFee(params): Promise<bigint>`
+
+Get the fee (in base-token wei) required to open a dispute or appeal on an option.
+
+```typescript
+const fee = await rain.getDisputeAppealFee({
+  marketContractAddress: '0x...',
+  option: 1n,
+});
+```
+
+### `optionResolverBond(params): Promise<bigint>`
+
+Get the resolver bond currently posted on an option (0n if no resolution has been proposed).
+
+```typescript
+const bond = await rain.optionResolverBond({
+  marketContractAddress: '0x...',
+  option: 1n,
+});
+```
+
+### `optionResolutionProposer(params): Promise<`0x${string}`>`
+
+Get the address that proposed the resolution for an option (zero address if none).
+
+```typescript
+const proposer = await rain.optionResolutionProposer({
+  marketContractAddress: '0x...',
+  option: 1n,
+});
+```
+
+### `isOptionDisputed(params): Promise<boolean>`
+
+Check whether an option's resolution has been disputed.
+
+```typescript
+const disputed = await rain.isOptionDisputed({
+  marketContractAddress: '0x...',
+  option: 1n,
+});
+```
+
+### `isOptionAppealed(params): Promise<boolean>`
+
+Check whether an option's dispute resolution has been appealed.
+
+```typescript
+const appealed = await rain.isOptionAppealed({
+  marketContractAddress: '0x...',
+  option: 1n,
+});
+```
+
+### `optionDispute(params): Promise<OptionDisputeInfo>`
+
+Get the dispute details for an option: fee paid, the winner claimed by the disputer, the disputer address, and the dispute resolver.
+
+```typescript
+const dispute = await rain.optionDispute({
+  marketContractAddress: '0x...',
+  option: 1n,
+});
+// { disputeFee: bigint, disputedWinner: bigint, disputer: '0x...', disputeResolver: '0x...' }
+```
+
+### `optionAppeal(params): Promise<OptionAppealInfo>`
+
+Get the appeal details for an option: fee paid, the winner claimed by the appellant, the disputer address, and the appeal resolver.
+
+```typescript
+const appeal = await rain.optionAppeal({
+  marketContractAddress: '0x...',
+  option: 1n,
+});
+// { disputeFee: bigint, disputedWinner: bigint, disputer: '0x...', appealResolver: '0x...' }
+```
+
 ### `getUserActiveBuyOrders(params): Promise<bigint>`
 
 Get count of user's active buy orders.
@@ -1237,6 +1327,64 @@ const priceData = await rain.getTokenPrice('0x...'); // token contract address
 // priceData.data = { price: 0.05 } — USD price per token
 ```
 
+### Leaderboard
+
+Public endpoints — no access token required. Boards are served from a materialized document rebuilt by a cron (~20 min), so changes appear after the next tick rather than on the next request.
+
+```typescript
+// Get a ranked leaderboard — one board per (board, window, category)
+const board = await rain.getLeaderboard({
+  board: 'profit',        // 'profit' (net realized PnL) or 'correct_calls' (sum of 1 − entryPrice over winning positions)
+  window: 'all_time',     // 'all_time' (default) or 'monthly' (current UTC calendar month)
+  category: 'Crypto',     // optional, case-insensitive; omit for the global board
+  limit: 10,              // up to the stored cap of 100 (default 10)
+});
+// board.data = { board, window, category, categoryLabel, period, limit, totalRanked, priceBasis, entries, lastUpdatedAt }
+// Each entry carries all four table columns — profit, correctCalls, winRate, trades —
+// whichever board is sorting, so switching the sorted column needs no second request.
+
+// Search traders on a board — the leaderboard's trader search box
+const found = await rain.searchLeaderboard({
+  q: '0x742d',            // wallet address, address fragment (with/without 0x, prefix/middle/tail), or user id
+  board: 'profit',        // required — searches the stored board for this (board, window, category)
+  window: 'all_time',     // optional, default 'all_time'
+  category: 'Crypto',     // optional; omit for the global board
+  limit: 10,              // up to 50 (default 10)
+});
+// found.data = { board, window, category, period, query, matched, searchedTop, totalRanked, lastUpdatedAt, results }
+// `results` are the same entry objects getLeaderboard returns, in rank order.
+// Scoped to the stored board — a trader outside the top N is simply not found.
+// Empty `results` means "not on this board"; `searchedTop` + `totalRanked` let you
+// say "not in the top 100" precisely. Queries under 2 characters return empty, not a 400.
+
+// Get a trader's most recent trades — the rows inside an expanded leaderboard row
+const recent = await rain.getTraderRecentTrades({
+  userId: '...',          // from a leaderboard entry's `userId`
+  limit: 5,               // rendered rows (a multi-side trade flattens into more lines), up to 25 (default 5)
+});
+// recent.data = { userId, limit, trades }
+// Each trade: { action ('Buy'|'Sell'), origin, transactionHash, tradedAt, poolId, question,
+//               poolImage, subPoolId, subQuestion, side (1=YES, 2=NO), optionName, shares,
+//               amountUSD, pricePerShare, priceCents, status ('open'|'pending'|'settled'),
+//               pnlScope, pnlUSD }
+// Directional trades only (origin ∈ {enter, orderFill}), newest first — and unlike the
+// track-record endpoint, OPEN positions are included (status 'open').
+// `pnlUSD` is POSITION-level, not per-fill: several trades in the same market report the
+// same number. Null until settled; `amountUSD`/`pnlUSD` are dollars × 1e6.
+
+// Get categories that currently have a ranked board (feeds the category filter)
+const categories = await rain.getLeaderboardCategories();
+// categories.data = [{ category: 'CRYPTO', label: 'Crypto' }, ...]
+// Pass `category` back as the `category` param of getLeaderboard.
+```
+
+**Notes:**
+- **Units:** every `*USD` number (including `profit` and `score` on the profit board) is **dollars × 1e6** — divide by 1,000,000 to display. E.g. `profit: 887505347` is **$887.51**.
+- **Monthly window** buckets on when PnL *settled*, not when the position was opened; `window: 'monthly'` always means the current UTC month (`period` reports it as `YYYY-MM`).
+- **Only positive scores are ranked.** An unknown `category` returns an empty board, not a 400.
+- **Top-N only** — there is no rank-of-user lookup. Empty `entries` with `lastUpdatedAt: null` means the cron hasn't built the board yet; empty with a timestamp means nobody qualifies.
+- The client can highlight the viewer's own row by matching `userId` in `entries`.
+
 ---
 
 ## WebSocket Events (Socket.IO)

package/dist/Rain.d.ts

@@ -4,8 +4,9 @@ import { ExtendTimeTxParams } from './tx/buildExtendTimeRawTx.js';
 import { RainCoreConfig, RainEnvironment } from './types.js';
 import { LoginParams, LoginResult } from './auth/types.js';
 import { SellProceedsResult } from './markets/getSellProceeds.js';
+import { OptionDisputeInfo, OptionAppealInfo } from './markets/getDisputeState.js';
 import { EntrySharesResult } from './markets/getEntryShares.js';
-import type { UserProfileUpdateParams, UserHistoryParams, CreateCommentParams, CommentsListingParams, UpdateCommentParams, CommentCountParams, PublicPoolsParams, PrivatePoolsParams, PoolListingByCreatorParams, VerifyAccessCodeParams, PoolTotalParticipantsParams, SearchPoolParams, RelatedPoolsParams, UpdateStreamingParams, UpdatePoolResolutionTimeParams, FindPoolFallbackParams, SignOraclesExtendTimeParams, TrendingTagsParams, UserTotalInvestmentParams, OptionsTotalVolumeParams, PoolActivityParams, TopHoldersParams, UserInvestedPoolsParams, InvestmentVolumeGraphParams, UserPnlGraphParams, TopWinnersLosersParams, PnlByPoolIdParams, UserPositionsParams, OpenPositionsParams, UserSharePositionsParams, SearchInvestedPoolsParams, PriceDataParams, AddReviewParams, GetUserOrdersParams, OrderBookParams, GetUserOrderByPoolIdParams, OrdersListingByPoolParams, AddUserPointsParams, UserOnboardingParams, PointsGraphParams, GetNotificationsParams, MarkNotificationAsReadParams, CreateDisputeMessageParams, GetPoolDisputeConvoParams, FollowToggleParams, FollowCheckParams, FollowListParams, FollowStatsParams, RainBurnPerPoolParams, ToggleBookmarkParams, GetBookmarksParams, CheckBookmarkParams } from './api/types.js';
+import type { UserProfileUpdateParams, UserHistoryParams, CreateCommentParams, CommentsListingParams, UpdateCommentParams, CommentCountParams, PublicPoolsParams, PrivatePoolsParams, PoolListingByCreatorParams, VerifyAccessCodeParams, PoolTotalParticipantsParams, SearchPoolParams, RelatedPoolsParams, UpdateStreamingParams, UpdatePoolResolutionTimeParams, FindPoolFallbackParams, SignOraclesExtendTimeParams, TrendingTagsParams, UserTotalInvestmentParams, OptionsTotalVolumeParams, PoolActivityParams, TopHoldersParams, UserInvestedPoolsParams, InvestmentVolumeGraphParams, UserPnlGraphParams, TopWinnersLosersParams, PnlByPoolIdParams, UserPositionsParams, OpenPositionsParams, UserSharePositionsParams, SearchInvestedPoolsParams, PriceDataParams, AddReviewParams, GetUserOrdersParams, OrderBookParams, GetUserOrderByPoolIdParams, OrdersListingByPoolParams, AddUserPointsParams, UserOnboardingParams, PointsGraphParams, GetNotificationsParams, MarkNotificationAsReadParams, CreateDisputeMessageParams, GetPoolDisputeConvoParams, FollowToggleParams, FollowCheckParams, FollowListParams, FollowStatsParams, RainBurnPerPoolParams, ToggleBookmarkParams, GetBookmarksParams, CheckBookmarkParams, LeaderboardParams, LeaderboardSearchParams, TraderRecentTradesParams } from './api/types.js';
 export declare class Rain {
     readonly environment: RainEnvironment;
     private readonly marketFactory;
@@ -58,6 +59,38 @@ export declare class Rain {
     getDisputeWindow(params: {
         marketContractAddress: `0x${string}`;
     }): Promise<bigint>;
+    getResolverBondAmount(params: {
+        marketContractAddress: `0x${string}`;
+        option: bigint;
+    }): Promise<bigint>;
+    getDisputeAppealFee(params: {
+        marketContractAddress: `0x${string}`;
+        option: bigint;
+    }): Promise<bigint>;
+    optionResolverBond(params: {
+        marketContractAddress: `0x${string}`;
+        option: bigint;
+    }): Promise<bigint>;
+    optionResolutionProposer(params: {
+        marketContractAddress: `0x${string}`;
+        option: bigint;
+    }): Promise<`0x${string}`>;
+    isOptionDisputed(params: {
+        marketContractAddress: `0x${string}`;
+        option: bigint;
+    }): Promise<boolean>;
+    isOptionAppealed(params: {
+        marketContractAddress: `0x${string}`;
+        option: bigint;
+    }): Promise<boolean>;
+    optionDispute(params: {
+        marketContractAddress: `0x${string}`;
+        option: bigint;
+    }): Promise<OptionDisputeInfo>;
+    optionAppeal(params: {
+        marketContractAddress: `0x${string}`;
+        option: bigint;
+    }): Promise<OptionAppealInfo>;
     getEntryShares(params: {
         marketContractAddress: `0x${string}`;
         option: bigint;
@@ -292,4 +325,8 @@ export declare class Rain {
     toggleBookmark(params: ToggleBookmarkParams, accessToken: string): Promise<import("./api/types.js").ApiResponse<unknown>>;
     getBookmarks(params: GetBookmarksParams, accessToken: string): Promise<import("./api/types.js").ApiResponse<unknown>>;
     checkBookmark(params: CheckBookmarkParams, accessToken: string): Promise<import("./api/types.js").ApiResponse<unknown>>;
+    getLeaderboard(params: LeaderboardParams): Promise<import("./api/types.js").ApiResponse<import("./api/types.js").LeaderboardData>>;
+    searchLeaderboard(params: LeaderboardSearchParams): Promise<import("./api/types.js").ApiResponse<import("./api/types.js").LeaderboardSearchData>>;
+    getTraderRecentTrades(params: TraderRecentTradesParams): Promise<import("./api/types.js").ApiResponse<import("./api/types.js").TraderRecentTradesData>>;
+    getLeaderboardCategories(): Promise<import("./api/types.js").ApiResponse<import("./api/types.js").LeaderboardCategory[]>>;
 }

package/dist/Rain.js

@@ -24,6 +24,9 @@ import { getSellProceeds } from './markets/getSellProceeds.js';
 import { getUserSharesInEscrow } from './markets/getUserSharesInEscrow.js';
 import { getOptionClaimed } from './markets/getOptionClaimed.js';
 import { getDisputeWindow } from './markets/getDisputeWindow.js';
+import { getResolverBondAmount } from './markets/getResolverBondAmount.js';
+import { getDisputeAppealFee } from './markets/getDisputeFee.js';
+import { optionResolverBond, optionResolutionProposer, isOptionDisputed, isOptionAppealed, optionDispute, optionAppeal } from './markets/getDisputeState.js';
 import { getEntryShares } from './markets/getEntryShares.js';
 import { createPublicClient, http, parseAbi } from 'viem';
 import { arbitrum } from 'viem/chains';
@@ -41,6 +44,7 @@ import * as disputeApi from './api/dispute.js';
 import * as followApi from './api/follow.js';
 import * as whitelistedTokensApi from './api/whitelistedTokens.js';
 import * as bookmarksApi from './api/bookmarks.js';
+import * as leaderboardApi from './api/leaderboard.js';
 const erc20AllowanceAbi = parseAbi(['function allowance(address owner, address spender) view returns (uint256)']);
 const factoryViewAbi = parseAbi([
     'function oracleFixedFee() view returns (uint256)',
@@ -136,6 +140,30 @@ export class Rain {
     async getDisputeWindow(params) {
         return getDisputeWindow({ ...params, rpcUrl: this.rpcUrl });
     }
+    async getResolverBondAmount(params) {
+        return getResolverBondAmount({ ...params, rpcUrl: this.rpcUrl });
+    }
+    async getDisputeAppealFee(params) {
+        return getDisputeAppealFee({ ...params, rpcUrl: this.rpcUrl });
+    }
+    async optionResolverBond(params) {
+        return optionResolverBond({ ...params, rpcUrl: this.rpcUrl });
+    }
+    async optionResolutionProposer(params) {
+        return optionResolutionProposer({ ...params, rpcUrl: this.rpcUrl });
+    }
+    async isOptionDisputed(params) {
+        return isOptionDisputed({ ...params, rpcUrl: this.rpcUrl });
+    }
+    async isOptionAppealed(params) {
+        return isOptionAppealed({ ...params, rpcUrl: this.rpcUrl });
+    }
+    async optionDispute(params) {
+        return optionDispute({ ...params, rpcUrl: this.rpcUrl });
+    }
+    async optionAppeal(params) {
+        return optionAppeal({ ...params, rpcUrl: this.rpcUrl });
+    }
     async getEntryShares(params) {
         return getEntryShares({ ...params, rpcUrl: this.rpcUrl });
     }
@@ -503,4 +531,17 @@ export class Rain {
     async checkBookmark(params, accessToken) {
         return bookmarksApi.checkBookmark(params, this.cfg(accessToken));
     }
+    // ─── Leaderboard ────────────────────────────────────────────────────────────
+    async getLeaderboard(params) {
+        return leaderboardApi.getLeaderboard(params, this.cfg());
+    }
+    async searchLeaderboard(params) {
+        return leaderboardApi.searchLeaderboard(params, this.cfg());
+    }
+    async getTraderRecentTrades(params) {
+        return leaderboardApi.getTraderRecentTrades(params, this.cfg());
+    }
+    async getLeaderboardCategories() {
+        return leaderboardApi.getLeaderboardCategories(this.cfg());
+    }
 }

package/dist/api/index.d.ts

@@ -14,3 +14,4 @@ export * from './dispute.js';
 export * from './follow.js';
 export * from './whitelistedTokens.js';
 export * from './bookmarks.js';
+export * from './leaderboard.js';

package/dist/api/index.js

@@ -14,3 +14,4 @@ export * from './dispute.js';
 export * from './follow.js';
 export * from './whitelistedTokens.js';
 export * from './bookmarks.js';
+export * from './leaderboard.js';

package/dist/api/leaderboard.d.ts

@@ -0,0 +1,5 @@
+import { ApiConfig, ApiResponse, LeaderboardParams, LeaderboardData, LeaderboardCategory, LeaderboardSearchParams, LeaderboardSearchData, TraderRecentTradesParams, TraderRecentTradesData } from './types.js';
+export declare function getLeaderboard(params: LeaderboardParams, config: ApiConfig): Promise<ApiResponse<LeaderboardData>>;
+export declare function searchLeaderboard(params: LeaderboardSearchParams, config: ApiConfig): Promise<ApiResponse<LeaderboardSearchData>>;
+export declare function getTraderRecentTrades(params: TraderRecentTradesParams, config: ApiConfig): Promise<ApiResponse<TraderRecentTradesData>>;
+export declare function getLeaderboardCategories(config: ApiConfig): Promise<ApiResponse<LeaderboardCategory[]>>;

package/dist/api/leaderboard.js

@@ -0,0 +1,32 @@
+import { buildHeaders, buildQuery, handleResponse } from './helpers.js';
+export async function getLeaderboard(params, config) {
+    const qs = buildQuery({ board: params.board, window: params.window, category: params.category, limit: params.limit });
+    const res = await fetch(`${config.apiUrl}/leaderboard${qs}`, {
+        method: 'GET',
+        headers: buildHeaders(config),
+    });
+    return handleResponse(res);
+}
+export async function searchLeaderboard(params, config) {
+    const qs = buildQuery({ q: params.q, board: params.board, window: params.window, category: params.category, limit: params.limit });
+    const res = await fetch(`${config.apiUrl}/leaderboard/search${qs}`, {
+        method: 'GET',
+        headers: buildHeaders(config),
+    });
+    return handleResponse(res);
+}
+export async function getTraderRecentTrades(params, config) {
+    const qs = buildQuery({ limit: params.limit });
+    const res = await fetch(`${config.apiUrl}/leaderboard/traders/${encodeURIComponent(params.userId)}/recent-trades${qs}`, {
+        method: 'GET',
+        headers: buildHeaders(config),
+    });
+    return handleResponse(res);
+}
+export async function getLeaderboardCategories(config) {
+    const res = await fetch(`${config.apiUrl}/leaderboard/categories`, {
+        method: 'GET',
+        headers: buildHeaders(config),
+    });
+    return handleResponse(res);
+}

package/dist/api/types.d.ts

@@ -322,3 +322,141 @@ export interface GetBookmarksParams {
 export interface CheckBookmarkParams {
     poolId: string;
 }
+export type LeaderboardBoard = 'profit' | 'correct_calls';
+export type LeaderboardWindow = 'all_time' | 'monthly';
+export interface LeaderboardParams {
+    /** Ranking to serve: net realized PnL, or the weighted correct-calls score. */
+    board: LeaderboardBoard;
+    /** `all_time` (default) or the current UTC calendar month. */
+    window?: LeaderboardWindow;
+    /** Market category (case-insensitive). Omit for the global board. Unknown categories return an empty board. */
+    category?: string;
+    /** Entries to return, up to the stored cap of 100. Default 10. */
+    limit?: number;
+}
+export interface LeaderboardEntry {
+    rank: number;
+    userId: string;
+    walletAddress: string | null;
+    eoaWalletAddress: string | null;
+    /** The ranking key. On `profit`, dollars × 1e6 (divide by 1,000,000 to display); on `correct_calls`, an unscaled weight. */
+    score: number;
+    positions: number;
+    /** Net realized PnL in dollars × 1e6. Present on both boards. */
+    profit: number;
+    /** Sum of `1 − entryPrice` over winning positions — a weight, not a count. Present on both boards. */
+    correctCalls: number;
+    /** Resolved directional positions — the denominator of `winRate`. */
+    trades: number;
+    wins: number;
+    /** `wins / trades`, a fraction in [0,1]. */
+    winRate: number;
+    badge: 'none' | 'blue' | 'gold';
+    /** Crowns held on this board and category — the row's crown indicator. */
+    categoryCrowns: number;
+    /** Newest crowned month in this bucket, `YYYY-MM` (UTC), or null. */
+    lastCrownPeriod: string | null;
+    /** Crowns held across all boards and categories. */
+    crownCount: number;
+    marketScore: number;
+    costScore: number;
+}
+export interface LeaderboardData {
+    board: LeaderboardBoard;
+    window: LeaderboardWindow;
+    /** Upper-cased matched key, or null for the global board. */
+    category: string | null;
+    /** Display spelling of the matched category, or null. */
+    categoryLabel: string | null;
+    /** `YYYY-MM` (UTC) on the monthly window; null on all-time. */
+    period: string | null;
+    limit: number;
+    /** Users ranked in total (before the stored cap). */
+    totalRanked: number;
+    /** Entry-price basis the correct-calls board was ranked on: `market` or `cost`. */
+    priceBasis: 'market' | 'cost';
+    entries: LeaderboardEntry[];
+    /** When the cron last rebuilt this board; null means never. */
+    lastUpdatedAt: string | null;
+}
+export interface LeaderboardCategory {
+    /** Upper-cased key — pass this back as `category`. */
+    category: string;
+    /** First-seen spelling, for display. */
+    label: string;
+}
+export interface LeaderboardSearchParams {
+    /** Wallet address, address fragment (with or without 0x, prefix/middle/tail), or user id. Case-insensitive substring match. */
+    q: string;
+    /** Board to search: `profit` or `correct_calls`. */
+    board: LeaderboardBoard;
+    /** `all_time` (default) or the current UTC calendar month. */
+    window?: LeaderboardWindow;
+    /** Market category (case-insensitive). Omit for the global board. */
+    category?: string;
+    /** Results to return, up to 50. Default 10. */
+    limit?: number;
+}
+export interface TraderRecentTradesParams {
+    /** The trader's user id, as returned in leaderboard entries. */
+    userId: string;
+    /** Rendered rows to return (a trade carrying more than one side flattens into more than one line), up to 25. Default 5. */
+    limit?: number;
+}
+export interface TraderRecentTrade {
+    /** Rendered form of `transactionType`: `Buy` or `Sell`. */
+    action: 'Buy' | 'Sell';
+    transactionType: string;
+    origin: 'enter' | 'orderFill';
+    transactionHash: string;
+    tradedAt: string;
+    poolId: string;
+    question: string | null;
+    poolImage: string | null;
+    subPoolId: string | null;
+    /** The sub-market — e.g. "Match winner". */
+    subQuestion: string | null;
+    /** 1 = YES, 2 = NO */
+    side: number;
+    optionName: string;
+    shares: number;
+    /** Collateral paid, in dollars × 1e6 (divide by 1,000,000 to display). */
+    amountUSD: number;
+    /** Collateral paid per share, in (0,1). Null when the recorded ratio is not a price (e.g. a 1:1 AMM entry). */
+    pricePerShare: number | null;
+    /** `pricePerShare` in cents, for the "9c" label. */
+    priceCents: number | null;
+    /** `open` = market not resolved; `pending` = won but unclaimed (no PnL yet, never booked as a loss); `settled` = realized. */
+    status: 'open' | 'pending' | 'settled';
+    /** Always `position` — PnL is per (pool, subPool), not per fill. */
+    pnlScope: string;
+    /** Realized PnL of the POSITION this trade belongs to, in dollars × 1e6. Null until settled. */
+    pnlUSD: number | null;
+    /** Resolved-but-unclaimed winnings of the position, in dollars × 1e6. */
+    pendingUSD?: number;
+    /** Whether the position won, once resolved. */
+    won?: boolean;
+}
+export interface TraderRecentTradesData {
+    userId: string;
+    limit: number;
+    /** Most recent directional trades, newest first. */
+    trades: TraderRecentTrade[];
+}
+export interface LeaderboardSearchData {
+    board: LeaderboardBoard;
+    window: LeaderboardWindow;
+    category: string | null;
+    /** `YYYY-MM` (UTC) on the monthly window; null on all-time. */
+    period: string | null;
+    query: string;
+    /** Board entries the term matched, before `limit`. */
+    matched: number;
+    /** Board rows searched — the stored depth. With `matched: 0`, lets a client say "not in the top N" rather than "no such trader". */
+    searchedTop: number;
+    /** Users ranked on this board in total. */
+    totalRanked: number;
+    lastUpdatedAt: string | null;
+    /** Matching board entries — the same objects `getLeaderboard` returns, in rank order. */
+    results: LeaderboardEntry[];
+}

package/dist/index.d.ts

@@ -8,6 +8,7 @@ export { signLoginMessage } from './auth/signMessage.js';
 export type { ExtendTimeTxParams } from './tx/buildExtendTimeRawTx.js';
 export type { CalculateWinnerTxParams } from './tx/buildCalculateWinnerRawTx.js';
 export type { TokenConfig } from './config/environments.js';
+export type { OptionDisputeInfo, OptionAppealInfo } from './markets/getDisputeState.js';
 export * from './api/index.js';
 export { RainSocket } from './socket/RainSocket.js';
 export type { RainSocketEvent, EnterOptionEventData, ExitOptionEventData, LiquidityEventData, SplitEventData, MergeEventData, RemoveLiquidityEventData, SyncPriceEventData, OrderCreatedEventData, OrderCancelledEventData, OrderFilledEventData, PoolClosedEventData, PoolEventData, WinnerEventData, DisputeOpenedEventData, OracleCreatedEventData, AppealOpenedEventData, DisputeWinnerEventData, AppealWinnerEventData, ClaimRewardEventData, DisputeRefundEventData } from './socket/RainSocket.js';

package/dist/markets/getDisputeState.d.ts

@@ -0,0 +1,24 @@
+export interface OptionDisputeInfo {
+    disputeFee: bigint;
+    disputedWinner: bigint;
+    disputer: `0x${string}`;
+    disputeResolver: `0x${string}`;
+}
+export interface OptionAppealInfo {
+    disputeFee: bigint;
+    disputedWinner: bigint;
+    disputer: `0x${string}`;
+    appealResolver: `0x${string}`;
+}
+interface OptionReadParams {
+    marketContractAddress: `0x${string}`;
+    option: bigint;
+    rpcUrl: string;
+}
+export declare function optionResolverBond(params: OptionReadParams): Promise<bigint>;
+export declare function optionResolutionProposer(params: OptionReadParams): Promise<`0x${string}`>;
+export declare function isOptionDisputed(params: OptionReadParams): Promise<boolean>;
+export declare function isOptionAppealed(params: OptionReadParams): Promise<boolean>;
+export declare function optionDispute(params: OptionReadParams): Promise<OptionDisputeInfo>;
+export declare function optionAppeal(params: OptionReadParams): Promise<OptionAppealInfo>;
+export {};

package/dist/markets/getDisputeState.js

@@ -0,0 +1,69 @@
+import { createPublicClient, http } from 'viem';
+import { arbitrum } from 'viem/chains';
+import { MarketsAbi } from '../abi/MarketsAbi.js';
+function client(rpcUrl) {
+    return createPublicClient({
+        chain: arbitrum,
+        transport: http(rpcUrl),
+    });
+}
+export async function optionResolverBond(params) {
+    const { marketContractAddress, option, rpcUrl } = params;
+    const bond = await client(rpcUrl).readContract({
+        address: marketContractAddress,
+        abi: MarketsAbi,
+        functionName: 'optionResolverBond',
+        args: [option],
+    });
+    return bond;
+}
+export async function optionResolutionProposer(params) {
+    const { marketContractAddress, option, rpcUrl } = params;
+    const proposer = await client(rpcUrl).readContract({
+        address: marketContractAddress,
+        abi: MarketsAbi,
+        functionName: 'optionResolutionProposer',
+        args: [option],
+    });
+    return proposer;
+}
+export async function isOptionDisputed(params) {
+    const { marketContractAddress, option, rpcUrl } = params;
+    const disputed = await client(rpcUrl).readContract({
+        address: marketContractAddress,
+        abi: MarketsAbi,
+        functionName: 'isOptionDisputed',
+        args: [option],
+    });
+    return disputed;
+}
+export async function isOptionAppealed(params) {
+    const { marketContractAddress, option, rpcUrl } = params;
+    const appealed = await client(rpcUrl).readContract({
+        address: marketContractAddress,
+        abi: MarketsAbi,
+        functionName: 'isOptionAppealed',
+        args: [option],
+    });
+    return appealed;
+}
+export async function optionDispute(params) {
+    const { marketContractAddress, option, rpcUrl } = params;
+    const [disputeFee, disputedWinner, disputer, disputeResolver] = await client(rpcUrl).readContract({
+        address: marketContractAddress,
+        abi: MarketsAbi,
+        functionName: 'optionDispute',
+        args: [option],
+    });
+    return { disputeFee, disputedWinner, disputer, disputeResolver };
+}
+export async function optionAppeal(params) {
+    const { marketContractAddress, option, rpcUrl } = params;
+    const [disputeFee, disputedWinner, disputer, appealResolver] = await client(rpcUrl).readContract({
+        address: marketContractAddress,
+        abi: MarketsAbi,
+        functionName: 'optionAppeal',
+        args: [option],
+    });
+    return { disputeFee, disputedWinner, disputer, appealResolver };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "rain-sdk-v2",
-    "version": "2.1.3",
+    "version": "2.1.5",
     "type": "module",
     "description": "Rain SDK V2 — TypeScript SDK for Rain prediction markets on Arbitrum. Market creation, trading, liquidity, order book, split/merge, dispute, and smart account support.",
     "main": "dist/index.js",