@0xmonaco/types 0.8.14 → 0.8.16

package/dist/applications/requests.d.ts

@@ -12,17 +12,17 @@ export interface ListAppOrdersParams {
     /** Page number (starts from 1) */
     page?: number;
     /** Items per page (max 100) */
-    page_size?: number;
+    pageSize?: number;
     /** Filter by order status (e.g. SUBMITTED, PARTIALLY_FILLED, FILLED, SETTLED, CANCELLED, EXPIRED, REJECTED) */
     status?: string;
     /** Filter by user UUID */
-    user_id?: string;
+    userId?: string;
     /** Filter by trading pair UUID */
-    trading_pair_id?: string;
+    tradingPairId?: string;
     /** Filter by order side: BUY or SELL */
     side?: string;
     /** Filter by order type (e.g. LIMIT, MARKET, STOP_LOSS, TAKE_PROFIT, STOP_LIMIT, TRAILING_STOP) */
-    order_type?: string;
+    orderType?: string;
 }
 /**
  * Query parameters for listing application users.
@@ -31,11 +31,11 @@ export interface ListAppUsersParams {
     /** Page number (starts from 1) */
     page?: number;
     /** Items per page (max 100) */
-    page_size?: number;
+    pageSize?: number;
     /** Filter by active status */
-    is_active?: boolean;
+    isActive?: boolean;
     /** Filter by account type: master or sub */
-    account_type?: string;
+    accountType?: string;
     /** Filter by wallet address (partial match, case-insensitive) */
     address?: string;
 }
@@ -46,15 +46,15 @@ export interface ListAppMovementsParams {
     /** Page number (starts from 1) */
     page?: number;
     /** Items per page (max 100) */
-    page_size?: number;
+    pageSize?: number;
     /** Filter by user UUID */
-    user_id?: string;
+    userId?: string;
     /** Filter by transaction type (e.g. DEPOSIT, WITHDRAWAL, TRADE, FEE, FUNDING, LIQUIDATION, INTEREST, REWARD) */
-    transaction_type?: string;
+    transactionType?: string;
     /** Filter by entry type (e.g. CREDIT, DEBIT, LOCK, UNLOCK, FEE) */
-    entry_type?: string;
+    entryType?: string;
     /** Filter by asset UUID */
-    asset_id?: string;
+    assetId?: string;
 }
 /**
  * Query parameters for listing application balances.
@@ -63,11 +63,11 @@ export interface ListAppBalancesParams {
     /** Page number (starts from 1) */
     page?: number;
     /** Items per page (max 100) */
-    page_size?: number;
+    pageSize?: number;
     /** Filter by user UUID */
-    user_id?: string;
+    userId?: string;
     /** Filter by asset UUID */
-    asset_id?: string;
+    assetId?: string;
 }
 /**
  * Query parameters for application stats.

package/dist/applications/responses.d.ts

@@ -30,11 +30,11 @@ export interface AppOrder {
     /** Order UUID */
     id: string;
     /** User UUID who placed the order */
-    user_id: string;
+    userId: string;
     /** Trading pair UUID */
-    trading_pair_id: string;
+    tradingPairId: string;
     /** Order type: LIMIT, MARKET, STOP_LOSS, TAKE_PROFIT, STOP_LIMIT, or TRAILING_STOP */
-    order_type: string;
+    orderType: string;
     /** Order side: BUY or SELL */
     side: string;
     /** Order price (null for market orders) */
@@ -42,23 +42,23 @@ export interface AppOrder {
     /** Order quantity (normalized for display) */
     quantity: string;
     /** Order quantity in raw format (for precision) */
-    quantity_raw: string;
+    quantityRaw: string;
     /** Filled quantity (normalized for display) */
-    filled_quantity: string | null;
+    filledQuantity: string | null;
     /** Filled quantity in raw format */
-    filled_quantity_raw: string | null;
+    filledQuantityRaw: string | null;
     /** Volume-weighted average fill price */
-    average_fill_price: string | null;
+    averageFillPrice: string | null;
     /** Order status */
     status: string;
     /** Trading mode: SPOT or MARGIN */
-    trading_mode: string;
+    tradingMode: string;
     /** Time in force: GTC, IOC, or FOK */
-    time_in_force: string | null;
+    timeInForce: string | null;
     /** Order creation timestamp (ISO 8601) */
-    created_at: string | null;
+    createdAt: string | null;
     /** Order last update timestamp (ISO 8601) */
-    updated_at: string | null;
+    updatedAt: string | null;
 }
 /**
  * One user belonging to an application.
@@ -71,21 +71,21 @@ export interface AppUser {
     /** Display username */
     username: string | null;
     /** Account type: master or sub */
-    account_type: string;
+    accountType: string;
     /** Whether the user is allowed to withdraw */
-    can_withdraw: boolean;
+    canWithdraw: boolean;
     /** Account creation timestamp (ISO 8601) */
-    created_at: string | null;
+    createdAt: string | null;
     /** Email address */
     email: string | null;
     /** Whether the user account is active */
-    is_active: boolean | null;
+    isActive: boolean | null;
     /** Whether the user is banned */
-    is_banned: boolean | null;
+    isBanned: boolean | null;
     /** Master account ID (for sub-accounts) */
-    master_account_id: string | null;
+    masterAccountId: string | null;
     /** Last update timestamp (ISO 8601) */
-    updated_at: string | null;
+    updatedAt: string | null;
 }
 /**
  * One ledger movement (deposit, withdrawal, trade, etc.) for an application.
@@ -94,68 +94,68 @@ export interface AppMovement {
     /** Transaction amount */
     amount: string;
     /** Balance after this transaction */
-    balance_after: string | null;
+    balanceAfter: string | null;
     /** Balance before this transaction */
-    balance_before: string | null;
+    balanceBefore: string | null;
     /** Balance UUID this movement affects */
-    balance_id: string;
+    balanceId: string;
     /** Blockchain block number */
-    block_number: number | null;
+    blockNumber: number | null;
     /** Transaction timestamp (ISO 8601) */
-    created_at: string | null;
+    createdAt: string | null;
     /** Human readable description */
     description: string | null;
     /** Type of ledger entry */
-    entry_type: string;
+    entryType: string;
     /** Movement UUID */
     id: string;
     /** Locked balance after transaction */
-    locked_after: string | null;
+    lockedAfter: string | null;
     /** Locked balance before transaction */
-    locked_before: string | null;
+    lockedBefore: string | null;
     /** Reference identifier for related operations */
-    reference_id: string | null;
+    referenceId: string | null;
     /** Reference type */
-    reference_type: string | null;
+    referenceType: string | null;
     /** Token address */
     token: Address;
     /** Type of transaction */
-    transaction_type: string;
+    transactionType: string;
     /** Blockchain transaction hash */
-    tx_hash: string | null;
+    txHash: string | null;
     /** User UUID who owns this movement */
-    user_id: string;
+    userId: string;
 }
 /**
  * One user balance held within an application.
  */
 export interface AppBalance {
     /** Available balance for trading */
-    available_balance: string;
+    availableBalance: string;
     /** Balance creation timestamp (ISO 8601) */
-    created_at: string | null;
+    createdAt: string | null;
     /** Token decimals */
     decimals: number;
     /** Balance UUID */
     id: string;
     /** Last sync timestamp (ISO 8601) */
-    last_sync_at: string | null;
+    lastSyncAt: string | null;
     /** Last sync block number */
-    last_sync_block: number | null;
+    lastSyncBlock: number | null;
     /** Locked balance */
-    locked_balance: string;
+    lockedBalance: string;
     /** On-chain balance */
-    on_chain_balance: string;
+    onChainBalance: string;
     /** Token symbol */
     symbol: string | null;
     /** Token address */
     token: Address;
     /** Total balance */
-    total_balance: string;
+    totalBalance: string;
     /** Balance last update timestamp (ISO 8601) */
-    updated_at: string | null;
+    updatedAt: string | null;
     /** User UUID who owns this balance */
-    user_id: string;
+    userId: string;
 }
 /**
  * Paginated list of application orders.
@@ -167,9 +167,9 @@ export interface ListAppOrdersResponse {
     /** Current page number */
     page: number;
     /** Items per page */
-    page_size: number;
+    pageSize: number;
     /** Total number of pages */
-    total_pages: number;
+    totalPages: number;
 }
 /**
  * Paginated list of application users.
@@ -181,9 +181,9 @@ export interface ListAppUsersResponse {
     /** Current page number */
     page: number;
     /** Items per page */
-    page_size: number;
+    pageSize: number;
     /** Total number of pages */
-    total_pages: number;
+    totalPages: number;
 }
 /**
  * Paginated list of application movements.
@@ -195,9 +195,9 @@ export interface ListAppMovementsResponse {
     /** Current page number */
     page: number;
     /** Items per page */
-    page_size: number;
+    pageSize: number;
     /** Total number of pages */
-    total_pages: number;
+    totalPages: number;
 }
 /**
  * Paginated list of application balances.
@@ -209,9 +209,9 @@ export interface ListAppBalancesResponse {
     /** Current page number */
     page: number;
     /** Items per page */
-    page_size: number;
+    pageSize: number;
     /** Total number of pages */
-    total_pages: number;
+    totalPages: number;
 }
 /**
  * Aggregate volume and fee stats for an application.
@@ -223,11 +223,11 @@ export interface GetAppStatsResponse {
     /** Total quote volume for trades where this application's users were the taker */
     volume: string;
     /** Total maker fees collected */
-    maker_fee: string;
+    makerFee: string;
     /** Total taker fees collected */
-    taker_fee: string;
+    takerFee: string;
     /** Application revenue share from taker fees */
-    application_taker_fee: string;
+    applicationTakerFee: string;
     /** Total number of trades */
-    trade_count: number;
+    tradeCount: number;
 }

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

@@ -16,30 +16,30 @@ export interface UpsertDelegatedAgentRequest {
 }
 export interface DelegatedAgent {
     id: string;
-    owner_user_id: string;
-    agent_address: Address;
+    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 {
-    owner_user_id: string;
-    delegation_id: string;
+    ownerUserId: string;
+    delegationId: string;
     name?: string;
-    is_active: boolean;
-    expires_at?: string;
+    isActive: boolean;
+    expiresAt?: string;
 }
 export interface ListDelegatedOwnersResponse {
     owners: DelegatedAgentOwner[];
@@ -54,10 +54,10 @@ export interface CreateDelegatedSessionRequest {
     sessionPublicKey: string;
 }
 export interface CreateDelegatedSessionResponse {
-    expires_at: number;
-    delegation_id: string;
-    owner_user_id: string;
-    agent_address: Address;
+    expiresAt: number;
+    delegationId: string;
+    ownerUserId: string;
+    agentAddress: Address;
 }
 export interface DelegatedAgentsAPI extends BaseAPI {
     upsertDelegatedAgent(request: UpsertDelegatedAgentRequest): Promise<DelegatedAgent>;

package/dist/faucet/index.d.ts

@@ -12,18 +12,18 @@ import type { BaseAPI } from "../api";
 /** A token successfully minted by the faucet. */
 export interface MintedToken {
     /** Asset UUID */
-    asset_id: string;
+    assetId: string;
     /** Token symbol */
     symbol: string;
     /** Amount minted in token units */
     amount: string;
     /** On-chain transaction hash */
-    tx_hash: string;
+    txHash: string;
 }
 /** A token the faucet failed to mint. */
 export interface FailedMint {
     /** Asset UUID */
-    asset_id: string;
+    assetId: string;
     /** Token symbol */
     symbol: string;
     /** Error message describing why the mint failed */
@@ -36,7 +36,7 @@ export interface MintTokensResponse {
     /** Tokens that failed to mint */
     failed: FailedMint[];
     /** Remaining faucet requests in the next 24h */
-    remaining_requests_24h: number;
+    remainingRequests24h: number;
 }
 /**
  * Faucet API interface. Session-authenticated.

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(),
 });