@0xmonaco/types 1.0.25 → 1.0.26-develop.aeb6d5b

package/dist/faucet/index.d.ts

@@ -47,6 +47,51 @@ export interface MintTokensResponse {
     /** Remaining faucet requests in the next 24h */
     remainingRequests24h: number;
 }
+/** One token minted by a past faucet request. */
+export interface FaucetMintRecord {
+    /** Asset UUID */
+    assetId: string;
+    /** Token symbol */
+    symbol: string;
+    /** Amount minted in token units */
+    amount: string;
+    /**
+     * On-chain transaction hash; absent when the transaction was submitted but
+     * never confirmed
+     */
+    txHash?: string;
+}
+/**
+ * Past faucet mints grouped by clock minute for display. A group can span
+ * several endpoint calls made in the same minute; the daily quota counts
+ * each call individually.
+ */
+export interface FaucetRequestRecord {
+    /**
+     * Timestamp (ISO 8601) of the request, truncated to the minute (display
+     * grouping; the daily quota counts every call)
+     */
+    requestedAt: string;
+    /** Tokens minted in the group, oldest first */
+    minted: FaucetMintRecord[];
+}
+/** Result of a faucet info request. */
+export interface GetFaucetInfoResponse {
+    /** Remaining faucet requests in the rolling 24h window */
+    remainingRequests24h: number;
+    /** Maximum faucet requests per rolling 24h window */
+    dailyLimit: number;
+    /**
+     * Timestamp (ISO 8601) safe to retry at or after: when the wallet's next
+     * faucet slot frees under the current daily limit, with a small safety
+     * margin. When remainingRequests24h is 0 this is when the next mint
+     * becomes possible. Absent when no requests are in the rolling 24h window
+     * or when the daily limit is 0. Not a calendar-day reset.
+     */
+    nextAvailableAt?: string;
+    /** Up to 5 most recent faucet requests, newest first */
+    recentRequests: FaucetRequestRecord[];
+}
 /**
  * Faucet API interface. Session-authenticated.
  */
@@ -68,4 +113,14 @@ export interface FaucetAPI extends BaseAPI {
      * @returns Promise resolving to the minted tokens and remaining quota
      */
     mint(params: MintTokensParams): Promise<MintTokensResponse>;
+    /**
+     * Fetches the authenticated wallet's faucet quota and recent requests.
+     *
+     * Read-only: remaining requests in the rolling 24h window, when the next
+     * request becomes available, and the 5 most recent requests. Wallet-scoped
+     * across apps, matching mint enforcement.
+     *
+     * @returns Promise resolving to the quota and recent-request history
+     */
+    getInfo(): Promise<GetFaucetInfoResponse>;
 }

package/dist/index.d.ts

@@ -17,6 +17,7 @@ export * from "./pitpass";
 export * from "./portfolio";
 export * from "./positions";
 export * from "./profile";
+export * from "./pulse";
 export * from "./sdk";
 export * from "./sub-accounts";
 export * from "./trading";

package/dist/index.js

@@ -18,6 +18,7 @@ export * from "./pitpass";
 export * from "./portfolio";
 export * from "./positions";
 export * from "./profile";
+export * from "./pulse";
 export * from "./sdk";
 export * from "./sub-accounts";
 export * from "./trading";

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

@@ -114,11 +114,13 @@ export interface GetMarginAccountMovementsResponse {
 export interface SimulateOrderRiskRequest {
     tradingPairId: string;
     side: OrderSide;
-    positionSide: PositionSide;
+    /** @deprecated `side` is authoritative; when present BUY=LONG and SELL=SHORT. */
+    positionSide?: PositionSide;
     orderType: OrderType;
     price?: string;
     quantity: string;
-    leverage: string;
+    /** Required for normal orders; optional and ignored for reduce-only. */
+    leverage?: string;
     reduceOnly?: boolean;
 }
 export type SimulateIsolatedRiskBucketOrderRiskRequest = SimulateOrderRiskRequest & {

package/dist/market/index.d.ts

@@ -213,6 +213,17 @@ export interface ScreenerItem {
     totalQuoteVolumeLtd: string;
     /** Life-to-date cumulative number of trades since inception (0 if no trades yet) */
     totalTradeCountLtd: number;
+    /**
+     * Latest settled funding rate as a decimal fraction per funding window (the
+     * capped settled value); null for spot pairs and margin pairs with no
+     * settled funding window yet
+     */
+    latestFundingRate: string | null;
+    /**
+     * Close time of the latest settled funding window (ms since epoch, as string);
+     * null for spot pairs and margin pairs with no settled funding window yet
+     */
+    lastFundingTime: string | null;
 }
 /**
  * Paginated screener response, sorted by quoteVolume24h desc (nulls last)
@@ -273,11 +284,12 @@ export interface MarketStats {
     totalTradeCountLtd: number;
 }
 export interface RiskTier {
-    notional_floor: string;
-    notional_cap?: string;
     initialMarginRatio: string;
     maintenanceMarginRatio: string;
-    maxLeverage: string;
+    /** Maximum authoritative absolute base-asset quantity. */
+    maxPositionSize?: string;
+    /** @deprecated This legacy alias is base quantity, not notional. */
+    maxPositionNotional?: string;
 }
 export interface PerpMarketConfig {
     tradingPairId: string;
@@ -343,12 +355,16 @@ export interface FundingRecord {
     tradingPairId: string;
     fundingRate: string;
     cumulativeFundingPerUnit?: string;
+    /** True when the window settled at the carried last rate (sparse-sample rule). */
+    carried?: boolean;
 }
 export interface ListFundingHistoryParams {
     startTime?: string;
     endTime?: string;
     page?: number;
     pageSize?: number;
+    /** Sort direction for epoch: "ASC" or "DESC" (default DESC). */
+    orderBy?: "ASC" | "DESC";
 }
 export interface ListFundingHistoryResponse {
     records: FundingRecord[];
@@ -356,6 +372,20 @@ export interface ListFundingHistoryResponse {
     page: number;
     pageSize: number;
 }
+export interface ListAllFundingHistoryParams {
+    startTime?: string;
+    endTime?: string;
+    page?: number;
+    pageSize?: number;
+    /** Sort direction for settledAt (default DESC). */
+    orderBy?: "ASC" | "DESC";
+}
+export interface ListAllFundingHistoryResponse {
+    records: FundingRecord[];
+    total: number;
+    page: number;
+    pageSize: number;
+}
 export interface OpenInterest {
     tradingPairId: string;
     openInterest?: string;
@@ -430,5 +460,14 @@ export interface MarketAPI extends BaseAPI {
     getIndexPrice(tradingPairId: string): Promise<IndexPrice>;
     getFundingState(tradingPairId: string): Promise<FundingState>;
     listFundingHistory(tradingPairId: string, params?: ListFundingHistoryParams): Promise<ListFundingHistoryResponse>;
+    /**
+     * Fetch settled funding history across every market in one call, so clients
+     * don't have to fan out one listFundingHistory request per trading pair.
+     * Each record carries its tradingPairId; sorted by settledAt (default DESC).
+     * @param params - Optional time bounds (ms-epoch strings, inclusive on
+     *   settledAt), pagination, and orderBy (ASC or DESC)
+     * @returns Promise resolving to the paginated all-markets funding history
+     */
+    listAllFundingHistory(params?: ListAllFundingHistoryParams): Promise<ListAllFundingHistoryResponse>;
     getOpenInterest(tradingPairId: string): Promise<OpenInterest>;
 }

package/dist/portfolio/index.d.ts

@@ -77,10 +77,17 @@ export interface PortfolioRealizedTotals {
     netRealizedPnl: string;
 }
 export interface PortfolioClosedTradeStats {
+    /** Fill-based: closing fills in the window (partial fills each counted). */
     count: number;
+    /**
+     * Position-level: each position (one flat -> open -> flat round-trip) is
+     * classified once by its net realized PnL after all fees.
+     */
     winners: number;
     losers: number;
     breakEven: number;
+    /** Total classified positions (= winners + losers + breakEven). */
+    positions: number;
     winRatePct?: string;
 }
 export interface PortfolioBestDay {

package/dist/positions/index.d.ts

@@ -10,12 +10,23 @@ export interface Position {
     marginMode?: MarginMode;
     tradingPairId: string;
     side: PositionSide;
+    /**
+     * Open rows: current absolute position quantity. Terminal rows
+     * (CLOSED/LIQUIDATED/EXPIRED): total quantity closed over the position's
+     * life, summed from its reducing executions when available.
+     */
     size: string;
     entryPrice: string;
     markPrice: string;
     indexPrice?: string;
     unrealizedPnl: string;
     realizedPnl: string;
+    /**
+     * Open rows: current isolated collateral for this position's risk bucket.
+     * Terminal rows: total initial margin allocated across the position's
+     * reducing executions when available — the margin basis for lifetime
+     * realized return.
+     */
     isolatedMargin: string;
     leverage?: string;
     /**
@@ -39,6 +50,16 @@ export interface Position {
     liquidationPrice: string;
     status: PositionStatus;
     updatedAt: string;
+    /**
+     * Lifetime realized PnL net of trading fees and funding. Terminal rows
+     * only; absent when the position's reducing executions are unavailable.
+     */
+    netRealizedPnl?: string;
+    /**
+     * Lifetime realized return on the total allocated initial margin, as a
+     * percentage. Terminal rows only; absent when unavailable.
+     */
+    realizedRoe?: string;
 }
 export interface ListPositionsParams {
     marginAccountId?: string;
@@ -133,6 +154,8 @@ export interface TpSlLeg {
     orderType: OrderType;
     limitPrice?: string;
     quantity?: string;
+    /** Resolve the full live position size when triggered. */
+    closePosition?: boolean;
     timeInForce?: Extract<TimeInForce, "GTC" | "IOC">;
     slippageToleranceBps?: number;
     expiresAt?: string;
@@ -140,6 +163,8 @@ export interface TpSlLeg {
 export interface AttachPositionTpSlRequest {
     takeProfit?: TpSlLeg;
     stopLoss?: TpSlLeg;
+    /** Cancel the sibling after one leg triggers. Requires both legs. */
+    oco?: boolean;
 }
 export interface AttachPositionTpSlResponse {
     positionId: string;

package/dist/profile/index.d.ts

@@ -237,6 +237,23 @@ export interface GetUserTradesParams {
     pageSize?: number;
     /** Filter by trading pair ID (UUID) */
     tradingPairId?: string;
+    /**
+     * Pagination cursor with three distinct states:
+     * - Omitted (`undefined`): legacy page-number pagination via `page`,
+     *   limited to recent history once the archive window is enabled.
+     * - Empty string (`""`): start a cursor walk with no prior position, from
+     *   the newest row (this endpoint always sorts newest-first).
+     * - Non-empty: an opaque cursor from a previous response's
+     *   `nextPageToken`; results resume immediately after that position.
+     *
+     * In either cursor-walk state (empty or non-empty), `page` is ignored, the
+     * response omits exact totals (`total`/`totalPages`/`page` are 0), and
+     * results cover full trade history — hot and archived rows merged —
+     * unlike page-number mode, which only ever sees recent history. Clients
+     * that need complete trade history must use the cursor form (pass `""` to
+     * start, then follow `nextPageToken`) rather than `page`.
+     */
+    pageToken?: string;
 }
 /**
  * Response from getting user trades
@@ -252,6 +269,21 @@ export interface GetUserTradesResponse {
     total: number;
     /** Total number of pages */
     totalPages: number;
+    /**
+     * Cursor for the next page. Empty on every page-number (legacy) response —
+     * page-number mode never mints a token, full page or not, since resuming
+     * from a legacy-minted position could silently strand archived history
+     * newer than wherever that page happened to end.
+     *
+     * To walk full history, start a cursor-mode request with `pageToken`
+     * present but empty (`""`); from then on the token is present whenever
+     * that page returned any rows (AIP-158 "maybe more" semantics), not only
+     * when the page is exactly full. Empty only when a cursor-mode page
+     * returned zero rows, which is the sole proof the walk is exhausted. The
+     * two modes never bridge — page-number pagination is deprecated for deep
+     * history.
+     */
+    nextPageToken: string;
 }
 /**
  * Direction of a funding payment from the user's perspective.
@@ -395,7 +427,12 @@ export interface PortfolioStats {
     totalTrades: number;
     /** Total fees paid */
     feesPaid: string;
-    /** Ratio of profitable trades to total trades. Null when there are no closed trades in the period. */
+    /**
+     * Position-level win rate: winning positions over winning + losing positions
+     * (break-even excluded). Each position (one flat→open→flat round-trip) is
+     * classified once by its net realized PnL after all fees, not per fill. Null
+     * when the period has no closed positions.
+     */
     winLossRatio: number | null;
     /** Total equity in USDC terms (spot balances plus perps account equity) */
     totalEquity: string;

package/dist/pulse/index.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Pulse Types
+ *
+ * Types for the public market-pulse news feed: AI-synthesized, per-asset
+ * headlines served from the backend's hourly-refreshed cache.
+ *
+ * NOTE: This endpoint is **public (unauthenticated)** and ETag-cacheable.
+ * It returns 503 while the backend cache is cold.
+ */
+import type { BaseAPI } from "../api";
+/** Provenance for one pulse item, for attribution links. */
+export interface PulseSource {
+    /** Source article or post URL. */
+    url: string;
+    /** Source author or publication name. */
+    author: string;
+    /** Source channel: "twitter" or "news". */
+    source: string;
+    /** Source publication time, ISO-8601. */
+    createdAt: string;
+    /** Relevance score, 1 (low) to 5 (high). */
+    relevance: number;
+}
+/** One synthesized market-pulse headline. */
+export interface PulseItem {
+    /** Watchlist ticker (e.g. "BTC") or "MARKET" for a cross-asset story. */
+    asset: string;
+    /** Sentiment tag: "Bullish", "Neutral", or "Bearish". */
+    sentiment: string;
+    /** Synthesized 1-2 sentence summary (at most 240 characters). */
+    summary: string;
+    /** Timestamp of the most recent source; render relative time client-side. */
+    updatedAt: string;
+    /** Provenance for the item. */
+    sources: PulseSource[];
+}
+/** The latest pulse snapshot. */
+export interface GetPulseResponse {
+    /** When this snapshot was produced upstream (ISO-8601 UTC); also the ETag value. */
+    generatedAt: string;
+    /** Asset universe the snapshot was synthesized against. */
+    watchlist: string[];
+    /** Pulse items, pre-sorted (watchlist order, MARKET last, newest first per asset). */
+    items: PulseItem[];
+}
+/**
+ * Pulse API interface. The endpoint is public (no auth required).
+ */
+export interface PulseAPI extends BaseAPI {
+    /**
+     * Get the latest market pulse news feed snapshot.
+     *
+     * Public/unauthenticated; served from the backend cache (refreshed hourly).
+     * Items whose figures could not be verified upstream are removed
+     * server-side before caching.
+     *
+     * @returns Promise resolving to the latest snapshot
+     * @throws 503 while the backend cache is cold
+     */
+    getPulse(): Promise<GetPulseResponse>;
+}

package/dist/pulse/index.js

@@ -0,0 +1,9 @@
+/**
+ * Pulse Types
+ *
+ * Types for the public market-pulse news feed: AI-synthesized, per-asset
+ * headlines served from the backend's hourly-refreshed cache.
+ *
+ * NOTE: This endpoint is **public (unauthenticated)** and ETag-cacheable.
+ * It returns 503 while the backend cache is cold.
+ */

package/dist/sdk/index.d.ts

@@ -10,6 +10,7 @@ import type { PitpassAPI } from "../pitpass";
 import type { PortfolioAPI } from "../portfolio";
 import type { PositionsAPI } from "../positions";
 import type { ProfileAPI } from "../profile";
+import type { PulseAPI } from "../pulse";
 import type { SubAccountsAPI } from "../sub-accounts";
 import type { TradingAPI, TradingMode } from "../trading";
 import type { VaultAPI } from "../vault";
@@ -56,6 +57,14 @@ export interface SDKConfig {
      * (e.g. Docker DNS `ws://ws-api:8080/ws`). Must be a valid absolute URL.
      */
     wsUrl?: string;
+    /**
+     * Polling frequency in milliseconds for the SDK's internal viem public
+     * 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.
+     */
+    pollingInterval?: number;
 }
 /**
  * Core SDK interface providing access to all Monaco functionality.
@@ -93,6 +102,8 @@ export interface MonacoSDK {
     whitelist: WhitelistAPI;
     /** Profile operations API */
     profile: ProfileAPI;
+    /** Public market-pulse news feed API (cached, hourly-refreshed) */
+    pulse: PulseAPI;
     /** Orderbook REST API for fetching orderbook snapshots */
     orderbook: {
         getOrderbook: (tradingPairId: string, options?: {

package/dist/trading/index.d.ts

@@ -34,6 +34,7 @@ export interface TradingAPI extends BaseAPI {
         riskBucketId?: string;
         riskBucketCollateral?: string;
         strategyKey?: string;
+        /** @deprecated Order side is authoritative. */
         positionSide?: PositionSide;
         leverage?: string;
         reduceOnly?: boolean;
@@ -58,6 +59,7 @@ export interface TradingAPI extends BaseAPI {
         riskBucketId?: string;
         riskBucketCollateral?: string;
         strategyKey?: string;
+        /** @deprecated Order side is authoritative. */
         positionSide?: PositionSide;
         leverage?: string;
         reduceOnly?: boolean;
@@ -140,6 +142,6 @@ export interface TradingAPI extends BaseAPI {
      */
     getOrder(orderId: string): Promise<GetOrderResponse>;
 }
-export type { ConditionalOrderConditionType, ConditionalOrderState, ConditionalOrderTriggerSource, Order, OrderRole, OrderSide, OrderStatus, OrderType, PositionSide, TimeInForce, TradingMode, } from "./orders";
+export type { ConditionalOrderConditionType, ConditionalOrderState, ConditionalOrderTriggerSource, Order, OrderRole, OrderSide, OrderStatus, OrderTerminalReason, OrderType, PositionSide, TimeInForce, TradingMode, } from "./orders";
 export { ORDER_STATUS_VALUES } from "./orders";
 export type { BatchCancelError, BatchCancelOrdersResponse, BatchCancelResult, BatchCreateOrderParams, BatchCreateOrdersResponse, BatchCreateResult, BatchError, BatchReplaceOrderParams, BatchReplaceOrdersResponse, BatchReplaceResult, CancelConditionalOrderResponse, CancelOrderResponse, ConditionalOrder, CreateOrderResponse, GetOrderResponse, GetPaginatedOrdersParams, GetPaginatedOrdersResponse, ListConditionalOrdersParams, ListConditionalOrdersResponse, MatchResult, ParentTpSlLegParams, ReplaceOrderResponse, UpdatedFields, } from "./responses";

package/dist/trading/orders.d.ts

@@ -70,7 +70,11 @@ export interface Order {
     reduceOnly?: boolean;
     /** Position ID linked to the order, when available */
     positionId?: string;
+    /** Stable cause when status is CANCELLED */
+    terminalReason?: OrderTerminalReason;
 }
+/** Stable terminal causes for accepted orders that end as CANCELLED. */
+export type OrderTerminalReason = "USER_REQUESTED" | "REPLACED" | "LIQUIDATION" | "INSUFFICIENT_MARGIN" | "REDUCE_ONLY_EXHAUSTED" | "POSITION_CLOSED" | "OCO_SIBLING_TRIGGERED" | "SYSTEM";
 /**
  * Role of the creator or order
  */

package/dist/trading/responses.d.ts

@@ -38,8 +38,6 @@ export interface MatchResult {
     } | null;
 }
 /**
- * Parent TP/SL leg attached to a normal margin order.
- *
  * Parent TP/SL follows the parent order quantity and becomes active once the
  * parent order creates or extends a position.
  */
@@ -139,6 +137,23 @@ export interface GetPaginatedOrdersParams {
     page?: number;
     /** Number of orders per page (default: 10, max: 100) */
     pageSize?: number;
+    /**
+     * Pagination cursor with three distinct states:
+     * - Omitted (`undefined`): legacy page-number pagination via `page`,
+     *   limited to recent history once the archive window is enabled.
+     * - Empty string (`""`): start a cursor walk with no prior position, from
+     *   the newest row (or the oldest, when `orderBy` is `"ASC"`).
+     * - Non-empty: an opaque cursor from a previous response's
+     *   `nextPageToken`; results resume immediately after that position.
+     *
+     * In either cursor-walk state (empty or non-empty), `page` is ignored, the
+     * response omits exact totals (`total`/`totalPages`/`page` are 0), and
+     * results cover full order history — hot and archived rows merged —
+     * unlike page-number mode, which only ever sees recent history. Clients
+     * that need complete order history must use the cursor form (pass `""` to
+     * start, then follow `nextPageToken`) rather than `page`.
+     */
+    pageToken?: string;
 }
 /**
  * Response from getting paginated orders
@@ -159,6 +174,21 @@ export interface GetPaginatedOrdersResponse {
     pageSize: number;
     /** Total number of pages */
     totalPages: number;
+    /**
+     * Cursor for the next page. Empty on every page-number (legacy) response —
+     * page-number mode never mints a token, full page or not, since resuming
+     * from a legacy-minted position could silently strand archived history
+     * newer than wherever that page happened to end.
+     *
+     * To walk full history, start a cursor-mode request with `pageToken`
+     * present but empty (`""`); from then on the token is present whenever
+     * that page returned any rows (AIP-158 "maybe more" semantics), not only
+     * when the page is exactly full. Empty only when a cursor-mode page
+     * returned zero rows, which is the sole proof the walk is exhausted. The
+     * two modes never bridge — page-number pagination is deprecated for deep
+     * history.
+     */
+    nextPageToken: string;
 }
 /**
  * Response from getting a single order by ID

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

@@ -75,18 +75,18 @@ export declare const SimulateOrderRiskSchema: z.ZodObject<{
             BUY: "BUY";
             SELL: "SELL";
         }>;
-        positionSide: z.ZodEnum<{
+        positionSide: z.ZodOptional<z.ZodEnum<{
             LONG: "LONG";
             SHORT: "SHORT";
             NONE: "NONE";
-        }>;
+        }>>;
         orderType: z.ZodEnum<{
             LIMIT: "LIMIT";
             MARKET: "MARKET";
         }>;
         price: z.ZodOptional<z.ZodString>;
         quantity: z.ZodString;
-        leverage: z.ZodString;
+        leverage: z.ZodOptional<z.ZodString>;
         reduceOnly: z.ZodOptional<z.ZodBoolean>;
     }, z.core.$strict>;
 }, z.core.$strip>;
@@ -97,18 +97,18 @@ export declare const SimulateParentMarginOrderRiskSchema: z.ZodObject<{
             BUY: "BUY";
             SELL: "SELL";
         }>;
-        positionSide: z.ZodEnum<{
+        positionSide: z.ZodOptional<z.ZodEnum<{
             LONG: "LONG";
             SHORT: "SHORT";
             NONE: "NONE";
-        }>;
+        }>>;
         orderType: z.ZodEnum<{
             LIMIT: "LIMIT";
             MARKET: "MARKET";
         }>;
         price: z.ZodOptional<z.ZodString>;
         quantity: z.ZodString;
-        leverage: z.ZodString;
+        leverage: z.ZodOptional<z.ZodString>;
         reduceOnly: z.ZodOptional<z.ZodBoolean>;
     }, z.core.$strict>;
 }, z.core.$strip>;
@@ -118,18 +118,18 @@ export declare const SimulateRiskBucketOrderRiskSchema: z.ZodObject<{
             BUY: "BUY";
             SELL: "SELL";
         }>;
-        positionSide: z.ZodEnum<{
+        positionSide: z.ZodOptional<z.ZodEnum<{
             LONG: "LONG";
             SHORT: "SHORT";
             NONE: "NONE";
-        }>;
+        }>>;
         orderType: z.ZodEnum<{
             LIMIT: "LIMIT";
             MARKET: "MARKET";
         }>;
         price: z.ZodOptional<z.ZodString>;
         quantity: z.ZodString;
-        leverage: z.ZodString;
+        leverage: z.ZodOptional<z.ZodString>;
         reduceOnly: z.ZodOptional<z.ZodBoolean>;
         tradingPairId: z.ZodUUID;
         strategyKey: z.ZodOptional<z.ZodString>;
@@ -141,18 +141,18 @@ export declare const SimulateRiskBucketOrderRiskSchema: z.ZodObject<{
             BUY: "BUY";
             SELL: "SELL";
         }>;
-        positionSide: z.ZodEnum<{
+        positionSide: z.ZodOptional<z.ZodEnum<{
             LONG: "LONG";
             SHORT: "SHORT";
             NONE: "NONE";
-        }>;
+        }>>;
         orderType: z.ZodEnum<{
             LIMIT: "LIMIT";
             MARKET: "MARKET";
         }>;
         price: z.ZodOptional<z.ZodString>;
         quantity: z.ZodString;
-        leverage: z.ZodString;
+        leverage: z.ZodOptional<z.ZodString>;
         reduceOnly: z.ZodOptional<z.ZodBoolean>;
         marginMode: z.ZodLiteral<"CROSS">;
         selectedTradingPairIds: z.ZodArray<z.ZodUUID>;

package/dist/validation/margin-accounts.js

@@ -78,17 +78,39 @@ export const GetParentMarginAccountMovementsSchema = PaginationSchema.extend({
 const BaseSimulateOrderRiskRequestSchema = z.object({
     tradingPairId: UUIDSchema,
     side: OrderSideSchema,
-    positionSide: PositionSideSchema,
+    positionSide: PositionSideSchema.optional(),
     orderType: OrderTypeSchema,
     price: PositiveDecimalStringSchema.optional(),
     quantity: PositiveDecimalStringSchema,
-    leverage: PositiveDecimalStringSchema,
+    leverage: PositiveDecimalStringSchema.optional(),
     reduceOnly: z.boolean().optional(),
 });
-const SimulateOrderRiskRequestSchema = BaseSimulateOrderRiskRequestSchema.strict();
-const SimulateIsolatedRiskBucketOrderRiskRequestSchema = BaseSimulateOrderRiskRequestSchema.merge(IsolatedRiskBucketRequestSchema).strict();
+const validateOneWaySimulationFields = (data, ctx) => {
+    if (data.positionSide !== undefined) {
+        const expected = data.side === "BUY" ? "LONG" : "SHORT";
+        if (data.positionSide !== expected) {
+            ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                message: "positionSide must match side when provided (BUY=LONG, SELL=SHORT)",
+                path: ["positionSide"],
+            });
+        }
+    }
+    if (data.reduceOnly !== true && data.leverage === undefined) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: "leverage is required for normal margin orders",
+            path: ["leverage"],
+        });
+    }
+};
+const SimulateOrderRiskRequestSchema = BaseSimulateOrderRiskRequestSchema.strict().superRefine(validateOneWaySimulationFields);
+const SimulateIsolatedRiskBucketOrderRiskRequestSchema = BaseSimulateOrderRiskRequestSchema.merge(IsolatedRiskBucketRequestSchema)
+    .strict()
+    .superRefine(validateOneWaySimulationFields);
 const SimulateCrossRiskBucketOrderRiskRequestSchema = BaseSimulateOrderRiskRequestSchema.merge(CrossRiskBucketScopeSchema)
     .strict()
+    .superRefine(validateOneWaySimulationFields)
     .refine((data) => data.selectedTradingPairIds.includes(data.tradingPairId), {
     message: "tradingPairId must be included in selectedTradingPairIds for CROSS risk buckets",
     path: ["selectedTradingPairIds"],