@0xmonaco/types 1.0.69 → 1.0.70

package/dist/validation/copy-trading.d.ts

@@ -0,0 +1,113 @@
+/**
+ * Copy trading validation schemas (0XM-2851).
+ *
+ * Client-side checks for the copy trading request params, run before a
+ * request is sent. The server stays the authority on every business rule
+ * (minimum allocation, the platform's profit-share range, leader
+ * eligibility); these catch malformed input early and mirror the request
+ * shape the REST gateway accepts, which rejects unknown fields.
+ */
+import { z } from "zod";
+/** A leader's custom TraderCode handle, as used in the leader paths. */
+export declare const LeaderHandleSchema: z.ZodString;
+/** Params for registering as a lead trader or editing your profile. */
+export declare const UpsertLeadTraderSchema: z.ZodObject<{
+    shareBps: z.ZodOptional<z.ZodNumber>;
+    bio: z.ZodOptional<z.ZodString>;
+    status: z.ZodOptional<z.ZodEnum<{
+        ACTIVE: "ACTIVE";
+        PAUSED: "PAUSED";
+    }>>;
+    minAllocation: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+/**
+ * Params for following a lead trader (no `followId`) or editing one of your
+ * follows (`followId` set). An edit REPLACES the follow's settings: every
+ * optional setting left out reverts to its default, so an edit that omits
+ * `slPct` removes the stop-loss.
+ */
+export declare const UpsertFollowSchema: z.ZodObject<{
+    followId: z.ZodOptional<z.ZodUUID>;
+    leader: z.ZodOptional<z.ZodString>;
+    marginModePolicy: z.ZodOptional<z.ZodEnum<{
+        ISOLATED: "ISOLATED";
+        CROSS: "CROSS";
+        FOLLOW: "FOLLOW";
+    }>>;
+    sizingMode: z.ZodOptional<z.ZodEnum<{
+        PROPORTIONAL: "PROPORTIONAL";
+        FIXED_MARGIN: "FIXED_MARGIN";
+    }>>;
+    sizingParam: z.ZodOptional<z.ZodString>;
+    leverageMode: z.ZodOptional<z.ZodEnum<{
+        FOLLOW: "FOLLOW";
+        FIXED: "FIXED";
+    }>>;
+    fixedLeverage: z.ZodOptional<z.ZodString>;
+    allocation: z.ZodString;
+    slPct: z.ZodOptional<z.ZodString>;
+    tradingPairIds: z.ZodOptional<z.ZodArray<z.ZodUUID>>;
+    copyExisting: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strict>;
+/** Params for previewing what copying a leader's open positions would place. */
+export declare const PreviewFollowSchema: z.ZodObject<{
+    leader: z.ZodString;
+    marginModePolicy: z.ZodOptional<z.ZodEnum<{
+        ISOLATED: "ISOLATED";
+        CROSS: "CROSS";
+        FOLLOW: "FOLLOW";
+    }>>;
+    sizingMode: z.ZodOptional<z.ZodEnum<{
+        PROPORTIONAL: "PROPORTIONAL";
+        FIXED_MARGIN: "FIXED_MARGIN";
+    }>>;
+    sizingParam: z.ZodOptional<z.ZodString>;
+    leverageMode: z.ZodOptional<z.ZodEnum<{
+        FOLLOW: "FOLLOW";
+        FIXED: "FIXED";
+    }>>;
+    fixedLeverage: z.ZodOptional<z.ZodString>;
+    allocation: z.ZodString;
+    tradingPairIds: z.ZodOptional<z.ZodArray<z.ZodUUID>>;
+}, z.core.$strict>;
+/** Params for the public leaderboard. */
+export declare const ListLeadTradersSchema: z.ZodObject<{
+    pageSize: z.ZodOptional<z.ZodNumber>;
+    pageToken: z.ZodOptional<z.ZodString>;
+    sort: z.ZodOptional<z.ZodEnum<{
+        roi: "roi";
+        pnl: "pnl";
+        followers: "followers";
+        allocated: "allocated";
+        aum: "aum";
+        win_rate: "win_rate";
+    }>>;
+    window: z.ZodOptional<z.ZodEnum<{
+        "7d": "7d";
+        "30d": "30d";
+        "90d": "90d";
+        all: "all";
+    }>>;
+}, z.core.$strict>;
+/** Params for a leader's closed trades. */
+export declare const ListLeadTraderClosedTradesSchema: z.ZodObject<{
+    pageSize: z.ZodOptional<z.ZodNumber>;
+    pageToken: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+/** Params for your follows. */
+export declare const ListMyFollowsSchema: z.ZodObject<{
+    pageSize: z.ZodOptional<z.ZodNumber>;
+    pageToken: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+/** Params for your followers, as a leader. */
+export declare const ListMyFollowersSchema: z.ZodObject<{
+    pageSize: z.ZodOptional<z.ZodNumber>;
+    pageToken: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type UpsertLeadTraderParams = z.input<typeof UpsertLeadTraderSchema>;
+export type UpsertFollowParams = z.input<typeof UpsertFollowSchema>;
+export type PreviewFollowParams = z.input<typeof PreviewFollowSchema>;
+export type ListLeadTradersParams = z.input<typeof ListLeadTradersSchema>;
+export type ListLeadTraderClosedTradesParams = z.input<typeof ListLeadTraderClosedTradesSchema>;
+export type ListMyFollowsParams = z.input<typeof ListMyFollowsSchema>;
+export type ListMyFollowersParams = z.input<typeof ListMyFollowersSchema>;

package/dist/validation/copy-trading.js

@@ -0,0 +1,141 @@
+/**
+ * Copy trading validation schemas (0XM-2851).
+ *
+ * Client-side checks for the copy trading request params, run before a
+ * request is sent. The server stays the authority on every business rule
+ * (minimum allocation, the platform's profit-share range, leader
+ * eligibility); these catch malformed input early and mirror the request
+ * shape the REST gateway accepts, which rejects unknown fields.
+ */
+import { z } from "zod";
+import { PositiveDecimalStringSchema, UUIDSchema } from "./trading.js";
+/** A leader's custom TraderCode handle, as used in the leader paths. */
+export const LeaderHandleSchema = z.string().trim().min(1, "leader handle is required");
+/** A decimal fraction in (0, 1], e.g. `"0.25"` for a stop-loss at a quarter of the allocation. */
+const StopLossFractionSchema = z
+    .string()
+    .trim()
+    .regex(/^\d+(\.\d+)?$/, "slPct must be a decimal fraction (e.g. '0.25')")
+    .refine((value) => {
+    const parsed = Number.parseFloat(value);
+    return parsed > 0 && parsed <= 1;
+}, "slPct must be greater than 0 and at most 1");
+/** Page size bounded to `max`, and an opaque cursor from a previous response. */
+function cursorPage(max) {
+    return {
+        pageSize: z.number().int("Page size must be an integer").min(1, "Page size must be at least 1").max(max, `Page size cannot exceed ${max}`).optional(),
+        pageToken: z.string().optional(),
+    };
+}
+/** Params for registering as a lead trader or editing your profile. */
+export const UpsertLeadTraderSchema = z
+    .object({
+    /** Profit share in basis points; omitted keeps the current share (the platform default on a registration). */
+    shareBps: z.number().int("shareBps must be an integer").min(0, "shareBps cannot be negative").max(10000, "shareBps cannot exceed 10000").optional(),
+    /** Free-text profile description, at most 2,000 bytes; omitted clears it. */
+    bio: z
+        .string()
+        .refine((value) => new TextEncoder().encode(value).length <= 2000, "bio cannot exceed 2,000 bytes")
+        .optional(),
+    /** `ACTIVE` (default) or `PAUSED`. */
+    status: z.enum(["ACTIVE", "PAUSED"]).optional(),
+    /** Minimum follow allocation in quote units; omitted clears it. */
+    minAllocation: PositiveDecimalStringSchema.optional(),
+})
+    .strict();
+/**
+ * Params for following a lead trader (no `followId`) or editing one of your
+ * follows (`followId` set). An edit REPLACES the follow's settings: every
+ * optional setting left out reverts to its default, so an edit that omits
+ * `slPct` removes the stop-loss.
+ */
+export const UpsertFollowSchema = z
+    .object({
+    /** Omit to create a follow; set to edit one of your follows. */
+    followId: UUIDSchema.optional(),
+    /** The leader's custom TraderCode handle; required on a create, optional on an edit. */
+    leader: LeaderHandleSchema.optional(),
+    /** `FOLLOW` (default: the leader's mode per market), `CROSS` or `ISOLATED`. */
+    marginModePolicy: z.enum(["FOLLOW", "CROSS", "ISOLATED"]).optional(),
+    /** `PROPORTIONAL` (default) or `FIXED_MARGIN`. */
+    sizingMode: z.enum(["PROPORTIONAL", "FIXED_MARGIN"]).optional(),
+    /** Margin per leader order in quote units; required for `FIXED_MARGIN`, omitted otherwise. */
+    sizingParam: PositiveDecimalStringSchema.optional(),
+    /** `FOLLOW` (default: the leader's leverage) or `FIXED`. */
+    leverageMode: z.enum(["FOLLOW", "FIXED"]).optional(),
+    /** Leverage for every copy; required for `FIXED`, omitted otherwise. */
+    fixedLeverage: PositiveDecimalStringSchema.optional(),
+    /** Collateral for the copy account, in quote units, at or above the minimum. */
+    allocation: PositiveDecimalStringSchema,
+    /** Copy stop-loss as a fraction of the allocation in (0, 1]; omitted means none. */
+    slPct: StopLossFractionSchema.optional(),
+    /** Markets to copy; omit (or pass an empty list) to copy every market the leader trades. */
+    tradingPairIds: z.array(UUIDSchema).max(256, "at most 256 markets can be copied").optional(),
+    /** On a create, also copy the leader's currently open positions (see `previewFollow`). Refused on an edit. */
+    copyExisting: z.boolean().optional(),
+})
+    .strict()
+    .superRefine((params, ctx) => {
+    if (params.followId === undefined && params.leader === undefined) {
+        ctx.addIssue({ code: "custom", message: "leader is required when creating a follow", path: ["leader"] });
+    }
+    if (params.followId !== undefined && params.copyExisting === true) {
+        ctx.addIssue({ code: "custom", message: "copyExisting applies only when creating a follow", path: ["copyExisting"] });
+    }
+    termRules(params, ctx);
+});
+/** The sizing and leverage parameters are present exactly when their mode needs them. */
+function termRules(params, ctx) {
+    const fixedMargin = params.sizingMode === "FIXED_MARGIN";
+    if (fixedMargin && params.sizingParam === undefined) {
+        ctx.addIssue({ code: "custom", message: "sizingParam is required for FIXED_MARGIN sizing", path: ["sizingParam"] });
+    }
+    if (!fixedMargin && params.sizingParam !== undefined) {
+        ctx.addIssue({ code: "custom", message: "sizingParam is only accepted with FIXED_MARGIN sizing", path: ["sizingParam"] });
+    }
+    const fixedLeverage = params.leverageMode === "FIXED";
+    if (fixedLeverage && params.fixedLeverage === undefined) {
+        ctx.addIssue({ code: "custom", message: "fixedLeverage is required for FIXED leverage", path: ["fixedLeverage"] });
+    }
+    if (!fixedLeverage && params.fixedLeverage !== undefined) {
+        ctx.addIssue({ code: "custom", message: "fixedLeverage is only accepted with FIXED leverage", path: ["fixedLeverage"] });
+    }
+}
+/** Params for previewing what copying a leader's open positions would place. */
+export const PreviewFollowSchema = z
+    .object({
+    /** The leader's custom TraderCode handle. */
+    leader: LeaderHandleSchema,
+    /** `FOLLOW` (default), `CROSS` or `ISOLATED`. */
+    marginModePolicy: z.enum(["FOLLOW", "CROSS", "ISOLATED"]).optional(),
+    /** `PROPORTIONAL` (default) or `FIXED_MARGIN`. */
+    sizingMode: z.enum(["PROPORTIONAL", "FIXED_MARGIN"]).optional(),
+    /** Margin per leader order in quote units; required for `FIXED_MARGIN`, omitted otherwise. */
+    sizingParam: PositiveDecimalStringSchema.optional(),
+    /** `FOLLOW` (default) or `FIXED`. */
+    leverageMode: z.enum(["FOLLOW", "FIXED"]).optional(),
+    /** Leverage for every copy; required for `FIXED`, omitted otherwise. */
+    fixedLeverage: PositiveDecimalStringSchema.optional(),
+    /** Collateral the copy account would start with, in quote units. */
+    allocation: PositiveDecimalStringSchema,
+    /** Markets to copy; omit to copy every market the leader trades. */
+    tradingPairIds: z.array(UUIDSchema).max(256, "at most 256 markets can be copied").optional(),
+})
+    .strict()
+    .superRefine((params, ctx) => termRules(params, ctx));
+/** Params for the public leaderboard. */
+export const ListLeadTradersSchema = z
+    .object({
+    /** Metric to rank by, highest first: `roi` (default), `pnl`, `followers`, `allocated`, `aum` (marked copy account equity; leaders without it last) or `win_rate`. */
+    sort: z.enum(["roi", "pnl", "followers", "allocated", "aum", "win_rate"]).optional(),
+    /** Stats window: `7d`, `30d` (default), `90d` or `all`. */
+    window: z.enum(["7d", "30d", "90d", "all"]).optional(),
+    ...cursorPage(100),
+})
+    .strict();
+/** Params for a leader's closed trades. */
+export const ListLeadTraderClosedTradesSchema = z.object(cursorPage(100)).strict();
+/** Params for your follows. */
+export const ListMyFollowsSchema = z.object(cursorPage(1000)).strict();
+/** Params for your followers, as a leader. */
+export const ListMyFollowersSchema = z.object(cursorPage(1000)).strict();

package/dist/validation/index.d.ts

@@ -14,6 +14,7 @@
  * - Market schemas (trading pairs, candlesticks)
  */
 export * from "./common.js";
+export * from "./copy-trading.js";
 export * from "./margin-accounts.js";
 export * from "./market.js";
 export * from "./positions.js";

package/dist/validation/index.js

@@ -15,6 +15,7 @@
  */
 // Export validation utilities
 export * from "./common.js";
+export * from "./copy-trading.js";
 export * from "./margin-accounts.js";
 export * from "./market.js";
 export * from "./positions.js";

package/dist/validation/positions.d.ts

@@ -21,9 +21,9 @@ export declare const ClosePositionSchema: z.ZodObject<{
     positionId: z.ZodUUID;
     request: z.ZodObject<{
         closeType: z.ZodEnum<{
+            IOC: "IOC";
             LIMIT: "LIMIT";
             MARKET: "MARKET";
-            IOC: "IOC";
         }>;
         limitPrice: z.ZodOptional<z.ZodString>;
         slippageToleranceBps: z.ZodOptional<z.ZodNumber>;

package/dist/validation/profile.d.ts

@@ -76,7 +76,7 @@ export declare const GetUserMovementsSchema: z.ZodObject<{
  * All fields are optional — an empty object or undefined is valid.
  */
 export declare const GetUserTradesSchema: z.ZodObject<{
-    page: z.ZodOptional<z.ZodNumber>;
+    page: z.ZodOptional<z.ZodNever>;
     pageSize: z.ZodOptional<z.ZodNumber>;
     tradingPairId: z.ZodOptional<z.ZodUUID>;
     pageToken: z.ZodOptional<z.ZodString>;

package/dist/validation/profile.js

@@ -45,25 +45,17 @@ export const GetUserMovementsSchema = z.object({
  * Validates parameters for fetching paginated user trades.
  * All fields are optional — an empty object or undefined is valid.
  */
-export const GetUserTradesSchema = z
-    .object({
-    page: z.number().int("Page must be an integer").min(1, "Page must be at least 1").optional(),
+export const GetUserTradesSchema = z.object({
+    /**
+     * Rejected, not ignored. A non-strict object would let a JS or `any`
+     * caller keep passing `page`, and the SDK would then send `pageToken=""`
+     * and hand back the first cursor page on every call — the same silent
+     * duplicate-page failure the REST 400 guard exists to prevent.
+     */
+    page: z.never().optional(),
     pageSize: z.number().int("Page size must be an integer").min(1, "Page size must be at least 1").max(1000, "Page size cannot exceed 1000").optional(),
     tradingPairId: UUIDSchema.optional(),
     pageToken: z.string().optional(),
-})
-    .superRefine((params, ctx) => {
-    // The higher 1000 cap only applies to cursor (pageToken) requests; the
-    // server keeps the 100 cap for page-number requests (offset scans).
-    // Legacy page-number mode is selected only by passing `page` without
-    // `pageToken` — omitting both starts a cursor walk.
-    if (params.page !== undefined && params.pageToken === undefined && params.pageSize !== undefined && params.pageSize > 100) {
-        ctx.addIssue({
-            code: z.ZodIssueCode.custom,
-            message: "Page size cannot exceed 100 in page-number mode (page without pageToken)",
-            path: ["pageSize"],
-        });
-    }
 });
 export const ListFundingPaymentsSchema = z.object({
     page: z.number().int("Page must be an integer").min(1, "Page must be at least 1").optional(),

package/dist/validation/trading.d.ts

@@ -332,10 +332,10 @@ export declare const ReplaceOrderSchema: z.ZodObject<{
  * Matches the getPaginatedOrders method signature which accepts:
  * - status: OrderStatus, or a non-empty array of them (optional filter)
  * - tradingPairId: trading pair UUID (optional filter)
- * - page: number (default: 1)
- * - pageSize: number (default: 10, max: 100 in page-number mode, 1000 when pageToken is present)
+ * - pageSize: number (default: 10, max: 1000)
  */
 export declare const GetPaginatedOrdersSchema: z.ZodObject<{
+    page: z.ZodOptional<z.ZodNever>;
     status: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
         SUBMITTED: "SUBMITTED";
         PARTIALLY_FILLED: "PARTIALLY_FILLED";
@@ -361,7 +361,6 @@ export declare const GetPaginatedOrdersSchema: z.ZodObject<{
         MARGIN: "MARGIN";
     }>>;
     marginAccountId: z.ZodOptional<z.ZodUUID>;
-    page: z.ZodOptional<z.ZodNumber>;
     pageSize: z.ZodOptional<z.ZodNumber>;
     pageToken: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
@@ -390,6 +389,7 @@ export declare const CancelConditionalOrderSchema: z.ZodObject<{
     conditionalOrderId: z.ZodUUID;
 }, z.core.$strip>;
 export declare const ListConditionalOrdersSchema: z.ZodObject<{
+    page: z.ZodOptional<z.ZodNever>;
     marginAccountId: z.ZodOptional<z.ZodUUID>;
     tradingPairId: z.ZodOptional<z.ZodUUID>;
     state: z.ZodOptional<z.ZodEnum<{
@@ -401,7 +401,6 @@ export declare const ListConditionalOrdersSchema: z.ZodObject<{
         TRIGGERING: "TRIGGERING";
         TRIGGERED: "TRIGGERED";
     }>>;
-    page: z.ZodOptional<z.ZodNumber>;
     pageSize: z.ZodOptional<z.ZodNumber>;
     pageToken: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
@@ -456,6 +455,7 @@ export declare const CancelTwapOrderSchema: z.ZodObject<{
     twapOrderId: z.ZodUUID;
 }, z.core.$strip>;
 export declare const ListTwapOrdersSchema: z.ZodObject<{
+    page: z.ZodOptional<z.ZodNever>;
     state: z.ZodOptional<z.ZodEnum<{
         CANCELLED: "CANCELLED";
         ACTIVE: "ACTIVE";
@@ -463,7 +463,6 @@ export declare const ListTwapOrdersSchema: z.ZodObject<{
         COMPLETED: "COMPLETED";
     }>>;
     tradingPairId: z.ZodOptional<z.ZodUUID>;
-    page: z.ZodOptional<z.ZodNumber>;
     pageSize: z.ZodOptional<z.ZodNumber>;
     pageToken: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;

package/dist/validation/trading.js

@@ -379,31 +379,22 @@ export const ReplaceOrderSchema = z.object({
  * Matches the getPaginatedOrders method signature which accepts:
  * - status: OrderStatus, or a non-empty array of them (optional filter)
  * - tradingPairId: trading pair UUID (optional filter)
- * - page: number (default: 1)
- * - pageSize: number (default: 10, max: 100 in page-number mode, 1000 when pageToken is present)
+ * - pageSize: number (default: 10, max: 1000)
  */
-export const GetPaginatedOrdersSchema = z
-    .object({
+export const GetPaginatedOrdersSchema = z.object({
+    /**
+     * Rejected, not ignored. A non-strict object would let a JS or `any`
+     * caller keep passing `page`, and the SDK would then send `pageToken=""`
+     * and hand back the first cursor page on every call — the same silent
+     * duplicate-page failure the REST 400 guard exists to prevent.
+     */
+    page: z.never().optional(),
     status: z.union([z.enum(ORDER_STATUS_VALUES), z.array(z.enum(ORDER_STATUS_VALUES)).min(1, "Status filter must list at least one status")]).optional(),
     tradingPairId: UUIDSchema.optional(),
     tradingMode: TradingModeSchema.optional(),
     marginAccountId: UUIDSchema.optional(),
-    page: z.number().int().min(1, "Page must be at least 1").optional(),
     pageSize: z.number().int().min(1, "Page size must be at least 1").max(1000, "Page size cannot exceed 1000").optional(),
     pageToken: z.string().optional(),
-})
-    .superRefine((params, ctx) => {
-    // The higher 1000 cap only applies to cursor (pageToken) requests; the
-    // server keeps the 100 cap for page-number requests (offset scans).
-    // Legacy page-number mode is selected only by passing `page` without
-    // `pageToken` — omitting both starts a cursor walk.
-    if (params.page !== undefined && params.pageToken === undefined && params.pageSize !== undefined && params.pageSize > 100) {
-        ctx.addIssue({
-            code: z.ZodIssueCode.custom,
-            message: "Page size cannot exceed 100 in page-number mode (page without pageToken)",
-            path: ["pageSize"],
-        });
-    }
 });
 export const ConditionalOrderConditionTypeSchema = z.enum(["STOP_LOSS", "TAKE_PROFIT", "TRAILING_STOP"], {
     message: 'conditionType must be "STOP_LOSS", "TAKE_PROFIT", or "TRAILING_STOP"',
@@ -420,27 +411,19 @@ export const ClosePositionSideSchema = z.enum(["LONG", "SHORT"], {
 export const CancelConditionalOrderSchema = z.object({
     conditionalOrderId: UUIDSchema,
 });
-export const ListConditionalOrdersSchema = z
-    .object({
+export const ListConditionalOrdersSchema = z.object({
+    /**
+     * Rejected, not ignored. A non-strict object would let a JS or `any`
+     * caller keep passing `page`, and the SDK would then send `pageToken=""`
+     * and hand back the first cursor page on every call — the same silent
+     * duplicate-page failure the REST 400 guard exists to prevent.
+     */
+    page: z.never().optional(),
     marginAccountId: UUIDSchema.optional(),
     tradingPairId: UUIDSchema.optional(),
     state: ConditionalOrderStateSchema.optional(),
-    page: z.number().int().min(1, "Page must be at least 1").optional(),
     pageSize: z.number().int().min(1, "Page size must be at least 1").max(1000, "Page size cannot exceed 1000").optional(),
     pageToken: z.string().optional(),
-})
-    .superRefine((params, ctx) => {
-    // The higher 1000 cap only applies to cursor (pageToken) requests; the
-    // server keeps the 100 cap for page-number requests (offset scans).
-    // Legacy page-number mode is selected only by passing `page` without
-    // `pageToken` — omitting both starts a cursor walk.
-    if (params.page !== undefined && params.pageToken === undefined && params.pageSize !== undefined && params.pageSize > 100) {
-        ctx.addIssue({
-            code: z.ZodIssueCode.custom,
-            message: "Page size cannot exceed 100 in page-number mode (page without pageToken)",
-            path: ["pageSize"],
-        });
-    }
 });
 export const TwapOrderStateSchema = z.enum(["PENDING", "ACTIVE", "COMPLETED", "CANCELLED"], {
     message: "Invalid TWAP order state",
@@ -564,26 +547,18 @@ export const CreateTwapOrderSchema = z
 export const CancelTwapOrderSchema = z.object({
     twapOrderId: UUIDSchema,
 });
-export const ListTwapOrdersSchema = z
-    .object({
+export const ListTwapOrdersSchema = z.object({
+    /**
+     * Rejected, not ignored. A non-strict object would let a JS or `any`
+     * caller keep passing `page`, and the SDK would then send `pageToken=""`
+     * and hand back the first cursor page on every call — the same silent
+     * duplicate-page failure the REST 400 guard exists to prevent.
+     */
+    page: z.never().optional(),
     state: TwapOrderStateSchema.optional(),
     tradingPairId: UUIDSchema.optional(),
-    page: z.number().int().min(1, "Page must be at least 1").optional(),
     pageSize: z.number().int().min(1, "Page size must be at least 1").max(1000, "Page size cannot exceed 1000").optional(),
     pageToken: z.string().optional(),
-})
-    .superRefine((params, ctx) => {
-    // The higher 1000 cap only applies to cursor (pageToken) requests; the
-    // server keeps the 100 cap for page-number requests (offset scans).
-    // Legacy page-number mode is selected only by passing `page` without
-    // `pageToken` — omitting both starts a cursor walk.
-    if (params.page !== undefined && params.pageToken === undefined && params.pageSize !== undefined && params.pageSize > 100) {
-        ctx.addIssue({
-            code: z.ZodIssueCode.custom,
-            message: "Page size cannot exceed 100 in page-number mode (page without pageToken)",
-            path: ["pageSize"],
-        });
-    }
 });
 /**
  * Single batch create order item validation schema

package/dist/websocket/client.d.ts

@@ -52,7 +52,7 @@ import type { Interval } from "../market";
 import type { TradingMode } from "../trading";
 import type { WebSocketStatus } from "./base";
 import type { OrderbookQuotationMode } from "./clients/orderbook-client";
-import type { AccountEvent, AccountEventData, ConditionalOrderEvent, ConditionalOrderEventData, InstrumentEvent, InstrumentEventData, LiquidationEvent, LiquidationEventData, MarketStatsAllEvent, MarketStatsData, MarketStatsEvent, MarketStatsSummary, OHLCVEvent, OHLCVPriceType, OrderbookEvent, OrderEvent, PositionEvent, PositionEventData, TradeEvent, TwapOrderEvent, TwapOrderEventData, UserBalanceEvent, UserBalanceEventData, UserMovementEvent } from "./events";
+import type { AccountEvent, AccountEventData, ConditionalOrderEvent, ConditionalOrderEventData, CopyEvent, CopyRelationshipEventData, InstrumentEvent, InstrumentEventData, LiquidationEvent, LiquidationEventData, MarketStatsAllEvent, MarketStatsData, MarketStatsEvent, MarketStatsSummary, OHLCVEvent, OHLCVPriceType, OrderbookEvent, OrderEvent, PositionEvent, PositionEventData, TradeEvent, TwapOrderEvent, TwapOrderEventData, UserBalanceEvent, UserBalanceEventData, UserMovementEvent } from "./events";
 import type { OrderSnapshotItem, SnapshotHandler } from "./snapshots";
 export type MessageHandler<T> = (data: T) => void;
 export interface MonacoWebSocket {
@@ -90,6 +90,14 @@ export interface MonacoWebSocket {
     liquidations: (handler: MessageHandler<LiquidationEvent>, tradingPairId?: string, onSnapshot?: SnapshotHandler<LiquidationEventData>) => () => void;
     /** Subscribe to account-level margin health updates for the authenticated user (requires authentication) */
     account: (handler: MessageHandler<AccountEvent>, onSnapshot?: SnapshotHandler<AccountEventData>) => () => void;
+    /**
+     * Subscribe to your copy trading relationships as a follower (requires
+     * authentication): a `copy_relationship_update` frame on every change to one
+     * of your follows, and a `copy_skip` frame for every leader fill a follow
+     * could not mirror. There is no per-pair variant. `onSnapshot` receives every
+     * live follow (status `ACTIVE` or `CLOSE_ONLY`) with `change: "snapshot"`.
+     */
+    copy: (handler: MessageHandler<CopyEvent>, onSnapshot?: SnapshotHandler<CopyRelationshipEventData>) => () => void;
     /**
      * Subscribe to market lifecycle + config changes (public); omit
      * `tradingPairId` for all markets. `onSnapshot` receives the full current

package/dist/websocket/events/copy-events.d.ts

@@ -0,0 +1,133 @@
+/**
+ * Copy trading WebSocket event types (owner-private `copy` channel, 0XM-2848).
+ *
+ * The channel streams to the FOLLOWER: every change to one of your copy
+ * relationships (follows), and every leader fill a relationship could not
+ * mirror. A leader receives nothing on this channel.
+ *
+ * Field names mirror the backend payloads (snake_case on the wire, camelCased
+ * by the client). The SDK parser normalizes explicit `null` values to absent,
+ * so nullable wire fields are optional here.
+ *
+ * **The value unions below are the values the server sends today, not a
+ * runtime guarantee**, which is why each value field is typed
+ * `Union | (string & {})`: `@0xmonaco/core` validates no value field, so an
+ * unrecognized status, policy or reason arrives as-is rather than dropping the
+ * update (0XM-2628). `switch` over one with a `default` branch.
+ */
+/** Lifecycle status of a copy relationship (follow). */
+export type CopyRelationshipStatus = "ACTIVE" | "CLOSE_ONLY" | "STOPPED";
+/** How a follow picks the margin mode of each copied position. */
+export type CopyMarginModePolicy = "FOLLOW" | "CROSS" | "ISOLATED";
+/** How a follow sizes each copied order. */
+export type CopySizingMode = "PROPORTIONAL" | "FIXED_MARGIN";
+/** How a follow picks the leverage of each copied order. */
+export type CopyLeverageMode = "FOLLOW" | "FIXED";
+/** Why a follow stopped. */
+export type CopyStopReason = "FOLLOWER" | "STOP_LOSS" | "SKIP_LIMIT" | "ADMIN" | "LEADER_SUSPENDED";
+/**
+ * Why a leader fill was not mirrored. Only `INSUFFICIENT_MARGIN` advances the
+ * relationship's `consecutiveSkips` streak.
+ */
+export type CopySkipReason = "INSUFFICIENT_MARGIN" | "BELOW_MIN" | "LEVERAGE_MISMATCH" | "MARKET_STATE" | "LEADER_EQUITY" | "NO_LIQUIDITY";
+/**
+ * Why a relationship frame was sent. `snapshot` marks a subscribe-time
+ * baseline row; every other value names the change that produced a live
+ * frame.
+ */
+export type CopyRelationshipChange = "created" | "updated" | "close_only" | "stopped" | "skip_recorded" | "reactivated" | "snapshot";
+/**
+ * A copy relationship's full state after one sequencer step: the
+ * `copy_relationship_update` payload, and (with `change: "snapshot"`) each
+ * subscribe-time snapshot row. Every frame carries the whole row, so it
+ * supersedes the previous one for the same `relationshipId`; compare
+ * `version` to order frames for one relationship.
+ */
+export interface CopyRelationshipEventData {
+    /** The follow's id — the same value as `Follow.followId` over REST */
+    relationshipId: string;
+    /** The leader's wallet address (lowercase hex) */
+    leaderWallet: string;
+    status: CopyRelationshipStatus | (string & {});
+    marginModePolicy: CopyMarginModePolicy | (string & {});
+    /** The copy account: the follow's cross risk bucket in your margin account */
+    copyRiskBucketId: string;
+    sizingMode: CopySizingMode | (string & {});
+    /** Margin per leader order in quote units, for `FIXED_MARGIN` */
+    sizingParam?: string;
+    leverageMode: CopyLeverageMode | (string & {});
+    /** Leverage for every copy, for `FIXED` */
+    fixedLeverage?: string;
+    /** Collateral allocated to the follow, in quote units */
+    allocation: string;
+    /** Copy stop-loss as a fraction of the allocation; absent when none */
+    slPct?: string;
+    /** Whether the follow copied the leader's open positions at creation */
+    copyExisting: boolean;
+    /** Markets mirrored; empty means every market the leader trades */
+    tradingPairIds: string[];
+    /**
+     * The relationship's realized PnL net of fees since `startedAt`, in quote
+     * units — the profit-share basis. This is NOT the copy risk bucket's
+     * balance: that bucket's `realizedPnl` is its cash balance, which also moves
+     * on transfers with no trade.
+     */
+    cumNetRealized: string;
+    /** High-water mark of `cumNetRealized` — the profit-share basis, not a balance */
+    hwm: string;
+    /** Consecutive mirrors skipped for insufficient margin */
+    consecutiveSkips: number;
+    /** When the follow started (RFC 3339) */
+    startedAt: string;
+    /** When the follow stopped (RFC 3339); absent while live */
+    stoppedAt?: string;
+    /** Why the follow stopped; absent while live */
+    stopReason?: CopyStopReason | (string & {});
+    /** Why this frame was sent */
+    change: CopyRelationshipChange | (string & {});
+    /**
+     * Durable-log sequence of the entry that produced this state; higher is
+     * newer for one relationship. Absent when unknown.
+     */
+    version?: number;
+}
+/**
+ * One leader fill a relationship did NOT mirror: the `copy_skip` payload.
+ * Events only; the subscribe-time snapshot carries no skips.
+ */
+export interface CopySkipEventData {
+    /** The follow's id */
+    relationshipId: string;
+    /** The leader's wallet address (lowercase hex) */
+    leaderWallet: string;
+    /** The leader's trade that was not mirrored */
+    leaderTradeId: string;
+    /** The leader's order behind that trade */
+    leaderOrderId: string;
+    tradingPairId: string;
+    reason: CopySkipReason | (string & {});
+    /** The copy size the sizing step asked for before the skip, in base units */
+    requestedQuantity: string;
+    /** The relationship's streak after this skip */
+    consecutiveSkips: number;
+    /** Optional human-readable diagnostics */
+    detail?: string;
+    /** Durable-log sequence of the entry that recorded the skip, when known */
+    version?: number;
+}
+/** A `copy_relationship_update` frame. */
+export interface CopyRelationshipEvent {
+    eventType: "copy_relationship_update";
+    /** The follower (you) */
+    userId: string;
+    data: CopyRelationshipEventData;
+}
+/** A `copy_skip` frame. */
+export interface CopySkipEvent {
+    eventType: "copy_skip";
+    /** The follower (you) */
+    userId: string;
+    data: CopySkipEventData;
+}
+/** Any `copy` channel frame; narrow on `eventType`. */
+export type CopyEvent = CopyRelationshipEvent | CopySkipEvent;