@0xmonaco/types 0.8.5 → 0.8.7-develop.0f12336

package/dist/contracts/balances.d.ts

@@ -33,7 +33,7 @@ export interface Token {
  */
 export interface UserBalance {
     /** Token address */
-    token: string;
+    token: Address;
     /** Available balance for trading */
     available: bigint;
     /** Locked balance in open orders */

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

@@ -1,3 +1,4 @@
+import type { Address } from "viem";
 import type { BaseAPI } from "../api";
 export type DelegatedAgentAction = "CREATE_ORDER" | "CANCEL_ORDER" | "REPLACE_ORDER" | "create_order" | "cancel_order" | "replace_order";
 export interface UpsertDelegatedAgentRequest {
@@ -15,37 +16,53 @@ export interface UpsertDelegatedAgentRequest {
 }
 export interface DelegatedAgent {
     id: string;
-    owner_user_id: string;
-    agent_address: string;
+    ownerUserId: string;
+    agentAddress: Address;
     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;
+    isActive: boolean;
+    expiresAt?: string;
+    revokedAt?: string;
+    allowedActions: string[];
+    allowedTradingPairIds: string[];
+    allowedMarginAccountIds: string[];
+    allowedOrderTypes?: string[];
+    allowedTimeInForce?: string[];
+    maxLeverage?: string;
+    maxOrderNotional?: string;
+    maxOpenOrders?: number;
 }
 export interface ListDelegatedAgentsResponse {
     agents: DelegatedAgent[];
 }
+export interface DelegatedAgentOwner {
+    ownerUserId: string;
+    delegationId: string;
+    name?: string;
+    isActive: boolean;
+    expiresAt?: string;
+}
+export interface ListDelegatedOwnersResponse {
+    owners: DelegatedAgentOwner[];
+}
 export interface CreateDelegatedSessionRequest {
     ownerUserId: string;
+    /**
+     * Lowercase-hex (64 chars) ed25519 public key the agent generated for this
+     * delegated session. Required: subsequent requests acting on the owner's
+     * behalf are signed with the matching private key.
+     */
+    sessionPublicKey: string;
 }
 export interface CreateDelegatedSessionResponse {
-    access_token: string;
-    expires_at: number;
-    delegation_id: string;
-    owner_user_id: string;
-    agent_address: string;
+    expiresAt: number;
+    delegationId: string;
+    ownerUserId: string;
+    agentAddress: Address;
 }
 export interface DelegatedAgentsAPI extends BaseAPI {
     upsertDelegatedAgent(request: UpsertDelegatedAgentRequest): Promise<DelegatedAgent>;
     listDelegatedAgents(): Promise<ListDelegatedAgentsResponse>;
+    listDelegatedOwners(): Promise<ListDelegatedOwnersResponse>;
     revokeDelegatedAgent(delegatedAgentId: string): Promise<{
         status: "REVOKED";
     }>;

package/dist/faucet/index.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Faucet Types
+ *
+ * Types for the testnet token faucet. Wire shapes are snake_case.
+ *
+ * NOTE: The faucet is **testnet-only** and performs real on-chain mints from a
+ * backend-operator-funded signer. It is disabled (returns an error) if the
+ * gateway operator has not configured a signer; the SDK caller has no control
+ * over that. It is rate-limited per user (default 1 request / 24h).
+ */
+import type { BaseAPI } from "../api";
+/** A token successfully minted by the faucet. */
+export interface MintedToken {
+    /** Asset UUID */
+    assetId: string;
+    /** Token symbol */
+    symbol: string;
+    /** Amount minted in token units */
+    amount: string;
+    /** On-chain transaction hash */
+    txHash: string;
+}
+/** A token the faucet failed to mint. */
+export interface FailedMint {
+    /** Asset UUID */
+    assetId: string;
+    /** Token symbol */
+    symbol: string;
+    /** Error message describing why the mint failed */
+    error: string;
+}
+/** Result of a faucet mint request. */
+export interface MintTokensResponse {
+    /** Tokens that were successfully minted */
+    minted: MintedToken[];
+    /** Tokens that failed to mint */
+    failed: FailedMint[];
+    /** Remaining faucet requests in the next 24h */
+    remainingRequests24h: number;
+}
+/**
+ * Faucet API interface. Session-authenticated.
+ */
+export interface FaucetAPI extends BaseAPI {
+    /**
+     * Mints the full set of testnet tokens to the authenticated user.
+     *
+     * Testnet-only and rate-limited; see the module note. Partial success is
+     * possible — inspect `minted` and `failed` in the response.
+     *
+     * @returns Promise resolving to the minted/failed tokens and remaining quota
+     */
+    mint(): Promise<MintTokensResponse>;
+}

package/dist/faucet/index.js

@@ -0,0 +1,10 @@
+/**
+ * Faucet Types
+ *
+ * Types for the testnet token faucet. Wire shapes are snake_case.
+ *
+ * NOTE: The faucet is **testnet-only** and performs real on-chain mints from a
+ * backend-operator-funded signer. It is disabled (returns an error) if the
+ * gateway operator has not configured a signer; the SDK caller has no control
+ * over that. It is rate-limited per user (default 1 request / 24h).
+ */

package/dist/fees/index.d.ts

@@ -15,7 +15,7 @@ export interface FeesAPI extends BaseAPI {
      * Returns exact fees for that specific order.
      *
      * @param params - Parameters for fee simulation
-     * @param params.trading_pair_id - Trading pair ID
+     * @param params.tradingPairId - Trading pair ID
      * @param params.side - Order side ("BUY" or "SELL")
      * @param params.price - Price per unit
      * @param params.quantity - Quantity to trade
@@ -24,13 +24,13 @@ export interface FeesAPI extends BaseAPI {
      * @example
      * ```typescript
      * const feeDetails = await feesAPI.simulateFees({
-     *   trading_pair_id: "123e4567-e89b-12d3-a456-426614174000",
+     *   tradingPairId: "123e4567-e89b-12d3-a456-426614174000",
      *   side: "BUY",
      *   price: "40000.00",
      *   quantity: "0.5"
      * });
-     * console.log(`Total taker fees: ${feeDetails.total_taker_fees}`);
-     * console.log(`Taker must pay: ${feeDetails.taker_total_payment}`);
+     * console.log(`Total taker fees: ${feeDetails.totalTakerFees}`);
+     * console.log(`Taker must pay: ${feeDetails.takerTotalPayment}`);
      * ```
      */
     simulateFees(params: SimulateFeeParams): Promise<SimulateFeeResponse>;

package/dist/fees/responses.d.ts

@@ -9,38 +9,38 @@ import { z } from "zod";
  * Zod schema for simulating order fees parameters
  */
 export declare const SimulateFeeParamsSchema: z.ZodObject<{
-    trading_pair_id: z.ZodString;
+    tradingPairId: z.ZodString;
     side: z.ZodEnum<{
         BUY: "BUY";
         SELL: "SELL";
     }>;
     price: z.ZodString;
     quantity: z.ZodString;
-    order_type: z.ZodOptional<z.ZodEnum<{
+    orderType: z.ZodOptional<z.ZodEnum<{
         LIMIT: "LIMIT";
         MARKET: "MARKET";
     }>>;
-    slippage_tolerance_bps: z.ZodOptional<z.ZodNumber>;
+    slippageToleranceBps: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strip>;
 /**
  * Zod schema for fee simulation response
  */
 export declare const SimulateFeeResponseSchema: z.ZodObject<{
-    application_name: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-    application_taker_fee: z.ZodString;
-    application_taker_fee_bps: z.ZodNumber;
-    buy_order_lock_amount: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-    maker_total_receipt: z.ZodString;
-    monaco_maker_rebate: z.ZodString;
-    monaco_maker_rebate_bps: z.ZodNumber;
-    monaco_taker_fee: z.ZodString;
-    monaco_taker_fee_bps: z.ZodNumber;
+    applicationName: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    applicationTakerFee: z.ZodString;
+    applicationTakerFeeBps: z.ZodNumber;
+    buyOrderLockAmount: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    makerTotalReceipt: z.ZodString;
+    monacoMakerRebate: z.ZodString;
+    monacoMakerRebateBps: z.ZodNumber;
+    monacoTakerFee: z.ZodString;
+    monacoTakerFeeBps: z.ZodNumber;
     notional: z.ZodString;
-    taker_total_payment: z.ZodString;
-    total_taker_fees: z.ZodString;
-    max_quantity: z.ZodNullable<z.ZodString>;
-    max_quantity_raw: z.ZodNullable<z.ZodString>;
-    slippage_tolerance_bps: z.ZodNullable<z.ZodNumber>;
+    takerTotalPayment: z.ZodString;
+    totalTakerFees: z.ZodString;
+    maxQuantity: z.ZodNullable<z.ZodString>;
+    maxQuantityRaw: z.ZodNullable<z.ZodString>;
+    slippageToleranceBps: z.ZodNullable<z.ZodNumber>;
 }, z.core.$strip>;
 /**
  * Parameters for simulating order fees

package/dist/fees/responses.js

@@ -11,7 +11,7 @@ import { z } from "zod";
 export const SimulateFeeParamsSchema = z
     .object({
     /** Trading pair ID */
-    trading_pair_id: z.string().trim().min(1, "Trading pair ID is required and cannot be empty"),
+    tradingPairId: z.string().trim().min(1, "Trading pair ID is required and cannot be empty"),
     /** Order side: "BUY" or "SELL" */
     side: z.enum(["BUY", "SELL"], {
         message: "Order side is required and must be either 'BUY' or 'SELL'",
@@ -31,9 +31,9 @@ export const SimulateFeeParamsSchema = z
         .refine((val) => !Number.isNaN(Number(val)), "Quantity must be a valid number")
         .refine((val) => Number(val) > 0, "Quantity must be greater than 0"),
     /** Order type: "LIMIT" (default) or "MARKET". MARKET orders include a slippage buffer in the lock amount. */
-    order_type: z.enum(["LIMIT", "MARKET"]).optional(),
+    orderType: z.enum(["LIMIT", "MARKET"]).optional(),
     /** Slippage tolerance in basis points (0–1000). Only valid for MARKET orders. Default: 500 (5%). */
-    slippage_tolerance_bps: z
+    slippageToleranceBps: z
         .number()
         .int()
         .min(0, "Slippage tolerance must be between 0 and 1000 bps")
@@ -41,11 +41,11 @@ export const SimulateFeeParamsSchema = z
         .optional(),
 })
     .superRefine((data, ctx) => {
-    if (data.slippage_tolerance_bps !== undefined && data.order_type !== "MARKET") {
+    if (data.slippageToleranceBps !== undefined && data.orderType !== "MARKET") {
         ctx.addIssue({
             code: z.ZodIssueCode.custom,
-            message: "slippage_tolerance_bps is only valid when order_type is MARKET",
-            path: ["slippage_tolerance_bps"],
+            message: "slippageToleranceBps is only valid when orderType is MARKET",
+            path: ["slippageToleranceBps"],
         });
     }
 });
@@ -54,33 +54,33 @@ export const SimulateFeeParamsSchema = z
  */
 export const SimulateFeeResponseSchema = z.object({
     /** Application name (if applicable) */
-    application_name: z.string().nullable().optional(),
+    applicationName: z.string().nullable().optional(),
     /** Frontend application taker fee */
-    application_taker_fee: z.string(),
+    applicationTakerFee: z.string(),
     /** Application fee in basis points */
-    application_taker_fee_bps: z.number(),
+    applicationTakerFeeBps: z.number(),
     /** Amount to lock for BUY orders (null for `SELL`) */
-    buy_order_lock_amount: z.string().nullable().optional(),
+    buyOrderLockAmount: z.string().nullable().optional(),
     /** Total amount maker receives */
-    maker_total_receipt: z.string(),
+    makerTotalReceipt: z.string(),
     /** Monaco protocol maker rebate (negative = rebate) */
-    monaco_maker_rebate: z.string(),
+    monacoMakerRebate: z.string(),
     /** Monaco maker rebate in basis points */
-    monaco_maker_rebate_bps: z.number(),
+    monacoMakerRebateBps: z.number(),
     /** Monaco protocol taker fee */
-    monaco_taker_fee: z.string(),
+    monacoTakerFee: z.string(),
     /** Monaco taker fee in basis points */
-    monaco_taker_fee_bps: z.number(),
+    monacoTakerFeeBps: z.number(),
     /** Notional value (price * quantity) */
     notional: z.string(),
     /** Total amount taker must pay */
-    taker_total_payment: z.string(),
+    takerTotalPayment: z.string(),
     /** Total taker fees (monaco + application) */
-    total_taker_fees: z.string(),
+    totalTakerFees: z.string(),
     /** Maximum quantity affordable at the given price, accounting for fees (null if not authenticated or balance unavailable) */
-    max_quantity: z.string().nullable(),
+    maxQuantity: z.string().nullable(),
     /** Maximum quantity in RAW (smallest unit) format */
-    max_quantity_raw: z.string().nullable(),
+    maxQuantityRaw: z.string().nullable(),
     /** Slippage tolerance used in the calculation, echoed back for MARKET orders (null for LIMIT orders) */
-    slippage_tolerance_bps: z.number().nullable(),
+    slippageToleranceBps: z.number().nullable(),
 });

package/dist/index.d.ts

@@ -9,13 +9,17 @@ export * from "./applications";
 export * from "./auth";
 export * from "./contracts";
 export * from "./delegated-agents";
+export * from "./faucet";
 export * from "./fees";
 export * from "./margin-accounts";
 export * from "./market";
 export * from "./positions";
 export * from "./profile";
 export * from "./sdk";
+export * from "./sub-accounts";
 export * from "./trading";
 export * from "./validation";
 export * from "./vault";
 export * from "./websocket";
+export * from "./whitelist";
+export * from "./withdrawals";

package/dist/index.js

@@ -10,13 +10,17 @@ export * from "./applications";
 export * from "./auth";
 export * from "./contracts";
 export * from "./delegated-agents";
+export * from "./faucet";
 export * from "./fees";
 export * from "./margin-accounts";
 export * from "./market";
 export * from "./positions";
 export * from "./profile";
 export * from "./sdk";
+export * from "./sub-accounts";
 export * from "./trading";
 export * from "./validation";
 export * from "./vault";
 export * from "./websocket";
+export * from "./whitelist";
+export * from "./withdrawals";

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

@@ -1,24 +1,26 @@
 import type { BaseAPI } from "../api";
 import type { OrderSide, OrderType, PositionSide } from "../trading";
 export interface MarginAccountSummary {
-    margin_account_id: string;
+    marginAccountId: string;
     label?: string;
-    trading_pair_id?: string;
-    strategy_key?: string;
-    account_state: string;
+    riskBucketId?: string;
+    marginMode?: "ISOLATED" | "CROSS";
+    tradingPairId?: string;
+    strategyKey?: string;
+    accountState: string;
     equity: string;
-    initial_margin_required: string;
-    maintenance_margin_required: string;
-    free_collateral: string;
-    withdrawable_collateral: string;
-    total_position_notional: string;
-    unrealized_pnl: string;
-    realized_pnl: string;
-    updated_at: string;
+    initialMarginRequired: string;
+    maintenanceMarginRequired: string;
+    freeCollateral: string;
+    withdrawableCollateral: string;
+    totalPositionNotional: string;
+    unrealizedPnl: string;
+    realizedPnl: string;
+    updatedAt: string;
 }
 export interface ListMarginAccountsParams {
     page?: number;
-    page_size?: number;
+    pageSize?: number;
     state?: string;
     tradingPairId?: string;
 }
@@ -26,69 +28,77 @@ export interface ListMarginAccountsResponse {
     accounts: MarginAccountSummary[];
     total: number;
     page: number;
-    page_size: number;
+    pageSize: number;
 }
-export interface CreateMarginAccountRequest {
-    label?: string;
-    collateralAsset?: string;
-}
-export interface CreateMarginAccountResponse {
-    margin_account_id: string;
-    label?: string;
-    account_state: string;
-    collateral_asset: string;
-    created_at: string;
+export interface GetMarginAccountSummaryParams {
+    tradingPairId?: string;
 }
 export interface GetAvailableCollateralParams {
     asset?: string;
 }
 export interface GetAvailableCollateralResponse {
     asset: string;
-    wallet_available: string;
-    wallet_locked: string;
-    margin_transferable?: string;
+    walletAvailable: string;
+    walletLocked: string;
+    marginTransferable?: string;
+    /**
+     * Free collateral held in the user's parent margin account for this asset
+     * (equity minus initial margin required) — collateral already inside margin
+     * and available to open new positions or transfer back out. Absent when the
+     * user has no margin account yet.
+     */
+    marginAvailableCollateral?: string;
 }
 export interface TransferCollateralRequest {
     asset: string;
     amount: string;
+    tradingPairId?: string;
+    strategyKey?: string;
 }
-export interface TransferCollateralToAutoMarginAccountRequest extends TransferCollateralRequest {
+export interface TransferCollateralToParentMarginAccountRequest {
+    asset: string;
+    amount: string;
+}
+export interface TransferCollateralToRiskBucketRequest extends TransferCollateralToParentMarginAccountRequest {
     tradingPairId: string;
     strategyKey?: string;
 }
+export interface TransferCollateralFromParentMarginAccountRequest {
+    asset: string;
+    amount: string;
+}
 export interface TransferCollateralResponse {
-    movement_id: string;
-    margin_account_id: string;
-    strategy_key?: string;
+    movementId: string;
+    marginAccountId: string;
+    strategyKey?: string;
     asset: string;
     amount: string;
     status: string;
-    new_equity: string;
-    new_total_collateral_value: string;
-    new_withdrawable_collateral: string;
+    newEquity: string;
+    newTotalCollateralValue: string;
+    newWithdrawableCollateral: string;
 }
 export interface GetMarginAccountMovementsParams {
-    movement_type?: string;
+    movementType?: string;
     page?: number;
-    page_size?: number;
+    pageSize?: number;
 }
 export interface MarginAccountMovement {
-    movement_id: string;
-    margin_account_id: string;
-    movement_type: string;
+    movementId: string;
+    marginAccountId: string;
+    movementType: string;
     asset: string;
     amount: string;
-    created_at: string;
+    createdAt: string;
 }
 export interface GetMarginAccountMovementsResponse {
     movements: MarginAccountMovement[];
     total: number;
     page: number;
-    page_size: number;
+    pageSize: number;
 }
 export interface SimulateOrderRiskRequest {
     tradingPairId: string;
-    strategyKey?: string;
     side: OrderSide;
     positionSide: PositionSide;
     orderType: OrderType;
@@ -97,27 +107,53 @@ export interface SimulateOrderRiskRequest {
     leverage: string;
     reduceOnly?: boolean;
 }
+export interface SimulateRiskBucketOrderRiskRequest extends SimulateOrderRiskRequest {
+    strategyKey?: string;
+}
 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;
-    free_collateral_after: string;
-    estimated_fee?: string;
-    estimated_liquidation_price?: string;
+    rejectReason?: string;
+    marginAccountId: string;
+    strategyKey?: string;
+    equityAfter: string;
+    initialMarginRequiredAfter: string;
+    maintenanceMarginRequiredAfter: string;
+    freeCollateralAfter: string;
+    estimatedFee?: string;
+    estimatedLiquidationPrice?: string;
 }
 export interface MarginAccountsAPI extends BaseAPI {
     listMarginAccounts(params?: ListMarginAccountsParams): Promise<ListMarginAccountsResponse>;
-    createMarginAccount(request?: CreateMarginAccountRequest): Promise<CreateMarginAccountResponse>;
-    getMarginAccountSummary(marginAccountId: string): Promise<MarginAccountSummary>;
+    getParentMarginAccountSummary(params?: GetMarginAccountSummaryParams): Promise<MarginAccountSummary>;
+    /**
+     * @deprecated Prefer getParentMarginAccountSummary(). Parent margin account ids
+     * are auto-resolved for the authenticated wallet/application scope.
+     */
+    getMarginAccountSummary(marginAccountId: string, params?: GetMarginAccountSummaryParams): Promise<MarginAccountSummary>;
     getAvailableCollateral(params?: GetAvailableCollateralParams): Promise<GetAvailableCollateralResponse>;
+    /**
+     * @deprecated Prefer transferCollateralToParentMarginAccount() or
+     * transferCollateralToRiskBucket().
+     */
     transferCollateralToMarginAccount(marginAccountId: string, request: TransferCollateralRequest): Promise<TransferCollateralResponse>;
-    transferCollateralToAutoMarginAccount(request: TransferCollateralToAutoMarginAccountRequest): Promise<TransferCollateralResponse>;
+    transferCollateralToParentMarginAccount(request: TransferCollateralToParentMarginAccountRequest): Promise<TransferCollateralResponse>;
+    transferCollateralToRiskBucket(request: TransferCollateralToRiskBucketRequest): Promise<TransferCollateralResponse>;
+    /**
+     * @deprecated Prefer transferCollateralFromParentMarginAccount().
+     */
     transferCollateralFromMarginAccount(marginAccountId: string, request: TransferCollateralRequest): Promise<TransferCollateralResponse>;
+    transferCollateralFromParentMarginAccount(request: TransferCollateralFromParentMarginAccountRequest): Promise<TransferCollateralResponse>;
+    getParentMarginAccountMovements(params?: GetMarginAccountMovementsParams): Promise<GetMarginAccountMovementsResponse>;
+    /**
+     * @deprecated Prefer getParentMarginAccountMovements(). Parent margin account ids
+     * are auto-resolved for the authenticated wallet/application scope.
+     */
     getMarginAccountMovements(marginAccountId: string, params?: GetMarginAccountMovementsParams): Promise<GetMarginAccountMovementsResponse>;
+    simulateParentMarginOrderRisk(request: SimulateOrderRiskRequest): Promise<SimulateOrderRiskResponse>;
+    /**
+     * @deprecated Prefer simulateParentMarginOrderRisk(). Parent margin account ids
+     * are auto-resolved for the authenticated wallet/application scope.
+     */
     simulateOrderRisk(marginAccountId: string, request: SimulateOrderRiskRequest): Promise<SimulateOrderRiskResponse>;
-    simulateAutoMarginOrderRisk(request: SimulateOrderRiskRequest): Promise<SimulateOrderRiskResponse>;
+    simulateRiskBucketOrderRisk(request: SimulateRiskBucketOrderRiskRequest): Promise<SimulateOrderRiskResponse>;
 }