@0xmonaco/core 0.8.7-develop.34bd452 → 0.8.7-develop.a107b34

package/dist/api/sub-accounts/api.js

@@ -0,0 +1,80 @@
+/**
+ * Sub-Accounts API Implementation
+ *
+ * Manage a master account's sub-accounts and their per-asset spending limits.
+ * All methods are session-authenticated. The limit mutations (`createLimit`,
+ * `updateLimit`, `deleteLimit`) additionally require the master account to hold
+ * the `ManageSubAccounts` permission — enforced server-side, so a non-master or
+ * unpermissioned caller receives a 403.
+ *
+ * @example
+ * ```typescript
+ * const { sub_accounts } = await sdk.subAccounts.list();
+ * await sdk.subAccounts.createLimit({ sub_account_id, asset_id, max_amount: "1000.00" });
+ * ```
+ */
+import { BaseAPI } from "../base";
+import { perpRoutes } from "../perp/routes";
+export class SubAccountsAPIImpl extends BaseAPI {
+    /**
+     * Lists the authenticated master account's sub-accounts with balances.
+     *
+     * @returns Promise resolving to the sub-accounts and total count
+     */
+    async list() {
+        return await this.makeAuthenticatedRequest(perpRoutes.subAccounts.list());
+    }
+    /**
+     * Creates a per-asset spending limit on a sub-account.
+     *
+     * Requires the `ManageSubAccounts` permission (enforced server-side).
+     *
+     * @param body - Sub-account, asset, max amount, and optional daily limit
+     * @returns Promise resolving to the created limit
+     */
+    async createLimit(body) {
+        return await this.makeAuthenticatedRequest(perpRoutes.subAccounts.createLimit(), {
+            method: "POST",
+            body: JSON.stringify(body),
+        });
+    }
+    /**
+     * Gets the limits configured for a sub-account.
+     *
+     * @param subAccountId - Sub-account UUID
+     * @returns Promise resolving to the sub-account's limits
+     */
+    async getLimits(subAccountId) {
+        return await this.makeAuthenticatedRequest(perpRoutes.subAccounts.getLimits(subAccountId));
+    }
+    /**
+     * Updates a sub-account's per-asset limit (partial update).
+     *
+     * Requires the `ManageSubAccounts` permission (enforced server-side).
+     *
+     * @param subAccountId - Sub-account UUID
+     * @param assetId - Asset UUID
+     * @param body - Fields to update
+     * @returns Promise resolving to the updated limit
+     */
+    async updateLimit(subAccountId, assetId, body) {
+        return await this.makeAuthenticatedRequest(perpRoutes.subAccounts.limit(subAccountId, assetId), {
+            method: "PUT",
+            body: JSON.stringify(body),
+        });
+    }
+    /**
+     * Deletes a sub-account's per-asset limit.
+     *
+     * Requires the `ManageSubAccounts` permission (enforced server-side).
+     *
+     * @param subAccountId - Sub-account UUID
+     * @param assetId - Asset UUID
+     * @returns Promise resolving when the limit is deleted
+     */
+    async deleteLimit(subAccountId, assetId) {
+        await this.makeAuthenticatedRequest(perpRoutes.subAccounts.limit(subAccountId, assetId), {
+            method: "DELETE",
+        });
+    }
+}

package/dist/api/sub-accounts/index.d.ts

@@ -0,0 +1 @@
+export { SubAccountsAPIImpl } from "./api";

package/dist/api/sub-accounts/index.js

@@ -0,0 +1 @@
+export { SubAccountsAPIImpl } from "./api";

package/dist/api/trades/api.d.ts

@@ -11,8 +11,11 @@ interface RawTradeEvent {
         trade_id: string;
         price: string;
         quantity: string;
+        /** Raw (integer) quantity; present on single-trade lookups, ignored when mapping */
+        quantity_raw?: string;
         maker_side: string;
-        executed_at: string;
+        /** Absent when the trade has no recorded execution time */
+        executed_at?: string;
     };
 }
 /**
@@ -40,5 +43,13 @@ export declare class TradesAPIImpl extends BaseAPI {
      * @returns Array of TradeEvent records sorted by executed_at descending (newest first)
      */
     getTrades(tradingPairId: string, options?: GetTradesOptions): Promise<TradeEvent[]>;
+    /**
+     * Get a single trade by its UUID.
+     *
+     * @param tradeId - The trade UUID
+     * @returns The matching TradeEvent
+     * @throws {APIError} If the trade is not found
+     */
+    getTradeById(tradeId: string): Promise<TradeEvent>;
 }
 export {};

package/dist/api/trades/api.js

@@ -1,4 +1,5 @@
 import { BaseAPI } from "../base";
+import { perpRoutes } from "../perp";
 /**
  * Convert a raw trade event (snake_case) to a TradeEvent (camelCase)
  */
@@ -12,7 +13,7 @@ export function parseRawTradeEvent(raw) {
             price: raw.data.price,
             quantity: raw.data.quantity,
             makerSide: raw.data.maker_side.toUpperCase(),
-            executedAt: raw.data.executed_at,
+            executedAt: raw.data.executed_at ?? "",
         },
     };
 }
@@ -39,4 +40,15 @@ export class TradesAPIImpl extends BaseAPI {
         const response = await this.makePublicRequest(`/api/v1/trades/${encodeURIComponent(tradingPairId)}?${params.toString()}`);
         return response.trades.map(parseRawTradeEvent);
     }
+    /**
+     * Get a single trade by its UUID.
+     *
+     * @param tradeId - The trade UUID
+     * @returns The matching TradeEvent
+     * @throws {APIError} If the trade is not found
+     */
+    async getTradeById(tradeId) {
+        const response = await this.makePublicRequest(perpRoutes.trades.byId(tradeId));
+        return parseRawTradeEvent(response);
+    }
 }

package/dist/api/trading/api.d.ts

@@ -21,7 +21,7 @@
  * );
  * ```
  */
-import type { BatchCancelOrdersResponse, BatchCreateOrderParams, BatchCreateOrdersResponse, BatchReplaceOrderParams, BatchReplaceOrdersResponse, CancelConditionalOrderResponse, CancelOrderResponse, CreateConditionalOrderParams, CreateConditionalOrderResponse, CreateOrderResponse, GetOrderResponse, GetPaginatedOrdersParams, GetPaginatedOrdersResponse, ListConditionalOrdersParams, ListConditionalOrdersResponse, OrderSide, ParentTpSlLegParams, PositionSide, ReplaceOrderResponse, TimeInForce, TradingAPI, TradingMode } from "@0xmonaco/types";
+import type { BatchCancelOrdersResponse, BatchCreateOrderParams, BatchCreateOrdersResponse, BatchReplaceOrderParams, BatchReplaceOrdersResponse, CancelConditionalOrderResponse, CancelOrderResponse, CreateOrderResponse, GetOrderResponse, GetPaginatedOrdersParams, GetPaginatedOrdersResponse, ListConditionalOrdersParams, ListConditionalOrdersResponse, OrderSide, ParentTpSlLegParams, PositionSide, ReplaceOrderResponse, TimeInForce, TradingAPI, TradingMode } from "@0xmonaco/types";
 import { BaseAPI } from "../base";
 export declare class TradingAPIImpl extends BaseAPI implements TradingAPI {
     /**
@@ -80,6 +80,8 @@ export declare class TradingAPIImpl extends BaseAPI implements TradingAPI {
         expirationDate?: string;
         timeInForce?: TimeInForce;
         marginAccountId?: string;
+        riskBucketId?: string;
+        riskBucketCollateral?: string;
         strategyKey?: string;
         positionSide?: PositionSide;
         leverage?: string;
@@ -132,6 +134,8 @@ export declare class TradingAPIImpl extends BaseAPI implements TradingAPI {
         tradingMode?: TradingMode;
         slippageTolerance?: number;
         marginAccountId?: string;
+        riskBucketId?: string;
+        riskBucketCollateral?: string;
         strategyKey?: string;
         positionSide?: PositionSide;
         leverage?: string;
@@ -156,7 +160,6 @@ export declare class TradingAPIImpl extends BaseAPI implements TradingAPI {
      * ```
      */
     cancelOrder(orderId: string): Promise<CancelOrderResponse>;
-    createConditionalOrder(params: CreateConditionalOrderParams): Promise<CreateConditionalOrderResponse>;
     cancelConditionalOrder(conditionalOrderId: string): Promise<CancelConditionalOrderResponse>;
     listConditionalOrders(params?: ListConditionalOrdersParams): Promise<ListConditionalOrdersResponse>;
     /**

package/dist/api/trading/api.js

@@ -21,7 +21,7 @@
  * );
  * ```
  */
-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) {
@@ -107,6 +107,8 @@ export class TradingAPIImpl extends BaseAPI {
             expiration_date: options?.expirationDate,
             time_in_force: options?.timeInForce,
             margin_account_id: options?.marginAccountId,
+            risk_bucket_id: options?.riskBucketId,
+            risk_bucket_collateral: options?.riskBucketCollateral,
             strategy_key: options?.strategyKey,
             position_side: options?.positionSide,
             leverage: options?.leverage,
@@ -177,6 +179,8 @@ export class TradingAPIImpl extends BaseAPI {
             quantity,
             trading_mode: options?.tradingMode || "SPOT",
             margin_account_id: options?.marginAccountId,
+            risk_bucket_id: options?.riskBucketId,
+            risk_bucket_collateral: options?.riskBucketCollateral,
             strategy_key: options?.strategyKey,
             position_side: options?.positionSide,
             leverage: options?.leverage,
@@ -216,29 +220,6 @@ export class TradingAPIImpl extends BaseAPI {
             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), {
@@ -363,6 +344,8 @@ export class TradingAPIImpl extends BaseAPI {
                 expiration_date: order.expirationDate,
                 time_in_force: order.timeInForce,
                 margin_account_id: order.marginAccountId,
+                risk_bucket_id: order.riskBucketId,
+                risk_bucket_collateral: order.riskBucketCollateral,
                 strategy_key: order.strategyKey,
                 position_side: order.positionSide,
                 leverage: order.leverage,

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,41 @@ 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>;
+    /**
+     * 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.
+     *
+     * @throws {APIError} On non-transient errors, or when the timeout elapses
+     * before the proof is available.
+     */
+    private pollWithdrawalCalldata;
     /**
-     * Initiates a withdrawal through the API Gateway and submits the resulting
-     * pre-signed calldata on-chain via the connected wallet.
+     * 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 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 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`.
      *
      * @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)
+     * @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 `{ withdrawalIndex, transaction }`
-     * @throws {APIError} When the asset is not found or the request is rejected
+     * @throws {APIError} When the asset is not found, the request is rejected, or the proof never becomes available within the timeout
      * @throws {ContractError} When the on-chain submission fails
      * @throws {InvalidConfigError} When wallet account is not available
      *
@@ -176,36 +218,38 @@ export declare class VaultAPIImpl extends BaseAPI implements VaultAPI {
      * console.log(`Withdrawal index: ${result.withdrawalIndex}`);
      * 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.
      *
-     * 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.
+     * 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.
      *
      * @param withdrawalIndex - The index returned by the original `withdraw()` call
      * @param autoWait - Whether to await on-chain confirmation (defaults to true)
+     * @param retry - Polling cadence/timeout while waiting for the proof
      * @returns Promise resolving to `{ withdrawalIndex, ...transaction }`
-     * @throws {APIError} When the index doesn't exist
+     * @throws {APIError} When the index doesn't exist or the proof never becomes available within the timeout
      * @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.
      *