@0xmonaco/types 0.6.3 → 0.7.0

package/dist/trading/responses.d.ts

@@ -3,7 +3,7 @@
  *
  * Response types for trading operations.
  */
-import type { Order, OrderSide, OrderStatus, OrderType, TimeInForce, TradingMode } from "./orders";
+import type { ConditionalOrderConditionType, ConditionalOrderState, ConditionalOrderTriggerSource, Order, OrderSide, OrderStatus, OrderType, PositionSide, TimeInForce, TradingMode } from "./orders";
 /**
  * Match result information for order execution.
  * Contains detailed information about trades, fills, and execution quality.
@@ -97,7 +97,11 @@ export interface GetPaginatedOrdersParams {
     /** Filter by order status */
     status?: OrderStatus;
     /** Filter by trading pair UUID */
-    trading_pair?: string;
+    trading_pair_id?: string;
+    /** Filter by trading mode */
+    trading_mode?: TradingMode;
+    /** Filter by margin account UUID */
+    margin_account_id?: string;
     /** Page number for pagination (default: 1) */
     page?: number;
     /** Number of orders per page (default: 10, max: 100) */
@@ -147,8 +151,6 @@ export interface BatchCancelError {
 export interface BatchCancelResult {
     /** Order identifier */
     order_id: string;
-    /** Whether the cancellation was successful */
-    success: boolean;
     /** Timestamp when the order was canceled (ISO 8601 format) */
     cancelled_at?: string;
     /** Error details if the cancellation failed */
@@ -158,8 +160,6 @@ export interface BatchCancelResult {
  * Response from batch cancelling orders
  */
 export interface BatchCancelOrdersResponse {
-    /** Overall operation success */
-    success: boolean;
     /** Total number of orders requested to cancel */
     total_requested: number;
     /** Total number of orders successfully canceled */
@@ -184,8 +184,6 @@ export interface BatchError {
 export interface BatchCreateResult {
     /** Order identifier (empty string if creation failed before ID assignment) */
     order_id: string;
-    /** Whether the order was successfully created */
-    success: boolean;
     /** Match result information if the order was processed */
     match_result?: MatchResult;
     /** Error details if the creation failed */
@@ -195,8 +193,6 @@ export interface BatchCreateResult {
  * Response from batch creating orders
  */
 export interface BatchCreateOrdersResponse {
-    /** Overall operation success */
-    success: boolean;
     /** Total number of orders requested to create */
     total_requested: number;
     /** Total number of orders successfully created */
@@ -212,8 +208,6 @@ export interface BatchCreateOrdersResponse {
 export interface BatchReplaceResult {
     /** Original order identifier */
     original_order_id: string;
-    /** Whether the order was successfully replaced */
-    success: boolean;
     /** New order identifier (if successful) */
     new_order_id?: string;
     /** Fields that were updated (if successful) */
@@ -227,8 +221,6 @@ export interface BatchReplaceResult {
  * Response from batch replacing orders
  */
 export interface BatchReplaceOrdersResponse {
-    /** Overall operation success */
-    success: boolean;
     /** Total number of orders requested to replace */
     total_requested: number;
     /** Total number of orders successfully replaced */
@@ -253,7 +245,7 @@ export interface BatchCreateOrderParams {
     /** Order quantity */
     quantity: string;
     /** Trading mode (defaults to "SPOT") */
-    tradingMode?: Extract<TradingMode, "SPOT">;
+    tradingMode?: TradingMode;
     /** Maximum slippage for market orders as decimal (e.g., 0.01 for 1%) */
     slippageTolerance?: number;
     /** For sub-accounts: use master's balance */
@@ -262,6 +254,14 @@ export interface BatchCreateOrderParams {
     expirationDate?: string;
     /** Time in force: "GTC", "IOC", or "FOK" */
     timeInForce?: Extract<TimeInForce, "GTC" | "IOC" | "FOK">;
+    /** Margin account UUID for margin/perp orders */
+    marginAccountId?: string;
+    /** Position side for margin/perp orders */
+    positionSide?: PositionSide;
+    /** Leverage for margin/perp orders */
+    leverage?: string;
+    /** Whether the order can only reduce existing exposure */
+    reduceOnly?: boolean;
 }
 /**
  * Parameters for a single order in a batch replace request
@@ -276,3 +276,72 @@ export interface BatchReplaceOrderParams {
     /** For sub-accounts: use master's balance (optional) */
     useMasterBalance?: boolean;
 }
+/**
+ * Parameters for creating a standalone conditional TP/SL order.
+ */
+export interface CreateConditionalOrderParams {
+    tradingPairId: string;
+    marginAccountId: string;
+    conditionType: ConditionalOrderConditionType;
+    triggerPrice: string;
+    triggerSource?: ConditionalOrderTriggerSource;
+    side: OrderSide;
+    positionSide: Exclude<PositionSide, "NONE">;
+    orderType: OrderType;
+    limitPrice?: string;
+    quantity?: string;
+    reduceOnly?: boolean;
+    timeInForce?: Extract<TimeInForce, "GTC" | "IOC">;
+    slippageToleranceBps?: number;
+    expiresAt?: string;
+}
+export interface CreateConditionalOrderResponse {
+    conditional_order_id: string;
+    status: "SUCCESS" | "FAILED";
+    message: string;
+    state: ConditionalOrderState;
+}
+export interface CancelConditionalOrderResponse {
+    conditional_order_id: string;
+    status: "SUCCESS" | "FAILED";
+    message: string;
+}
+export interface ListConditionalOrdersParams {
+    margin_account_id?: string;
+    trading_pair_id?: string;
+    state?: ConditionalOrderState;
+    page?: number;
+    page_size?: number;
+}
+export interface ConditionalOrder {
+    conditional_order_id: string;
+    trading_pair_id: string;
+    margin_account_id: string;
+    position_id?: string;
+    linked_group_id?: string;
+    condition_type: ConditionalOrderConditionType;
+    trigger_source: ConditionalOrderTriggerSource;
+    trigger_price: string;
+    side: OrderSide;
+    position_side: PositionSide;
+    order_type: OrderType;
+    limit_price?: string;
+    quantity?: string;
+    slippage_tolerance_bps?: number;
+    reduce_only: boolean;
+    time_in_force?: TimeInForce;
+    state: ConditionalOrderState;
+    triggered_order_id?: string;
+    triggered_at?: string;
+    cancelled_at?: string;
+    expires_at?: string;
+    failure_reason?: string;
+    created_at: string;
+    updated_at: string;
+}
+export interface ListConditionalOrdersResponse {
+    orders: ConditionalOrder[];
+    total: number;
+    page: number;
+    page_size: number;
+}

package/dist/validation/index.d.ts

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

package/dist/validation/index.js

@@ -15,7 +15,9 @@
  */
 // Export validation utilities
 export * from "./common.js";
+export * from "./margin-accounts.js";
 export * from "./market.js";
+export * from "./positions.js";
 // Export module-specific schemas
 export * from "./profile.js";
 export * from "./trading.js";

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

@@ -0,0 +1,55 @@
+/**
+ * Margin Account API Validation Schemas
+ */
+import { z } from "zod";
+export declare const ListMarginAccountsSchema: z.ZodObject<{
+    page: z.ZodOptional<z.ZodNumber>;
+    page_size: z.ZodOptional<z.ZodNumber>;
+    state: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const CreateMarginAccountSchema: z.ZodOptional<z.ZodObject<{
+    label: z.ZodOptional<z.ZodString>;
+    collateralAsset: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>>;
+export declare const GetMarginAccountSummarySchema: z.ZodObject<{
+    marginAccountId: z.ZodUUID;
+}, z.core.$strip>;
+export declare const GetAvailableCollateralSchema: z.ZodOptional<z.ZodObject<{
+    asset: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>>;
+export declare const TransferCollateralSchema: z.ZodObject<{
+    marginAccountId: z.ZodUUID;
+    request: z.ZodObject<{
+        asset: z.ZodString;
+        amount: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const GetMarginAccountMovementsSchema: z.ZodObject<{
+    page: z.ZodOptional<z.ZodNumber>;
+    page_size: z.ZodOptional<z.ZodNumber>;
+    marginAccountId: z.ZodUUID;
+    movement_type: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const SimulateOrderRiskSchema: z.ZodObject<{
+    marginAccountId: z.ZodUUID;
+    request: z.ZodObject<{
+        tradingPairId: z.ZodUUID;
+        side: z.ZodEnum<{
+            BUY: "BUY";
+            SELL: "SELL";
+        }>;
+        positionSide: 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;
+        reduceOnly: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>;
+}, z.core.$strip>;

package/dist/validation/margin-accounts.js

@@ -0,0 +1,59 @@
+/**
+ * Margin Account API Validation Schemas
+ */
+import { z } from "zod";
+import { OrderSideSchema, OrderTypeSchema, PositionSideSchema, PositiveDecimalStringSchema, UUIDSchema } from "./trading";
+const PaginationSchema = z.object({
+    page: z.number().int().min(1, "Page must be at least 1").optional(),
+    page_size: z.number().int().min(1, "Page size must be at least 1").max(100, "Page size cannot exceed 100").optional(),
+});
+export const ListMarginAccountsSchema = PaginationSchema.extend({
+    state: z.string().trim().min(1, "State cannot be empty").optional(),
+});
+export const CreateMarginAccountSchema = z
+    .object({
+    label: z.string().trim().min(1, "Label cannot be empty").optional(),
+    collateralAsset: z.string().trim().min(1, "Collateral asset cannot be empty").optional(),
+})
+    .optional();
+export const GetMarginAccountSummarySchema = z.object({
+    marginAccountId: UUIDSchema,
+});
+export const GetAvailableCollateralSchema = z
+    .object({
+    asset: z.string().trim().min(1, "Asset cannot be empty").optional(),
+})
+    .optional();
+export const TransferCollateralSchema = z.object({
+    marginAccountId: UUIDSchema,
+    request: z.object({
+        asset: z.string().trim().min(1, "Asset cannot be empty"),
+        amount: PositiveDecimalStringSchema,
+    }),
+});
+export const GetMarginAccountMovementsSchema = PaginationSchema.extend({
+    marginAccountId: UUIDSchema,
+    movement_type: z.string().trim().min(1, "Movement type cannot be empty").optional(),
+});
+export const SimulateOrderRiskSchema = z
+    .object({
+    marginAccountId: UUIDSchema,
+    request: z.object({
+        tradingPairId: UUIDSchema,
+        side: OrderSideSchema,
+        positionSide: PositionSideSchema,
+        orderType: OrderTypeSchema,
+        price: PositiveDecimalStringSchema.optional(),
+        quantity: PositiveDecimalStringSchema,
+        leverage: PositiveDecimalStringSchema,
+        reduceOnly: z.boolean().optional(),
+    }),
+})
+    .refine((data) => data.request.orderType !== "LIMIT" || data.request.price !== undefined, {
+    message: "price is required for LIMIT risk simulations",
+    path: ["request", "price"],
+})
+    .refine((data) => data.request.orderType !== "MARKET" || data.request.price === undefined, {
+    message: "price must not be provided for MARKET risk simulations",
+    path: ["request", "price"],
+});

package/dist/validation/market.d.ts

@@ -203,8 +203,8 @@ export declare const GetTradingPairSchema: z.ZodObject<{
  */
 export declare const SearchTradingPairsSchema: z.ZodObject<{
     query: z.ZodOptional<z.ZodString>;
-    limit: z.ZodOptional<z.ZodNumber>;
-    offset: z.ZodOptional<z.ZodNumber>;
+    page_size: z.ZodOptional<z.ZodNumber>;
+    page: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strip>;
 /**
  * Get Market Metadata validation schema

package/dist/validation/market.js

@@ -214,8 +214,8 @@ export const GetTradingPairSchema = z.object({
  */
 export const SearchTradingPairsSchema = z.object({
     query: z.string().min(1, "Search query cannot be empty").optional(),
-    limit: z.number().int().min(1).max(100).optional(),
-    offset: z.number().int().min(0).optional(),
+    page_size: z.number().int().min(1).max(100).optional(),
+    page: z.number().int().min(1).optional(),
 });
 /**
  * Get Market Metadata validation schema

package/dist/validation/positions.d.ts

@@ -0,0 +1,89 @@
+/**
+ * Positions API Validation Schemas
+ */
+import { z } from "zod";
+export declare const ListPositionsSchema: z.ZodObject<{
+    page: z.ZodOptional<z.ZodNumber>;
+    page_size: z.ZodOptional<z.ZodNumber>;
+    margin_account_id: z.ZodOptional<z.ZodUUID>;
+    trading_pair_id: z.ZodOptional<z.ZodUUID>;
+    status: z.ZodOptional<z.ZodEnum<{
+        OPEN: "OPEN";
+        CLOSED: "CLOSED";
+        LIQUIDATING: "LIQUIDATING";
+    }>>;
+}, z.core.$strip>;
+export declare const GetPositionSchema: z.ZodObject<{
+    positionId: z.ZodUUID;
+}, z.core.$strip>;
+export declare const ClosePositionSchema: z.ZodObject<{
+    positionId: z.ZodUUID;
+    request: z.ZodObject<{
+        closeType: z.ZodEnum<{
+            LIMIT: "LIMIT";
+            MARKET: "MARKET";
+            IOC: "IOC";
+        }>;
+        limitPrice: z.ZodOptional<z.ZodString>;
+        slippageToleranceBps: z.ZodOptional<z.ZodNumber>;
+        quantity: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const GetPositionRiskSchema: z.ZodObject<{
+    positionId: z.ZodUUID;
+}, z.core.$strip>;
+export declare const AddPositionMarginSchema: z.ZodObject<{
+    positionId: z.ZodUUID;
+    request: z.ZodObject<{
+        amount: z.ZodString;
+        asset: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const ReducePositionMarginSchema: z.ZodObject<{
+    positionId: z.ZodUUID;
+    request: z.ZodObject<{
+        amount: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const AttachPositionTpSlSchema: z.ZodObject<{
+    positionId: z.ZodUUID;
+    request: z.ZodObject<{
+        takeProfit: z.ZodOptional<z.ZodObject<{
+            triggerPrice: z.ZodString;
+            orderType: z.ZodEnum<{
+                LIMIT: "LIMIT";
+                MARKET: "MARKET";
+            }>;
+            limitPrice: z.ZodOptional<z.ZodString>;
+            quantity: z.ZodOptional<z.ZodString>;
+            timeInForce: z.ZodOptional<z.ZodEnum<{
+                GTC: "GTC";
+                IOC: "IOC";
+            }>>;
+            slippageToleranceBps: z.ZodOptional<z.ZodNumber>;
+            expiresAt: z.ZodOptional<z.ZodISODateTime>;
+        }, z.core.$strip>>;
+        stopLoss: z.ZodOptional<z.ZodObject<{
+            triggerPrice: z.ZodString;
+            orderType: z.ZodEnum<{
+                LIMIT: "LIMIT";
+                MARKET: "MARKET";
+            }>;
+            limitPrice: z.ZodOptional<z.ZodString>;
+            quantity: z.ZodOptional<z.ZodString>;
+            timeInForce: z.ZodOptional<z.ZodEnum<{
+                GTC: "GTC";
+                IOC: "IOC";
+            }>>;
+            slippageToleranceBps: z.ZodOptional<z.ZodNumber>;
+            expiresAt: z.ZodOptional<z.ZodISODateTime>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const ListPositionHistorySchema: z.ZodObject<{
+    page: z.ZodOptional<z.ZodNumber>;
+    page_size: z.ZodOptional<z.ZodNumber>;
+    position_id: z.ZodOptional<z.ZodUUID>;
+    margin_account_id: z.ZodOptional<z.ZodUUID>;
+    trading_pair_id: z.ZodOptional<z.ZodUUID>;
+}, z.core.$strip>;

package/dist/validation/positions.js

@@ -0,0 +1,93 @@
+/**
+ * Positions API Validation Schemas
+ */
+import { z } from "zod";
+import { ConditionalTimeInForceSchema, ISO8601DateSchema, OrderTypeSchema, PositiveDecimalStringSchema, SlippageToleranceBpsSchema, UUIDSchema, } from "./trading";
+const PaginationSchema = z.object({
+    page: z.number().int().min(1, "Page must be at least 1").optional(),
+    page_size: z.number().int().min(1, "Page size must be at least 1").max(100, "Page size cannot exceed 100").optional(),
+});
+const PositionStatusSchema = z.enum(["OPEN", "CLOSED", "LIQUIDATING"], {
+    message: 'Position status must be "OPEN", "CLOSED", or "LIQUIDATING"',
+});
+const ClosePositionTypeSchema = z.enum(["MARKET", "LIMIT", "IOC"], {
+    message: 'Close type must be "MARKET", "LIMIT", or "IOC"',
+});
+const PositionIdSchema = z.object({
+    positionId: UUIDSchema,
+});
+export const ListPositionsSchema = PaginationSchema.extend({
+    margin_account_id: UUIDSchema.optional(),
+    trading_pair_id: UUIDSchema.optional(),
+    status: PositionStatusSchema.optional(),
+});
+export const GetPositionSchema = PositionIdSchema;
+export const ClosePositionSchema = PositionIdSchema.extend({
+    request: z.object({
+        closeType: ClosePositionTypeSchema,
+        limitPrice: PositiveDecimalStringSchema.optional(),
+        slippageToleranceBps: SlippageToleranceBpsSchema.optional(),
+        quantity: PositiveDecimalStringSchema.optional(),
+    }),
+})
+    .refine((data) => data.request.closeType !== "LIMIT" || data.request.limitPrice !== undefined, {
+    message: "limitPrice is required for LIMIT close requests",
+    path: ["request", "limitPrice"],
+})
+    .refine((data) => data.request.closeType === "LIMIT" || data.request.limitPrice === undefined, {
+    message: "limitPrice is only allowed for LIMIT close requests",
+    path: ["request", "limitPrice"],
+});
+export const GetPositionRiskSchema = PositionIdSchema;
+export const AddPositionMarginSchema = PositionIdSchema.extend({
+    request: z.object({
+        amount: PositiveDecimalStringSchema,
+        asset: z.string().trim().min(1, "Asset cannot be empty"),
+    }),
+});
+export const ReducePositionMarginSchema = PositionIdSchema.extend({
+    request: z.object({
+        amount: PositiveDecimalStringSchema,
+    }),
+});
+const TpSlLegSchema = z
+    .object({
+    triggerPrice: PositiveDecimalStringSchema,
+    orderType: OrderTypeSchema,
+    limitPrice: PositiveDecimalStringSchema.optional(),
+    quantity: PositiveDecimalStringSchema.optional(),
+    timeInForce: ConditionalTimeInForceSchema.optional(),
+    slippageToleranceBps: SlippageToleranceBpsSchema.optional(),
+    expiresAt: ISO8601DateSchema.optional(),
+})
+    .refine((data) => data.orderType !== "LIMIT" || data.limitPrice !== undefined, {
+    message: "limitPrice is required for LIMIT TP/SL legs",
+    path: ["limitPrice"],
+})
+    .refine((data) => data.orderType !== "MARKET" || data.limitPrice === undefined, {
+    message: "limitPrice must not be provided for MARKET TP/SL legs",
+    path: ["limitPrice"],
+})
+    .refine((data) => data.orderType !== "MARKET" || data.timeInForce === undefined, {
+    message: "timeInForce is only allowed for LIMIT TP/SL legs",
+    path: ["timeInForce"],
+})
+    .refine((data) => data.orderType !== "LIMIT" || data.slippageToleranceBps === undefined, {
+    message: "slippageToleranceBps is only allowed for MARKET TP/SL legs",
+    path: ["slippageToleranceBps"],
+});
+export const AttachPositionTpSlSchema = PositionIdSchema.extend({
+    request: z
+        .object({
+        takeProfit: TpSlLegSchema.optional(),
+        stopLoss: TpSlLegSchema.optional(),
+    })
+        .refine((data) => data.takeProfit !== undefined || data.stopLoss !== undefined, {
+        message: "At least one of takeProfit or stopLoss is required",
+    }),
+});
+export const ListPositionHistorySchema = PaginationSchema.extend({
+    position_id: UUIDSchema.optional(),
+    margin_account_id: UUIDSchema.optional(),
+    trading_pair_id: UUIDSchema.optional(),
+});

package/dist/validation/profile.d.ts

@@ -36,7 +36,7 @@ export declare const TransactionTypeSchema: z.ZodEnum<{
  */
 export declare const GetUserMovementsSchema: z.ZodObject<{
     page: z.ZodOptional<z.ZodNumber>;
-    limit: z.ZodOptional<z.ZodNumber>;
+    page_size: z.ZodOptional<z.ZodNumber>;
     entry_type: z.ZodOptional<z.ZodEnum<{
         CREDIT: "CREDIT";
         DEBIT: "DEBIT";
@@ -64,6 +64,6 @@ export declare const GetUserMovementsSchema: z.ZodObject<{
  */
 export declare const GetUserTradesSchema: z.ZodObject<{
     page: z.ZodOptional<z.ZodNumber>;
-    limit: z.ZodOptional<z.ZodNumber>;
+    page_size: z.ZodOptional<z.ZodNumber>;
     trading_pair_id: z.ZodOptional<z.ZodUUID>;
 }, z.core.$strip>;

package/dist/validation/profile.js

@@ -26,7 +26,7 @@ export const TransactionTypeSchema = z.enum(["DEPOSIT", "WITHDRAWAL", "TRADE", "
  */
 export const GetUserMovementsSchema = z.object({
     page: z.number().int("Page must be an integer").min(1, "Page must be at least 1").optional(),
-    limit: z.number().int("Limit must be an integer").min(1, "Limit must be at least 1").max(100, "Limit cannot exceed 100").optional(),
+    page_size: z.number().int("Page size must be an integer").min(1, "Page size must be at least 1").max(100, "Page size cannot exceed 100").optional(),
     entry_type: LedgerEntryTypeSchema.optional(),
     transaction_type: TransactionTypeSchema.optional(),
     asset_id: UUIDSchema.optional(),
@@ -39,6 +39,6 @@ export const GetUserMovementsSchema = z.object({
  */
 export const GetUserTradesSchema = z.object({
     page: z.number().int("Page must be an integer").min(1, "Page must be at least 1").optional(),
-    limit: z.number().int("Limit must be an integer").min(1, "Limit must be at least 1").max(100, "Limit cannot exceed 100").optional(),
+    page_size: z.number().int("Page size must be an integer").min(1, "Page size must be at least 1").max(100, "Page size cannot exceed 100").optional(),
     trading_pair_id: UUIDSchema.optional(),
 });