@0xmonaco/core 1.0.69 → 1.0.70

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

@@ -0,0 +1,94 @@
+/**
+ * Copy Trading API Implementation (0XM-2851)
+ *
+ * Lead trader profiles and the public leaderboard, and the caller's follows.
+ * Followers allocate collateral to a per-leader copy account (a cross risk
+ * bucket in their margin account) and every fill the leader makes is mirrored
+ * into it.
+ *
+ * Leaders are addressed by their custom TraderCode handle. The leaderboard, a
+ * leader's profile and a leader's closed trades are public; every other call
+ * is signed and scoped to the session's account.
+ *
+ * The REST gateway rejects unknown request fields, so every request body and
+ * query string is built key by key from validated params.
+ *
+ * @example
+ * ```typescript
+ * const { leaders } = await sdk.copyTrading.listLeadTraders({ sort: "roi", window: "30d" });
+ * const leader = leaders[0].profile.leader.handle!;
+ * const { followId } = await sdk.copyTrading.upsertFollow({ leader, allocation: "1000", slPct: "0.25" });
+ * ```
+ */
+import type { CopyTradingAPI, GetFollowResponse, GetLeadTraderResponse, ListFollowLeaderPositionsResponse, ListLeadTraderClosedTradesParams, ListLeadTraderClosedTradesResponse, ListLeadTraderOpenPositionsResponse, ListLeadTradersParams, ListLeadTradersResponse, ListMyFollowersParams, ListMyFollowersResponse, ListMyFollowsParams, ListMyFollowsResponse, PreviewFollowParams, PreviewFollowResponse, StopFollowResponse, UpsertFollowParams, UpsertFollowResponse, UpsertLeadTraderParams, UpsertLeadTraderResponse } from "@0xmonaco/types";
+import { BaseAPI } from "../base";
+export declare class CopyTradingAPIImpl extends BaseAPI implements CopyTradingAPI {
+    /**
+     * List lead traders (the public leaderboard), highest first by `sort`
+     * (default `roi`) over `window` (default `30d`). No session needed.
+     *
+     * Cursor paged: pass the previous response's `nextPageToken` with the SAME
+     * sort and window; an empty token means the end. Rows come from a periodic
+     * leaderboard snapshot taken at `asOf`.
+     */
+    listLeadTraders(params?: ListLeadTradersParams): Promise<ListLeadTradersResponse>;
+    /**
+     * Get one lead trader by custom TraderCode handle: profile, follow summary
+     * and stats for 7d, 30d, 90d and all. No session needed. 404 for an unknown
+     * or suspended leader.
+     */
+    getLeadTrader(handle: string): Promise<GetLeadTraderResponse>;
+    /**
+     * List a lead trader's closed trades — partial and full closes,
+     * liquidations and auto-deleveraging — newest first. No session needed.
+     */
+    listLeadTraderClosedTrades(handle: string, params?: ListLeadTraderClosedTradesParams): Promise<ListLeadTraderClosedTradesResponse>;
+    /**
+     * List a lead trader's open positions. Only current followers of that
+     * leader may read them (403 otherwise).
+     */
+    listLeadTraderOpenPositions(handle: string): Promise<ListLeadTraderOpenPositionsResponse>;
+    /**
+     * Register as a lead trader, or edit your profile. The profile is replaced
+     * as sent: an omitted `bio` or `minAllocation` clears it and an omitted
+     * `status` means `ACTIVE`; an omitted `shareBps` keeps the current share.
+     */
+    upsertLeadTrader(params?: UpsertLeadTraderParams): Promise<UpsertLeadTraderResponse>;
+    /** Get your own lead trader profile (404 when you are not a lead trader). */
+    getMyLeadTrader(): Promise<GetLeadTraderResponse>;
+    /** List your followers, as a leader. Cursor paged, up to 1000 per page. */
+    listMyFollowers(params?: ListMyFollowersParams): Promise<ListMyFollowersResponse>;
+    /**
+     * Follow a lead trader (no `followId`), or edit 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. The leader comes from the stored follow on an edit, so
+     * `leader` may be omitted there.
+     */
+    upsertFollow(params: UpsertFollowParams): Promise<UpsertFollowResponse>;
+    /**
+     * Preview what a follow with these terms would open if it set
+     * `copyExisting`, as totals only: estimated margin and fees, and how many
+     * of the leader's positions would and would not be copied. Read-only;
+     * nothing is placed or reserved.
+     */
+    previewFollow(params: PreviewFollowParams): Promise<PreviewFollowResponse>;
+    /** Stop one of your follows: the leader's fills stop being mirrored. */
+    stopFollow(followId: string): Promise<StopFollowResponse>;
+    /** List your follows, newest first. Cursor paged, up to 1000 per page. */
+    listMyFollows(params?: ListMyFollowsParams): Promise<ListMyFollowsResponse>;
+    /**
+     * Get one of your follows with its most recent skipped mirrors (up to 100)
+     * and `copyAccountEquity`, the copy account's marked equity (absent when it
+     * could not be read).
+     */
+    getFollow(followId: string): Promise<GetFollowResponse>;
+    /**
+     * List the open positions of the leader one of your follows copies. The
+     * leader comes from the follow, so this works after the leader releases
+     * their handle. 404 for a follow that is not yours; 403 for a stopped one.
+     */
+    listFollowLeaderPositions(followId: string): Promise<ListFollowLeaderPositionsResponse>;
+}

package/dist/api/copy-trading/api.js

@@ -0,0 +1,207 @@
+/**
+ * Copy Trading API Implementation (0XM-2851)
+ *
+ * Lead trader profiles and the public leaderboard, and the caller's follows.
+ * Followers allocate collateral to a per-leader copy account (a cross risk
+ * bucket in their margin account) and every fill the leader makes is mirrored
+ * into it.
+ *
+ * Leaders are addressed by their custom TraderCode handle. The leaderboard, a
+ * leader's profile and a leader's closed trades are public; every other call
+ * is signed and scoped to the session's account.
+ *
+ * The REST gateway rejects unknown request fields, so every request body and
+ * query string is built key by key from validated params.
+ *
+ * @example
+ * ```typescript
+ * const { leaders } = await sdk.copyTrading.listLeadTraders({ sort: "roi", window: "30d" });
+ * const leader = leaders[0].profile.leader.handle!;
+ * const { followId } = await sdk.copyTrading.upsertFollow({ leader, allocation: "1000", slPct: "0.25" });
+ * ```
+ */
+import { LeaderHandleSchema, ListLeadTraderClosedTradesSchema, ListLeadTradersSchema, ListMyFollowersSchema, ListMyFollowsSchema, PreviewFollowSchema, UpsertFollowSchema, UpsertLeadTraderSchema, UUIDSchema, validate, } from "@0xmonaco/types";
+import { BaseAPI } from "../base";
+const BASE = "/api/v1/copy-trading";
+/** `?k=v&...` from the defined entries, or `""` when there are none. */
+function queryString(params) {
+    const search = new URLSearchParams();
+    for (const [key, value] of Object.entries(params)) {
+        if (value !== undefined)
+            search.append(key, String(value));
+    }
+    const encoded = search.toString();
+    return encoded ? `?${encoded}` : "";
+}
+/** The leader path segment for a validated handle. */
+function leaderPath(handle) {
+    return `${BASE}/leaders/${encodeURIComponent(validate(LeaderHandleSchema, handle))}`;
+}
+/** The follow path segment for a validated follow id. */
+function followPath(followId) {
+    return `${BASE}/follows/${validate(UUIDSchema, followId)}`;
+}
+export class CopyTradingAPIImpl extends BaseAPI {
+    /**
+     * List lead traders (the public leaderboard), highest first by `sort`
+     * (default `roi`) over `window` (default `30d`). No session needed.
+     *
+     * Cursor paged: pass the previous response's `nextPageToken` with the SAME
+     * sort and window; an empty token means the end. Rows come from a periodic
+     * leaderboard snapshot taken at `asOf`.
+     */
+    async listLeadTraders(params = {}) {
+        const { sort, window, pageSize, pageToken } = validate(ListLeadTradersSchema, params);
+        return await this.makePublicRequest(`${BASE}/leaders${queryString({ sort, window, pageSize, pageToken })}`, {
+            method: "GET",
+        });
+    }
+    /**
+     * Get one lead trader by custom TraderCode handle: profile, follow summary
+     * and stats for 7d, 30d, 90d and all. No session needed. 404 for an unknown
+     * or suspended leader.
+     */
+    async getLeadTrader(handle) {
+        return await this.makePublicRequest(leaderPath(handle), { method: "GET" });
+    }
+    /**
+     * List a lead trader's closed trades — partial and full closes,
+     * liquidations and auto-deleveraging — newest first. No session needed.
+     */
+    async listLeadTraderClosedTrades(handle, params = {}) {
+        const path = leaderPath(handle);
+        const { pageSize, pageToken } = validate(ListLeadTraderClosedTradesSchema, params);
+        return await this.makePublicRequest(`${path}/closed-trades${queryString({ pageSize, pageToken })}`, {
+            method: "GET",
+        });
+    }
+    /**
+     * List a lead trader's open positions. Only current followers of that
+     * leader may read them (403 otherwise).
+     */
+    async listLeadTraderOpenPositions(handle) {
+        return await this.makeAuthenticatedRequest(`${leaderPath(handle)}/positions`, { method: "GET" });
+    }
+    /**
+     * Register as a lead trader, or edit your profile. The profile is replaced
+     * as sent: an omitted `bio` or `minAllocation` clears it and an omitted
+     * `status` means `ACTIVE`; an omitted `shareBps` keeps the current share.
+     */
+    async upsertLeadTrader(params = {}) {
+        const { shareBps, bio, status, minAllocation } = validate(UpsertLeadTraderSchema, params);
+        const body = {};
+        if (shareBps !== undefined)
+            body.shareBps = shareBps;
+        if (bio !== undefined)
+            body.bio = bio;
+        if (status !== undefined)
+            body.status = status;
+        if (minAllocation !== undefined)
+            body.minAllocation = minAllocation;
+        return await this.makeAuthenticatedRequest(`${BASE}/leaders/me`, {
+            method: "PUT",
+            body: JSON.stringify(body),
+        });
+    }
+    /** Get your own lead trader profile (404 when you are not a lead trader). */
+    async getMyLeadTrader() {
+        return await this.makeAuthenticatedRequest(`${BASE}/leaders/me`, { method: "GET" });
+    }
+    /** List your followers, as a leader. Cursor paged, up to 1000 per page. */
+    async listMyFollowers(params = {}) {
+        const { pageSize, pageToken } = validate(ListMyFollowersSchema, params);
+        return await this.makeAuthenticatedRequest(`${BASE}/leaders/me/followers${queryString({ pageSize, pageToken })}`, {
+            method: "GET",
+        });
+    }
+    /**
+     * Follow a lead trader (no `followId`), or edit 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. The leader comes from the stored follow on an edit, so
+     * `leader` may be omitted there.
+     */
+    async upsertFollow(params) {
+        const validated = validate(UpsertFollowSchema, params);
+        const body = {};
+        if (validated.followId !== undefined)
+            body.followId = validated.followId;
+        // The gateway requires the `leader` key on every request; an edit takes the
+        // leader from the stored follow and accepts it empty.
+        body.leader = validated.leader ?? "";
+        body.allocation = validated.allocation;
+        if (validated.marginModePolicy !== undefined)
+            body.marginModePolicy = validated.marginModePolicy;
+        if (validated.sizingMode !== undefined)
+            body.sizingMode = validated.sizingMode;
+        if (validated.sizingParam !== undefined)
+            body.sizingParam = validated.sizingParam;
+        if (validated.leverageMode !== undefined)
+            body.leverageMode = validated.leverageMode;
+        if (validated.fixedLeverage !== undefined)
+            body.fixedLeverage = validated.fixedLeverage;
+        if (validated.slPct !== undefined)
+            body.slPct = validated.slPct;
+        if (validated.tradingPairIds !== undefined)
+            body.markets = { tradingPairIds: validated.tradingPairIds };
+        if (validated.copyExisting !== undefined)
+            body.copyExisting = validated.copyExisting;
+        return await this.makeAuthenticatedRequest(`${BASE}/follows`, {
+            method: "POST",
+            body: JSON.stringify(body),
+        });
+    }
+    /**
+     * Preview what a follow with these terms would open if it set
+     * `copyExisting`, as totals only: estimated margin and fees, and how many
+     * of the leader's positions would and would not be copied. Read-only;
+     * nothing is placed or reserved.
+     */
+    async previewFollow(params) {
+        const validated = validate(PreviewFollowSchema, params);
+        const body = { leader: validated.leader, allocation: validated.allocation };
+        if (validated.marginModePolicy !== undefined)
+            body.marginModePolicy = validated.marginModePolicy;
+        if (validated.sizingMode !== undefined)
+            body.sizingMode = validated.sizingMode;
+        if (validated.sizingParam !== undefined)
+            body.sizingParam = validated.sizingParam;
+        if (validated.leverageMode !== undefined)
+            body.leverageMode = validated.leverageMode;
+        if (validated.fixedLeverage !== undefined)
+            body.fixedLeverage = validated.fixedLeverage;
+        if (validated.tradingPairIds !== undefined)
+            body.markets = { tradingPairIds: validated.tradingPairIds };
+        return await this.makeAuthenticatedRequest(`${BASE}/follows/preview`, {
+            method: "POST",
+            body: JSON.stringify(body),
+        });
+    }
+    /** Stop one of your follows: the leader's fills stop being mirrored. */
+    async stopFollow(followId) {
+        return await this.makeAuthenticatedRequest(`${followPath(followId)}/stop`, { method: "POST" });
+    }
+    /** List your follows, newest first. Cursor paged, up to 1000 per page. */
+    async listMyFollows(params = {}) {
+        const { pageSize, pageToken } = validate(ListMyFollowsSchema, params);
+        return await this.makeAuthenticatedRequest(`${BASE}/follows${queryString({ pageSize, pageToken })}`, { method: "GET" });
+    }
+    /**
+     * Get one of your follows with its most recent skipped mirrors (up to 100)
+     * and `copyAccountEquity`, the copy account's marked equity (absent when it
+     * could not be read).
+     */
+    async getFollow(followId) {
+        return await this.makeAuthenticatedRequest(followPath(followId), { method: "GET" });
+    }
+    /**
+     * List the open positions of the leader one of your follows copies. The
+     * leader comes from the follow, so this works after the leader releases
+     * their handle. 404 for a follow that is not yours; 403 for a stopped one.
+     */
+    async listFollowLeaderPositions(followId) {
+        return await this.makeAuthenticatedRequest(`${followPath(followId)}/leader-positions`, { method: "GET" });
+    }
+}

package/dist/api/copy-trading/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Copy Trading API Module
+ *
+ * Exports the copy trading API implementation.
+ */
+export { CopyTradingAPIImpl } from "./api";

package/dist/api/copy-trading/index.js

@@ -0,0 +1,6 @@
+/**
+ * Copy Trading API Module
+ *
+ * Exports the copy trading API implementation.
+ */
+export { CopyTradingAPIImpl } from "./api";

package/dist/api/index.d.ts

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

package/dist/api/index.js

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

package/dist/api/perp/routes.d.ts

@@ -2,8 +2,8 @@ export declare const perpRoutes: {
     readonly orders: {
         readonly create: () => string;
         readonly list: (params?: {
-            page?: number;
             pageSize?: number;
+            pageToken?: string;
             status?: string;
             tradingPair?: string;
             tradingMode?: string;
@@ -21,7 +21,6 @@ export declare const perpRoutes: {
             marginAccountId?: string;
             tradingPairId?: string;
             state?: string;
-            page?: number;
             pageSize?: number;
             pageToken?: string;
         }) => string;
@@ -31,7 +30,6 @@ export declare const perpRoutes: {
         readonly listTwap: (params?: {
             state?: string;
             tradingPairId?: string;
-            page?: number;
             pageSize?: number;
             pageToken?: string;
         }) => string;
@@ -115,8 +113,8 @@ export declare const perpRoutes: {
         readonly user: (params?: {
             marginAccountId?: string;
             tradingPairId?: string;
-            page?: number;
             pageSize?: number;
+            pageToken?: string;
         }) => string;
     };
     readonly applications: {

package/dist/api/profile/api.d.ts

@@ -50,8 +50,13 @@ export declare class ProfileAPIImpl extends BaseAPI implements ProfileAPI {
      * Fetches the user's transaction history from the /api/v1/accounts/movements endpoint.
      * Requires a valid access token to be set.
      *
+     * The response `total` and `totalPages` are bounded by the listing's pagination reach:
+     * exact up to `pageSize` x 10,000 rows (10,000 pages) and saturating there, so a user
+     * with more matching movements than the listing can page through reads the cap, not
+     * their lifetime total. A `page` above 10,000 is rejected.
+     *
      * @param params - Optional query parameters for pagination and filtering
-     * @param params.page - Page number (starts from 1, default: 1)
+     * @param params.page - Page number (starts from 1, default: 1, at most 10,000)
      * @param params.limit - Number of items per page (default: 20, max: 100)
      * @param params.entryType - Filter by entry type (CREDIT, DEBIT, LOCK, UNLOCK, FEE)
      * @param params.transactionType - Filter by transaction type (DEPOSIT, WITHDRAWAL, TRADE, FEE, FUNDING, LIQUIDATION, INTEREST, REWARD)
@@ -171,23 +176,16 @@ export declare class ProfileAPIImpl extends BaseAPI implements ProfileAPI {
      *
      * When neither `page` nor `pageToken` is passed, the SDK drives cursor (pageToken)
      * pagination: it starts a cursor walk from the newest row and the response's
-     * `nextPageToken` resumes it. Cursor responses carry no exact totals
-     * (`total`/`page`/`totalPages` are 0).
+     * `nextPageToken` resumes it. Responses carry no item count: the `trades`
+     * table is too large to count behind a filter.
      *
      * @param params - Optional query parameters for pagination and filtering
-     * @param params.page - Deprecated: page number for legacy offset pagination (starts
-     * from 1, at most 10,000). Passing it selects legacy page-number mode, which only sees
-     * recent (hot) history and populates `total`/`totalPages` — bounded at the pagination
-     * reach (`total` saturates at `pageSize` × 10,000 rows, `totalPages` at 10,000 pages).
-     * Use cursor pagination (`pageToken`) instead.
-     * @param params.pageSize - Number of items per page (default: 20; max 100
-     * in page-number mode, up to 1000 when pageToken is present)
+     * @param params.pageSize - Number of items per page (default: 20; up to 1000)
      * @param params.tradingPairId - Filter by trading pair ID (UUID)
      * @param params.pageToken - Pagination cursor: pass `""` to start a cursor walk from
-     * the newest row; pass a previous response's `nextPageToken` to resume. Any
-     * cursor-walk value (`""` or non-empty) ignores `page` and covers full trade history
-     * (hot and archived rows merged), unlike page-number mode. Omitting both `page` and
-     * `pageToken` starts a cursor walk (`pageToken=""`).
+     * the newest row; pass a previous response's `nextPageToken` to resume. Omitting it
+     * starts the same walk. Every walk covers full trade history, hot and archived rows
+     * merged.
      * @returns Promise resolving to paginated trades response
      * @throws {ValidationError} When the provided params fail client-side validation
      * @throws {APIError} When the request fails or user is not authenticated
@@ -214,10 +212,10 @@ export declare class ProfileAPIImpl extends BaseAPI implements ProfileAPI {
      * Starts a cursor walk (`pageToken: ""`) and follows each response's
      * `nextPageToken` until the server proves exhaustion (a page with zero rows
      * and an empty token). Covers full trade history — hot and archived rows
-     * merged — unlike the deprecated page-number mode.
+     * merged.
      *
-     * @param params - Optional filters and page size; `page`/`pageToken` are
-     * managed by the iterator and cannot be passed.
+     * @param params - Optional filters and page size; `pageToken` is managed by
+     * the iterator and cannot be passed.
      * @returns Async generator yielding trades newest-first
      * @throws {APIError} When any underlying request fails
      *
@@ -235,6 +233,11 @@ export declare class ProfileAPIImpl extends BaseAPI implements ProfileAPI {
      * Fetches funding payments from the /api/v1/accounts/funding-payments endpoint.
      * Requires a valid access token to be set.
      *
+     * The response `total` and `totalPages` are bounded by the listing's pagination reach:
+     * exact up to `pageSize` x 10,000 rows (10,000 pages) and saturating there, so a user
+     * with more matching payments than the listing can page through reads the cap, not
+     * their lifetime total. A `page` above 10,000 is rejected.
+     *
      * @param params - Optional query parameters for pagination and filtering
      * @returns Promise resolving to paginated funding payments response
      * @throws {APIError} When the request fails or user is not authenticated

package/dist/api/profile/api.js

@@ -53,8 +53,13 @@ export class ProfileAPIImpl extends BaseAPI {
      * Fetches the user's transaction history from the /api/v1/accounts/movements endpoint.
      * Requires a valid access token to be set.
      *
+     * The response `total` and `totalPages` are bounded by the listing's pagination reach:
+     * exact up to `pageSize` x 10,000 rows (10,000 pages) and saturating there, so a user
+     * with more matching movements than the listing can page through reads the cap, not
+     * their lifetime total. A `page` above 10,000 is rejected.
+     *
      * @param params - Optional query parameters for pagination and filtering
-     * @param params.page - Page number (starts from 1, default: 1)
+     * @param params.page - Page number (starts from 1, default: 1, at most 10,000)
      * @param params.limit - Number of items per page (default: 20, max: 100)
      * @param params.entryType - Filter by entry type (CREDIT, DEBIT, LOCK, UNLOCK, FEE)
      * @param params.transactionType - Filter by transaction type (DEPOSIT, WITHDRAWAL, TRADE, FEE, FUNDING, LIQUIDATION, INTEREST, REWARD)
@@ -222,23 +227,16 @@ export class ProfileAPIImpl extends BaseAPI {
      *
      * When neither `page` nor `pageToken` is passed, the SDK drives cursor (pageToken)
      * pagination: it starts a cursor walk from the newest row and the response's
-     * `nextPageToken` resumes it. Cursor responses carry no exact totals
-     * (`total`/`page`/`totalPages` are 0).
+     * `nextPageToken` resumes it. Responses carry no item count: the `trades`
+     * table is too large to count behind a filter.
      *
      * @param params - Optional query parameters for pagination and filtering
-     * @param params.page - Deprecated: page number for legacy offset pagination (starts
-     * from 1, at most 10,000). Passing it selects legacy page-number mode, which only sees
-     * recent (hot) history and populates `total`/`totalPages` — bounded at the pagination
-     * reach (`total` saturates at `pageSize` × 10,000 rows, `totalPages` at 10,000 pages).
-     * Use cursor pagination (`pageToken`) instead.
-     * @param params.pageSize - Number of items per page (default: 20; max 100
-     * in page-number mode, up to 1000 when pageToken is present)
+     * @param params.pageSize - Number of items per page (default: 20; up to 1000)
      * @param params.tradingPairId - Filter by trading pair ID (UUID)
      * @param params.pageToken - Pagination cursor: pass `""` to start a cursor walk from
-     * the newest row; pass a previous response's `nextPageToken` to resume. Any
-     * cursor-walk value (`""` or non-empty) ignores `page` and covers full trade history
-     * (hot and archived rows merged), unlike page-number mode. Omitting both `page` and
-     * `pageToken` starts a cursor walk (`pageToken=""`).
+     * the newest row; pass a previous response's `nextPageToken` to resume. Omitting it
+     * starts the same walk. Every walk covers full trade history, hot and archived rows
+     * merged.
      * @returns Promise resolving to paginated trades response
      * @throws {ValidationError} When the provided params fail client-side validation
      * @throws {APIError} When the request fails or user is not authenticated
@@ -261,27 +259,17 @@ export class ProfileAPIImpl extends BaseAPI {
         if (params) {
             validate(GetUserTradesSchema, params);
         }
-        // Legacy offset mode only when the caller explicitly asked for a page and
-        // no cursor was given; everything else drives cursor (pageToken) mode.
-        const legacyOffsetMode = params?.page !== undefined && params?.pageToken === undefined;
         const searchParams = new URLSearchParams();
-        if (legacyOffsetMode && params?.page !== undefined) {
-            searchParams.append("page", params.page.toString());
-        }
         if (params?.pageSize !== undefined) {
             searchParams.append("pageSize", params.pageSize.toString());
         }
         if (params?.tradingPairId !== undefined) {
             searchParams.append("tradingPairId", params.tradingPairId);
         }
-        // Cursor mode selects itself by the *presence* of `pageToken` on the wire,
-        // even when it is the empty string (the documented way to start a walk),
-        // so it must be sent explicitly rather than dropped like a falsy value.
-        // When the caller gave neither `page` nor `pageToken`, default to starting
-        // a cursor walk (`pageToken=""`).
-        if (!legacyOffsetMode) {
-            searchParams.append("pageToken", params?.pageToken ?? "");
-        }
+        // One pagination mode. `pageToken` is sent even as the empty string — the
+        // server selects the walk by the token's PRESENCE, not its value — so it
+        // must not be dropped the way a falsy value usually would be.
+        searchParams.append("pageToken", params?.pageToken ?? "");
         const queryString = searchParams.toString();
         const url = queryString ? `/api/v1/accounts/trades?${queryString}` : "/api/v1/accounts/trades";
         return await this.makeAuthenticatedRequest(url);
@@ -293,10 +281,10 @@ export class ProfileAPIImpl extends BaseAPI {
      * Starts a cursor walk (`pageToken: ""`) and follows each response's
      * `nextPageToken` until the server proves exhaustion (a page with zero rows
      * and an empty token). Covers full trade history — hot and archived rows
-     * merged — unlike the deprecated page-number mode.
+     * merged.
      *
-     * @param params - Optional filters and page size; `page`/`pageToken` are
-     * managed by the iterator and cannot be passed.
+     * @param params - Optional filters and page size; `pageToken` is managed by
+     * the iterator and cannot be passed.
      * @returns Async generator yielding trades newest-first
      * @throws {APIError} When any underlying request fails
      *
@@ -327,6 +315,11 @@ export class ProfileAPIImpl extends BaseAPI {
      * Fetches funding payments from the /api/v1/accounts/funding-payments endpoint.
      * Requires a valid access token to be set.
      *
+     * The response `total` and `totalPages` are bounded by the listing's pagination reach:
+     * exact up to `pageSize` x 10,000 rows (10,000 pages) and saturating there, so a user
+     * with more matching payments than the listing can page through reads the cap, not
+     * their lifetime total. A `page` above 10,000 is rejected.
+     *
      * @param params - Optional query parameters for pagination and filtering
      * @returns Promise resolving to paginated funding payments response
      * @throws {APIError} When the request fails or user is not authenticated

package/dist/api/trading/api.d.ts

@@ -197,14 +197,10 @@ export declare class TradingAPIImpl extends BaseAPI implements TradingAPI {
      * via each response's `nextPageToken` until that token comes back empty. A
      * cursor page size may go up to 1000.
      *
-     * Passing the deprecated `page` (without `pageToken`) selects legacy
-     * page-number mode instead, which keeps the 100 page-size cap and populates a
-     * bounded `total` (exact up to `pageSize` x 10,000 rows, saturating there);
-     * `page` is capped at 10,000. Cursor mode returns `total`/`page` as 0 and runs
-     * no COUNT.
-     *
-     * @param params - Optional filters and pagination; `pageToken` drives cursor
-     * mode, `page` drives the deprecated legacy mode
+     * `total` is the count of matching rows, bounded at a server ceiling of
+     * 10,000 and saturating there.
+     *
+     * @param params - Optional filters and cursor pagination via `pageToken`
      * @returns Promise resolving to ListConditionalOrdersResponse with orders and pagination info
      * @throws {APIError} When API communication fails
      */
@@ -334,17 +330,13 @@ export declare class TradingAPIImpl extends BaseAPI implements TradingAPI {
      * @param params.status - Filter by order status (e.g., "SUBMITTED", "FILLED"), or by
      * any of several statuses at once by passing an array (e.g., ["SUBMITTED", "PARTIALLY_FILLED"]) (optional)
      * @param params.tradingPairId - Filter by trading pair UUID (optional)
-     * @param params.page - Deprecated: page number for legacy offset pagination (must be > 0).
-     * Passing it selects legacy page-number mode, which only sees recent (hot) history. Both
-     * modes populate `total`/`totalPages` (bounded — see `totalCapped`); use cursor
-     * pagination (`pageToken`) instead for full history.
-     * @param params.pageSize - Number of orders per page (defaults to 10, must be > 0; max 100
-     * in page-number mode, up to 1000 when pageToken is present)
+     * @param params.pageSize - Number of orders per page (defaults to 10, must be > 0;
+     * up to 1000)
      * @param params.pageToken - Pagination cursor: pass `""` to start a cursor walk from
      * the newest (or oldest, for `orderBy: "ASC"`) row; pass a previous response's
-     * `nextPageToken` to resume. Any cursor-walk value (`""` or non-empty) ignores `page`
-     * and covers full order history (hot and archived rows merged), unlike page-number
-     * mode. Omitting both `page` and `pageToken` starts a cursor walk (`pageToken=""`).
+     * `nextPageToken` to resume. Omitting it starts the same walk. Every walk covers
+     * full order history, hot and archived rows merged. `total`/`totalPages` are
+     * bounded — see `totalCapped`.
      * @returns Promise resolving to GetPaginatedOrdersResponse with orders and pagination info
      * @throws {APIError} When API communication fails
      *
@@ -378,10 +370,10 @@ export declare class TradingAPIImpl extends BaseAPI implements TradingAPI {
      * Starts a cursor walk (`pageToken: ""`) and follows each response's
      * `nextPageToken` until the server proves exhaustion (a page with zero rows
      * and an empty token). Covers full order history — hot and archived rows
-     * merged — unlike the deprecated page-number mode.
+     * merged.
      *
-     * @param params - Optional filters and page size; `page`/`pageToken` are
-     * managed by the iterator and cannot be passed.
+     * @param params - Optional filters and page size; `pageToken` is managed by
+     * the iterator and cannot be passed.
      * @returns Async generator yielding orders newest-first (or oldest-first for
      * `orderBy: "ASC"`)
      * @throws {APIError} When any underlying request fails
@@ -535,14 +527,10 @@ export declare class TradingAPIImpl extends BaseAPI implements TradingAPI {
      * via each response's `nextPageToken` until that token comes back empty. A
      * cursor page size may go up to 1000.
      *
-     * Passing the deprecated `page` (without `pageToken`) selects legacy
-     * page-number mode instead, which keeps the 100 page-size cap and populates a
-     * bounded `total` (exact up to `pageSize` x 10,000 rows, saturating there);
-     * `page` is capped at 10,000. Cursor mode returns `total`/`page` as 0 and runs
-     * no COUNT.
+     * `total` is the count of matching rows, bounded at a server ceiling of
+     * 10,000 and saturating there.
      *
-     * @param params - Optional filters and pagination; `pageToken` drives cursor
-     * mode, `page` drives the deprecated legacy mode
+     * @param params - Optional filters and cursor pagination via `pageToken`
      * @returns Promise resolving to ListTwapOrdersResponse with orders and pagination info
      * @throws {APIError} When API communication fails
      *

package/dist/api/trading/api.js

@@ -282,14 +282,10 @@ export class TradingAPIImpl extends BaseAPI {
      * via each response's `nextPageToken` until that token comes back empty. A
      * cursor page size may go up to 1000.
      *
-     * Passing the deprecated `page` (without `pageToken`) selects legacy
-     * page-number mode instead, which keeps the 100 page-size cap and populates a
-     * bounded `total` (exact up to `pageSize` x 10,000 rows, saturating there);
-     * `page` is capped at 10,000. Cursor mode returns `total`/`page` as 0 and runs
-     * no COUNT.
-     *
-     * @param params - Optional filters and pagination; `pageToken` drives cursor
-     * mode, `page` drives the deprecated legacy mode
+     * `total` is the count of matching rows, bounded at a server ceiling of
+     * 10,000 and saturating there.
+     *
+     * @param params - Optional filters and cursor pagination via `pageToken`
      * @returns Promise resolving to ListConditionalOrdersResponse with orders and pagination info
      * @throws {APIError} When API communication fails
      */
@@ -297,24 +293,16 @@ export class TradingAPIImpl extends BaseAPI {
         if (params) {
             validate(ListConditionalOrdersSchema, params);
         }
-        const { page, pageSize = 20, marginAccountId, tradingPairId, state, pageToken } = params || {};
-        // Legacy offset mode only when the caller explicitly asked for a page and no
-        // cursor was given; everything else drives cursor (pageToken) mode.
-        const legacyOffsetMode = page !== undefined && pageToken === undefined;
-        // Cursor requests may use pages up to 1000 (keyset reads); page-number
-        // requests keep the server's 100 cap.
-        const boundedPageSize = Math.min(Math.max(pageSize, 1), legacyOffsetMode ? 100 : 1000);
+        const { pageSize = 20, marginAccountId, tradingPairId, state, pageToken } = params || {};
+        const boundedPageSize = Math.min(Math.max(pageSize, 1), 1000);
         return await this.makeAuthenticatedRequest(perpRoutes.orders.listConditional({
             marginAccountId,
             tradingPairId,
             state,
-            // Legacy mode sends `page` and omits `pageToken`; cursor mode omits
-            // `page` and sends `pageToken` — present even as the empty string, the
-            // documented way to start a walk (the server selects cursor mode by the
-            // token's presence, not its value).
-            page: legacyOffsetMode ? page : undefined,
             pageSize: boundedPageSize,
-            pageToken: legacyOffsetMode ? undefined : (pageToken ?? ""),
+            // Sent even as the empty string: the server starts a walk on the
+            // token's PRESENCE, not its value.
+            pageToken: pageToken ?? "",
         }), { method: "GET" });
     }
     /**
@@ -522,17 +510,13 @@ export class TradingAPIImpl extends BaseAPI {
      * @param params.status - Filter by order status (e.g., "SUBMITTED", "FILLED"), or by
      * any of several statuses at once by passing an array (e.g., ["SUBMITTED", "PARTIALLY_FILLED"]) (optional)
      * @param params.tradingPairId - Filter by trading pair UUID (optional)
-     * @param params.page - Deprecated: page number for legacy offset pagination (must be > 0).
-     * Passing it selects legacy page-number mode, which only sees recent (hot) history. Both
-     * modes populate `total`/`totalPages` (bounded — see `totalCapped`); use cursor
-     * pagination (`pageToken`) instead for full history.
-     * @param params.pageSize - Number of orders per page (defaults to 10, must be > 0; max 100
-     * in page-number mode, up to 1000 when pageToken is present)
+     * @param params.pageSize - Number of orders per page (defaults to 10, must be > 0;
+     * up to 1000)
      * @param params.pageToken - Pagination cursor: pass `""` to start a cursor walk from
      * the newest (or oldest, for `orderBy: "ASC"`) row; pass a previous response's
-     * `nextPageToken` to resume. Any cursor-walk value (`""` or non-empty) ignores `page`
-     * and covers full order history (hot and archived rows merged), unlike page-number
-     * mode. Omitting both `page` and `pageToken` starts a cursor walk (`pageToken=""`).
+     * `nextPageToken` to resume. Omitting it starts the same walk. Every walk covers
+     * full order history, hot and archived rows merged. `total`/`totalPages` are
+     * bounded — see `totalCapped`.
      * @returns Promise resolving to GetPaginatedOrdersResponse with orders and pagination info
      * @throws {APIError} When API communication fails
      *
@@ -564,19 +548,10 @@ export class TradingAPIImpl extends BaseAPI {
             validate(GetPaginatedOrdersSchema, params);
         }
         // Set pagination defaults with destructuring and validation
-        const { page, pageSize: requestedPageSize = 10, status, tradingPairId, tradingMode, marginAccountId, pageToken } = params || {};
+        const { pageSize: requestedPageSize = 10, status, tradingPairId, tradingMode, marginAccountId, pageToken } = params || {};
         const validPageSize = requestedPageSize > 0 ? requestedPageSize : 10;
-        // Legacy offset mode only when the caller explicitly asked for a page and
-        // no cursor was given; everything else drives cursor (pageToken) mode.
-        const legacyOffsetMode = page !== undefined && pageToken === undefined;
-        // Cursor requests may use pages up to 1000 (keyset reads); page-number
-        // requests keep the server's 100 cap.
-        const pageSize = Math.min(validPageSize, legacyOffsetMode ? 100 : 1000);
+        const pageSize = Math.min(validPageSize, 1000);
         const searchParams = new URLSearchParams();
-        if (legacyOffsetMode) {
-            const validPage = page > 0 ? page : 1;
-            searchParams.append("page", validPage.toString());
-        }
         searchParams.append("pageSize", pageSize.toString());
         // An array filter is sent as one comma-separated `status` value, which the
         // API reads as "any of these", so several statuses cost a single request.
@@ -593,14 +568,10 @@ export class TradingAPIImpl extends BaseAPI {
         if (marginAccountId) {
             searchParams.append("marginAccountId", marginAccountId);
         }
-        // Cursor mode selects itself by the *presence* of `pageToken` on the wire,
-        // even when it is the empty string (the documented way to start a walk),
-        // so it must be sent explicitly rather than dropped like a falsy value.
-        // When the caller gave neither `page` nor `pageToken`, default to starting
-        // a cursor walk (`pageToken=""`).
-        if (!legacyOffsetMode) {
-            searchParams.append("pageToken", pageToken ?? "");
-        }
+        // One pagination mode. `pageToken` is sent even as the empty string — the
+        // server selects the walk by the token's PRESENCE, not its value — so it
+        // must not be dropped the way a falsy value usually would be.
+        searchParams.append("pageToken", pageToken ?? "");
         const endpoint = `/api/v1/orders?${searchParams.toString()}`;
         return await this.makeAuthenticatedRequest(endpoint, {
             method: "GET",
@@ -613,10 +584,10 @@ export class TradingAPIImpl extends BaseAPI {
      * Starts a cursor walk (`pageToken: ""`) and follows each response's
      * `nextPageToken` until the server proves exhaustion (a page with zero rows
      * and an empty token). Covers full order history — hot and archived rows
-     * merged — unlike the deprecated page-number mode.
+     * merged.
      *
-     * @param params - Optional filters and page size; `page`/`pageToken` are
-     * managed by the iterator and cannot be passed.
+     * @param params - Optional filters and page size; `pageToken` is managed by
+     * the iterator and cannot be passed.
      * @returns Async generator yielding orders newest-first (or oldest-first for
      * `orderBy: "ASC"`)
      * @throws {APIError} When any underlying request fails
@@ -845,14 +816,10 @@ export class TradingAPIImpl extends BaseAPI {
      * via each response's `nextPageToken` until that token comes back empty. A
      * cursor page size may go up to 1000.
      *
-     * Passing the deprecated `page` (without `pageToken`) selects legacy
-     * page-number mode instead, which keeps the 100 page-size cap and populates a
-     * bounded `total` (exact up to `pageSize` x 10,000 rows, saturating there);
-     * `page` is capped at 10,000. Cursor mode returns `total`/`page` as 0 and runs
-     * no COUNT.
+     * `total` is the count of matching rows, bounded at a server ceiling of
+     * 10,000 and saturating there.
      *
-     * @param params - Optional filters and pagination; `pageToken` drives cursor
-     * mode, `page` drives the deprecated legacy mode
+     * @param params - Optional filters and cursor pagination via `pageToken`
      * @returns Promise resolving to ListTwapOrdersResponse with orders and pagination info
      * @throws {APIError} When API communication fails
      *
@@ -866,23 +833,15 @@ export class TradingAPIImpl extends BaseAPI {
         if (params) {
             validate(ListTwapOrdersSchema, params);
         }
-        const { page, pageSize = 20, state, tradingPairId, pageToken } = params || {};
-        // Legacy offset mode only when the caller explicitly asked for a page and no
-        // cursor was given; everything else drives cursor (pageToken) mode.
-        const legacyOffsetMode = page !== undefined && pageToken === undefined;
-        // Cursor requests may use pages up to 1000 (keyset reads); page-number
-        // requests keep the server's 100 cap.
-        const boundedPageSize = Math.min(Math.max(pageSize, 1), legacyOffsetMode ? 100 : 1000);
+        const { pageSize = 20, state, tradingPairId, pageToken } = params || {};
+        const boundedPageSize = Math.min(Math.max(pageSize, 1), 1000);
         return await this.makeAuthenticatedRequest(perpRoutes.orders.listTwap({
             state,
             tradingPairId,
-            // Legacy mode sends `page` and omits `pageToken`; cursor mode omits
-            // `page` and sends `pageToken` — present even as the empty string, the
-            // documented way to start a walk (the server selects cursor mode by the
-            // token's presence, not its value).
-            page: legacyOffsetMode ? page : undefined,
             pageSize: boundedPageSize,
-            pageToken: legacyOffsetMode ? undefined : (pageToken ?? ""),
+            // Sent even as the empty string: the server starts a walk on the
+            // token's PRESENCE, not its value.
+            pageToken: pageToken ?? "",
         }), { method: "GET" });
     }
 }

package/dist/api/websocket/websocket.js

@@ -69,6 +69,12 @@ function readBoolean(source, field) {
     }
     return value;
 }
+function readOptionalBoolean(source, field) {
+    const value = source[field];
+    if (value === undefined || value === null)
+        return undefined;
+    return readBoolean(source, field);
+}
 /**
  * Read a wire sequence counter: a non-negative safe integer. The server
  * serializes Rust `u64` sequence fields as plain JSON numbers, so a negative,
@@ -528,6 +534,67 @@ function parseTwapOrderEventData(raw) {
     }
     return data;
 }
+/**
+ * camelCase a `copy` channel payload and drop explicit `null`s, so the result
+ * matches the optional (`?:`) fields of the published copy event types. Only
+ * the named identity fields are validated.
+ */
+function copyPayload(raw, what, required) {
+    if (!isRecord(raw)) {
+        throw new Error(`Invalid copy ${what}: data must be an object`);
+    }
+    const data = keysToCamelCase(raw);
+    for (const key of Object.keys(data)) {
+        if (data[key] === null) {
+            delete data[key];
+        }
+    }
+    for (const field of required) {
+        const value = data[field];
+        if (typeof value !== "string" || value.length === 0) {
+            throw new Error(`Invalid copy ${what}: ${field} must be a non-empty string`);
+        }
+    }
+    return data;
+}
+/**
+ * Parse a copy relationship row: the `copy_relationship_update` payload, and
+ * each subscribe-time snapshot row. The identity fields and `status` are
+ * required; every value field (status, policies, `change`, `stopReason`) is
+ * passed through unchecked, so a label this SDK version predates is delivered
+ * rather than dropping the update (0XM-2627). The declared unions document the
+ * values the server sends today.
+ */
+function parseCopyRelationshipEventData(raw) {
+    return copyPayload(raw, "relationship update", ["relationshipId", "status"]);
+}
+/**
+ * Parse a `copy_skip` payload. The skip `reason` is passed through unchecked
+ * for the same reason as the relationship labels.
+ */
+function parseCopySkipEventData(raw) {
+    return copyPayload(raw, "skip", ["relationshipId", "reason"]);
+}
+/**
+ * Parse a `copy` channel frame. `event_type` is the channel-class
+ * discriminator that picks the payload shape, so it is matched strictly: a
+ * frame of any other type (such as the reserved `copy_payout`) is rejected
+ * rather than parsed as the wrong shape.
+ */
+function parseCopyEvent(rawData) {
+    if (!isRecord(rawData)) {
+        throw new Error("Invalid copy event: payload must be an object");
+    }
+    const userId = rawData.user_id;
+    if (typeof userId !== "string" || userId.length === 0) {
+        throw new Error("Invalid copy event: user_id must be a non-empty string");
+    }
+    const eventType = readEnum(rawData, "event_type", ["copy_relationship_update", "copy_skip"]);
+    if (eventType === "copy_relationship_update") {
+        return { eventType, userId, data: parseCopyRelationshipEventData(rawData.data) };
+    }
+    return { eventType, userId, data: parseCopySkipEventData(rawData.data) };
+}
 /**
  * Parse a user balance payload. Shared by the live event and the subscribe-time
  * snapshot (see {@link parseConditionalOrderEventData}).
@@ -597,6 +664,10 @@ function parseOrderSnapshotItem(raw) {
     const clientOrderId = readOptionalString(item, "clientOrderId");
     const selfTradePreventionMode = readOptionalString(item, "selfTradePreventionMode");
     const parentOrderId = readOptionalString(item, "parentOrderId");
+    const postOnly = readOptionalBoolean(item, "postOnly");
+    const expirationDate = readOptionalString(item, "expirationDate");
+    const triggerPrice = readOptionalString(item, "triggerPrice");
+    const positionSide = readOptionalString(item, "positionSide");
     const version = readOptionalNumber(item, "version");
     return {
         orderId: readString(item, "orderId"),
@@ -634,6 +705,12 @@ function parseOrderSnapshotItem(raw) {
         // Spread in conditionally too: absent for an order that is not a TWAP
         // child, and absent must stay absent.
         ...(parentOrderId === undefined ? {} : { parentOrderId }),
+        // The four REST order-shape fields, each omitted by the server when REST
+        // omits it, so absent must stay absent.
+        ...(postOnly === undefined ? {} : { postOnly }),
+        ...(expirationDate === undefined ? {} : { expirationDate }),
+        ...(triggerPrice === undefined ? {} : { triggerPrice }),
+        ...(positionSide === undefined ? {} : { positionSide }),
         // Spread in conditionally for the same reason as `clientOrderId`: the
         // server omits the key when unknown, and absent must stay absent rather
         // than becoming `version: undefined` — a resync compares this value, and
@@ -1420,6 +1497,25 @@ export function createMonacoWebSocket(baseUrl, options = {}, serverClock = new S
             }
         }, onSnapshot && snapshotFrameHandler("TWAP orders", parseTwapOrderEventData, onSnapshot));
     };
+    /**
+     * Subscribe to the authenticated follower's copy trading stream: every
+     * change to one of their follows, and every leader fill a follow could not
+     * mirror. Bare channel only — relationships span markets. The snapshot is
+     * the follower's live follows (`change: "snapshot"`).
+     */
+    const subscribeCopy = (handler, onSnapshot) => {
+        if (!handler) {
+            throw new Error("copy subscription requires a handler");
+        }
+        return subscribe("copy", (rawData) => {
+            try {
+                handler(parseCopyEvent(rawData));
+            }
+            catch (err) {
+                console.error("WebSocket: Error processing copy event", err);
+            }
+        }, onSnapshot && snapshotFrameHandler("copy", parseCopyRelationshipEventData, onSnapshot));
+    };
     /**
      * Subscribe to authenticated user's position updates.
      * Requires authentication - user is identified from the signed session-key
@@ -1718,6 +1814,7 @@ export function createMonacoWebSocket(baseUrl, options = {}, serverClock = new S
         balances: subscribeBalances,
         conditionalOrders: subscribeConditionalOrders,
         twapOrders: subscribeTwapOrders,
+        copy: subscribeCopy,
         positions: subscribePositions,
         liquidations: subscribeLiquidations,
         account: subscribeAccount,

package/dist/coverage.d.ts

@@ -10,6 +10,19 @@ export declare const COVERED: {
     cancel_conditional_order: string;
     get_conditional_order: string;
     cancel_order: string;
+    upsert_lead_trader: string;
+    get_my_lead_trader: string;
+    list_my_followers: string;
+    list_lead_traders: string;
+    get_lead_trader: string;
+    list_lead_trader_closed_trades: string;
+    list_lead_trader_open_positions: string;
+    upsert_follow: string;
+    stop_follow: string;
+    list_my_follows: string;
+    get_follow: string;
+    list_follow_leader_positions: string;
+    preview_follow: string;
     cancel_twap_order: string;
     create_twap_order: string;
     get_twap_order: string;

package/dist/coverage.js

@@ -10,6 +10,19 @@ export const COVERED = {
     cancel_conditional_order: "cancelConditionalOrder",
     get_conditional_order: "getConditionalOrder",
     cancel_order: "cancelOrder",
+    upsert_lead_trader: "copyTrading.upsertLeadTrader",
+    get_my_lead_trader: "copyTrading.getMyLeadTrader",
+    list_my_followers: "copyTrading.listMyFollowers",
+    list_lead_traders: "copyTrading.listLeadTraders",
+    get_lead_trader: "copyTrading.getLeadTrader",
+    list_lead_trader_closed_trades: "copyTrading.listLeadTraderClosedTrades",
+    list_lead_trader_open_positions: "copyTrading.listLeadTraderOpenPositions",
+    upsert_follow: "copyTrading.upsertFollow",
+    stop_follow: "copyTrading.stopFollow",
+    list_my_follows: "copyTrading.listMyFollows",
+    get_follow: "copyTrading.getFollow",
+    list_follow_leader_positions: "copyTrading.listFollowLeaderPositions",
+    preview_follow: "copyTrading.previewFollow",
     cancel_twap_order: "cancelTwapOrder",
     create_twap_order: "createTwapOrder",
     get_twap_order: "getTwapOrder",

package/dist/sdk.d.ts

@@ -1,4 +1,4 @@
-import type { ApplicationsAPI, AuthAPI, AuthState, BuildercodesAPI, DelegatedAgentsAPI, FaucetAPI, FeesAPI, ManagedMarketsAPI, MarginAccountsAPI, MarketAPI, MonacoSDK, Network, PitpassAPI, PortfolioAPI, PositionsAPI, ProfileAPI, PulseAPI, SDKConfig, SubAccountsAPI, SweeperAPI, TradingAPI, VaultAPI, WhitelistAPI, WithdrawalsAPI } from "@0xmonaco/types";
+import type { ApplicationsAPI, AuthAPI, AuthState, BuildercodesAPI, CopyTradingAPI, DelegatedAgentsAPI, FaucetAPI, FeesAPI, ManagedMarketsAPI, MarginAccountsAPI, MarketAPI, MonacoSDK, Network, PitpassAPI, PortfolioAPI, PositionsAPI, ProfileAPI, PulseAPI, SDKConfig, SubAccountsAPI, SweeperAPI, TradingAPI, VaultAPI, WhitelistAPI, WithdrawalsAPI } from "@0xmonaco/types";
 import { type Address, type PublicClient, type TransactionReceipt, type WalletClient } from "viem";
 import { type MonacoWebSocket, OrderbookAPIImpl, TradesAPIImpl } from "./api";
 export declare class MonacoSDKImpl implements MonacoSDK {
@@ -7,6 +7,7 @@ export declare class MonacoSDKImpl implements MonacoSDK {
     applications: ApplicationsAPI;
     fees: FeesAPI;
     buildercodes: BuildercodesAPI;
+    copyTrading: CopyTradingAPI;
     pitpass: PitpassAPI;
     vault: VaultAPI;
     withdrawals: WithdrawalsAPI;

package/dist/sdk.js

@@ -4,6 +4,7 @@ import { sei, seiTestnet } from "viem/chains";
 import { ApplicationsAPIImpl, createMonacoWebSocket, OrderbookAPIImpl, TradesAPIImpl } from "./api";
 import { AuthAPIImpl } from "./api/auth";
 import { BuildercodesAPIImpl } from "./api/buildercodes";
+import { CopyTradingAPIImpl } from "./api/copy-trading";
 import { DelegatedAgentsAPIImpl } from "./api/delegated-agents";
 import { FaucetAPIImpl } from "./api/faucet";
 import { FeesAPIImpl } from "./api/fees";
@@ -48,6 +49,7 @@ export class MonacoSDKImpl {
     applications;
     fees;
     buildercodes;
+    copyTrading;
     pitpass;
     vault;
     withdrawals;
@@ -81,6 +83,7 @@ export class MonacoSDKImpl {
         this.applications.setSessionKeypair(credentials);
         this.fees.setSessionKeypair(credentials);
         this.buildercodes.setSessionKeypair(credentials);
+        this.copyTrading.setSessionKeypair(credentials);
         this.pitpass.setSessionKeypair(credentials);
         this.vault.setSessionKeypair(credentials);
         this.withdrawals.setSessionKeypair(credentials);
@@ -123,6 +126,7 @@ export class MonacoSDKImpl {
         this.applications.setServerKey(serverKey);
         this.fees.setServerKey(serverKey);
         this.buildercodes.setServerKey(serverKey);
+        this.copyTrading.setServerKey(serverKey);
         this.pitpass.setServerKey(serverKey);
         this.vault.setServerKey(serverKey);
         this.withdrawals.setServerKey(serverKey);
@@ -211,6 +215,7 @@ export class MonacoSDKImpl {
         this.delegatedAgents = configureSigning(new DelegatedAgentsAPIImpl(apiUrl));
         this.fees = configureSigning(new FeesAPIImpl(apiUrl));
         this.buildercodes = configureSigning(new BuildercodesAPIImpl(apiUrl));
+        this.copyTrading = configureSigning(new CopyTradingAPIImpl(apiUrl));
         this.pitpass = configureSigning(new PitpassAPIImpl(apiUrl));
         this.profile = configureSigning(new ProfileAPIImpl(apiUrl));
         this.vault = configureSigning(new VaultAPIImpl(this.publicClient, this.walletClient, this.chain, this.applications, this.profile, apiUrl));

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@0xmonaco/core",
-	"version": "1.0.69",
+	"version": "1.0.70",
 	"type": "module",
 	"homepage": "https://docs.0xmonaco.com/sdk/typescript",
 	"main": "./dist/index.js",
@@ -19,8 +19,8 @@
 		"viem": "^2.45.2"
 	},
 	"dependencies": {
-		"@0xmonaco/contracts": "1.0.69",
-		"@0xmonaco/types": "1.0.69",
+		"@0xmonaco/contracts": "1.0.70",
+		"@0xmonaco/types": "1.0.70",
 		"@noble/curves": "^1.9.1",
 		"@noble/hashes": "^2.4.0",
 		"http-status-codes": "^2.3.0"