@0xmonaco/core 0.8.7-develop.0e951a5 → 0.8.7-develop.0f12336

package/dist/api/trading/api.js

@@ -21,19 +21,19 @@
  * );
  * ```
  */
-import { BatchCreateOrdersSchema, BatchReplaceOrdersSchema, CancelConditionalOrderSchema, CancelOrderSchema, CreateConditionalOrderSchema, GetPaginatedOrdersSchema, ListConditionalOrdersSchema, PlaceLimitOrderSchema, PlaceMarketOrderSchema, ReplaceOrderSchema, validate, } from "@0xmonaco/types";
+import { BatchCreateOrdersSchema, BatchReplaceOrdersSchema, CancelConditionalOrderSchema, CancelOrderSchema, GetPaginatedOrdersSchema, ListConditionalOrdersSchema, PlaceLimitOrderSchema, PlaceMarketOrderSchema, ReplaceOrderSchema, validate, } from "@0xmonaco/types";
 import { BaseAPI } from "../base";
 import { perpRoutes } from "../perp";
 function parentTpSlLegToRequest(leg) {
     if (!leg)
         return undefined;
     return {
-        trigger_price: leg.triggerPrice,
-        order_type: leg.orderType,
-        limit_price: leg.limitPrice,
-        time_in_force: leg.timeInForce,
-        slippage_tolerance_bps: leg.slippageToleranceBps,
-        expires_at: leg.expiresAt,
+        triggerPrice: leg.triggerPrice,
+        orderType: leg.orderType,
+        limitPrice: leg.limitPrice,
+        timeInForce: leg.timeInForce,
+        slippageToleranceBps: leg.slippageToleranceBps,
+        expiresAt: leg.expiresAt,
     };
 }
 export class TradingAPIImpl extends BaseAPI {
@@ -97,22 +97,24 @@ export class TradingAPIImpl extends BaseAPI {
             options,
         });
         const requestBody = {
-            trading_pair_id: tradingPairId,
-            order_type: "LIMIT",
+            tradingPairId: tradingPairId,
+            orderType: "LIMIT",
             side,
             price,
             quantity,
-            trading_mode: options?.tradingMode || "SPOT",
-            use_master_balance: options?.useMasterBalance,
-            expiration_date: options?.expirationDate,
-            time_in_force: options?.timeInForce,
-            margin_account_id: options?.marginAccountId,
-            strategy_key: options?.strategyKey,
-            position_side: options?.positionSide,
+            tradingMode: options?.tradingMode || "SPOT",
+            useMasterBalance: options?.useMasterBalance,
+            expirationDate: options?.expirationDate,
+            timeInForce: options?.timeInForce,
+            marginAccountId: options?.marginAccountId,
+            riskBucketId: options?.riskBucketId,
+            riskBucketCollateral: options?.riskBucketCollateral,
+            strategyKey: options?.strategyKey,
+            positionSide: options?.positionSide,
             leverage: options?.leverage,
-            reduce_only: options?.reduceOnly,
-            take_profit: parentTpSlLegToRequest(options?.takeProfit),
-            stop_loss: parentTpSlLegToRequest(options?.stopLoss),
+            reduceOnly: options?.reduceOnly,
+            takeProfit: parentTpSlLegToRequest(options?.takeProfit),
+            stopLoss: parentTpSlLegToRequest(options?.stopLoss),
         };
         return await this.makeAuthenticatedRequest(perpRoutes.orders.create(), {
             method: "POST",
@@ -169,20 +171,22 @@ export class TradingAPIImpl extends BaseAPI {
             options,
         });
         const requestBody = {
-            trading_pair_id: tradingPairId,
-            order_type: "MARKET",
+            tradingPairId: tradingPairId,
+            orderType: "MARKET",
             side,
-            slippage_tolerance_bps: options?.slippageTolerance !== undefined ? Math.round(options.slippageTolerance * 10000) : undefined,
+            slippageToleranceBps: options?.slippageTolerance !== undefined ? Math.round(options.slippageTolerance * 10000) : undefined,
             price: null, // Market orders don't need price
             quantity,
-            trading_mode: options?.tradingMode || "SPOT",
-            margin_account_id: options?.marginAccountId,
-            strategy_key: options?.strategyKey,
-            position_side: options?.positionSide,
+            tradingMode: options?.tradingMode || "SPOT",
+            marginAccountId: options?.marginAccountId,
+            riskBucketId: options?.riskBucketId,
+            riskBucketCollateral: options?.riskBucketCollateral,
+            strategyKey: options?.strategyKey,
+            positionSide: options?.positionSide,
             leverage: options?.leverage,
-            reduce_only: options?.reduceOnly,
-            take_profit: parentTpSlLegToRequest(options?.takeProfit),
-            stop_loss: parentTpSlLegToRequest(options?.stopLoss),
+            reduceOnly: options?.reduceOnly,
+            takeProfit: parentTpSlLegToRequest(options?.takeProfit),
+            stopLoss: parentTpSlLegToRequest(options?.stopLoss),
         };
         return await this.makeAuthenticatedRequest(perpRoutes.orders.create(), {
             method: "POST",
@@ -209,36 +213,13 @@ export class TradingAPIImpl extends BaseAPI {
         // Validate inputs before making API call
         validate(CancelOrderSchema, { orderId });
         const requestBody = {
-            order_id: orderId,
+            orderId: orderId,
         };
         return await this.makeAuthenticatedRequest(perpRoutes.orders.cancel(), {
             method: "POST",
             body: JSON.stringify(requestBody),
         });
     }
-    async createConditionalOrder(params) {
-        validate(CreateConditionalOrderSchema, params);
-        const requestBody = {
-            trading_pair_id: params.tradingPairId,
-            margin_account_id: params.marginAccountId,
-            condition_type: params.conditionType,
-            trigger_price: params.triggerPrice,
-            trigger_source: params.triggerSource ?? "MARK_PRICE",
-            side: params.side,
-            position_side: params.positionSide,
-            order_type: params.orderType,
-            limit_price: params.limitPrice,
-            quantity: params.quantity,
-            reduce_only: params.reduceOnly ?? true,
-            time_in_force: params.timeInForce,
-            slippage_tolerance_bps: params.slippageToleranceBps,
-            expires_at: params.expiresAt,
-        };
-        return await this.makeAuthenticatedRequest(perpRoutes.orders.createConditional(), {
-            method: "POST",
-            body: JSON.stringify(requestBody),
-        });
-    }
     async cancelConditionalOrder(conditionalOrderId) {
         validate(CancelConditionalOrderSchema, { conditionalOrderId });
         return await this.makeAuthenticatedRequest(perpRoutes.orders.cancelConditional(conditionalOrderId), {
@@ -249,12 +230,12 @@ export class TradingAPIImpl extends BaseAPI {
         if (params) {
             validate(ListConditionalOrdersSchema, params);
         }
-        const { page = 1, page_size = 20, margin_account_id, trading_pair_id, state } = params || {};
+        const { page = 1, pageSize = 20, marginAccountId, tradingPairId, state } = params || {};
         return await this.makeAuthenticatedRequest(perpRoutes.orders.listConditional({
             page,
-            page_size: Math.min(Math.max(page_size, 1), 100),
-            margin_account_id,
-            trading_pair_id,
+            pageSize: Math.min(Math.max(pageSize, 1), 100),
+            marginAccountId,
+            tradingPairId,
             state,
         }), { method: "GET" });
     }
@@ -276,7 +257,7 @@ export class TradingAPIImpl extends BaseAPI {
         }
         return this.makeAuthenticatedRequest(perpRoutes.orders.batchCancel(), {
             method: "POST",
-            body: JSON.stringify({ order_ids: orderIds }),
+            body: JSON.stringify({ orderIds: orderIds }),
         });
     }
     /**
@@ -305,7 +286,7 @@ export class TradingAPIImpl extends BaseAPI {
         // Validate inputs before making API call
         validate(ReplaceOrderSchema, { orderId, newOrder });
         const requestBody = {
-            use_master_balance: newOrder.useMasterBalance ?? false,
+            useMasterBalance: newOrder.useMasterBalance ?? false,
         };
         if (newOrder.price !== undefined) {
             requestBody.price = newOrder.price;
@@ -352,21 +333,23 @@ export class TradingAPIImpl extends BaseAPI {
         validate(BatchCreateOrdersSchema, { orders });
         const requestBody = {
             orders: orders.map((order) => ({
-                trading_pair_id: order.tradingPairId,
-                order_type: order.orderType,
+                tradingPairId: order.tradingPairId,
+                orderType: order.orderType,
                 side: order.side,
                 price: order.price,
                 quantity: order.quantity,
-                trading_mode: order.tradingMode || "SPOT",
-                slippage_tolerance_bps: order.slippageTolerance !== undefined ? Math.round(order.slippageTolerance * 10000) : undefined,
-                use_master_balance: order.useMasterBalance,
-                expiration_date: order.expirationDate,
-                time_in_force: order.timeInForce,
-                margin_account_id: order.marginAccountId,
-                strategy_key: order.strategyKey,
-                position_side: order.positionSide,
+                tradingMode: order.tradingMode || "SPOT",
+                slippageToleranceBps: order.slippageTolerance !== undefined ? Math.round(order.slippageTolerance * 10000) : undefined,
+                useMasterBalance: order.useMasterBalance,
+                expirationDate: order.expirationDate,
+                timeInForce: order.timeInForce,
+                marginAccountId: order.marginAccountId,
+                riskBucketId: order.riskBucketId,
+                riskBucketCollateral: order.riskBucketCollateral,
+                strategyKey: order.strategyKey,
+                positionSide: order.positionSide,
                 leverage: order.leverage,
-                reduce_only: order.reduceOnly,
+                reduceOnly: order.reduceOnly,
             })),
         };
         return this.makeAuthenticatedRequest(perpRoutes.orders.batchCreate(), {
@@ -403,10 +386,10 @@ export class TradingAPIImpl extends BaseAPI {
         validate(BatchReplaceOrdersSchema, { orders });
         const requestBody = {
             orders: orders.map((order) => ({
-                order_id: order.orderId,
+                orderId: order.orderId,
                 price: order.price,
                 quantity: order.quantity,
-                use_master_balance: order.useMasterBalance,
+                useMasterBalance: order.useMasterBalance,
             })),
         };
         return this.makeAuthenticatedRequest(perpRoutes.orders.batchReplace(), {
@@ -422,9 +405,9 @@ export class TradingAPIImpl extends BaseAPI {
      *
      * @param params - Query parameters for filtering orders
      * @param params.status - Filter by order status (e.g., "SUBMITTED", "FILLED") (optional)
-     * @param params.trading_pair_id - Filter by trading pair UUID (optional)
+     * @param params.tradingPairId - Filter by trading pair UUID (optional)
      * @param params.page - Page number for pagination (defaults to 1, must be > 0)
-     * @param params.page_size - Number of orders per page (defaults to 10, max 100, must be > 0)
+     * @param params.pageSize - Number of orders per page (defaults to 10, max 100, must be > 0)
      * @returns Promise resolving to GetPaginatedOrdersResponse with orders and pagination info
      * @throws {APIError} When API communication fails
      *
@@ -433,13 +416,13 @@ export class TradingAPIImpl extends BaseAPI {
      * // Get submitted orders for a specific trading pair with custom pagination
      * const orders = await tradingAPI.getPaginatedOrders({
      *   status: "SUBMITTED",
-     *   trading_pair_id: "456e7890-e12b-12d3-a456-426614174000",
+     *   tradingPairId: "456e7890-e12b-12d3-a456-426614174000",
      *   page: 1,
-     *   page_size: 20
+     *   pageSize: 20
      * });
      * console.log(`Found ${orders.total} orders, showing page ${orders.page}`);
      *
-     * // Get all orders with default pagination (page=1, page_size=10)
+     * // Get all orders with default pagination (page=1, pageSize=10)
      * const allOrders = await tradingAPI.getPaginatedOrders();
      * ```
      */
@@ -449,25 +432,25 @@ export class TradingAPIImpl extends BaseAPI {
             validate(GetPaginatedOrdersSchema, params);
         }
         // Set pagination defaults with destructuring and validation
-        const { page = 1, page_size = 10, status, trading_pair_id, trading_mode, margin_account_id } = params || {};
+        const { page = 1, pageSize: requestedPageSize = 10, status, tradingPairId, tradingMode, marginAccountId } = params || {};
         const validPage = page > 0 ? page : 1;
-        const validPageSize = page_size > 0 ? page_size : 10;
+        const validPageSize = requestedPageSize > 0 ? requestedPageSize : 10;
         const pageSize = Math.min(validPageSize, 100);
         const searchParams = new URLSearchParams();
         // Always include pagination parameters for consistent API behavior
         searchParams.append("page", validPage.toString());
-        searchParams.append("page_size", pageSize.toString());
+        searchParams.append("pageSize", pageSize.toString());
         if (status) {
             searchParams.append("status", status);
         }
-        if (trading_pair_id) {
-            searchParams.append("trading_pair_id", trading_pair_id);
+        if (tradingPairId) {
+            searchParams.append("tradingPairId", tradingPairId);
         }
-        if (trading_mode) {
-            searchParams.append("trading_mode", trading_mode);
+        if (tradingMode) {
+            searchParams.append("tradingMode", tradingMode);
         }
-        if (margin_account_id) {
-            searchParams.append("margin_account_id", margin_account_id);
+        if (marginAccountId) {
+            searchParams.append("marginAccountId", marginAccountId);
         }
         const endpoint = `/api/v1/orders?${searchParams.toString()}`;
         return await this.makeAuthenticatedRequest(endpoint, {
@@ -489,7 +472,7 @@ export class TradingAPIImpl extends BaseAPI {
      * // Get order details by ID
      * const orderDetails = await tradingAPI.getOrder("order_123");
      * console.log(`Order status: ${orderDetails.order.status}`);
-     * console.log(`Remaining quantity: ${orderDetails.order.remaining_quantity}`);
+     * console.log(`Remaining quantity: ${orderDetails.order.remainingQuantity}`);
      * ```
      */
     async getOrder(orderId) {

package/dist/api/vault/api.d.ts

@@ -23,9 +23,21 @@
  * console.log(`Deposit transaction: ${result.hash}`);
  * ```
  */
-import type { ApplicationsAPI, Balance, ProfileAPI, TransactionResult, VaultAPI, WithdrawResult } from "@0xmonaco/types";
+import type { ApplicationsAPI, Balance, DepositTarget, ProfileAPI, TransactionResult, VaultAPI, WithdrawalRetryOptions, WithdrawalSource, WithdrawResult } from "@0xmonaco/types";
 import { type Address, type Chain, type PublicClient, type WalletClient } from "viem";
 import { BaseAPI } from "../base";
+/**
+ * Encode the on-chain `applicationData` for a deposit.
+ *
+ * For `"spot"` (the default) this stays the bare `clientId` string — byte-for-byte
+ * identical to the legacy encoding, so existing deposits are unchanged. For
+ * `"margin"` it emits a small JSON routing hint the indexer decodes to credit the
+ * deposit to margin collateral.
+ *
+ * MUST stay in sync with the indexer decoder in
+ * `indexer/src/listeners/deposit_routing.rs`.
+ */
+export declare function encodeDepositApplicationData(clientId: string, target: DepositTarget): string;
 export declare class VaultAPIImpl extends BaseAPI implements VaultAPI {
     private readonly publicClient;
     private readonly chain;
@@ -121,6 +133,10 @@ export declare class VaultAPIImpl extends BaseAPI implements VaultAPI {
      * @param assetId - The asset identifier (UUID) to deposit
      * @param amount - The amount of tokens to deposit (as bigint)
      * @param autoWait - Whether to automatically wait for transaction confirmation (defaults to true)
+     * @param target - Destination ledger: `"spot"` (default) credits the spot
+     *   wallet; `"margin"` routes the deposit into the parent margin account's
+     *   collateral (auto-creating the account if needed). Margin deposits that
+     *   cannot be routed safely fall back to spot.
      * @returns Promise resolving to TransactionResult with transaction details
      * @throws {ContractError} When deposit fails or approval is insufficient
      * @throws {APIError} When the asset is not found or the assetId is invalid
@@ -136,6 +152,14 @@ export declare class VaultAPIImpl extends BaseAPI implements VaultAPI {
      * console.log(`Deposit transaction: ${result.hash}`);
      * console.log(`Status: ${result.status}`); // "confirmed" if successful
      *
+     * // Deposit straight into margin collateral
+     * const marginDeposit = await vaultAPI.deposit(
+     *   "123e4567-e89b-12d3-a456-426614174000",
+     *   parseUnits("100", 6),
+     *   true,
+     *   "margin"
+     * );
+     *
      * // Or skip auto-waiting
      * const result = await vaultAPI.deposit(
      *   "123e4567-e89b-12d3-a456-426614174000",
@@ -146,23 +170,54 @@ export declare class VaultAPIImpl extends BaseAPI implements VaultAPI {
      * const receipt = await sdk.waitForTransaction(result.hash);
      * ```
      */
-    deposit(assetId: string, amount: bigint, autoWait?: boolean): Promise<TransactionResult>;
+    deposit(assetId: string, amount: bigint, autoWait?: boolean, target?: DepositTarget): Promise<TransactionResult>;
     /**
-     * Initiates a withdrawal through the API Gateway and submits the resulting
-     * pre-signed calldata on-chain via the connected wallet.
+     * Polls `GET /api/v1/withdrawals/{index}` until the gateway can serve the
+     * `executeWithdrawal` calldata, then returns it with the vault address.
+     *
+     * The calldata only exists once the withdrawal's root is confirmed on-chain
+     * and its merkle proof is persisted. Until then the gateway returns 404 (the
+     * row is written asynchronously by the persistor after `initiate`) or 409
+     * (the proof is not confirmed yet); both are transient for a freshly-allocated
+     * index, so we retry on each until ready or the timeout elapses.
      *
-     * The gateway allocates a `withdrawalIndex` via the matching engine and returns
-     * ABI-encoded calldata for `executeSignedWithdrawal(...)` signed by the
-     * server-side `WITHDRAWAL_SIGNER`. The user's wallet pays gas to submit it,
-     * but the contract authenticates against the embedded signature — not the
-     * `msg.sender`. The connected wallet's address is sent as the on-chain
-     * `destination`.
+     * Returns `null` when the timeout elapses before the proof is available — the
+     * index is still valid and the balance already debited, so callers surface
+     * this as `awaiting_proof` (with the index intact) rather than as a thrown
+     * error that would strand the index. Only non-transient errors (anything
+     * other than 404/409) throw.
+     *
+     * @throws {APIError} On non-transient errors while polling.
+     */
+    private pollWithdrawalCalldata;
+    /**
+     * Initiates a withdrawal through the API Gateway, waits for its on-chain
+     * confirmation, then submits the resulting `executeWithdrawal` calldata via
+     * the connected wallet.
+     *
+     * The gateway allocates a `withdrawalIndex` via the matching engine and debits
+     * the balance immediately, but the executable calldata needs the withdrawal's
+     * merkle proof, which only exists once its root is confirmed on-chain. This
+     * method polls until the calldata is available (see `retry`), then submits it.
+     * The connected wallet pays gas; the contract authorises the withdrawal
+     * against the merkle proof embedded in the calldata. The wallet's address is
+     * sent as the on-chain `destination`.
+     *
+     * If the proof does not become available within the poll window, this method
+     * does NOT throw — it returns `{ withdrawalIndex, status: "awaiting_proof" }`
+     * with nothing submitted on-chain. The balance is already debited, so losing
+     * the index would strand the funds; the caller keeps it and finishes the
+     * withdrawal later with `retryWithdrawal(withdrawalIndex)`.
      *
      * @param assetId - The asset identifier (UUID) to withdraw
      * @param amount - The raw token amount to withdraw (as bigint)
      * @param autoWait - Whether to automatically wait for transaction confirmation (defaults to true)
-     * @returns Promise resolving to `{ withdrawalIndex, transaction }`
-     * @throws {APIError} When the asset is not found or the request is rejected
+     * @param sourceOrRetry - Source ledger (`"spot"` or `"margin"`) or legacy retry options
+     * @param retry - Polling cadence/timeout while waiting for the proof when a source is supplied
+     * @returns Promise resolving to a [`WithdrawResult`]: on success the submitted
+     *   transaction plus `withdrawalIndex`; on poll-timeout `{ withdrawalIndex,
+     *   status: "awaiting_proof" }`.
+     * @throws {APIError} When the asset is not found or the initiate request is rejected
      * @throws {ContractError} When the on-chain submission fails
      * @throws {InvalidConfigError} When wallet account is not available
      *
@@ -174,38 +229,50 @@ export declare class VaultAPIImpl extends BaseAPI implements VaultAPI {
      *   parseUnits("50", 6),
      * );
      * console.log(`Withdrawal index: ${result.withdrawalIndex}`);
-     * console.log(`Tx hash: ${result.hash}, status: ${result.status}`);
+     * if (result.status === "awaiting_proof") {
+     *   // Proof not ready yet — balance already debited. Finish later:
+     *   await vaultAPI.retryWithdrawal(result.withdrawalIndex);
+     * } else {
+     *   console.log(`Tx hash: ${result.hash}, status: ${result.status}`);
+     * }
      *
-     * // Or skip auto-waiting and finalise later
+     * // Custom polling (check every 10s, wait up to an hour)
      * const result = await vaultAPI.withdraw(
      *   "123e4567-e89b-12d3-a456-426614174000",
      *   parseUnits("50", 6),
-     *   false,
+     *   true,
+     *   { pollIntervalMs: 10_000, timeoutMs: 3_600_000 },
      * );
-     * const receipt = await sdk.waitForTransaction(result.hash);
      * ```
      */
-    withdraw(assetId: string, amount: bigint, autoWait?: boolean): Promise<WithdrawResult>;
+    withdraw(assetId: string, amount: bigint, autoWait?: boolean, sourceOrRetry?: WithdrawalSource | WithdrawalRetryOptions, retry?: WithdrawalRetryOptions): Promise<WithdrawResult>;
     /**
-     * Retries a previously-initiated withdrawal whose on-chain submission never
-     * landed — e.g. the wallet rejected the tx, the page reloaded before the
-     * receipt came back, or a stuck mempool entry needs resending.
+     * Submits (or resubmits) a previously-initiated withdrawal on-chain.
+     *
+     * Use this when the original `withdraw()` could not complete — e.g. the proof
+     * was not yet confirmed within its polling window, the wallet rejected the tx,
+     * the page reloaded before the receipt came back, or a stuck mempool entry
+     * needs resending. Polls `GET /withdrawals/{index}` for the
+     * `executeWithdrawal` calldata (retrying while it is not yet confirmed), then
+     * submits it through the connected wallet. Does NOT initiate a new withdrawal
+     * — the matching engine already debited the balance and allocated the index.
+     * The contract is idempotent against double-submission of a settled
+     * withdrawal: it reverts once the index is consumed on-chain.
      *
-     * Re-fetches the same `executeSignedWithdrawal` calldata the gateway
-     * generated when the withdrawal was initiated, then submits it through the
-     * connected wallet. Does NOT initiate a new withdrawal — the matching engine
-     * already debited the balance and allocated the index. The contract is
-     * idempotent against double-submission of a settled withdrawal: it will
-     * revert once the index is consumed on-chain.
+     * Like `withdraw()`, if the proof is still unavailable within the poll window
+     * this returns `{ withdrawalIndex, status: "awaiting_proof" }` instead of
+     * throwing, so the caller can simply retry again later.
      *
      * @param withdrawalIndex - The index returned by the original `withdraw()` call
      * @param autoWait - Whether to await on-chain confirmation (defaults to true)
-     * @returns Promise resolving to `{ withdrawalIndex, ...transaction }`
-     * @throws {APIError} When the index doesn't exist
+     * @param retry - Polling cadence/timeout while waiting for the proof
+     * @returns Promise resolving to a [`WithdrawResult`]: the submitted transaction
+     *   plus `withdrawalIndex`, or `{ withdrawalIndex, status: "awaiting_proof" }`
+     *   if the proof did not arrive within the poll window.
      * @throws {ContractError} When the on-chain submission fails
      * @throws {InvalidConfigError} When wallet account is not available
      */
-    retryWithdrawal(withdrawalIndex: number, autoWait?: boolean): Promise<WithdrawResult>;
+    retryWithdrawal(withdrawalIndex: number, autoWait?: boolean, retry?: WithdrawalRetryOptions): Promise<WithdrawResult>;
     /**
      * Retrieves the user's token balance in the vault.
      *