@0xmonaco/types 1.0.69 → 1.0.72

package/dist/copy-trading/responses.js

@@ -0,0 +1,317 @@
+/**
+ * Copy trading response types (0XM-2851).
+ *
+ * Zod schemas for every copy trading REST/gRPC response, with the inferred
+ * TypeScript types. The REST API returns camelCase JSON; an optional field the
+ * server has no value for arrives as `null`, so optional fields are typed
+ * `T | null | undefined` (`.nullish()`).
+ *
+ * Leaders are only ever identified by their public wallet address and custom
+ * TraderCode handle, never by an internal id.
+ *
+ * Label fields (statuses, modes, reasons) are typed `Union | (string & {})`:
+ * the unions name the values the server sends today, and the schemas accept
+ * any string so a value added server-side later does not fail parsing.
+ */
+import { z } from "zod";
+/** A string schema typed as a known-value union that still admits unknown values. */
+function openUnion() {
+    return z.string();
+}
+/** A lead trader as the public sees them: wallet and handle, never an internal id. */
+export const LeadTraderRefSchema = z.object({
+    /** The leader's wallet address (lowercase hex). */
+    walletAddress: z.string(),
+    /** The leader's custom TraderCode handle, when claimed. */
+    handle: z.string().nullish(),
+    /** The handle when claimed, else the wallet address. */
+    display: z.string(),
+});
+/** A lead trader's public profile. */
+export const LeadTraderProfileSchema = z.object({
+    leader: LeadTraderRefSchema,
+    /** `ACTIVE` (accepting follows), `PAUSED` (existing follows keep mirroring, no new follows) or `SUSPENDED` (own profile only). */
+    status: openUnion(),
+    /** The leader's share of followers' realized profit, in basis points. */
+    shareBps: z.number(),
+    /** Free-text profile description; empty when none. */
+    bio: z.string(),
+    /** Minimum follow allocation in quote units, when above the platform floor. */
+    minAllocation: z.string().nullish(),
+    /** Registration time (RFC 3339). */
+    registeredAt: z.string(),
+});
+/** Live follows of a leader. */
+export const LeadTraderFollowSummarySchema = z.object({
+    /** Live follows (`ACTIVE` or `CLOSE_ONLY`). */
+    followerCount: z.number(),
+    /** Collateral allocated by live follows, in quote units (AUM as allocated, not marked). */
+    allocated: z.string(),
+    /**
+     * Equity of live follows' copy accounts at the engine's marks, in quote
+     * units (AUM marked: collateral plus unrealized PnL of copy positions).
+     * Absent when it could not be read. Not trading PnL.
+     */
+    aumEquity: z.string().nullish(),
+});
+/** A leader's trading stats over one window. */
+export const LeadTraderStatsSchema = z.object({
+    /** `7d`, `30d`, `90d` or `all`. */
+    window: openUnion(),
+    /** Trading PnL over the window in quote units: realized plus unrealized, net of fees and funding. */
+    pnl: z.string(),
+    /** PnL as a percentage of the highest base balance over the window; absent when that base is not positive. */
+    roiPct: z.string().nullish(),
+    /** Largest peak-to-trough fall of cumulative PnL over the window, as a percentage of the highest base balance. */
+    maxDrawdownPct: z.string().nullish(),
+    /** Winning closes as a percentage of winning plus losing closes; absent when there were none. */
+    winRatePct: z.string().nullish(),
+    /** Closes over the window, break-even included. */
+    closedTrades: z.number(),
+});
+/** One lead trader: profile, follow summary and stats for every window (7d, 30d, 90d, all). */
+export const GetLeadTraderResponseSchema = z.object({
+    profile: LeadTraderProfileSchema,
+    followSummary: LeadTraderFollowSummarySchema,
+    stats: z.array(LeadTraderStatsSchema),
+});
+/** One leaderboard row: stats for the requested window only. */
+export const LeadTraderListingSchema = z.object({
+    profile: LeadTraderProfileSchema,
+    followSummary: LeadTraderFollowSummarySchema,
+    stats: LeadTraderStatsSchema,
+});
+/** A page of the public leaderboard. */
+export const ListLeadTradersResponseSchema = z.object({
+    leaders: z.array(LeadTraderListingSchema),
+    /** Cursor for the next page; empty at the end. Pinned to the sort and window that produced it. */
+    nextPageToken: z.string(),
+    /** Time of the leaderboard snapshot these rows come from (RFC 3339). */
+    asOf: z.string(),
+});
+/** Result of registering as, or editing, a lead trader. */
+export const UpsertLeadTraderResponseSchema = z.object({
+    /** True when this call registered you, false when it edited your profile. */
+    created: z.boolean(),
+    /** Your status after the call. */
+    status: openUnion(),
+    /** Your profit share after the call, in basis points. */
+    shareBps: z.number(),
+});
+/** One of your followers, as a leader sees them. */
+export const FollowerSchema = z.object({
+    /** The follower's wallet address (lowercase hex). */
+    walletAddress: z.string(),
+    /** The follower's custom TraderCode handle when claimed, else the wallet address. */
+    display: z.string(),
+    /** `ACTIVE` or `CLOSE_ONLY`. */
+    status: openUnion(),
+    /** Collateral allocated to the follow, in quote units. */
+    allocation: z.string(),
+    /** When the follow started (RFC 3339). */
+    startedAt: z.string(),
+});
+/** A page of your followers. */
+export const ListMyFollowersResponseSchema = z.object({
+    followers: z.array(FollowerSchema),
+    /** Cursor for the next page; empty at the end. */
+    nextPageToken: z.string(),
+});
+/** One reducing execution of a leader's position. */
+export const ClosedTradeSchema = z.object({
+    tradingPairId: z.string(),
+    /** `LONG` or `SHORT`; empty on legacy rows. */
+    positionSide: z.string(),
+    /** `DECREASE`, `CLOSE`, `LIQUIDATE` or `ADL`. */
+    action: openUnion(),
+    /** Closed size in base units. */
+    size: z.string().nullish(),
+    /** Execution price. */
+    exitPrice: z.string().nullish(),
+    /** Average entry price of the position at the close. */
+    entryPrice: z.string().nullish(),
+    /** Gross realized PnL of the execution, in quote units. */
+    realizedPnl: z.string().nullish(),
+    /** Realized PnL net of the execution's fees and funding, in quote units. */
+    netRealizedPnl: z.string().nullish(),
+    /** Net realized PnL as a percentage of the initial margin released by the execution. */
+    realizedRoe: z.string().nullish(),
+    /** Execution time (RFC 3339). */
+    closedAt: z.string(),
+});
+/** A page of a leader's closed trades. */
+export const ListLeadTraderClosedTradesResponseSchema = z.object({
+    closedTrades: z.array(ClosedTradeSchema),
+    /** Cursor for the next page; empty at the end. */
+    nextPageToken: z.string(),
+});
+/** One open position of a leader you follow. */
+export const LeadTraderOpenPositionSchema = z.object({
+    tradingPairId: z.string(),
+    /** `LONG` or `SHORT`. */
+    side: z.string(),
+    /** Position size in base units. */
+    size: z.string(),
+    /** Average entry price. */
+    entryPrice: z.string(),
+    /** Current mark price. */
+    markPrice: z.string().nullish(),
+    /** Unrealized PnL at the mark, in quote units. */
+    unrealizedPnl: z.string().nullish(),
+    /** Position leverage. */
+    leverage: z.string().nullish(),
+    /** `CROSS` or `ISOLATED`. */
+    marginMode: z.string(),
+});
+/** A followed leader's open positions (current followers only). */
+export const ListLeadTraderOpenPositionsResponseSchema = z.object({
+    positions: z.array(LeadTraderOpenPositionSchema),
+});
+/** One of your follows. */
+export const FollowSchema = z.object({
+    /** The follow's id. */
+    followId: z.string(),
+    leader: LeadTraderRefSchema,
+    /** `ACTIVE`, `CLOSE_ONLY` (only reductions mirror) or `STOPPED`. */
+    status: openUnion(),
+    /** `FOLLOW`, `CROSS` or `ISOLATED`. */
+    marginModePolicy: openUnion(),
+    /** `PROPORTIONAL` or `FIXED_MARGIN`. */
+    sizingMode: openUnion(),
+    /** Margin per leader order for `FIXED_MARGIN`, in quote units. */
+    sizingParam: z.string().nullish(),
+    /** `FOLLOW` or `FIXED`. */
+    leverageMode: openUnion(),
+    /** Leverage for `FIXED`. */
+    fixedLeverage: z.string().nullish(),
+    /** Collateral allocated to the follow, in quote units. */
+    allocation: z.string(),
+    /** Copy stop-loss as a fraction of the allocation. */
+    slPct: z.string().nullish(),
+    /** Whether the follow copied the leader's open positions at creation. */
+    copyExisting: z.boolean(),
+    /** Markets mirrored; empty means every market the leader trades. */
+    tradingPairIds: z.array(z.string()),
+    /** Consecutive mirrors skipped for insufficient margin. */
+    consecutiveSkips: z.number(),
+    /** The copy account's cross risk bucket in your margin account. */
+    copyRiskBucketId: z.string(),
+    /** When the follow started (RFC 3339). */
+    startedAt: z.string(),
+    /** When the follow stopped (RFC 3339). */
+    stoppedAt: z.string().nullish(),
+    /** `FOLLOWER`, `STOP_LOSS`, `SKIP_LIMIT`, `ADMIN` or `LEADER_SUSPENDED`. */
+    stopReason: openUnion().nullish(),
+});
+/** A page of your follows. */
+export const ListMyFollowsResponseSchema = z.object({
+    follows: z.array(FollowSchema),
+    /** Cursor for the next page; empty at the end. */
+    nextPageToken: z.string(),
+});
+/** A leader fill one of your follows did not mirror. */
+export const CopySkipSchema = z.object({
+    /** Trading pair of the leader fill. */
+    tradingPairId: z.string(),
+    /** Why the mirror was skipped, e.g. `INSUFFICIENT_MARGIN`. */
+    reason: openUnion(),
+    /** The copy quantity that could not be placed, in base units. */
+    requestedQuantity: z.string(),
+    /** When the mirror was skipped (RFC 3339). */
+    skippedAt: z.string(),
+});
+/** One of your follows with its most recent skips (up to 100). */
+export const GetFollowResponseSchema = z.object({
+    follow: FollowSchema,
+    recentSkips: z.array(CopySkipSchema),
+    /**
+     * The copy account's equity at the engine's marks, in quote units: its
+     * collateral plus the unrealized PnL of its positions. Absent when the
+     * engine could not be read. A balance, not trading PnL.
+     */
+    copyAccountEquity: z.string().nullish(),
+});
+/** The open positions of the leader one of your follows copies. */
+export const ListFollowLeaderPositionsResponseSchema = z.object({
+    positions: z.array(LeadTraderOpenPositionSchema),
+});
+/** Result of following a leader or editing a follow. */
+export const UpsertFollowResponseSchema = z.object({
+    /** The follow's id. */
+    followId: z.string(),
+    /** The copy account: the cross risk bucket in your margin account that holds this follow's collateral and positions. */
+    copyRiskBucketId: z.string(),
+    /** True when this call created the follow, false when it edited one. */
+    created: z.boolean(),
+});
+/**
+ * What following with `copyExisting` would open, as totals only. The caller
+ * is never a follower of the leader, so the preview names no pair, side,
+ * size, mark or skip reason. Totals are rounded up to cents.
+ */
+export const PreviewFollowResponseSchema = z.object({
+    /** Estimated collateral the copied positions would reserve at placement, in quote units. */
+    estimatedMargin: z.string(),
+    /** Estimated taker fees of the copies, in quote units. */
+    estimatedFee: z.string(),
+    /** The leader's positions (in the copied markets) that would be copied. */
+    copiedPositions: z.number(),
+    /** The leader's positions (in the copied markets) that would not be copied. */
+    skippedPositions: z.number(),
+    /** More leader positions matched than one preview sizes (64); the totals and counts cover the first ones. */
+    truncated: z.boolean(),
+});
+/** Result of stopping a follow. */
+export const StopFollowResponseSchema = z.object({
+    /** The stopped follow's id. */
+    followId: z.string(),
+});
+/**
+ * One follow's copy positions closing: a batch acknowledgement, sent once the
+ * batch is durably logged. The closes are reduce-only and immediate-or-cancel;
+ * each one's fills arrive on the order, position and copy channels. Not a
+ * flatten guarantee: `positionsNotClosed` counts what a thin or halted market
+ * left open.
+ */
+export const CloseFollowPositionsResponseSchema = z.object({
+    /** The follow's id. */
+    followId: z.string(),
+    /** Close orders placed (each may fill in part). */
+    closeOrdersPlaced: z.number(),
+    /** Copy positions still open after the batch (for example a thin or halted market). */
+    positionsNotClosed: z.number(),
+});
+/** A follow whose close could not run. */
+export const FollowCloseFailureSchema = z.object({
+    /** The follow's id. */
+    followId: z.string(),
+    /** Why the close could not run, as a fixed sentence; retry the close. */
+    reason: z.string(),
+});
+/** Result of closing all your copy positions. */
+export const CloseAllCopyPositionsResponseSchema = z.object({
+    /**
+     * Every live follow whose stop is not in progress and whose close ran,
+     * including one with nothing to close (0 orders placed, 0 positions not closed).
+     */
+    follows: z.array(CloseFollowPositionsResponseSchema),
+    /** Follows whose stop is in progress: their stop closes their positions. */
+    stoppingFollowIds: z.array(z.string()),
+    /** Follows whose close could not run; the other follows still closed. */
+    failedFollows: z.array(FollowCloseFailureSchema),
+});
+/** Result of adding margin to one of your copy positions. */
+export const AddFollowPositionMarginResponseSchema = z.object({
+    /** The follow's id. */
+    followId: z.string(),
+    /** Trading pair of the copy position. */
+    tradingPairId: z.string(),
+    /** The copy position's isolated risk bucket. */
+    riskBucketId: z.string(),
+    /** The copy position's id. */
+    positionId: z.string(),
+    /** The copy position's margin after the add, in quote units. */
+    positionMargin: z.string(),
+    /** What the copy account can still put into this position after the add, in quote units. */
+    copyAccountAvailable: z.string(),
+});

package/dist/delegated-agents/index.d.ts

@@ -4,14 +4,21 @@ export type DelegatedAgentAction = "CREATE_ORDER" | "CANCEL_ORDER" | "REPLACE_OR
 export interface UpsertDelegatedAgentRequest {
     agentAddress: string;
     name?: string;
+    /** Delegation expiry (ISO 8601); ends reads, trading, and session refresh. */
     expiresAt?: string;
+    /** Required. An empty list permits no actions. */
     allowedActions: DelegatedAgentAction[];
+    /** Required. A matching market OR account permits an order; both scopes empty deny all orders. */
     allowedTradingPairIds: string[];
+    /** Additional account scope. Omit or send [] for market-only scope, not access to every account. */
     allowedMarginAccountIds?: string[];
+    /** Omit or send [] for unrestricted order types. */
     allowedOrderTypes?: Array<"LIMIT" | "MARKET">;
+    /** Omit or send [] for unrestricted time in force. */
     allowedTimeInForce?: Array<"GTC" | "IOC" | "FOK">;
     maxLeverage?: string;
     maxOrderNotional?: string;
+    /** @deprecated Unsupported: setting this field causes the server to reject the request. */
     maxOpenOrders?: number;
 }
 export interface DelegatedAgent {
@@ -29,6 +36,7 @@ export interface DelegatedAgent {
     allowedTimeInForce?: string[];
     maxLeverage?: string;
     maxOrderNotional?: string;
+    /** @deprecated Legacy data only; no concurrent open-order cap is enforced. */
     maxOpenOrders?: number;
 }
 export interface ListDelegatedAgentsResponse {
@@ -54,6 +62,7 @@ export interface CreateDelegatedSessionRequest {
     sessionPublicKey: string;
 }
 export interface CreateDelegatedSessionResponse {
+    /** Unix seconds; bounded by delegation expiry. Revocation may end access sooner. */
     expiresAt: number;
     delegationId: string;
     ownerUserId: string;

package/dist/fees/index.d.ts

@@ -41,6 +41,9 @@ export interface FeesAPI extends BaseAPI {
      * spot/perp breakdown), the volume still needed to reach the next tier, and the
      * requested pair's six-row fee schedule (threshold plus maker/taker bps).
      *
+     * The tier and volumes are wallet-wide: the caller's wallet total across every
+     * application it trades through, so they read the same from any application.
+     *
      * @param params - Parameters for the lookup
      * @param params.tradingPairId - Trading pair whose fee schedule to return
      * @returns Promise resolving to the caller's tier and the pair's schedule

package/dist/fees/responses.js

@@ -126,13 +126,13 @@ export const FeeTierScheduleRowSchema = z.object({
  * Zod schema for the "my fee tier" response
  */
 export const GetMyFeeTierResponseSchema = z.object({
-    /** Caller's resolved tier (1–6) from stored weighted 14-day volume */
+    /** Caller's resolved tier (1–6) from their wallet's stored weighted 14-day volume */
     currentTierLevel: z.number().int(),
-    /** Caller's weighted 14-day volume (perp + 2.5× spot) */
+    /** Caller's weighted 14-day volume (perp + 2.5× spot), summed across every application the wallet trades through */
     weightedVolume14d: z.string(),
-    /** Caller's rolling 14-day spot volume */
+    /** Caller's rolling 14-day spot volume, summed across every application the wallet trades through */
     spotVolume14d: z.string(),
-    /** Caller's rolling 14-day perp volume */
+    /** Caller's rolling 14-day perp volume, summed across every application the wallet trades through */
     perpVolume14d: z.string(),
     /** Additional weighted volume needed to reach the next tier; absent at tier 6 */
     volumeToNextTier: z.string().nullable().optional(),

package/dist/index.d.ts

@@ -9,6 +9,7 @@ export * from "./applications";
 export * from "./auth";
 export * from "./buildercodes";
 export * from "./contracts";
+export * from "./copy-trading";
 export * from "./delegated-agents";
 export * from "./faucet";
 export * from "./fees";

package/dist/index.js

@@ -10,6 +10,7 @@ export * from "./applications";
 export * from "./auth";
 export * from "./buildercodes";
 export * from "./contracts";
+export * from "./copy-trading";
 export * from "./delegated-agents";
 export * from "./faucet";
 export * from "./fees";

package/dist/margin-accounts/index.d.ts

@@ -30,6 +30,12 @@ export interface MarginAccountSummary {
     withdrawableCollateral: string;
     totalPositionNotional: string;
     unrealizedPnl: string;
+    /**
+     * On a risk bucket row, the risk bucket's cash balance (realized closes,
+     * funding, and transfers between a copy account's risk buckets land here),
+     * not trading profit; trading PnL comes from position history and the
+     * portfolio PnL endpoints.
+     */
     realizedPnl: string;
     updatedAt: string;
     /**
@@ -68,6 +74,18 @@ export interface MarginAccountSummary {
      * persisted-fallback reads.
      */
     availableOrderCollateral?: string;
+    /**
+     * Copy trading: present only on a copy risk bucket row (a follow's copy
+     * account — its cross risk bucket and any isolated children). The id of the
+     * follow that funds it, one of your own follows. Absent (the key is
+     * omitted, never null) on every other row.
+     */
+    copyFollowId?: string;
+    /**
+     * Copy trading: on a copy risk bucket row, the followed leader's custom
+     * TraderCode handle, when they still hold one. Absent otherwise.
+     */
+    copyLeaderHandle?: string;
 }
 export interface ListMarginAccountsParams {
     page?: number;

package/dist/portfolio/index.d.ts

@@ -236,6 +236,18 @@ export interface PortfolioRiskBucket {
      * over `riskBuckets`.
      */
     marginMode: MarginMode;
+    /**
+     * Copy trading: present only on a copy risk bucket row (a follow's copy
+     * account — its cross risk bucket and any isolated children). The id of the
+     * follow that funds it, one of your own follows. Absent (the key is
+     * omitted, never null) on every other row.
+     */
+    copyFollowId?: string;
+    /**
+     * Copy trading: on a copy risk bucket row, the followed leader's custom
+     * TraderCode handle, when they still hold one. Absent otherwise.
+     */
+    copyLeaderHandle?: string;
     /**
      * The trading pair this bucket is scoped to. Present for `ISOLATED`
      * buckets; absent (the key is omitted, never null) for `CROSS`, which spans

package/dist/profile/index.d.ts

@@ -98,7 +98,10 @@ export type TransactionType = "DEPOSIT" | "WITHDRAWAL" | "TRADE" | "FEE" | "FUND
  * Query parameters for getting user movements
  */
 export interface GetUserMovementsParams {
-    /** Page number (starts from 1) */
+    /**
+     * Page number (starts from 1, at most 10,000 — the last page this listing
+     * counts towards; a larger page is rejected).
+     */
     page?: number;
     /** Number of items per page (max 100) */
     pageSize?: number;
@@ -128,9 +131,17 @@ export interface GetPaginatedUserMovementsResponse {
     page: number;
     /** Items per page */
     pageSize: number;
-    /** Total number of movements in PostgreSQL */
+    /**
+     * Matching movements. Exact up to 10,000 pages of the requested `pageSize`
+     * (`pageSize` x 10,000 rows) and saturates there, so a user with more
+     * matching movements than the listing can page through reads the cap, not
+     * their lifetime total.
+     */
     total: number;
-    /** Total number of pages */
+    /**
+     * Number of pages at the requested `pageSize`. Exact up to 10,000 and
+     * saturates there, the last page this listing can reach.
+     */
     totalPages: number;
 }
 /**
@@ -257,15 +268,7 @@ export interface UserTrade {
  * Query parameters for getting user trades
  */
 export interface GetUserTradesParams {
-    /**
-     * Page number for legacy offset pagination (starts from 1).
-     *
-     * @deprecated Use cursor pagination (`pageToken`) instead. Passing `page`
-     * selects legacy page-number mode, which only ever sees recent (hot)
-     * history; omitting both `page` and `pageToken` now drives cursor mode.
-     */
-    page?: number;
-    /** Number of items per page (max 100 in page-number mode, up to 1000 when `pageToken` is present) */
+    /** Number of items per page (max 1000) */
     pageSize?: number;
     /** Filter by trading pair ID (UUID) */
     tradingPairId?: string;
@@ -295,32 +298,8 @@ export interface GetUserTradesParams {
 export interface GetUserTradesResponse {
     /** List of user trades */
     trades: UserTrade[];
-    /**
-     * Current page number.
-     *
-     * @deprecated Only populated by legacy page-number (offset) responses; 0 in
-     * cursor mode. Use `pageToken`/`nextPageToken` pagination instead.
-     */
-    page: number;
     /** Items per page */
     pageSize: number;
-    /**
-     * Total matching trades. In page-number mode it is exact up to
-     * `pageSize` × 10,000 rows and saturates there, so a wallet with more history
-     * than legacy mode can page through reads the cap, not its lifetime total.
-     *
-     * @deprecated Only populated by legacy page-number (offset) responses; 0 in
-     * cursor mode, which has no exact total. Walk `nextPageToken` instead.
-     */
-    total: number;
-    /**
-     * Total pages at this `pageSize`. Exact up to 10,000 in page-number mode and
-     * saturates there, the last page legacy mode can reach.
-     *
-     * @deprecated Only populated by legacy page-number (offset) responses; 0 in
-     * cursor mode, which has no exact total. Walk `nextPageToken` instead.
-     */
-    totalPages: number;
     /**
      * Cursor for the next page. Empty on every page-number (legacy) response —
      * page-number mode never mints a token, full page or not, since resuming
@@ -372,7 +351,10 @@ export interface FundingPayment {
  * Query parameters for listing funding payments.
  */
 export interface ListFundingPaymentsParams {
-    /** Page number (starts from 1) */
+    /**
+     * Page number (starts from 1, at most 10,000 — the last page this listing
+     * counts towards; a larger page is rejected).
+     */
     page?: number;
     /** Number of items per page (max 100) */
     pageSize?: number;
@@ -393,9 +375,17 @@ export interface ListFundingPaymentsResponse {
     page: number;
     /** Items per page */
     pageSize: number;
-    /** Total number of matching records */
+    /**
+     * Matching funding payment records. Exact up to 10,000 pages of the
+     * requested `pageSize` (`pageSize` x 10,000 rows) and saturates there, so a
+     * user with more matching payments than the listing can page through reads
+     * the cap, not their lifetime total.
+     */
     total: number;
-    /** Total number of pages */
+    /**
+     * Number of pages at the requested `pageSize`. Exact up to 10,000 and
+     * saturates there, the last page this listing can reach.
+     */
     totalPages: number;
 }
 /**
@@ -609,7 +599,7 @@ export interface ProfileAPI extends BaseAPI {
      *
      * @param params - Optional query parameters for pagination and filtering
      * @param params.page - Page number (starts from 1)
-     * @param params.limit - Number of items per page (max 100 in page-number mode, up to 1000 when `pageToken` is present)
+     * @param params.limit - Number of items per page (max 1000)
      * @param params.tradingPairId - Filter by trading pair ID (UUID)
      * @returns Promise resolving to paginated trades response
      * @throws ValidationError If pagination params (page/limit) are invalid or tradingPairId is not a valid UUID; this may occur before any network request.

package/dist/sdk/index.d.ts

@@ -2,6 +2,7 @@ import type { Address, PublicClient, TransactionReceipt, WalletClient } from "vi
 import type { ApplicationsAPI } from "../applications";
 import type { AuthAPI, AuthState } from "../auth/index";
 import type { BuildercodesAPI } from "../buildercodes";
+import type { CopyTradingAPI } from "../copy-trading";
 import type { DelegatedAgentsAPI } from "../delegated-agents";
 import type { FaucetAPI } from "../faucet";
 import type { FeesAPI } from "../fees";
@@ -115,6 +116,8 @@ export interface MonacoSDK {
     pitpass: PitpassAPI;
     /** BuilderCodes frontend revenue-share payout API */
     buildercodes: BuildercodesAPI;
+    /** Copy trading API: lead trader profiles and the leaderboard, and your follows */
+    copyTrading: CopyTradingAPI;
     /** Testnet faucet API */
     faucet: FaucetAPI;
     /** Deposit-address registration (sweeper) API; requires a session */