@0xmonaco/types 0.8.1 → 0.8.5

package/dist/delegated-agents/index.d.ts

@@ -0,0 +1,53 @@
+import type { BaseAPI } from "../api";
+export type DelegatedAgentAction = "CREATE_ORDER" | "CANCEL_ORDER" | "REPLACE_ORDER" | "create_order" | "cancel_order" | "replace_order";
+export interface UpsertDelegatedAgentRequest {
+    agentAddress: string;
+    name?: string;
+    expiresAt?: string;
+    allowedActions: DelegatedAgentAction[];
+    allowedTradingPairIds: string[];
+    allowedMarginAccountIds?: string[];
+    allowedOrderTypes?: Array<"LIMIT" | "MARKET">;
+    allowedTimeInForce?: Array<"GTC" | "IOC" | "FOK">;
+    maxLeverage?: string;
+    maxOrderNotional?: string;
+    maxOpenOrders?: number;
+}
+export interface DelegatedAgent {
+    id: string;
+    owner_user_id: string;
+    agent_address: string;
+    name?: string;
+    is_active: boolean;
+    expires_at?: string;
+    revoked_at?: string;
+    allowed_actions: string[];
+    allowed_trading_pair_ids: string[];
+    allowed_margin_account_ids: string[];
+    allowed_order_types?: string[];
+    allowed_time_in_force?: string[];
+    max_leverage?: string;
+    max_order_notional?: string;
+    max_open_orders?: number;
+}
+export interface ListDelegatedAgentsResponse {
+    agents: DelegatedAgent[];
+}
+export interface CreateDelegatedSessionRequest {
+    ownerUserId: string;
+}
+export interface CreateDelegatedSessionResponse {
+    access_token: string;
+    expires_at: number;
+    delegation_id: string;
+    owner_user_id: string;
+    agent_address: string;
+}
+export interface DelegatedAgentsAPI extends BaseAPI {
+    upsertDelegatedAgent(request: UpsertDelegatedAgentRequest): Promise<DelegatedAgent>;
+    listDelegatedAgents(): Promise<ListDelegatedAgentsResponse>;
+    revokeDelegatedAgent(delegatedAgentId: string): Promise<{
+        status: "REVOKED";
+    }>;
+    createDelegatedSession(request: CreateDelegatedSessionRequest): Promise<CreateDelegatedSessionResponse>;
+}

package/dist/index.d.ts

@@ -8,6 +8,7 @@ export * from "./api";
 export * from "./applications";
 export * from "./auth";
 export * from "./contracts";
+export * from "./delegated-agents";
 export * from "./fees";
 export * from "./margin-accounts";
 export * from "./market";

package/dist/index.js

@@ -9,6 +9,7 @@ export * from "./api";
 export * from "./applications";
 export * from "./auth";
 export * from "./contracts";
+export * from "./delegated-agents";
 export * from "./fees";
 export * from "./margin-accounts";
 export * from "./market";

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

@@ -3,6 +3,8 @@ import type { OrderSide, OrderType, PositionSide } from "../trading";
 export interface MarginAccountSummary {
     margin_account_id: string;
     label?: string;
+    trading_pair_id?: string;
+    strategy_key?: string;
     account_state: string;
     equity: string;
     initial_margin_required: string;
@@ -18,6 +20,7 @@ export interface ListMarginAccountsParams {
     page?: number;
     page_size?: number;
     state?: string;
+    tradingPairId?: string;
 }
 export interface ListMarginAccountsResponse {
     accounts: MarginAccountSummary[];
@@ -49,9 +52,14 @@ export interface TransferCollateralRequest {
     asset: string;
     amount: string;
 }
+export interface TransferCollateralToAutoMarginAccountRequest extends TransferCollateralRequest {
+    tradingPairId: string;
+    strategyKey?: string;
+}
 export interface TransferCollateralResponse {
     movement_id: string;
     margin_account_id: string;
+    strategy_key?: string;
     asset: string;
     amount: string;
     status: string;
@@ -80,6 +88,7 @@ export interface GetMarginAccountMovementsResponse {
 }
 export interface SimulateOrderRiskRequest {
     tradingPairId: string;
+    strategyKey?: string;
     side: OrderSide;
     positionSide: PositionSide;
     orderType: OrderType;
@@ -91,6 +100,8 @@ export interface SimulateOrderRiskRequest {
 export interface SimulateOrderRiskResponse {
     accepted: boolean;
     reject_reason?: string;
+    margin_account_id: string;
+    strategy_key?: string;
     equity_after: string;
     initial_margin_required_after: string;
     maintenance_margin_required_after: string;
@@ -104,7 +115,9 @@ export interface MarginAccountsAPI extends BaseAPI {
     getMarginAccountSummary(marginAccountId: string): Promise<MarginAccountSummary>;
     getAvailableCollateral(params?: GetAvailableCollateralParams): Promise<GetAvailableCollateralResponse>;
     transferCollateralToMarginAccount(marginAccountId: string, request: TransferCollateralRequest): Promise<TransferCollateralResponse>;
+    transferCollateralToAutoMarginAccount(request: TransferCollateralToAutoMarginAccountRequest): Promise<TransferCollateralResponse>;
     transferCollateralFromMarginAccount(marginAccountId: string, request: TransferCollateralRequest): Promise<TransferCollateralResponse>;
     getMarginAccountMovements(marginAccountId: string, params?: GetMarginAccountMovementsParams): Promise<GetMarginAccountMovementsResponse>;
     simulateOrderRisk(marginAccountId: string, request: SimulateOrderRiskRequest): Promise<SimulateOrderRiskResponse>;
+    simulateAutoMarginOrderRisk(request: SimulateOrderRiskRequest): Promise<SimulateOrderRiskResponse>;
 }

package/dist/sdk/index.d.ts

@@ -1,6 +1,7 @@
 import type { PublicClient, TransactionReceipt, WalletClient } from "viem";
 import type { ApplicationsAPI } from "../applications";
 import type { AuthAPI, AuthState } from "../auth/index";
+import type { DelegatedAgentsAPI } from "../delegated-agents";
 import type { FeesAPI } from "../fees";
 import type { MarginAccountsAPI } from "../margin-accounts";
 import type { Interval, MarketAPI } from "../market";
@@ -43,6 +44,8 @@ export interface MonacoSDK {
     auth: AuthAPI;
     /** Fees operations API */
     fees: FeesAPI;
+    /** Delegated trading agent operations API */
+    delegatedAgents: DelegatedAgentsAPI;
     /** Vault operations API */
     vault: VaultAPI;
     /** Trading operations API */

package/dist/trading/index.d.ts

@@ -29,6 +29,7 @@ export interface TradingAPI extends BaseAPI {
         expirationDate?: string;
         timeInForce?: TimeInForce;
         marginAccountId?: string;
+        strategyKey?: string;
         positionSide?: PositionSide;
         leverage?: string;
         reduceOnly?: boolean;
@@ -49,6 +50,7 @@ export interface TradingAPI extends BaseAPI {
         tradingMode?: TradingMode;
         slippageTolerance?: number;
         marginAccountId?: string;
+        strategyKey?: string;
         positionSide?: PositionSide;
         leverage?: string;
         reduceOnly?: boolean;

package/dist/trading/responses.d.ts

@@ -72,6 +72,12 @@ export interface CreateOrderResponse {
     message: string;
     /** Match result information if order was processed by matching engine */
     match_result?: MatchResult;
+    /** Resolved margin account ID for margin/perp orders */
+    margin_account_id?: string;
+    /** Resolved hidden strategy bucket key for auto margin buckets */
+    strategy_key?: string;
+    /** Delegated agent ID when submitted through a delegated session */
+    delegation_id?: string;
     /** Conditional order ID for an attached take-profit leg */
     take_profit_order_id?: string;
     /** Conditional order ID for an attached stop-loss leg */
@@ -280,6 +286,8 @@ export interface BatchCreateOrderParams {
     timeInForce?: Extract<TimeInForce, "GTC" | "IOC" | "FOK">;
     /** Margin account UUID for margin/perp orders */
     marginAccountId?: string;
+    /** Optional strategy bucket key used when marginAccountId is omitted */
+    strategyKey?: string;
     /** Position side for margin/perp orders */
     positionSide?: PositionSide;
     /** Leverage for margin/perp orders */

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

@@ -6,6 +6,7 @@ export declare const ListMarginAccountsSchema: z.ZodObject<{
     page: z.ZodOptional<z.ZodNumber>;
     page_size: z.ZodOptional<z.ZodNumber>;
     state: z.ZodOptional<z.ZodString>;
+    tradingPairId: z.ZodOptional<z.ZodUUID>;
 }, z.core.$strip>;
 export declare const CreateMarginAccountSchema: z.ZodOptional<z.ZodObject<{
     label: z.ZodOptional<z.ZodString>;
@@ -24,6 +25,14 @@ export declare const TransferCollateralSchema: z.ZodObject<{
         amount: z.ZodString;
     }, z.core.$strip>;
 }, z.core.$strip>;
+export declare const TransferCollateralToAutoMarginAccountSchema: z.ZodObject<{
+    request: z.ZodObject<{
+        asset: z.ZodString;
+        amount: z.ZodString;
+        tradingPairId: z.ZodUUID;
+        strategyKey: z.ZodOptional<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>;
@@ -34,6 +43,30 @@ export declare const SimulateOrderRiskSchema: z.ZodObject<{
     marginAccountId: z.ZodUUID;
     request: z.ZodObject<{
         tradingPairId: z.ZodUUID;
+        strategyKey: z.ZodOptional<z.ZodString>;
+        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>;
+export declare const SimulateAutoMarginOrderRiskSchema: z.ZodObject<{
+    request: z.ZodObject<{
+        tradingPairId: z.ZodUUID;
+        strategyKey: z.ZodOptional<z.ZodString>;
         side: z.ZodEnum<{
             BUY: "BUY";
             SELL: "SELL";

package/dist/validation/margin-accounts.js

@@ -9,6 +9,7 @@ const PaginationSchema = z.object({
 });
 export const ListMarginAccountsSchema = PaginationSchema.extend({
     state: z.string().trim().min(1, "State cannot be empty").optional(),
+    tradingPairId: UUIDSchema.optional(),
 });
 export const CreateMarginAccountSchema = z
     .object({
@@ -24,36 +25,50 @@ export const GetAvailableCollateralSchema = z
     asset: z.string().trim().min(1, "Asset cannot be empty").optional(),
 })
     .optional();
+const TransferCollateralRequestSchema = z.object({
+    asset: z.string().trim().min(1, "Asset cannot be empty"),
+    amount: PositiveDecimalStringSchema,
+});
+const AutoMarginBucketRequestSchema = z.object({
+    tradingPairId: UUIDSchema,
+    strategyKey: z.string().trim().min(1, "Strategy key cannot be empty").optional(),
+});
 export const TransferCollateralSchema = z.object({
     marginAccountId: UUIDSchema,
-    request: z.object({
-        asset: z.string().trim().min(1, "Asset cannot be empty"),
-        amount: PositiveDecimalStringSchema,
-    }),
+    request: TransferCollateralRequestSchema,
+});
+export const TransferCollateralToAutoMarginAccountSchema = z.object({
+    request: TransferCollateralRequestSchema.merge(AutoMarginBucketRequestSchema),
 });
 export const GetMarginAccountMovementsSchema = PaginationSchema.extend({
     marginAccountId: UUIDSchema,
     movement_type: z.string().trim().min(1, "Movement type cannot be empty").optional(),
 });
+const SimulateOrderRiskRequestSchema = z.object({
+    tradingPairId: UUIDSchema,
+    strategyKey: z.string().trim().min(1, "Strategy key cannot be empty").optional(),
+    side: OrderSideSchema,
+    positionSide: PositionSideSchema,
+    orderType: OrderTypeSchema,
+    price: PositiveDecimalStringSchema.optional(),
+    quantity: PositiveDecimalStringSchema,
+    leverage: PositiveDecimalStringSchema,
+    reduceOnly: z.boolean().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(),
-    }),
+    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 SimulateAutoMarginOrderRiskSchema = z
+    .object({
+    request: SimulateOrderRiskRequestSchema,
 })
-    .refine((data) => data.request.orderType !== "MARKET" || data.request.price === undefined, {
-    message: "price must not be provided for MARKET risk simulations",
+    .refine((data) => data.request.orderType !== "LIMIT" || data.request.price !== undefined, {
+    message: "price is required for LIMIT risk simulations",
     path: ["request", "price"],
 });

package/dist/validation/trading.d.ts

@@ -101,6 +101,7 @@ export declare const PlaceLimitOrderSchema: z.ZodObject<{
             FOK: "FOK";
         }>>;
         marginAccountId: z.ZodOptional<z.ZodUUID>;
+        strategyKey: z.ZodOptional<z.ZodString>;
         positionSide: z.ZodOptional<z.ZodEnum<{
             LONG: "LONG";
             SHORT: "SHORT";
@@ -155,6 +156,7 @@ export declare const PlaceMarketOrderSchema: z.ZodObject<{
         }>>;
         slippageTolerance: z.ZodOptional<z.ZodNumber>;
         marginAccountId: z.ZodOptional<z.ZodUUID>;
+        strategyKey: z.ZodOptional<z.ZodString>;
         positionSide: z.ZodOptional<z.ZodEnum<{
             LONG: "LONG";
             SHORT: "SHORT";
@@ -347,6 +349,7 @@ export declare const BatchCreateOrderItemSchema: z.ZodObject<{
         FOK: "FOK";
     }>>;
     marginAccountId: z.ZodOptional<z.ZodUUID>;
+    strategyKey: z.ZodOptional<z.ZodString>;
     positionSide: z.ZodOptional<z.ZodEnum<{
         LONG: "LONG";
         SHORT: "SHORT";
@@ -386,6 +389,7 @@ export declare const BatchCreateOrdersSchema: z.ZodObject<{
             FOK: "FOK";
         }>>;
         marginAccountId: z.ZodOptional<z.ZodUUID>;
+        strategyKey: z.ZodOptional<z.ZodString>;
         positionSide: z.ZodOptional<z.ZodEnum<{
             LONG: "LONG";
             SHORT: "SHORT";

package/dist/validation/trading.js

@@ -117,6 +117,7 @@ export const PlaceLimitOrderSchema = z
         expirationDate: ISO8601DateSchema.optional(),
         timeInForce: TimeInForceSchema.optional(),
         marginAccountId: UUIDSchema.optional(),
+        strategyKey: z.string().min(1).max(128).optional(),
         positionSide: PositionSideSchema.optional(),
         leverage: PositiveDecimalStringSchema.optional(),
         reduceOnly: z.boolean().optional(),
@@ -124,10 +125,6 @@ export const PlaceLimitOrderSchema = z
         stopLoss: ParentTpSlLegSchema.optional(),
     })
         .optional(),
-})
-    .refine((data) => data.options?.tradingMode !== "MARGIN" || data.options.marginAccountId !== undefined, {
-    message: "marginAccountId is required for MARGIN orders",
-    path: ["options", "marginAccountId"],
 })
     .refine((data) => data.options?.tradingMode !== "MARGIN" || data.options.positionSide !== undefined, {
     message: "positionSide is required for MARGIN orders",
@@ -162,6 +159,7 @@ export const PlaceMarketOrderSchema = z
         tradingMode: TradingModeSchema.optional(),
         slippageTolerance: SlippageToleranceSchema,
         marginAccountId: UUIDSchema.optional(),
+        strategyKey: z.string().min(1).max(128).optional(),
         positionSide: PositionSideSchema.optional(),
         leverage: PositiveDecimalStringSchema.optional(),
         reduceOnly: z.boolean().optional(),
@@ -169,10 +167,6 @@ export const PlaceMarketOrderSchema = z
         stopLoss: ParentTpSlLegSchema.optional(),
     })
         .optional(),
-})
-    .refine((data) => data.options?.tradingMode !== "MARGIN" || data.options.marginAccountId !== undefined, {
-    message: "marginAccountId is required for MARGIN orders",
-    path: ["options", "marginAccountId"],
 })
     .refine((data) => data.options?.tradingMode !== "MARGIN" || data.options.positionSide !== undefined, {
     message: "positionSide is required for MARGIN orders",
@@ -309,6 +303,7 @@ export const BatchCreateOrderItemSchema = z
     expirationDate: ISO8601DateSchema.optional(),
     timeInForce: TimeInForceSchema.optional(),
     marginAccountId: UUIDSchema.optional(),
+    strategyKey: z.string().min(1).max(128).optional(),
     positionSide: PositionSideSchema.optional(),
     leverage: PositiveDecimalStringSchema.optional(),
     reduceOnly: z.boolean().optional(),
@@ -320,10 +315,6 @@ export const BatchCreateOrderItemSchema = z
     .refine((data) => data.orderType !== "MARKET" || data.price === undefined, {
     message: "Price must not be provided for MARKET orders",
     path: ["price"],
-})
-    .refine((data) => data.tradingMode !== "MARGIN" || data.marginAccountId !== undefined, {
-    message: "marginAccountId is required for MARGIN orders",
-    path: ["marginAccountId"],
 })
     .refine((data) => data.tradingMode !== "MARGIN" || data.positionSide !== undefined, {
     message: "positionSide is required for MARGIN orders",

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@0xmonaco/types",
-	"version": "0.8.1",
+	"version": "0.8.5",
 	"type": "module",
 	"repository": {
 		"type": "git",
@@ -20,7 +20,7 @@
 		"lint": "biome lint ."
 	},
 	"dependencies": {
-		"@0xmonaco/contracts": "0.8.1",
+		"@0xmonaco/contracts": "0.8.5",
 		"zod": "^4.1.12"
 	},
 	"peerDependencies": {