@0xmonaco/types 1.0.88 → 1.0.91

package/dist/buildercodes/index.d.ts

@@ -48,8 +48,10 @@ export interface BuildercodesAPI extends BaseAPI {
      * The bucket is resolved from the authenticated caller's own wallet address,
      * so a caller can only ever claim their own accrued balance. A wallet that
      * has never been an enrolled frontend's payout address has nothing to claim.
-     * A wallet that *used to be* a payout address keeps what it accrued back then
-     * and can still claim it — payout-address changes are not retroactive.
+     * Shortly after Monaco moves a frontend's payout address to a new wallet, the
+     * unclaimed balance accrued to the old wallet moves with it. A wallet that
+     * *used to be* a payout address can still claim whatever remains in its
+     * bucket.
      *
      * Throws 403 when the session is a delegated agent — a permanent
      * restriction on that session type, not a rollout state. No program switch

package/dist/fees/responses.d.ts

@@ -34,10 +34,8 @@ export declare const SimulateFeeResponseSchema: z.ZodObject<{
     applicationMakerFee: z.ZodOptional<z.ZodString>;
     applicationMakerFeeBps: z.ZodOptional<z.ZodNumber>;
     monacoMakerRebate: z.ZodString;
-    monacoMakerRebateBps: z.ZodNumber;
     monacoMakerRebateBpsExact: z.ZodString;
     monacoTakerFee: z.ZodString;
-    monacoTakerFeeBps: z.ZodNumber;
     monacoTakerFeeBpsExact: z.ZodString;
     notional: z.ZodString;
     takerTotalPayment: z.ZodString;

package/dist/fees/responses.js

@@ -69,12 +69,6 @@ export const SimulateFeeResponseSchema = z.object({
     applicationMakerFeeBps: z.number().optional(),
     /** Monaco protocol maker rebate (negative = rebate) */
     monacoMakerRebate: z.string(),
-    /**
-     * Monaco maker rebate in basis points.
-     * @deprecated Integer field cannot represent fractional tiered rebates (e.g. -1.15); it
-     * echoes the flat trading-pair column, not the tier-resolved rate. Use monacoMakerRebateBpsExact.
-     */
-    monacoMakerRebateBps: z.number(),
     /**
      * Tier-resolved Monaco maker rebate as a decimal basis-points string (negative is a
      * rebate), e.g. "-1" — the exact rate the ledger credits this caller.
@@ -82,12 +76,6 @@ export const SimulateFeeResponseSchema = z.object({
     monacoMakerRebateBpsExact: z.string(),
     /** Monaco protocol taker fee */
     monacoTakerFee: z.string(),
-    /**
-     * Monaco taker fee in basis points.
-     * @deprecated Integer field cannot represent fractional tiered rates (e.g. 6.5); it echoes
-     * the flat trading-pair column, not the tier-resolved rate. Use monacoTakerFeeBpsExact.
-     */
-    monacoTakerFeeBps: z.number(),
     /**
      * Tier-resolved Monaco taker fee as a decimal basis-points string, e.g. "6.5" — the exact
      * rate the ledger charges this caller (equals monacoTakerFee / notional).

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

@@ -221,10 +221,26 @@ export interface TransferCollateralRequest {
      * bucket, which has no trading pair and so cannot be named any other way.
      */
     marginMode?: MarginMode;
+    /**
+     * Submission identity (1-64 of `A-Za-z0-9._:-`), shared with order create.
+     * Retrying the same key and request within 15 minutes returns the first
+     * transfer's result, its `movementId` included, and moves nothing again.
+     * Generate one per intended transfer and keep it across its retries; a
+     * different request under the same key fails with `IDEMPOTENCY_KEY_CONFLICT`.
+     */
+    idempotencyKey?: string;
 }
 export interface TransferCollateralToParentMarginAccountRequest {
     asset: string;
     amount: string;
+    /**
+     * Submission identity (1-64 of `A-Za-z0-9._:-`), shared with order create.
+     * Retrying the same key and request within 15 minutes returns the first
+     * transfer's result, its `movementId` included, and moves nothing again.
+     * Generate one per intended transfer and keep it across its retries; a
+     * different request under the same key fails with `IDEMPOTENCY_KEY_CONFLICT`.
+     */
+    idempotencyKey?: string;
 }
 /**
  * Fund a pair's isolated risk bucket from the parent margin account's
@@ -289,6 +305,14 @@ export type TransferCollateralToRiskBucketRequest = TransferCollateralToIsolated
 export interface TransferCollateralFromParentMarginAccountRequest {
     asset: string;
     amount: string;
+    /**
+     * Submission identity (1-64 of `A-Za-z0-9._:-`), shared with order create.
+     * Retrying the same key and request within 15 minutes returns the first
+     * transfer's result, its `movementId` included, and moves nothing again.
+     * Generate one per intended transfer and keep it across its retries; a
+     * different request under the same key fails with `IDEMPOTENCY_KEY_CONFLICT`.
+     */
+    idempotencyKey?: string;
 }
 export interface TransferCollateralResponse {
     movementId: string;
@@ -582,6 +606,14 @@ export interface TransferMarginCollateralRequest {
     amount: string;
     from: CollateralTransferEndpoint;
     to: CollateralTransferEndpoint;
+    /**
+     * Submission identity (1-64 of `A-Za-z0-9._:-`), shared with order create.
+     * Retrying the same key and request within 15 minutes returns the first
+     * transfer's result, its `movementId` included, and moves nothing again.
+     * Generate one per intended transfer and keep it across its retries; a
+     * different request under the same key fails with `IDEMPOTENCY_KEY_CONFLICT`.
+     */
+    idempotencyKey?: string;
 }
 export interface TransferMarginCollateralResponse {
     movementId: string;

package/dist/market/index.d.ts

@@ -423,6 +423,12 @@ export interface PerpMarketConfig {
      */
     riskTiers: RiskTier[];
     updatedAt: string;
+    /**
+     * Quote notional `Q_m` that each funding premium sample walks through each
+     * side of the book to read the market's impact bid and impact ask. Set per
+     * market; markets start at `"2000"`.
+     */
+    fundingImpactNotional: string;
 }
 export interface PerpMarketSummary {
     tradingPairId: string;
@@ -605,6 +611,124 @@ export interface OpenInterest {
     openInterestNotional: string;
     updatedAt: string;
 }
+/** Public account-positioning snapshot and distinct active-trader counts; responses may be cached for up to 30 seconds. */
+export interface TraderMetrics {
+    tradingPairId: string;
+    quoteAssetSymbol: string;
+    /** Snapshot calculation time as Unix milliseconds. */
+    asOf: number;
+    /** Position split fields are suppressed when either side has fewer than five accounts. */
+    positionMetricsSuppressed: boolean;
+    longAccountCount: number | null;
+    shortAccountCount: number | null;
+    /** Account shares and ratios are rounded to six decimal places. */
+    longAccountShare: string | null;
+    shortAccountShare: string | null;
+    accountRatio: string | null;
+    activeTraderWindows: ActiveTraderWindow[];
+}
+/** Distinct user IDs in executed trades for one rolling window; includes liquidation and ADL system IDs. */
+export interface ActiveTraderWindow {
+    window: "1h" | "24h" | "7d";
+    activeTraderCount: number | null;
+    takerBuyerCount: number | null;
+    takerSellerCount: number | null;
+    /** All three counts are null when any cohort in this window is below five users. */
+    suppressed: boolean;
+}
+export type TradeFlowInterval = "1m" | "5m" | "1h";
+export interface GetTradeFlowParams {
+    interval: TradeFlowInterval;
+    /** Inclusive start time as Unix milliseconds. */
+    startTime: number;
+    /** Exclusive end time as Unix milliseconds. */
+    endTime: number;
+}
+export interface TradeFlowBucket {
+    /** UTC-aligned bucket start as Unix milliseconds. */
+    bucketStart: number;
+    takerBuyNotional: string;
+    takerSellNotional: string;
+    /** Taker buy/sell ratio rounded to six decimal places. */
+    buySellRatio: string | null;
+    netNotional: string;
+    cumulativeVolumeDelta: string;
+    tradeCount: number;
+}
+export interface TradeFlow {
+    tradingPairId: string;
+    quoteAssetSymbol: string;
+    interval: TradeFlowInterval;
+    /** Inclusive selected start time as Unix milliseconds. */
+    startTime: number;
+    /** Exclusive selected end time as Unix milliseconds. */
+    endTime: number;
+    /** Buckets without executed trades are omitted. */
+    buckets: TradeFlowBucket[];
+}
+export interface ListLiquidationEventsParams {
+    /** Inclusive event-time lower bound as Unix milliseconds. */
+    startTime?: number;
+    /** Exclusive event-time upper bound as Unix milliseconds. */
+    endTime?: number;
+    /** Requested page size, from 1 through 1000 (defaults to 50). */
+    pageSize?: number;
+    /** Opaque cursor returned by the previous page; pages continue toward older rows. */
+    pageToken?: string;
+}
+export interface LiquidationHistoryEvent {
+    eventId: string;
+    /** Event time as Unix milliseconds. */
+    timestamp: number;
+    tradingPairId: string;
+    wallet: string;
+    side: "LONG" | "SHORT";
+    /** Absolute position size in base-asset units. */
+    positionSize: string;
+    /** Mark price captured for this event, in quote units per base unit. */
+    markPrice: string;
+    /** Position size × event-time mark price, in quote-asset units. */
+    markNotional: string;
+    quoteAssetSymbol: string;
+}
+export interface ListLiquidationEventsResponse {
+    tradingPairId: string;
+    /** Events are ordered newest first. */
+    events: LiquidationHistoryEvent[];
+    pageSize: number;
+    nextPageToken: string;
+}
+export type LiquidationMetricsInterval = "1m" | "5m" | "1h";
+export interface GetLiquidationMetricsParams {
+    interval: LiquidationMetricsInterval;
+    /** Inclusive range start as Unix milliseconds. */
+    startTime: number;
+    /** Exclusive range end as Unix milliseconds. */
+    endTime: number;
+}
+export interface LiquidationSideMetrics {
+    /** Number of stored liquidation-event rows on this side in the bucket. */
+    eventCount: number;
+    /** Sum of event position sizes in base-asset units. */
+    positionSize: string;
+    /** Sum of each row's position size × event-time mark in quote units. */
+    markNotional: string;
+}
+export interface LiquidationMetricsBucket {
+    /** UTC-aligned bucket start as Unix milliseconds. */
+    bucketStart: number;
+    long: LiquidationSideMetrics;
+    short: LiquidationSideMetrics;
+}
+export interface LiquidationMetrics {
+    tradingPairId: string;
+    quoteAssetSymbol: string;
+    interval: LiquidationMetricsInterval;
+    startTime: number;
+    endTime: number;
+    /** Buckets with no liquidation rows on either side are omitted. */
+    buckets: LiquidationMetricsBucket[];
+}
 /**
  * Market API interface.
  * Provides methods for fetching market metadata and trading pair information.
@@ -682,4 +806,12 @@ export interface MarketAPI extends BaseAPI {
      */
     listAllFundingHistory(params?: ListAllFundingHistoryParams): Promise<ListAllFundingHistoryResponse>;
     getOpenInterest(tradingPairId: string): Promise<OpenInterest>;
+    /** Fetch current public positioning and active-trader aggregates for a perp. */
+    getTraderMetrics(tradingPairId: string): Promise<TraderMetrics>;
+    /** Fetch bounded taker buy/sell quote flow and cumulative volume delta. */
+    getTradeFlow(tradingPairId: string, params: GetTradeFlowParams): Promise<TradeFlow>;
+    /** Fetch persisted per-fill liquidation events with a stable keyset cursor. */
+    listLiquidationEvents(tradingPairId: string, params?: ListLiquidationEventsParams): Promise<ListLiquidationEventsResponse>;
+    /** Fetch bounded UTC-aligned long/short liquidation totals by side. */
+    getLiquidationMetrics(tradingPairId: string, params: GetLiquidationMetricsParams): Promise<LiquidationMetrics>;
 }

package/dist/portfolio/index.d.ts

@@ -28,6 +28,12 @@ export interface PortfolioSummaryCurrent {
     spotEquity?: string;
     perpsEquity: string;
     unrealizedPnl?: string;
+    /**
+     * What the user can spend or withdraw now: USDC available on spot plus the
+     * parent margin account's `withdrawableCollateral`. Other spot assets and
+     * unrealized margin gains are not counted. Served even when the valuation
+     * is partial.
+     */
     availableValue?: string;
 }
 export interface PortfolioSummaryActivity {

package/dist/profile/index.d.ts

@@ -5,7 +5,7 @@
  */
 import type { Address } from "viem";
 import type { BaseAPI } from "../api";
-import type { OrderSide, OrderStatus, OrderType, SelfTradePreventionMode, TimeInForce } from "../trading";
+import type { OrderSide, OrderStatus, OrderType, SelfTradePreventionMode, TimeInForce, TradingMode } from "../trading";
 /**
  * Account movement/transaction information.
  * Represents transactions/movements returned in the profile's recent_movements array.
@@ -276,31 +276,56 @@ export interface UserTrade {
     tradeId: string;
     /** Trading pair identifier (UUID) */
     tradingPairId: string;
+    /** Trading mode of the pair the trade executed on */
+    tradingMode: TradingMode;
+    /** Maker order identifier (UUID) */
+    makerOrderId: string;
+    /** Taker order identifier (UUID) */
+    takerOrderId: string;
     /** Execution price (as string to preserve precision) */
     price: string;
     /** Executed quantity (as string to preserve precision) */
     quantity: string;
-    /** Quote volume (price * quantity, as string to preserve precision) */
-    quoteVolume: string;
-    /** Side of the trade */
+    /** `quantity` in the smallest base-token unit */
+    quantityRaw: string;
+    /** Quote volume (price * quantity, as string to preserve precision). Absent when the trade has none recorded. */
+    quoteVolume?: string;
+    /** `quoteVolume` in the smallest quote-token unit. Absent when `quoteVolume` is. */
+    quoteVolumeRaw?: string;
+    /** This user's side of the trade */
     side: OrderSide;
     /**
      * Total fee paid for this trade (as string to preserve precision). For a
      * taker this is Monaco's taker fee plus the frontend's builder fee; for a
      * maker it is the maker fee (negative for a rebate) plus the frontend's
-     * maker add-on. Equals `monacoFee + builderFee`.
-     */
-    fee: string;
-    /** Monaco's component of `fee`. Absent from servers older than this field. */
-    monacoFee?: string;
+     * maker add-on. Equals `monacoFee + builderFee`. Absent when the trade has
+     * no fee recorded for this user's side.
+     */
+    fee?: string;
+    /** `fee` in the smallest quote-token unit. Absent when `fee` is. */
+    feeRaw?: string;
+    /** Token address the fee was charged in. Absent when none is recorded. */
+    feeToken?: string;
+    /** Monaco's component of `fee`. `null` when `fee` is absent; absent from servers older than this field. */
+    monacoFee?: string | null;
+    /** `monacoFee` in the smallest quote-token unit. `null` when `monacoFee` is. */
+    monacoFeeRaw?: string | null;
     /**
      * The frontend's builder fee component of `fee`: the builder fee for a
      * taker, the maker add-on for a maker. Absent from servers older than this
      * field.
      */
     builderFee?: string;
-    /** Timestamp when the trade was executed (ISO string) */
-    executedAt: string;
+    /** `builderFee` in the smallest quote-token unit. Absent from servers older than this field. */
+    builderFeeRaw?: string;
+    /** Settlement status. Absent when the trade has none recorded. */
+    settlementStatus?: "PENDING" | "SETTLED" | "FAILED";
+    /** On-chain settlement transaction hash. Absent until one is recorded. */
+    settlementTxHash?: string;
+    /** This user's role in the fill. A self-trade reads as `MAKER`. */
+    liquidityRole: "MAKER" | "TAKER";
+    /** Timestamp when the trade was executed (RFC 3339). Absent when none is recorded. */
+    executedAt?: string;
 }
 /**
  * Query parameters for getting user trades
@@ -310,6 +335,18 @@ export interface GetUserTradesParams {
     pageSize?: number;
     /** Filter by trading pair ID (UUID) */
     tradingPairId?: string;
+    /**
+     * Filter by margin account ID (UUID): only trades whose side for this user
+     * was placed from that account. A self-trade is read as its maker side, so
+     * it matches through its maker order's account.
+     */
+    marginAccountId?: string;
+    /**
+     * Filter by order ID (UUID): only trades whose side for this user was
+     * placed by that order. A self-trade is read as its maker side, so it
+     * matches its maker order only.
+     */
+    orderId?: string;
     /**
      * Pagination cursor:
      * - Omitted or empty string (`""`): start a cursor walk from the newest row
@@ -321,7 +358,7 @@ export interface GetUserTradesParams {
      * is no page-number mode: a `page` param is rejected with a
      * `ValidationError` before the request is sent (the REST endpoint itself
      * answers `400`). An unfiltered response carries a bounded `total` (see
-     * `totalCapped`); one filtered by `tradingPairId` carries none.
+     * `totalCapped`); a filtered one carries none.
      */
     pageToken?: string;
 }

package/dist/sdk/index.d.ts

@@ -70,7 +70,8 @@ export interface SDKConfig {
      * client (e.g. `waitForTransactionReceipt` during vault deposits). Sei
      * produces sub-second blocks, so a value near the chain's block time
      * confirms transactions much sooner than viem's 4000ms default. Defaults to
-     * 750ms when omitted. Must be a positive finite number when provided.
+     * 200ms (about half a Sei block) when omitted. Must be a positive finite number when
+     * provided.
      */
     pollingInterval?: number;
     /**

package/dist/sweeper/index.d.ts

@@ -105,8 +105,108 @@ export interface GetSweeperChainsResponse {
     chains: SweeperChain[];
 }
 /**
- * Sweeper API interface. The register endpoint requires authentication;
- * the chain listing is public.
+ * Where a sweeper deposit is.
+ *
+ * - `RECEIVED` — indexed, not yet swept (a balance below the asset's minimum
+ *   waits for a later deposit).
+ * - `BURNED` — swept off its source chain; for a CCTP deposit, the burn is not
+ *   yet queued for attestation. Deposits bridged by a route other than CCTP
+ *   stay here.
+ * - `ATTESTING` — waiting for Circle's attestation.
+ * - `ATTESTED` — attested, not yet minted on the hub.
+ * - `SETTLING` — minted on the hub, being swept into the exchange.
+ * - `DEPOSITED` — credited to the exchange.
+ * - `FAILED` — the sweep returned the funds to the depositor's wallet (see
+ *   {@link SweeperDeposit.failureReason}).
+ *
+ * A deposit on the hub chain goes straight from `RECEIVED` to `DEPOSITED`.
+ */
+export type SweeperDepositStatus = "RECEIVED" | "BURNED" | "ATTESTING" | "ATTESTED" | "SETTLING" | "DEPOSITED" | "FAILED";
+/**
+ * One transfer into one of the caller's deposit addresses, and how far it has
+ * got. Amounts are raw base units of the source-chain token (decimal strings —
+ * they can exceed `Number.MAX_SAFE_INTEGER`); timestamps are RFC 3339 and
+ * record when the sweeper observed each step.
+ *
+ * Sweeps move balances rather than single transfers, so a sweep that collected
+ * several deposits is attributed to each of them first in, first out.
+ */
+export interface SweeperDeposit {
+    /** The deposit transaction's hash, lowercase */
+    txHash: string;
+    /** EVM chain id the deposit was made on, as listed by {@link SweeperAPI.getChains} */
+    sourceChainId: number;
+    /** The source chain's CCTP domain, once the deposit's CCTP burn is known; absent for hub deposits */
+    sourceDomain?: number | null;
+    /** The address the deposit is credited to (the caller's own), lowercase */
+    beneficiary: string;
+    /** Client id of the application the deposit address was registered under */
+    clientId: string;
+    /** The ledger the deposit address asks to be credited to */
+    depositTarget: "SPOT" | "MARGIN";
+    /** The deposited token's address on the source chain, lowercase */
+    token: string;
+    /** Amount deposited, raw base units of `token` */
+    amountRaw: string;
+    /**
+     * Amount credited to the exchange, once `DEPOSITED`. Absent when one CCTP
+     * burn carried several deposits (its fee cannot be split between them).
+     */
+    creditedAmountRaw?: string | null;
+    /**
+     * `amountRaw` minus `creditedAmountRaw`: Circle's fast-lane fee for a CCTP
+     * deposit, `"0"` on the hub. Absent whenever `creditedAmountRaw` is.
+     */
+    feeChargedRaw?: string | null;
+    /** The CCTP lane the burn requested, once the burn is known; absent for hub deposits */
+    transferType?: "FAST" | "STANDARD" | null;
+    /** Where the deposit is */
+    status: SweeperDepositStatus;
+    /** Why the deposit `FAILED`: `REFUNDED` — the exchange was paused, the user is blocked, or the token is not accepted */
+    failureReason?: "REFUNDED" | null;
+    /** The source-chain transaction that swept the deposit (the CCTP burn for a remote deposit) */
+    sweepTx?: string | null;
+    /** The hub transaction that deposited the funds into the exchange (the sweep itself for a hub deposit) */
+    settleTx?: string | null;
+    /** When Circle's attestation was first seen */
+    attestedAt?: string | null;
+    /** When the deposit was seen `DEPOSITED` */
+    settledAt?: string | null;
+    /** When the deposit was seen `FAILED` */
+    failedAt?: string | null;
+    /** When the sweeper indexed the deposit */
+    createdAt: string;
+    /** When the sweeper last observed progress on the deposit */
+    updatedAt: string;
+}
+/** The caller's sweeper deposits made by one transaction. */
+export interface GetSweeperDepositStatusResponse {
+    /**
+     * In chain then log order; empty until the sweeper has indexed the
+     * transaction (and for a transaction with no deposit of the caller's).
+     */
+    deposits: SweeperDeposit[];
+}
+/** Paging for {@link SweeperAPI.listDeposits}. */
+export interface ListSweeperDepositsParams {
+    /** Deposits per page, 1 to 100 (default 20). */
+    pageSize?: number;
+    /**
+     * The previous response's `nextPageToken`; omit (or pass `""`) to start
+     * from the newest deposit.
+     */
+    pageToken?: string;
+}
+/** One page of the caller's sweeper deposits. */
+export interface ListSweeperDepositsResponse {
+    /** This page, newest recorded first */
+    deposits: SweeperDeposit[];
+    /** Cursor for the next page; empty when this page is the last */
+    nextPageToken: string;
+}
+/**
+ * Sweeper API interface. Registration and deposit status require
+ * authentication; the chain listing is public.
  */
 export interface SweeperAPI extends BaseAPI {
     /**
@@ -140,4 +240,30 @@ export interface SweeperAPI extends BaseAPI {
      * changes only with operator configuration, so it is safe to cache briefly.
      */
     getChains(): Promise<GetSweeperChainsResponse>;
+    /**
+     * Where the caller's deposits made by one transaction are — look a deposit
+     * up by the hash of the transaction that sent funds to the caller's deposit
+     * address, on any supported chain, and poll until `DEPOSITED` (or
+     * `FAILED`).
+     *
+     * Authenticated: only deposits credited to the session's own address are
+     * returned. The list is empty until the sweeper has indexed the
+     * transaction, so an empty answer right after sending is expected.
+     *
+     * Throws on a malformed hash (before sending).
+     */
+    getDepositStatus(txHash: string): Promise<GetSweeperDepositStatusResponse>;
+    /**
+     * The caller's sweeper deposits, newest first, as the same
+     * {@link SweeperDeposit} entries {@link getDepositStatus} returns — a way to
+     * find a deposit whose transaction hash was lost. A swept CCTP deposit is
+     * listed once, by its source-chain transfer; a burn made straight to the
+     * hub deposit address is listed by its hub mint.
+     *
+     * Walk by cursor: omit `pageToken` to start, then pass each response's
+     * `nextPageToken` until it comes back empty. Authenticated: only the
+     * session's own deposits. Throws on an out-of-range `pageSize` (before
+     * sending).
+     */
+    listDeposits(params?: ListSweeperDepositsParams): Promise<ListSweeperDepositsResponse>;
 }

package/dist/trading/orders.d.ts

@@ -159,7 +159,7 @@ export interface Order {
      *
      * The snapshot frame alone does not close a reconnect gap: an order that
      * filled or was cancelled while the socket was down is in neither the
-     * resting snapshot nor the stream. Recover those explicitly — `listUserTrades`
+     * resting snapshot nor the stream. Recover those explicitly — `getUserTrades`
      * for fills, and a targeted `getOrder` for anything local state believes is
      * resting that the snapshot no longer lists.
      *

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

@@ -30,12 +30,14 @@ export declare const TransferCollateralSchema: z.ZodObject<{
             ISOLATED: "ISOLATED";
             CROSS: "CROSS";
         }>>;
+        idempotencyKey: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>;
 }, z.core.$strip>;
 export declare const TransferCollateralToParentMarginAccountSchema: z.ZodObject<{
     request: z.ZodObject<{
         asset: z.ZodString;
         amount: z.ZodString;
+        idempotencyKey: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>;
 }, z.core.$strip>;
 export declare const TransferCollateralToRiskBucketSchema: z.ZodObject<{
@@ -48,6 +50,7 @@ export declare const TransferCollateralToRiskBucketSchema: z.ZodObject<{
     }, z.core.$loose>, z.ZodUnion<readonly [z.ZodObject<{
         asset: z.ZodString;
         amount: z.ZodString;
+        idempotencyKey: z.ZodOptional<z.ZodString>;
         tradingPairId: z.ZodUUID;
         strategyKey: z.ZodOptional<z.ZodString>;
         marginMode: z.ZodOptional<z.ZodLiteral<"ISOLATED">>;
@@ -57,6 +60,7 @@ export declare const TransferCollateralToRiskBucketSchema: z.ZodObject<{
     }, z.core.$strict>, z.ZodObject<{
         asset: z.ZodString;
         amount: z.ZodString;
+        idempotencyKey: z.ZodOptional<z.ZodString>;
         marginMode: z.ZodLiteral<"CROSS">;
         marginAccountId: z.ZodOptional<z.ZodUUID>;
         selectedTradingPairIds: z.ZodOptional<z.ZodNever>;
@@ -68,6 +72,7 @@ export declare const TransferCollateralFromParentMarginAccountSchema: z.ZodObjec
     request: z.ZodObject<{
         asset: z.ZodString;
         amount: z.ZodString;
+        idempotencyKey: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>;
 }, z.core.$strip>;
 export declare const GetMarginAccountMovementsSchema: z.ZodObject<{
@@ -200,6 +205,7 @@ export declare const CloseMarginSubAccountSchema: z.ZodObject<{
 export declare const SubAccountCollateralTransferSchema: z.ZodObject<{
     marginAccountId: z.ZodUUID;
     amount: z.ZodString;
+    idempotencyKey: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 export declare const GetMarginAccountPnlSchema: z.ZodObject<{
     marginAccountId: z.ZodUUID;
@@ -220,5 +226,6 @@ export declare const TransferMarginCollateralSchema: z.ZodObject<{
             marginAccountId: z.ZodUUID;
             riskBucketId: z.ZodOptional<z.ZodUUID>;
         }, z.core.$strict>]>;
+        idempotencyKey: z.ZodOptional<z.ZodString>;
     }, z.core.$strict>;
 }, z.core.$strip>;

package/dist/validation/margin-accounts.js

@@ -2,7 +2,7 @@
  * Margin Account API Validation Schemas
  */
 import { z } from "zod";
-import { MarketSlippageToleranceBpsSchema, OrderSideSchema, OrderTypeSchema, PositionSideSchema, PositiveDecimalStringSchema, UUIDSchema } from "./trading";
+import { MarketSlippageToleranceBpsSchema, OrderIdempotencyKeySchema, OrderSideSchema, OrderTypeSchema, PositionSideSchema, PositiveDecimalStringSchema, UUIDSchema, } from "./trading";
 const CursorPaginationSchema = z.object({
     /**
      * Rejected, not ignored. A non-strict object would let a JS or `any` caller
@@ -41,6 +41,7 @@ const TransferCollateralRequestSchema = z
     // A cross risk bucket has no trading pair, so CROSS is the only way to name
     // one on the way out (0XM-2420). The two never combine.
     marginMode: z.enum(["ISOLATED", "CROSS"]).optional(),
+    idempotencyKey: OrderIdempotencyKeySchema.optional(),
 })
     .refine((request) => !(request.marginMode === "CROSS" && request.tradingPairId !== undefined), {
     message: "tradingPairId is not supported for CROSS risk buckets",
@@ -49,6 +50,7 @@ const TransferCollateralRequestSchema = z
 const ParentMarginAccountCollateralRequestSchema = z.object({
     asset: z.string().trim().min(1, "Asset cannot be empty"),
     amount: PositiveDecimalStringSchema,
+    idempotencyKey: OrderIdempotencyKeySchema.optional(),
 });
 const RiskBucketRequestSchema = z.object({
     tradingPairId: UUIDSchema,
@@ -256,6 +258,7 @@ export const CloseMarginSubAccountSchema = z.object({
 export const SubAccountCollateralTransferSchema = z.object({
     marginAccountId: UUIDSchema,
     amount: PositiveDecimalStringSchema,
+    idempotencyKey: OrderIdempotencyKeySchema.optional(),
 });
 export const GetMarginAccountPnlSchema = z.object({
     marginAccountId: UUIDSchema,
@@ -271,6 +274,7 @@ export const TransferMarginCollateralSchema = z.object({
         amount: PositiveDecimalStringSchema,
         from: CollateralTransferEndpointSchema,
         to: CollateralTransferEndpointSchema,
+        idempotencyKey: OrderIdempotencyKeySchema.optional(),
     })
         .strict(),
 });

package/dist/validation/profile.d.ts

@@ -84,6 +84,8 @@ export declare const GetUserTradesSchema: z.ZodObject<{
     page: z.ZodOptional<z.ZodNever>;
     pageSize: z.ZodOptional<z.ZodNumber>;
     tradingPairId: z.ZodOptional<z.ZodUUID>;
+    marginAccountId: z.ZodOptional<z.ZodUUID>;
+    orderId: z.ZodOptional<z.ZodUUID>;
     pageToken: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 /**

package/dist/validation/profile.js

@@ -63,6 +63,8 @@ export const GetUserTradesSchema = z.object({
     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(),
+    marginAccountId: UUIDSchema.optional(),
+    orderId: UUIDSchema.optional(),
     pageToken: z.string().optional(),
 });
 /**