@0xmonaco/core 0.8.11 → 0.8.15

package/dist/api/trading/api.js

@@ -28,12 +28,12 @@ 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,24 +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,
-            margin_bucket_id: options?.marginBucketId,
-            margin_bucket_collateral: options?.marginBucketCollateral,
-            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",
@@ -171,22 +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,
-            margin_bucket_id: options?.marginBucketId,
-            margin_bucket_collateral: options?.marginBucketCollateral,
-            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",
@@ -213,7 +213,7 @@ 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",
@@ -230,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" });
     }
@@ -257,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 }),
         });
     }
     /**
@@ -286,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;
@@ -333,23 +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,
-                margin_bucket_id: order.marginBucketId,
-                margin_bucket_collateral: order.marginBucketCollateral,
-                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(), {
@@ -386,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(), {
@@ -405,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
      *
@@ -416,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();
      * ```
      */
@@ -432,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, {
@@ -472,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,7 +23,7 @@
  * console.log(`Deposit transaction: ${result.hash}`);
  * ```
  */
-import type { ApplicationsAPI, Balance, DepositTarget, 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";
 /**
@@ -172,21 +172,52 @@ export declare class VaultAPIImpl extends BaseAPI implements VaultAPI {
      */
     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 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`.
+     * 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.
+     *
+     * 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
      *
@@ -198,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.
      *