@0xmonaco/types 0.8.11 → 0.8.15

package/dist/validation/margin-accounts.js

@@ -5,7 +5,7 @@ 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(),
+    pageSize: 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(),
@@ -15,6 +15,11 @@ export const GetMarginAccountSummarySchema = z.object({
     marginAccountId: UUIDSchema,
     tradingPairId: UUIDSchema.optional(),
 });
+export const GetParentMarginAccountSummarySchema = z
+    .object({
+    tradingPairId: UUIDSchema.optional(),
+})
+    .optional();
 export const GetAvailableCollateralSchema = z
     .object({
     asset: z.string().trim().min(1, "Asset cannot be empty").optional(),
@@ -26,7 +31,11 @@ const TransferCollateralRequestSchema = z.object({
     tradingPairId: UUIDSchema.optional(),
     strategyKey: z.string().trim().min(1, "Strategy key cannot be empty").optional(),
 });
-const AutoMarginBucketRequestSchema = z.object({
+const ParentMarginAccountCollateralRequestSchema = z.object({
+    asset: z.string().trim().min(1, "Asset cannot be empty"),
+    amount: PositiveDecimalStringSchema,
+});
+const RiskBucketRequestSchema = z.object({
     tradingPairId: UUIDSchema,
     strategyKey: z.string().trim().min(1, "Strategy key cannot be empty").optional(),
 });
@@ -34,13 +43,22 @@ export const TransferCollateralSchema = z.object({
     marginAccountId: UUIDSchema,
     request: TransferCollateralRequestSchema,
 });
-export const TransferCollateralToAutoMarginAccountSchema = z.object({
-    request: TransferCollateralRequestSchema.merge(AutoMarginBucketRequestSchema),
+export const TransferCollateralToParentMarginAccountSchema = z.object({
+    request: ParentMarginAccountCollateralRequestSchema,
+});
+export const TransferCollateralToRiskBucketSchema = z.object({
+    request: ParentMarginAccountCollateralRequestSchema.merge(RiskBucketRequestSchema),
+});
+export const TransferCollateralFromParentMarginAccountSchema = z.object({
+    request: ParentMarginAccountCollateralRequestSchema,
 });
 export const GetMarginAccountMovementsSchema = PaginationSchema.extend({
     marginAccountId: UUIDSchema,
-    movement_type: z.string().trim().min(1, "Movement type cannot be empty").optional(),
+    movementType: z.string().trim().min(1, "Movement type cannot be empty").optional(),
 });
+export const GetParentMarginAccountMovementsSchema = PaginationSchema.extend({
+    movementType: z.string().trim().min(1, "Movement type cannot be empty").optional(),
+}).optional();
 const BaseSimulateOrderRiskRequestSchema = z.object({
     tradingPairId: UUIDSchema,
     side: OrderSideSchema,
@@ -52,7 +70,7 @@ const BaseSimulateOrderRiskRequestSchema = z.object({
     reduceOnly: z.boolean().optional(),
 });
 const SimulateOrderRiskRequestSchema = BaseSimulateOrderRiskRequestSchema.strict();
-const SimulateAutoMarginOrderRiskRequestSchema = BaseSimulateOrderRiskRequestSchema.merge(AutoMarginBucketRequestSchema).strict();
+const SimulateRiskBucketOrderRiskRequestSchema = BaseSimulateOrderRiskRequestSchema.merge(RiskBucketRequestSchema).strict();
 export const SimulateOrderRiskSchema = z
     .object({
     marginAccountId: UUIDSchema,
@@ -62,9 +80,17 @@ export const SimulateOrderRiskSchema = z
     message: "price is required for LIMIT risk simulations",
     path: ["request", "price"],
 });
-export const SimulateAutoMarginOrderRiskSchema = z
+export const SimulateParentMarginOrderRiskSchema = z
+    .object({
+    request: SimulateOrderRiskRequestSchema,
+})
+    .refine((data) => data.request.orderType !== "LIMIT" || data.request.price !== undefined, {
+    message: "price is required for LIMIT risk simulations",
+    path: ["request", "price"],
+});
+export const SimulateRiskBucketOrderRiskSchema = z
     .object({
-    request: SimulateAutoMarginOrderRiskRequestSchema,
+    request: SimulateRiskBucketOrderRiskRequestSchema,
 })
     .refine((data) => data.request.orderType !== "LIMIT" || data.request.price !== undefined, {
     message: "price is required for LIMIT risk simulations",

package/dist/validation/market.d.ts

@@ -203,7 +203,7 @@ export declare const GetTradingPairSchema: z.ZodObject<{
  */
 export declare const SearchTradingPairsSchema: z.ZodObject<{
     query: z.ZodOptional<z.ZodString>;
-    page_size: z.ZodOptional<z.ZodNumber>;
+    pageSize: z.ZodOptional<z.ZodNumber>;
     page: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strip>;
 /**

package/dist/validation/market.js

@@ -214,7 +214,7 @@ export const GetTradingPairSchema = z.object({
  */
 export const SearchTradingPairsSchema = z.object({
     query: z.string().min(1, "Search query cannot be empty").optional(),
-    page_size: z.number().int().min(1).max(100).optional(),
+    pageSize: z.number().int().min(1).max(100).optional(),
     page: z.number().int().min(1).optional(),
 });
 /**

package/dist/validation/positions.d.ts

@@ -4,9 +4,9 @@
 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>;
+    pageSize: z.ZodOptional<z.ZodNumber>;
+    marginAccountId: z.ZodOptional<z.ZodUUID>;
+    tradingPairId: z.ZodOptional<z.ZodUUID>;
     status: z.ZodOptional<z.ZodEnum<{
         OPEN: "OPEN";
         CLOSED: "CLOSED";
@@ -29,6 +29,10 @@ export declare const ClosePositionSchema: z.ZodObject<{
         quantity: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>;
 }, z.core.$strip>;
+export declare const BatchCloseAllSchema: z.ZodObject<{
+    tradingPairId: z.ZodOptional<z.ZodUUID>;
+    slippageToleranceBps: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
 export declare const GetPositionRiskSchema: z.ZodObject<{
     positionId: z.ZodUUID;
 }, z.core.$strip>;
@@ -82,8 +86,8 @@ export declare const AttachPositionTpSlSchema: z.ZodObject<{
 }, 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>;
+    pageSize: z.ZodOptional<z.ZodNumber>;
+    positionId: z.ZodOptional<z.ZodUUID>;
+    marginAccountId: z.ZodOptional<z.ZodUUID>;
+    tradingPairId: z.ZodOptional<z.ZodUUID>;
 }, z.core.$strip>;

package/dist/validation/positions.js

@@ -5,7 +5,7 @@ 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(),
+    pageSize: 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"',
@@ -17,8 +17,8 @@ const PositionIdSchema = z.object({
     positionId: UUIDSchema,
 });
 export const ListPositionsSchema = PaginationSchema.extend({
-    margin_account_id: UUIDSchema.optional(),
-    trading_pair_id: UUIDSchema.optional(),
+    marginAccountId: UUIDSchema.optional(),
+    tradingPairId: UUIDSchema.optional(),
     status: PositionStatusSchema.optional(),
 });
 export const GetPositionSchema = PositionIdSchema;
@@ -38,6 +38,10 @@ export const ClosePositionSchema = PositionIdSchema.extend({
     message: "limitPrice is only allowed for LIMIT close requests",
     path: ["request", "limitPrice"],
 });
+export const BatchCloseAllSchema = z.object({
+    tradingPairId: UUIDSchema.optional(),
+    slippageToleranceBps: SlippageToleranceBpsSchema.optional(),
+});
 export const GetPositionRiskSchema = PositionIdSchema;
 export const AddPositionMarginSchema = PositionIdSchema.extend({
     request: z.object({
@@ -87,7 +91,7 @@ export const AttachPositionTpSlSchema = PositionIdSchema.extend({
     }),
 });
 export const ListPositionHistorySchema = PaginationSchema.extend({
-    position_id: UUIDSchema.optional(),
-    margin_account_id: UUIDSchema.optional(),
-    trading_pair_id: UUIDSchema.optional(),
+    positionId: UUIDSchema.optional(),
+    marginAccountId: UUIDSchema.optional(),
+    tradingPairId: UUIDSchema.optional(),
 });

package/dist/validation/profile.d.ts

@@ -36,15 +36,15 @@ export declare const TransactionTypeSchema: z.ZodEnum<{
  */
 export declare const GetUserMovementsSchema: z.ZodObject<{
     page: z.ZodOptional<z.ZodNumber>;
-    page_size: z.ZodOptional<z.ZodNumber>;
-    entry_type: z.ZodOptional<z.ZodEnum<{
+    pageSize: z.ZodOptional<z.ZodNumber>;
+    entryType: z.ZodOptional<z.ZodEnum<{
         CREDIT: "CREDIT";
         DEBIT: "DEBIT";
         LOCK: "LOCK";
         UNLOCK: "UNLOCK";
         FEE: "FEE";
     }>>;
-    transaction_type: z.ZodOptional<z.ZodEnum<{
+    transactionType: z.ZodOptional<z.ZodEnum<{
         FEE: "FEE";
         DEPOSIT: "DEPOSIT";
         WITHDRAWAL: "WITHDRAWAL";
@@ -54,7 +54,7 @@ export declare const GetUserMovementsSchema: z.ZodObject<{
         INTEREST: "INTEREST";
         REWARD: "REWARD";
     }>>;
-    asset_id: z.ZodOptional<z.ZodUUID>;
+    assetId: z.ZodOptional<z.ZodUUID>;
 }, z.core.$strip>;
 /**
  * Get User Trades validation schema
@@ -64,13 +64,13 @@ export declare const GetUserMovementsSchema: z.ZodObject<{
  */
 export declare const GetUserTradesSchema: z.ZodObject<{
     page: z.ZodOptional<z.ZodNumber>;
-    page_size: z.ZodOptional<z.ZodNumber>;
-    trading_pair_id: z.ZodOptional<z.ZodUUID>;
+    pageSize: z.ZodOptional<z.ZodNumber>;
+    tradingPairId: z.ZodOptional<z.ZodUUID>;
 }, z.core.$strip>;
 export declare const ListFundingPaymentsSchema: z.ZodObject<{
     page: z.ZodOptional<z.ZodNumber>;
-    page_size: z.ZodOptional<z.ZodNumber>;
-    trading_pair_id: z.ZodOptional<z.ZodUUID>;
-    position_id: z.ZodOptional<z.ZodUUID>;
-    margin_account_id: z.ZodOptional<z.ZodUUID>;
+    pageSize: z.ZodOptional<z.ZodNumber>;
+    tradingPairId: z.ZodOptional<z.ZodUUID>;
+    positionId: z.ZodOptional<z.ZodUUID>;
+    marginAccountId: z.ZodOptional<z.ZodUUID>;
 }, z.core.$strip>;

package/dist/validation/profile.js

@@ -26,10 +26,10 @@ 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(),
-    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(),
+    pageSize: 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(),
+    entryType: LedgerEntryTypeSchema.optional(),
+    transactionType: TransactionTypeSchema.optional(),
+    assetId: UUIDSchema.optional(),
 });
 /**
  * Get User Trades validation schema
@@ -39,13 +39,13 @@ 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(),
-    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(),
+    pageSize: 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(),
+    tradingPairId: UUIDSchema.optional(),
 });
 export const ListFundingPaymentsSchema = z.object({
     page: z.number().int("Page must be an integer").min(1, "Page must be at least 1").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(),
-    position_id: UUIDSchema.optional(),
-    margin_account_id: UUIDSchema.optional(),
+    pageSize: 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(),
+    tradingPairId: UUIDSchema.optional(),
+    positionId: UUIDSchema.optional(),
+    marginAccountId: UUIDSchema.optional(),
 });

package/dist/validation/trading.d.ts

@@ -101,8 +101,8 @@ export declare const PlaceLimitOrderSchema: z.ZodObject<{
             FOK: "FOK";
         }>>;
         marginAccountId: z.ZodOptional<z.ZodUUID>;
-        marginBucketId: z.ZodOptional<z.ZodUUID>;
-        marginBucketCollateral: z.ZodOptional<z.ZodString>;
+        riskBucketId: z.ZodOptional<z.ZodUUID>;
+        riskBucketCollateral: z.ZodOptional<z.ZodString>;
         strategyKey: z.ZodOptional<z.ZodString>;
         positionSide: z.ZodOptional<z.ZodEnum<{
             LONG: "LONG";
@@ -158,8 +158,8 @@ export declare const PlaceMarketOrderSchema: z.ZodObject<{
         }>>;
         slippageTolerance: z.ZodOptional<z.ZodNumber>;
         marginAccountId: z.ZodOptional<z.ZodUUID>;
-        marginBucketId: z.ZodOptional<z.ZodUUID>;
-        marginBucketCollateral: z.ZodOptional<z.ZodString>;
+        riskBucketId: z.ZodOptional<z.ZodUUID>;
+        riskBucketCollateral: z.ZodOptional<z.ZodString>;
         strategyKey: z.ZodOptional<z.ZodString>;
         positionSide: z.ZodOptional<z.ZodEnum<{
             LONG: "LONG";
@@ -226,9 +226,9 @@ export declare const ReplaceOrderSchema: z.ZodObject<{
  * Validates parameters for fetching paginated orders.
  * Matches the getPaginatedOrders method signature which accepts:
  * - status: OrderStatus (optional filter)
- * - trading_pair_id: trading pair UUID (optional filter)
+ * - tradingPairId: trading pair UUID (optional filter)
  * - page: number (default: 1)
- * - page_size: number (default: 10, max: 100)
+ * - pageSize: number (default: 10, max: 100)
  */
 export declare const GetPaginatedOrdersSchema: z.ZodObject<{
     status: z.ZodOptional<z.ZodEnum<{
@@ -241,14 +241,14 @@ export declare const GetPaginatedOrdersSchema: z.ZodObject<{
         REJECTED: "REJECTED";
         EXPIRED: "EXPIRED";
     }>>;
-    trading_pair_id: z.ZodOptional<z.ZodUUID>;
-    trading_mode: z.ZodOptional<z.ZodEnum<{
+    tradingPairId: z.ZodOptional<z.ZodUUID>;
+    tradingMode: z.ZodOptional<z.ZodEnum<{
         SPOT: "SPOT";
         MARGIN: "MARGIN";
     }>>;
-    margin_account_id: z.ZodOptional<z.ZodUUID>;
+    marginAccountId: z.ZodOptional<z.ZodUUID>;
     page: z.ZodOptional<z.ZodNumber>;
-    page_size: z.ZodOptional<z.ZodNumber>;
+    pageSize: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strip>;
 export declare const ConditionalOrderConditionTypeSchema: z.ZodEnum<{
     STOP_LOSS: "STOP_LOSS";
@@ -274,8 +274,8 @@ export declare const CancelConditionalOrderSchema: z.ZodObject<{
     conditionalOrderId: z.ZodUUID;
 }, z.core.$strip>;
 export declare const ListConditionalOrdersSchema: z.ZodObject<{
-    margin_account_id: z.ZodOptional<z.ZodUUID>;
-    trading_pair_id: z.ZodOptional<z.ZodUUID>;
+    marginAccountId: z.ZodOptional<z.ZodUUID>;
+    tradingPairId: z.ZodOptional<z.ZodUUID>;
     state: z.ZodOptional<z.ZodEnum<{
         CANCELLED: "CANCELLED";
         EXPIRED: "EXPIRED";
@@ -286,7 +286,7 @@ export declare const ListConditionalOrdersSchema: z.ZodObject<{
         FAILED: "FAILED";
     }>>;
     page: z.ZodOptional<z.ZodNumber>;
-    page_size: z.ZodOptional<z.ZodNumber>;
+    pageSize: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strip>;
 /**
  * Single batch create order item validation schema
@@ -320,8 +320,8 @@ export declare const BatchCreateOrderItemSchema: z.ZodObject<{
         FOK: "FOK";
     }>>;
     marginAccountId: z.ZodOptional<z.ZodUUID>;
-    marginBucketId: z.ZodOptional<z.ZodUUID>;
-    marginBucketCollateral: z.ZodOptional<z.ZodString>;
+    riskBucketId: z.ZodOptional<z.ZodUUID>;
+    riskBucketCollateral: z.ZodOptional<z.ZodString>;
     strategyKey: z.ZodOptional<z.ZodString>;
     positionSide: z.ZodOptional<z.ZodEnum<{
         LONG: "LONG";
@@ -362,8 +362,8 @@ export declare const BatchCreateOrdersSchema: z.ZodObject<{
             FOK: "FOK";
         }>>;
         marginAccountId: z.ZodOptional<z.ZodUUID>;
-        marginBucketId: z.ZodOptional<z.ZodUUID>;
-        marginBucketCollateral: z.ZodOptional<z.ZodString>;
+        riskBucketId: z.ZodOptional<z.ZodUUID>;
+        riskBucketCollateral: z.ZodOptional<z.ZodString>;
         strategyKey: z.ZodOptional<z.ZodString>;
         positionSide: z.ZodOptional<z.ZodEnum<{
             LONG: "LONG";

package/dist/validation/trading.js

@@ -117,8 +117,8 @@ export const PlaceLimitOrderSchema = z
         expirationDate: ISO8601DateSchema.optional(),
         timeInForce: TimeInForceSchema.optional(),
         marginAccountId: UUIDSchema.optional(),
-        marginBucketId: UUIDSchema.optional(),
-        marginBucketCollateral: PositiveDecimalStringSchema.optional(),
+        riskBucketId: UUIDSchema.optional(),
+        riskBucketCollateral: PositiveDecimalStringSchema.optional(),
         strategyKey: z.string().min(1).max(128).optional(),
         positionSide: PositionSideSchema.optional(),
         leverage: PositiveDecimalStringSchema.optional(),
@@ -148,16 +148,16 @@ export const PlaceLimitOrderSchema = z
     message: "Parent TP/SL cannot be attached to reduceOnly orders",
     path: ["options", "reduceOnly"],
 })
-    .refine((data) => data.options?.marginBucketCollateral === undefined || data.options?.tradingMode === "MARGIN", {
-    message: "marginBucketCollateral is only supported for MARGIN orders",
+    .refine((data) => data.options?.riskBucketCollateral === undefined || data.options?.tradingMode === "MARGIN", {
+    message: "riskBucketCollateral is only supported for MARGIN orders",
     path: ["options", "tradingMode"],
 })
-    .refine((data) => data.options?.marginBucketCollateral === undefined || data.options?.marginBucketId === undefined, {
-    message: "marginBucketCollateral creates a new bucket and cannot be combined with marginBucketId",
-    path: ["options", "marginBucketId"],
+    .refine((data) => data.options?.riskBucketCollateral === undefined || data.options?.riskBucketId === undefined, {
+    message: "riskBucketCollateral creates a new risk bucket and cannot be combined with riskBucketId",
+    path: ["options", "riskBucketId"],
 })
-    .refine((data) => data.options?.marginBucketCollateral === undefined || data.options?.reduceOnly !== true, {
-    message: "reduceOnly orders cannot create a new margin bucket",
+    .refine((data) => data.options?.riskBucketCollateral === undefined || data.options?.reduceOnly !== true, {
+    message: "reduceOnly orders cannot create a new risk bucket",
     path: ["options", "reduceOnly"],
 });
 /**
@@ -173,8 +173,8 @@ export const PlaceMarketOrderSchema = z
         tradingMode: TradingModeSchema.optional(),
         slippageTolerance: SlippageToleranceSchema,
         marginAccountId: UUIDSchema.optional(),
-        marginBucketId: UUIDSchema.optional(),
-        marginBucketCollateral: PositiveDecimalStringSchema.optional(),
+        riskBucketId: UUIDSchema.optional(),
+        riskBucketCollateral: PositiveDecimalStringSchema.optional(),
         strategyKey: z.string().min(1).max(128).optional(),
         positionSide: PositionSideSchema.optional(),
         leverage: PositiveDecimalStringSchema.optional(),
@@ -204,16 +204,16 @@ export const PlaceMarketOrderSchema = z
     message: "Parent TP/SL cannot be attached to reduceOnly orders",
     path: ["options", "reduceOnly"],
 })
-    .refine((data) => data.options?.marginBucketCollateral === undefined || data.options?.tradingMode === "MARGIN", {
-    message: "marginBucketCollateral is only supported for MARGIN orders",
+    .refine((data) => data.options?.riskBucketCollateral === undefined || data.options?.tradingMode === "MARGIN", {
+    message: "riskBucketCollateral is only supported for MARGIN orders",
     path: ["options", "tradingMode"],
 })
-    .refine((data) => data.options?.marginBucketCollateral === undefined || data.options?.marginBucketId === undefined, {
-    message: "marginBucketCollateral creates a new bucket and cannot be combined with marginBucketId",
-    path: ["options", "marginBucketId"],
+    .refine((data) => data.options?.riskBucketCollateral === undefined || data.options?.riskBucketId === undefined, {
+    message: "riskBucketCollateral creates a new risk bucket and cannot be combined with riskBucketId",
+    path: ["options", "riskBucketId"],
 })
-    .refine((data) => data.options?.marginBucketCollateral === undefined || data.options?.reduceOnly !== true, {
-    message: "reduceOnly orders cannot create a new margin bucket",
+    .refine((data) => data.options?.riskBucketCollateral === undefined || data.options?.reduceOnly !== true, {
+    message: "reduceOnly orders cannot create a new risk bucket",
     path: ["options", "reduceOnly"],
 });
 /**
@@ -244,17 +244,17 @@ export const ReplaceOrderSchema = z.object({
  * Validates parameters for fetching paginated orders.
  * Matches the getPaginatedOrders method signature which accepts:
  * - status: OrderStatus (optional filter)
- * - trading_pair_id: trading pair UUID (optional filter)
+ * - tradingPairId: trading pair UUID (optional filter)
  * - page: number (default: 1)
- * - page_size: number (default: 10, max: 100)
+ * - pageSize: number (default: 10, max: 100)
  */
 export const GetPaginatedOrdersSchema = z.object({
     status: z.enum(ORDER_STATUS_VALUES).optional(),
-    trading_pair_id: UUIDSchema.optional(),
-    trading_mode: TradingModeSchema.optional(),
-    margin_account_id: UUIDSchema.optional(),
+    tradingPairId: UUIDSchema.optional(),
+    tradingMode: TradingModeSchema.optional(),
+    marginAccountId: UUIDSchema.optional(),
     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(),
+    pageSize: z.number().int().min(1, "Page size must be at least 1").max(100, "Page size cannot exceed 100").optional(),
 });
 export const ConditionalOrderConditionTypeSchema = z.enum(["STOP_LOSS", "TAKE_PROFIT"], {
     message: 'conditionType must be "STOP_LOSS" or "TAKE_PROFIT"',
@@ -272,11 +272,11 @@ export const CancelConditionalOrderSchema = z.object({
     conditionalOrderId: UUIDSchema,
 });
 export const ListConditionalOrdersSchema = z.object({
-    margin_account_id: UUIDSchema.optional(),
-    trading_pair_id: UUIDSchema.optional(),
+    marginAccountId: UUIDSchema.optional(),
+    tradingPairId: UUIDSchema.optional(),
     state: ConditionalOrderStateSchema.optional(),
     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(),
+    pageSize: z.number().int().min(1, "Page size must be at least 1").max(100, "Page size cannot exceed 100").optional(),
 });
 /**
  * Single batch create order item validation schema
@@ -298,8 +298,8 @@ export const BatchCreateOrderItemSchema = z
     expirationDate: ISO8601DateSchema.optional(),
     timeInForce: TimeInForceSchema.optional(),
     marginAccountId: UUIDSchema.optional(),
-    marginBucketId: UUIDSchema.optional(),
-    marginBucketCollateral: PositiveDecimalStringSchema.optional(),
+    riskBucketId: UUIDSchema.optional(),
+    riskBucketCollateral: PositiveDecimalStringSchema.optional(),
     strategyKey: z.string().min(1).max(128).optional(),
     positionSide: PositionSideSchema.optional(),
     leverage: PositiveDecimalStringSchema.optional(),
@@ -313,16 +313,16 @@ export const BatchCreateOrderItemSchema = z
     message: "Price must not be provided for MARKET orders",
     path: ["price"],
 })
-    .refine((data) => data.marginBucketCollateral === undefined || data.tradingMode === "MARGIN", {
-    message: "marginBucketCollateral is only supported for MARGIN orders",
+    .refine((data) => data.riskBucketCollateral === undefined || data.tradingMode === "MARGIN", {
+    message: "riskBucketCollateral is only supported for MARGIN orders",
     path: ["tradingMode"],
 })
-    .refine((data) => data.marginBucketCollateral === undefined || data.marginBucketId === undefined, {
-    message: "marginBucketCollateral creates a new bucket and cannot be combined with marginBucketId",
-    path: ["marginBucketId"],
+    .refine((data) => data.riskBucketCollateral === undefined || data.riskBucketId === undefined, {
+    message: "riskBucketCollateral creates a new risk bucket and cannot be combined with riskBucketId",
+    path: ["riskBucketId"],
 })
-    .refine((data) => data.marginBucketCollateral === undefined || data.reduceOnly !== true, {
-    message: "reduceOnly orders cannot create a new margin bucket",
+    .refine((data) => data.riskBucketCollateral === undefined || data.reduceOnly !== true, {
+    message: "reduceOnly orders cannot create a new risk bucket",
     path: ["reduceOnly"],
 })
     .refine((data) => data.tradingMode !== "MARGIN" || data.positionSide !== undefined, {

package/dist/validation/vault.d.ts

@@ -61,6 +61,10 @@ export declare const WithdrawSchema: z.ZodObject<{
     amount: z.ZodUnion<readonly [z.ZodString, z.ZodBigInt]>;
     destination: z.ZodString;
     autoWait: z.ZodOptional<z.ZodBoolean>;
+    source: z.ZodOptional<z.ZodEnum<{
+        spot: "spot";
+        margin: "margin";
+    }>>;
 }, z.core.$strip>;
 /**
  * Get Balance validation schema

package/dist/validation/vault.js

@@ -72,6 +72,7 @@ export const WithdrawSchema = z.object({
     amount: PositiveBigIntStringSchema,
     destination: z.string().regex(/^0x[a-fA-F0-9]{40}$/, "destination must be a 0x-prefixed 20-byte hex address"),
     autoWait: z.boolean().optional(),
+    source: z.enum(["spot", "margin"]).optional(),
 });
 /**
  * Get Balance validation schema

package/dist/vault/index.d.ts

@@ -3,8 +3,9 @@
  *
  * Types for vault operations including deposits, withdrawals, and balance management.
  */
+import type { Address } from "viem";
 import type { BaseAPI } from "../api/index";
-import type { Balance, TransactionResult, WithdrawResult } from "./responses";
+import type { Balance, TransactionResult, WithdrawalRetryOptions, WithdrawResult } from "./responses";
 /**
  * Destination ledger for a deposit.
  * - `"spot"` (default): credit the spot/main wallet — unchanged behavior.
@@ -14,6 +15,13 @@ import type { Balance, TransactionResult, WithdrawResult } from "./responses";
  *   to spot — funds are never lost.
  */
 export type DepositTarget = "spot" | "margin";
+/**
+ * Source ledger for an external withdrawal.
+ * - `"spot"` (default): withdraw from the spot/main wallet.
+ * - `"margin"`: directly withdraw from the parent margin account's
+ *   withdrawable collateral.
+ */
+export type WithdrawalSource = "spot" | "margin";
 /**
  * Vault API interface.
  * Provides methods for managing token deposits and withdrawals.
@@ -40,27 +48,40 @@ export interface VaultAPI extends BaseAPI {
      */
     deposit(assetId: string, amount: bigint, autoWait?: boolean, target?: DepositTarget): Promise<TransactionResult>;
     /**
-     * Initiates a withdrawal: allocates a `withdrawalIndex` via the API Gateway,
-     * receives pre-signed calldata for `executeSignedWithdrawal(...)`, and
-     * submits it on-chain through the connected wallet.
+     * Initiates a withdrawal and submits its `executeWithdrawal(...)` calldata
+     * on-chain through the connected wallet.
+     *
+     * The API Gateway allocates a `withdrawalIndex` and debits the balance, but
+     * the executable calldata requires the withdrawal's merkle proof, which only
+     * exists once its root is confirmed on-chain (a process that can take a
+     * while). This method polls `GET /withdrawals/{index}` until the calldata is
+     * available — retrying while the gateway reports it is not yet confirmed —
+     * then submits it.
      *
      * @param assetId - Asset identifier (UUID) to withdraw
      * @param amount - Raw token amount (smallest unit, as bigint)
      * @param autoWait - Whether to await on-chain confirmation (defaults to true)
+     * @param source - Source ledger: `"spot"` (default) or `"margin"` to source
+     *   funds directly from the parent margin account's withdrawable collateral
+     * @param retry - Polling cadence/timeout while waiting for the proof
      * @returns Promise resolving to `{ withdrawalIndex, transaction }`
      */
-    withdraw(assetId: string, amount: bigint, autoWait?: boolean): Promise<WithdrawResult>;
+    withdraw(assetId: string, amount: bigint, autoWait?: boolean, source?: WithdrawalSource, retry?: WithdrawalRetryOptions): Promise<WithdrawResult>;
+    withdraw(assetId: string, amount: bigint, autoWait?: boolean, retry?: WithdrawalRetryOptions): Promise<WithdrawResult>;
     /**
-     * Retries a previously-initiated withdrawal whose on-chain submission never
-     * landed (wallet rejected, page reloaded before receipt, stuck mempool).
-     * Re-fetches the same signed calldata and resubmits via the connected wallet
-     * — does NOT initiate a new withdrawal.
+     * Submits (or resubmits) a previously-initiated withdrawal on-chain. Polls
+     * for the `executeWithdrawal` calldata the same way as `withdraw` — useful
+     * when the original submission never landed (wallet rejected, page reloaded
+     * before receipt, stuck mempool) or when the proof was not yet available at
+     * the time of the original `withdraw()` call. Does NOT initiate a new
+     * withdrawal.
      *
      * @param withdrawalIndex - Index returned by the original `withdraw()` call
      * @param autoWait - Whether to await on-chain confirmation (defaults to true)
+     * @param retry - Polling cadence/timeout while waiting for the proof
      * @returns Promise resolving to `{ withdrawalIndex, ...transaction }`
      */
-    retryWithdrawal(withdrawalIndex: number, autoWait?: boolean): Promise<WithdrawResult>;
+    retryWithdrawal(withdrawalIndex: number, autoWait?: boolean, retry?: WithdrawalRetryOptions): Promise<WithdrawResult>;
     /**
      * Gets the balance of a token in the vault.
      * @param assetId - Asset identifier (UUID) to check
@@ -85,7 +106,7 @@ export interface VaultAPI extends BaseAPI {
      * Gets the address of the vault.
      * @returns Promise resolving to the address of the vault
      */
-    getVaultAddress(): Promise<string>;
+    getVaultAddress(): Promise<Address>;
     /**
      * Sets the wallet client for signing transactions.
      * Used when the wallet becomes available after SDK initialization.
@@ -93,4 +114,4 @@ export interface VaultAPI extends BaseAPI {
      */
     setWalletClient(walletClient: unknown): void;
 }
-export type { Balance, TransactionResult, WithdrawResult } from "./responses";
+export type { Balance, TransactionResult, WithdrawalRetryOptions, WithdrawResult } from "./responses";