@0xmonaco/core 0.8.10 → 0.8.14

package/README.md

@@ -62,26 +62,17 @@ npm install viem@^2.31.7
 
 ## Network Support
 
-The SDK supports the following preset networks. Configure the network by providing the `network` and `seiRpcUrl` parameters:
+The SDK supports the following documented preset networks. Configure the network by providing the `network` and `seiRpcUrl` parameters:
 
 **Preset Networks:**
-- `"development"` - Development environment (https://develop.apimonaco.xyz)
 - `"staging"` - Staging environment (https://staging.apimonaco.xyz)
 - `"mainnet"` - Production environment (https://api.monaco.xyz)
-- `"local"` - Local development (http://localhost:8080)
 
 WebSocket URLs are automatically resolved per network.
 
 ```typescript
 import { MonacoSDK } from "@0xmonaco/core";
 
-// Development configuration
-const devSdk = new MonacoSDK({
-  walletClient,
-  network: "development",
-  seiRpcUrl: "https://evm-rpc-testnet.sei-apis.com",
-});
-
 // Staging configuration
 const stagingSdk = new MonacoSDK({
   walletClient,
@@ -114,7 +105,7 @@ const walletClient = createWalletClient({
 
 const monaco = new MonacoSDK({
   walletClient,
-  network: "development", // or "staging", "mainnet", "local"
+  network: "staging", // or "mainnet"
   seiRpcUrl: "https://evm-rpc-testnet.sei-apis.com", // or https://evm-rpc.sei-apis.com for mainnet
 });
 
@@ -251,7 +242,7 @@ interface SDKConfig {
   /** Wallet client for signing operations (optional - can be set later via setWalletClient) */
   walletClient?: WalletClient;
   
-  /** Network preset: "local", "development", "staging", or "mainnet" */
+  /** Use "staging" for public testnet or "mainnet" for production. */
   network: Network;
   
   /** RPC URL for Sei blockchain interactions */

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

@@ -1,13 +1,18 @@
-import type { GetAvailableCollateralParams, GetAvailableCollateralResponse, GetMarginAccountMovementsParams, GetMarginAccountMovementsResponse, GetMarginAccountSummaryParams, ListMarginAccountsParams, ListMarginAccountsResponse, MarginAccountSummary, MarginAccountsAPI, SimulateAutoMarginOrderRiskRequest, SimulateOrderRiskRequest, SimulateOrderRiskResponse, TransferCollateralRequest, TransferCollateralResponse, TransferCollateralToAutoMarginAccountRequest } from "@0xmonaco/types";
+import type { GetAvailableCollateralParams, GetAvailableCollateralResponse, GetMarginAccountMovementsParams, GetMarginAccountMovementsResponse, GetMarginAccountSummaryParams, ListMarginAccountsParams, ListMarginAccountsResponse, MarginAccountSummary, MarginAccountsAPI, SimulateOrderRiskRequest, SimulateOrderRiskResponse, SimulateRiskBucketOrderRiskRequest, TransferCollateralFromParentMarginAccountRequest, TransferCollateralRequest, TransferCollateralResponse, TransferCollateralToParentMarginAccountRequest, TransferCollateralToRiskBucketRequest } from "@0xmonaco/types";
 import { BaseAPI } from "../base";
 export declare class MarginAccountsAPIImpl extends BaseAPI implements MarginAccountsAPI {
     listMarginAccounts(params?: ListMarginAccountsParams): Promise<ListMarginAccountsResponse>;
     getMarginAccountSummary(marginAccountId: string, params?: GetMarginAccountSummaryParams): Promise<MarginAccountSummary>;
+    getParentMarginAccountSummary(params?: GetMarginAccountSummaryParams): Promise<MarginAccountSummary>;
     getAvailableCollateral(params?: GetAvailableCollateralParams): Promise<GetAvailableCollateralResponse>;
     transferCollateralToMarginAccount(marginAccountId: string, request: TransferCollateralRequest): Promise<TransferCollateralResponse>;
-    transferCollateralToAutoMarginAccount(request: TransferCollateralToAutoMarginAccountRequest): Promise<TransferCollateralResponse>;
+    transferCollateralToParentMarginAccount(request: TransferCollateralToParentMarginAccountRequest): Promise<TransferCollateralResponse>;
+    transferCollateralToRiskBucket(request: TransferCollateralToRiskBucketRequest): Promise<TransferCollateralResponse>;
     transferCollateralFromMarginAccount(marginAccountId: string, request: TransferCollateralRequest): Promise<TransferCollateralResponse>;
+    transferCollateralFromParentMarginAccount(request: TransferCollateralFromParentMarginAccountRequest): Promise<TransferCollateralResponse>;
     getMarginAccountMovements(marginAccountId: string, params?: GetMarginAccountMovementsParams): Promise<GetMarginAccountMovementsResponse>;
+    getParentMarginAccountMovements(params?: GetMarginAccountMovementsParams): Promise<GetMarginAccountMovementsResponse>;
     simulateOrderRisk(marginAccountId: string, request: SimulateOrderRiskRequest): Promise<SimulateOrderRiskResponse>;
-    simulateAutoMarginOrderRisk(request: SimulateAutoMarginOrderRiskRequest): Promise<SimulateOrderRiskResponse>;
+    simulateParentMarginOrderRisk(request: SimulateOrderRiskRequest): Promise<SimulateOrderRiskResponse>;
+    simulateRiskBucketOrderRisk(request: SimulateRiskBucketOrderRiskRequest): Promise<SimulateOrderRiskResponse>;
 }

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

@@ -1,4 +1,4 @@
-import { GetAvailableCollateralSchema, GetMarginAccountMovementsSchema, GetMarginAccountSummarySchema, ListMarginAccountsSchema, SimulateAutoMarginOrderRiskSchema, SimulateOrderRiskSchema, TransferCollateralSchema, TransferCollateralToAutoMarginAccountSchema, validate, } from "@0xmonaco/types";
+import { GetAvailableCollateralSchema, GetMarginAccountMovementsSchema, GetMarginAccountSummarySchema, GetParentMarginAccountMovementsSchema, GetParentMarginAccountSummarySchema, ListMarginAccountsSchema, SimulateOrderRiskSchema, SimulateParentMarginOrderRiskSchema, SimulateRiskBucketOrderRiskSchema, TransferCollateralFromParentMarginAccountSchema, TransferCollateralSchema, TransferCollateralToParentMarginAccountSchema, TransferCollateralToRiskBucketSchema, validate, } from "@0xmonaco/types";
 import { BaseAPI } from "../base";
 import { perpRoutes } from "../perp";
 export class MarginAccountsAPIImpl extends BaseAPI {
@@ -19,6 +19,10 @@ export class MarginAccountsAPIImpl extends BaseAPI {
         validate(GetMarginAccountSummarySchema, { marginAccountId, ...params });
         return await this.makeAuthenticatedRequest(perpRoutes.marginAccounts.summary(marginAccountId, { trading_pair_id: params?.tradingPairId }));
     }
+    async getParentMarginAccountSummary(params) {
+        validate(GetParentMarginAccountSummarySchema, params);
+        return await this.makeAuthenticatedRequest(perpRoutes.marginAccounts.parentSummary({ trading_pair_id: params?.tradingPairId }));
+    }
     async getAvailableCollateral(params) {
         validate(GetAvailableCollateralSchema, params);
         return await this.makeAuthenticatedRequest(perpRoutes.marginAccounts.availableCollateral(params));
@@ -35,9 +39,19 @@ export class MarginAccountsAPIImpl extends BaseAPI {
             }),
         });
     }
-    async transferCollateralToAutoMarginAccount(request) {
-        validate(TransferCollateralToAutoMarginAccountSchema, { request });
-        return await this.makeAuthenticatedRequest(perpRoutes.marginAccounts.transferInAuto(), {
+    async transferCollateralToParentMarginAccount(request) {
+        validate(TransferCollateralToParentMarginAccountSchema, { request });
+        return await this.makeAuthenticatedRequest(perpRoutes.marginAccounts.transferInParent(), {
+            method: "POST",
+            body: JSON.stringify({
+                asset: request.asset,
+                amount: request.amount,
+            }),
+        });
+    }
+    async transferCollateralToRiskBucket(request) {
+        validate(TransferCollateralToRiskBucketSchema, { request });
+        return await this.makeAuthenticatedRequest(perpRoutes.marginAccounts.transferInRiskBucket(), {
             method: "POST",
             body: JSON.stringify({
                 asset: request.asset,
@@ -59,10 +73,24 @@ export class MarginAccountsAPIImpl extends BaseAPI {
             }),
         });
     }
+    async transferCollateralFromParentMarginAccount(request) {
+        validate(TransferCollateralFromParentMarginAccountSchema, { request });
+        return await this.makeAuthenticatedRequest(perpRoutes.marginAccounts.transferOutParent(), {
+            method: "POST",
+            body: JSON.stringify({
+                asset: request.asset,
+                amount: request.amount,
+            }),
+        });
+    }
     async getMarginAccountMovements(marginAccountId, params) {
         validate(GetMarginAccountMovementsSchema, { marginAccountId, ...params });
         return await this.makeAuthenticatedRequest(perpRoutes.marginAccounts.movements(marginAccountId, params));
     }
+    async getParentMarginAccountMovements(params) {
+        validate(GetParentMarginAccountMovementsSchema, params);
+        return await this.makeAuthenticatedRequest(perpRoutes.marginAccounts.parentMovements(params));
+    }
     async simulateOrderRisk(marginAccountId, request) {
         validate(SimulateOrderRiskSchema, { marginAccountId, request });
         return await this.makeAuthenticatedRequest(perpRoutes.marginAccounts.simulateOrderRisk(marginAccountId), {
@@ -79,9 +107,25 @@ export class MarginAccountsAPIImpl extends BaseAPI {
             }),
         });
     }
-    async simulateAutoMarginOrderRisk(request) {
-        validate(SimulateAutoMarginOrderRiskSchema, { request });
-        return await this.makeAuthenticatedRequest(perpRoutes.marginAccounts.simulateOrderRiskAuto(), {
+    async simulateParentMarginOrderRisk(request) {
+        validate(SimulateParentMarginOrderRiskSchema, { request });
+        return await this.makeAuthenticatedRequest(perpRoutes.marginAccounts.simulateParentMarginOrderRisk(), {
+            method: "POST",
+            body: JSON.stringify({
+                trading_pair_id: request.tradingPairId,
+                side: request.side,
+                position_side: request.positionSide,
+                order_type: request.orderType,
+                price: request.price,
+                quantity: request.quantity,
+                leverage: request.leverage,
+                reduce_only: request.reduceOnly,
+            }),
+        });
+    }
+    async simulateRiskBucketOrderRisk(request) {
+        validate(SimulateRiskBucketOrderRiskSchema, { request });
+        return await this.makeAuthenticatedRequest(perpRoutes.marginAccounts.simulateRiskBucketOrderRisk(), {
             method: "POST",
             body: JSON.stringify({
                 trading_pair_id: request.tradingPairId,

package/dist/api/market/api.d.ts

@@ -1,4 +1,4 @@
-import type { Candlestick, FundingState, GetCandlesticksParams, GetScreenerParams, GetScreenerResponse, GetTradingPairsParams, GetTradingPairsResponse, IndexPrice, Interval, ListFundingHistoryParams, ListFundingHistoryResponse, MarketAPI, MarketMetadata, MarkPrice, OpenInterest, PerpMarketConfig, PerpMarketSummary, TradingPair } from "@0xmonaco/types";
+import type { Candlestick, FundingState, GetCandlesticksParams, GetScreenerParams, GetScreenerResponse, GetTradingPairsParams, GetTradingPairsResponse, IndexPrice, Interval, ListFundingHistoryParams, ListFundingHistoryResponse, MarketAPI, MarketMetadata, MarketStats, MarkPrice, OpenInterest, PerpMarketConfig, PerpMarketSummary, TradingMode, TradingPair } from "@0xmonaco/types";
 import { BaseAPI } from "../base";
 /**
  * Market API Implementation
@@ -8,7 +8,7 @@ import { BaseAPI } from "../base";
 export declare class MarketAPIImpl extends BaseAPI implements MarketAPI {
     getPaginatedTradingPairs(params?: GetTradingPairsParams): Promise<GetTradingPairsResponse>;
     getTradingPair(tradingPairId: string): Promise<TradingPair>;
-    getTradingPairBySymbol(symbol: string): Promise<TradingPair | undefined>;
+    getTradingPairBySymbol(symbol: string, marketType?: TradingMode): Promise<TradingPair | undefined>;
     getCandlesticks(tradingPairId: string, interval: Interval, params?: GetCandlesticksParams): Promise<Candlestick[]>;
     getMarketMetadata(tradingPairId: string): Promise<MarketMetadata>;
     getPerpMarketConfig(tradingPairId: string): Promise<PerpMarketConfig>;
@@ -19,4 +19,5 @@ export declare class MarketAPIImpl extends BaseAPI implements MarketAPI {
     listFundingHistory(tradingPairId: string, params?: ListFundingHistoryParams): Promise<ListFundingHistoryResponse>;
     getOpenInterest(tradingPairId: string): Promise<OpenInterest>;
     getScreener(params?: GetScreenerParams): Promise<GetScreenerResponse>;
+    getMarketStats(): Promise<MarketStats>;
 }

package/dist/api/market/api.js

@@ -27,6 +27,9 @@ export class MarketAPIImpl extends BaseAPI {
         if (params?.is_active !== undefined) {
             searchParams.append("is_active", params.is_active.toString());
         }
+        if (params?.category) {
+            searchParams.append("category", params.category);
+        }
         const queryString = searchParams.toString();
         const url = queryString ? `/api/v1/market/pairs?${queryString}` : "/api/v1/market/pairs";
         return await this.makePublicRequest(url);
@@ -36,9 +39,11 @@ export class MarketAPIImpl extends BaseAPI {
         const response = await this.makePublicRequest(perpRoutes.market.getTradingPair(tradingPairId));
         return response.trading_pair;
     }
-    async getTradingPairBySymbol(symbol) {
-        // Backend endpoint expects UUID, not symbol, so we fetch all pairs and filter
-        const response = await this.getPaginatedTradingPairs({ page_size: 100 });
+    async getTradingPairBySymbol(symbol, marketType) {
+        // Backend endpoint expects UUID, not symbol, so we fetch all pairs and filter.
+        // An optional market_type narrows the listing so a symbol present in both
+        // SPOT and MARGIN resolves unambiguously instead of returning the first match.
+        const response = await this.getPaginatedTradingPairs({ page_size: 100, market_type: marketType });
         return response.trading_pairs.find((pair) => pair.symbol === symbol);
     }
     async getCandlesticks(tradingPairId, interval, params) {
@@ -102,4 +107,7 @@ export class MarketAPIImpl extends BaseAPI {
     async getScreener(params) {
         return await this.makePublicRequest(perpRoutes.market.getScreener(params));
     }
+    async getMarketStats() {
+        return await this.makePublicRequest(perpRoutes.market.getMarketStats());
+    }
 }

package/dist/api/perp/routes.d.ts

@@ -69,7 +69,9 @@ export declare const perpRoutes: {
             page_size?: number;
             market_type?: string;
             is_active?: boolean;
+            category?: string;
         }) => string;
+        readonly getMarketStats: () => string;
     };
     readonly orderbook: {
         readonly get: (tradingPairId: string, params?: {
@@ -149,6 +151,7 @@ export declare const perpRoutes: {
         }) => string;
         readonly get: (positionId: string) => string;
         readonly close: (positionId: string) => string;
+        readonly batchCloseAll: () => string;
         readonly risk: (positionId: string) => string;
         readonly addMargin: (positionId: string) => string;
         readonly reduceMargin: (positionId: string) => string;
@@ -168,6 +171,9 @@ export declare const perpRoutes: {
             state?: string;
             trading_pair_id?: string;
         }) => string;
+        readonly parentSummary: (params?: {
+            trading_pair_id?: string;
+        }) => string;
         readonly summary: (marginAccountId: string, params?: {
             trading_pair_id?: string;
         }) => string;
@@ -175,15 +181,23 @@ export declare const perpRoutes: {
             asset?: string;
         }) => string;
         readonly transferIn: (marginAccountId: string) => string;
-        readonly transferInAuto: () => string;
+        readonly transferInParent: () => string;
+        readonly transferInRiskBucket: () => string;
         readonly transferOut: (marginAccountId: string) => string;
+        readonly transferOutParent: () => string;
         readonly movements: (marginAccountId: string, params?: {
             movement_type?: string;
             page?: number;
             page_size?: number;
         }) => string;
+        readonly parentMovements: (params?: {
+            movement_type?: string;
+            page?: number;
+            page_size?: number;
+        }) => string;
+        readonly simulateParentMarginOrderRisk: () => string;
         readonly simulateOrderRisk: (marginAccountId: string) => string;
-        readonly simulateOrderRiskAuto: () => string;
+        readonly simulateRiskBucketOrderRisk: () => string;
     };
     readonly streams: {
         readonly orderbook: () => string;

package/dist/api/perp/routes.js

@@ -52,6 +52,7 @@ export const perpRoutes = {
         listFundingHistory: (tradingPairId, params) => withQuery(`${API_V1}/market/pairs/${encodeSegment(tradingPairId)}/funding/history`, params),
         getOpenInterest: (tradingPairId) => `${API_V1}/market/pairs/${encodeSegment(tradingPairId)}/open-interest`,
         getScreener: (params) => withQuery(`${API_V1}/market/screener`, params),
+        getMarketStats: () => `${API_V1}/market/stats`,
     },
     orderbook: {
         get: (tradingPairId, params) => withQuery(`${API_V1}/orderbook/${encodeSegment(tradingPairId)}`, params),
@@ -84,6 +85,7 @@ export const perpRoutes = {
         list: (params) => withQuery(`${API_V1}/positions`, params),
         get: (positionId) => `${API_V1}/positions/${encodeSegment(positionId)}`,
         close: (positionId) => `${API_V1}/positions/${encodeSegment(positionId)}/close`,
+        batchCloseAll: () => `${API_V1}/positions/batch-close-all`,
         risk: (positionId) => `${API_V1}/positions/${encodeSegment(positionId)}/risk`,
         addMargin: (positionId) => `${API_V1}/positions/${encodeSegment(positionId)}/margin/add`,
         reduceMargin: (positionId) => `${API_V1}/positions/${encodeSegment(positionId)}/margin/reduce`,
@@ -92,14 +94,19 @@ export const perpRoutes = {
     },
     marginAccounts: {
         list: (params) => withQuery(`${API_V1}/margin/accounts`, params),
+        parentSummary: (params) => withQuery(`${API_V1}/margin/parent-margin-account`, params),
         summary: (marginAccountId, params) => withQuery(`${API_V1}/margin/accounts/${encodeSegment(marginAccountId)}`, params),
         availableCollateral: (params) => withQuery(`${API_V1}/margin/collateral/available`, params),
         transferIn: (marginAccountId) => `${API_V1}/margin/accounts/${encodeSegment(marginAccountId)}/collateral/transfer-in`,
-        transferInAuto: () => `${API_V1}/margin/collateral/transfer-in`,
+        transferInParent: () => `${API_V1}/margin/parent-margin-account/collateral/transfer-in`,
+        transferInRiskBucket: () => `${API_V1}/margin/risk-buckets/collateral/transfer-in`,
         transferOut: (marginAccountId) => `${API_V1}/margin/accounts/${encodeSegment(marginAccountId)}/collateral/transfer-out`,
+        transferOutParent: () => `${API_V1}/margin/parent-margin-account/collateral/transfer-out`,
         movements: (marginAccountId, params) => withQuery(`${API_V1}/margin/accounts/${encodeSegment(marginAccountId)}/movements`, params),
+        parentMovements: (params) => withQuery(`${API_V1}/margin/parent-margin-account/movements`, params),
+        simulateParentMarginOrderRisk: () => `${API_V1}/margin/parent-margin-account/simulate-order-risk`,
         simulateOrderRisk: (marginAccountId) => `${API_V1}/margin/accounts/${encodeSegment(marginAccountId)}/simulate-order-risk`,
-        simulateOrderRiskAuto: () => `${API_V1}/margin/simulate-order-risk`,
+        simulateRiskBucketOrderRisk: () => `${API_V1}/margin/risk-buckets/simulate-order-risk`,
     },
     streams: {
         orderbook: () => `${API_V1}/streaming/orderbook`,

package/dist/api/positions/api.d.ts

@@ -1,9 +1,10 @@
-import type { AddPositionMarginRequest, AttachPositionTpSlRequest, AttachPositionTpSlResponse, ClosePositionRequest, ClosePositionResponse, GetPositionResponse, ListPositionHistoryParams, ListPositionHistoryResponse, ListPositionsParams, ListPositionsResponse, PositionMarginResponse, PositionRisk, PositionsAPI, ReducePositionMarginRequest } from "@0xmonaco/types";
+import type { AddPositionMarginRequest, AttachPositionTpSlRequest, AttachPositionTpSlResponse, BatchCloseAllRequest, BatchCloseAllResponse, ClosePositionRequest, ClosePositionResponse, GetPositionResponse, ListPositionHistoryParams, ListPositionHistoryResponse, ListPositionsParams, ListPositionsResponse, PositionMarginResponse, PositionRisk, PositionsAPI, ReducePositionMarginRequest } from "@0xmonaco/types";
 import { BaseAPI } from "../base";
 export declare class PositionsAPIImpl extends BaseAPI implements PositionsAPI {
     listPositions(params?: ListPositionsParams): Promise<ListPositionsResponse>;
     getPosition(positionId: string): Promise<GetPositionResponse>;
     closePosition(positionId: string, request: ClosePositionRequest): Promise<ClosePositionResponse>;
+    batchCloseAllPositions(request?: BatchCloseAllRequest): Promise<BatchCloseAllResponse>;
     getPositionRisk(positionId: string): Promise<PositionRisk>;
     addPositionMargin(positionId: string, request: AddPositionMarginRequest): Promise<PositionMarginResponse>;
     reducePositionMargin(positionId: string, request: ReducePositionMarginRequest): Promise<PositionMarginResponse>;

package/dist/api/positions/api.js

@@ -1,4 +1,4 @@
-import { AddPositionMarginSchema, AttachPositionTpSlSchema, ClosePositionSchema, GetPositionRiskSchema, GetPositionSchema, ListPositionHistorySchema, ListPositionsSchema, ReducePositionMarginSchema, validate, } from "@0xmonaco/types";
+import { AddPositionMarginSchema, AttachPositionTpSlSchema, BatchCloseAllSchema, ClosePositionSchema, GetPositionRiskSchema, GetPositionSchema, ListPositionHistorySchema, ListPositionsSchema, ReducePositionMarginSchema, validate, } from "@0xmonaco/types";
 import { BaseAPI } from "../base";
 import { perpRoutes } from "../perp";
 export class PositionsAPIImpl extends BaseAPI {
@@ -24,6 +24,18 @@ export class PositionsAPIImpl extends BaseAPI {
             }),
         });
     }
+    async batchCloseAllPositions(request) {
+        if (request) {
+            validate(BatchCloseAllSchema, request);
+        }
+        return await this.makeAuthenticatedRequest(perpRoutes.positions.batchCloseAll(), {
+            method: "POST",
+            body: JSON.stringify({
+                trading_pair_id: request?.tradingPairId,
+                slippage_tolerance_bps: request?.slippageToleranceBps,
+            }),
+        });
+    }
     async getPositionRisk(positionId) {
         validate(GetPositionRiskSchema, { positionId });
         return await this.makeAuthenticatedRequest(perpRoutes.positions.risk(positionId));

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

@@ -80,8 +80,8 @@ export declare class TradingAPIImpl extends BaseAPI implements TradingAPI {
         expirationDate?: string;
         timeInForce?: TimeInForce;
         marginAccountId?: string;
-        marginBucketId?: string;
-        marginBucketCollateral?: string;
+        riskBucketId?: string;
+        riskBucketCollateral?: string;
         strategyKey?: string;
         positionSide?: PositionSide;
         leverage?: string;
@@ -134,8 +134,8 @@ export declare class TradingAPIImpl extends BaseAPI implements TradingAPI {
         tradingMode?: TradingMode;
         slippageTolerance?: number;
         marginAccountId?: string;
-        marginBucketId?: string;
-        marginBucketCollateral?: string;
+        riskBucketId?: string;
+        riskBucketCollateral?: string;
         strategyKey?: string;
         positionSide?: PositionSide;
         leverage?: string;

package/dist/api/trading/api.js

@@ -107,8 +107,8 @@ export class TradingAPIImpl extends BaseAPI {
             expiration_date: options?.expirationDate,
             time_in_force: options?.timeInForce,
             margin_account_id: options?.marginAccountId,
-            margin_bucket_id: options?.marginBucketId,
-            margin_bucket_collateral: options?.marginBucketCollateral,
+            risk_bucket_id: options?.riskBucketId,
+            risk_bucket_collateral: options?.riskBucketCollateral,
             strategy_key: options?.strategyKey,
             position_side: options?.positionSide,
             leverage: options?.leverage,
@@ -179,8 +179,8 @@ export class TradingAPIImpl extends BaseAPI {
             quantity,
             trading_mode: options?.tradingMode || "SPOT",
             margin_account_id: options?.marginAccountId,
-            margin_bucket_id: options?.marginBucketId,
-            margin_bucket_collateral: options?.marginBucketCollateral,
+            risk_bucket_id: options?.riskBucketId,
+            risk_bucket_collateral: options?.riskBucketCollateral,
             strategy_key: options?.strategyKey,
             position_side: options?.positionSide,
             leverage: options?.leverage,
@@ -344,8 +344,8 @@ export class TradingAPIImpl extends BaseAPI {
                 expiration_date: order.expirationDate,
                 time_in_force: order.timeInForce,
                 margin_account_id: order.marginAccountId,
-                margin_bucket_id: order.marginBucketId,
-                margin_bucket_collateral: order.marginBucketCollateral,
+                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,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.
      *

package/dist/api/vault/api.js

@@ -28,6 +28,31 @@ import { ApproveTokenSchema, DepositSchema, validate, WithdrawSchema } from "@0x
 import { erc20Abi, zeroAddress } from "viem";
 import { APIError, ContractError, InvalidConfigError } from "../../errors";
 import { BaseAPI } from "../base";
+/** Default delay between polls while waiting for a withdrawal's proof. */
+const DEFAULT_WITHDRAWAL_POLL_INTERVAL_MS = 5_000;
+/**
+ * Default total wait for a withdrawal's proof (5 minutes). A withdrawal's merkle
+ * proof only lands after its root is confirmed on-chain, which on a healthy
+ * pipeline takes ~20s but can lag behind a brief proposer hiccup; the previous
+ * 60s tripped too eagerly. On timeout the SDK returns `awaiting_proof` rather
+ * than throwing, so the caller never loses the index — it just retries later.
+ */
+const DEFAULT_WITHDRAWAL_TIMEOUT_MS = 300_000;
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+/**
+ * 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 function encodeDepositApplicationData(clientId, target) {
+    return target === "margin" ? JSON.stringify({ clientId, depositTarget: "MARGIN" }) : clientId;
+}
 export class VaultAPIImpl extends BaseAPI {
     publicClient;
     chain;
@@ -196,6 +221,10 @@ export class VaultAPIImpl extends BaseAPI {
      * @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
@@ -211,6 +240,14 @@ export class VaultAPIImpl extends BaseAPI {
      * 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",
@@ -221,14 +258,17 @@ export class VaultAPIImpl extends BaseAPI {
      * const receipt = await sdk.waitForTransaction(result.hash);
      * ```
      */
-    async deposit(assetId, amount, autoWait = true) {
+    async deposit(assetId, amount, autoWait = true, target = "spot") {
         if (!this.walletClient) {
             throw new InvalidConfigError("Wallet client not set. Connect a wallet first.", "walletClient");
         }
         // Validate inputs
-        validate(DepositSchema, { assetId, amount, autoWait });
+        validate(DepositSchema, { assetId, amount, autoWait, target });
         const vaultAddress = await this.getVaultAddress();
         const clientId = await this.getClientId();
+        // The on-chain applicationData carries the client id plus, for margin
+        // deposits, the routing hint the indexer decodes.
+        const applicationData = encodeDepositApplicationData(clientId, target);
         const { tokenAddress, isNativeToken } = await this.resolveAsset(assetId);
         if (!isNativeToken) {
             // Check if approval is needed before proceeding
@@ -250,7 +290,7 @@ export class VaultAPIImpl extends BaseAPI {
                 address: vaultAddress,
                 abi: CONTRACT_ABIS.vault,
                 functionName: "depositNative",
-                args: [walletAccount.address, clientId],
+                args: [walletAccount.address, applicationData],
                 account: walletAccount,
                 chain: this.chain,
                 value: amount,
@@ -261,7 +301,7 @@ export class VaultAPIImpl extends BaseAPI {
                 address: vaultAddress,
                 abi: CONTRACT_ABIS.vault,
                 functionName: "depositERC20",
-                args: [walletAccount.address, clientId, tokenAddress, amount],
+                args: [walletAccount.address, applicationData, tokenAddress, amount],
                 account: walletAccount,
                 chain: this.chain,
             });
@@ -275,21 +315,80 @@ export class VaultAPIImpl extends BaseAPI {
         return await this.waitForTransaction(txResult, autoWait);
     }
     /**
-     * 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.
+     */
+    async pollWithdrawalCalldata(withdrawalIndex, retry) {
+        const pollIntervalMs = retry?.pollIntervalMs ?? DEFAULT_WITHDRAWAL_POLL_INTERVAL_MS;
+        const timeoutMs = retry?.timeoutMs ?? DEFAULT_WITHDRAWAL_TIMEOUT_MS;
+        const deadline = Date.now() + timeoutMs;
+        for (;;) {
+            try {
+                const { vault_address: vaultAddress, calldata } = await this.makePublicRequest(`/api/v1/withdrawals/${withdrawalIndex}`);
+                // Ready: non-empty calldata. (Defensively treat an empty/`0x` body as
+                // not-ready too, though the gateway returns an error in that case.)
+                if (calldata && calldata !== "0x") {
+                    return { vaultAddress, calldata };
+                }
+            }
+            catch (error) {
+                // 404 (row not persisted yet) and 409 (proof not confirmed yet) are
+                // transient for a valid index — keep polling. Anything else is fatal.
+                const isTransient = error instanceof APIError && (error.statusCode === 404 || error.statusCode === 409);
+                if (!isTransient) {
+                    throw error;
+                }
+            }
+            if (Date.now() + pollIntervalMs > deadline) {
+                // Timed out waiting for the proof. Signal not-ready; the caller keeps the
+                // index and retries later rather than losing it inside a thrown error.
+                return null;
+            }
+            await sleep(pollIntervalMs);
+        }
+    }
+    /**
+     * 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
      *
@@ -301,18 +400,23 @@ export class VaultAPIImpl extends BaseAPI {
      *   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);
      * ```
      */
-    async withdraw(assetId, amount, autoWait = true) {
+    async withdraw(assetId, amount, autoWait = true, sourceOrRetry, retry) {
         if (!this.walletClient) {
             throw new InvalidConfigError("Wallet client not set. Connect a wallet first.", "walletClient");
         }
@@ -321,21 +425,33 @@ export class VaultAPIImpl extends BaseAPI {
             throw new InvalidConfigError("No account available in wallet client", "account");
         }
         const destination = walletAccount.address.toLowerCase();
-        validate(WithdrawSchema, { assetId, amount, destination, autoWait });
-        // 1. Gateway allocates withdrawal_index + returns pre-signed
-        // executeSignedWithdrawal calldata along with the vault address to send
-        // it to. Sourcing the vault address from this response (instead of
-        // GET /applications/config) keeps the calldata + target contract in
-        // lockstep and avoids an extra round-trip.
-        const { withdrawal_index: withdrawalIndex, vault_address: vaultAddress, calldata, } = await this.makeAuthenticatedRequest("/api/v1/withdrawals", {
+        const source = typeof sourceOrRetry === "string" ? sourceOrRetry : "spot";
+        const retryOptions = typeof sourceOrRetry === "string" ? retry : sourceOrRetry;
+        validate(WithdrawSchema, { assetId, amount, destination, autoWait, source });
+        // 1. Gateway allocates the withdrawal_index and debits the balance. No
+        // executable calldata yet — it needs the merkle proof, available only once
+        // the withdrawal root is confirmed on-chain.
+        const { withdrawal_index: withdrawalIndex } = await this.makeAuthenticatedRequest("/api/v1/withdrawals", {
             method: "POST",
             body: JSON.stringify({
                 asset_id: assetId,
                 amount: amount.toString(),
                 destination,
+                source,
             }),
         });
-        // 2. Submit the calldata on-chain through the connected wallet.
+        // 2. Poll for the executeWithdrawal calldata until the proof is confirmed.
+        // The vault address comes back with it, keeping calldata + target contract
+        // in lockstep.
+        const poll = await this.pollWithdrawalCalldata(withdrawalIndex, retryOptions);
+        if (!poll) {
+            // Proof not available within the poll window. The balance is already
+            // debited and the index is valid; return it (without submitting anything
+            // on-chain) so the caller can finish later via retryWithdrawal(index).
+            return { withdrawalIndex, status: "awaiting_proof" };
+        }
+        const { vaultAddress, calldata } = poll;
+        // 3. Submit the calldata on-chain through the connected wallet.
         let hash;
         try {
             hash = await this.walletClient.sendTransaction({
@@ -346,7 +462,7 @@ export class VaultAPIImpl extends BaseAPI {
             });
         }
         catch (error) {
-            throw new ContractError(`Failed to submit executeSignedWithdrawal for withdrawal ${withdrawalIndex}: ${error instanceof Error ? error.message : "unknown error"}`, { cause: error instanceof Error ? error : undefined });
+            throw new ContractError(`Failed to submit executeWithdrawal for withdrawal ${withdrawalIndex}: ${error instanceof Error ? error.message : "unknown error"}`, { cause: error instanceof Error ? error : undefined });
         }
         const nonce = walletAccount.getNonce ? await walletAccount.getNonce() : 0n;
         const txResult = {
@@ -358,25 +474,32 @@ export class VaultAPIImpl extends BaseAPI {
         return { ...settled, withdrawalIndex };
     }
     /**
-     * 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
      */
-    async retryWithdrawal(withdrawalIndex, autoWait = true) {
+    async retryWithdrawal(withdrawalIndex, autoWait = true, retry) {
         if (!this.walletClient) {
             throw new InvalidConfigError("Wallet client not set. Connect a wallet first.", "walletClient");
         }
@@ -384,7 +507,13 @@ export class VaultAPIImpl extends BaseAPI {
         if (!walletAccount) {
             throw new InvalidConfigError("No account available in wallet client", "account");
         }
-        const { vault_address: vaultAddress, calldata } = await this.makePublicRequest(`/api/v1/withdrawals/${withdrawalIndex}`);
+        const poll = await this.pollWithdrawalCalldata(withdrawalIndex, retry);
+        if (!poll) {
+            // Still not confirmed on-chain within the poll window — return the index
+            // so the caller can retry again later, rather than throwing.
+            return { withdrawalIndex, status: "awaiting_proof" };
+        }
+        const { vaultAddress, calldata } = poll;
         let hash;
         try {
             hash = await this.walletClient.sendTransaction({
@@ -395,7 +524,7 @@ export class VaultAPIImpl extends BaseAPI {
             });
         }
         catch (error) {
-            throw new ContractError(`Failed to resubmit executeSignedWithdrawal for withdrawal ${withdrawalIndex}: ${error instanceof Error ? error.message : "unknown error"}`, { cause: error instanceof Error ? error : undefined });
+            throw new ContractError(`Failed to resubmit executeWithdrawal for withdrawal ${withdrawalIndex}: ${error instanceof Error ? error.message : "unknown error"}`, { cause: error instanceof Error ? error : undefined });
         }
         const nonce = walletAccount.getNonce ? await walletAccount.getNonce() : 0n;
         const txResult = {

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

@@ -1,4 +1,4 @@
 /**
  * Vault API Module
  */
-export { VaultAPIImpl } from "./api";
+export { encodeDepositApplicationData, VaultAPIImpl } from "./api";

package/dist/api/vault/index.js

@@ -1,4 +1,4 @@
 /**
  * Vault API Module
  */
-export { VaultAPIImpl } from "./api";
+export { encodeDepositApplicationData, VaultAPIImpl } from "./api";

package/dist/api/withdrawals/api.d.ts

@@ -4,10 +4,12 @@ import { BaseAPI } from "../base";
  * Low-level withdrawals client.
  *
  * `initiateWithdrawal` debits the caller's balance via the matching engine and
- * returns the target vault address plus pre-signed `executeSignedWithdrawal`
- * calldata; `getWithdrawal` re-fetches that calldata for a previously-initiated
- * index. Neither submits on-chain — use the high-level vault API for the flow
- * that also broadcasts the transaction.
+ * allocates a `withdrawal_index` (its `calldata` is empty — the proof is not
+ * available until the withdrawal root is confirmed on-chain). `getWithdrawal`
+ * returns the `executeWithdrawal` calldata once that proof is ready, and throws
+ * an `APIError` (404 not-persisted-yet / 409 not-confirmed-yet) while it is not.
+ * Neither submits on-chain — use the high-level vault API, which polls for the
+ * calldata and broadcasts the transaction.
  */
 export declare class WithdrawalsAPIImpl extends BaseAPI implements WithdrawalsAPI {
     initiateWithdrawal(request: InitiateWithdrawalRequest): Promise<WithdrawalResponse>;

package/dist/api/withdrawals/api.js

@@ -4,10 +4,12 @@ import { perpRoutes } from "../perp";
  * Low-level withdrawals client.
  *
  * `initiateWithdrawal` debits the caller's balance via the matching engine and
- * returns the target vault address plus pre-signed `executeSignedWithdrawal`
- * calldata; `getWithdrawal` re-fetches that calldata for a previously-initiated
- * index. Neither submits on-chain — use the high-level vault API for the flow
- * that also broadcasts the transaction.
+ * allocates a `withdrawal_index` (its `calldata` is empty — the proof is not
+ * available until the withdrawal root is confirmed on-chain). `getWithdrawal`
+ * returns the `executeWithdrawal` calldata once that proof is ready, and throws
+ * an `APIError` (404 not-persisted-yet / 409 not-confirmed-yet) while it is not.
+ * Neither submits on-chain — use the high-level vault API, which polls for the
+ * calldata and broadcasts the transaction.
  */
 export class WithdrawalsAPIImpl extends BaseAPI {
     async initiateWithdrawal(request) {
@@ -17,6 +19,7 @@ export class WithdrawalsAPIImpl extends BaseAPI {
                 asset_id: request.assetId,
                 amount: request.amount,
                 destination: request.destination,
+                source: request.source ?? "spot",
             }),
         });
     }

package/dist/coverage.d.ts

@@ -5,6 +5,7 @@ export declare const COVERED: {
     batch_cancel_all: string;
     batch_cancel_all_by_pair: string;
     batch_cancel_orders: string;
+    batch_close_all_positions: string;
     batch_create_orders: string;
     batch_replace_orders: string;
     cancel_conditional_order: string;
@@ -25,6 +26,7 @@ export declare const COVERED: {
     get_margin_account_summary: string;
     get_mark_price: string;
     get_market_metadata: string;
+    get_market_stats: string;
     get_open_interest: string;
     get_order_by_id: string;
     get_orderbook_snapshot: string;
@@ -35,6 +37,8 @@ export declare const COVERED: {
     get_portfolio_stats: string;
     get_position: string;
     get_position_risk: string;
+    get_parent_margin_account_movements: string;
+    get_parent_margin_account_summary: string;
     get_screener: string;
     get_sub_account_limits: string;
     get_trade_by_id: string;
@@ -67,13 +71,16 @@ export declare const COVERED: {
     replace_order: string;
     revoke_delegated_agent: string;
     revoke_session: string;
-    simulate_auto_margin_order_risk: string;
+    simulate_risk_bucket_order_risk: string;
     simulate_fees: string;
     simulate_order_risk: string;
+    simulate_parent_margin_order_risk: string;
     submit_whitelist: string;
+    transfer_collateral_from_parent_margin_account: string;
     transfer_collateral_from_margin_account: string;
-    transfer_collateral_to_auto_margin_account: string;
     transfer_collateral_to_margin_account: string;
+    transfer_collateral_to_parent_margin_account: string;
+    transfer_collateral_to_risk_bucket: string;
     update_sub_account_limit: string;
     upsert_delegated_agent: string;
     verify_signature: string;

package/dist/coverage.js

@@ -5,6 +5,7 @@ export const COVERED = {
     batch_cancel_all: "batchCancelAll",
     batch_cancel_all_by_pair: "batchCancelAll (with tradingPairId)",
     batch_cancel_orders: "batchCancel",
+    batch_close_all_positions: "batchCloseAllPositions",
     batch_create_orders: "batchCreate",
     batch_replace_orders: "batchReplace",
     cancel_conditional_order: "cancelConditionalOrder",
@@ -25,6 +26,7 @@ export const COVERED = {
     get_margin_account_summary: "getMarginAccountSummary",
     get_mark_price: "getMarkPrice",
     get_market_metadata: "getMarketMetadata",
+    get_market_stats: "getMarketStats",
     get_open_interest: "getOpenInterest",
     get_order_by_id: "getOrder",
     get_orderbook_snapshot: "getOrderbook",
@@ -35,6 +37,8 @@ export const COVERED = {
     get_portfolio_stats: "getPortfolioStats",
     get_position: "getPosition",
     get_position_risk: "getPositionRisk",
+    get_parent_margin_account_movements: "getParentMarginAccountMovements",
+    get_parent_margin_account_summary: "getParentMarginAccountSummary",
     get_screener: "getScreener",
     get_sub_account_limits: "subAccounts.getLimits",
     get_trade_by_id: "getTradeById",
@@ -67,13 +71,16 @@ export const COVERED = {
     replace_order: "replaceOrder",
     revoke_delegated_agent: "revokeDelegatedAgent",
     revoke_session: "revokeSession",
-    simulate_auto_margin_order_risk: "simulateAutoMarginOrderRisk",
+    simulate_risk_bucket_order_risk: "simulateRiskBucketOrderRisk",
     simulate_fees: "simulateFees",
     simulate_order_risk: "simulateOrderRisk",
+    simulate_parent_margin_order_risk: "simulateParentMarginOrderRisk",
     submit_whitelist: "whitelist.submit",
+    transfer_collateral_from_parent_margin_account: "transferCollateralFromParentMarginAccount",
     transfer_collateral_from_margin_account: "transferCollateralFromMarginAccount",
-    transfer_collateral_to_auto_margin_account: "transferCollateralToAutoMarginAccount",
     transfer_collateral_to_margin_account: "transferCollateralToMarginAccount",
+    transfer_collateral_to_parent_margin_account: "transferCollateralToParentMarginAccount",
+    transfer_collateral_to_risk_bucket: "transferCollateralToRiskBucket",
     update_sub_account_limit: "subAccounts.updateLimit",
     upsert_delegated_agent: "upsertDelegatedAgent",
     verify_signature: "verifySignature",

package/dist/sdk.d.ts

@@ -1,5 +1,5 @@
 import type { ApplicationsAPI, AuthAPI, AuthState, DelegatedAgentsAPI, FaucetAPI, FeesAPI, MarginAccountsAPI, MarketAPI, MonacoSDK, Network, PositionsAPI, ProfileAPI, SDKConfig, SubAccountsAPI, TradingAPI, VaultAPI, WhitelistAPI, WithdrawalsAPI } from "@0xmonaco/types";
-import { type PublicClient, type TransactionReceipt, type WalletClient } from "viem";
+import { type Address, type PublicClient, type TransactionReceipt, type WalletClient } from "viem";
 import { type MonacoWebSocket, OrderbookAPIImpl, TradesAPIImpl } from "./api";
 export declare class MonacoSDKImpl implements MonacoSDK {
     auth: AuthAPI;
@@ -147,7 +147,7 @@ export declare class MonacoSDKImpl implements MonacoSDK {
     /**
      * Get the current account address
      */
-    getAccountAddress(): string;
+    getAccountAddress(): Address;
     /**
      * Get the current network
      */

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@0xmonaco/core",
-	"version": "0.8.10",
+	"version": "0.8.14",
 	"type": "module",
 	"repository": {
 		"type": "git",
@@ -23,8 +23,8 @@
 		"viem": "^2.45.2"
 	},
 	"dependencies": {
-		"@0xmonaco/contracts": "0.8.10",
-		"@0xmonaco/types": "0.8.10",
+		"@0xmonaco/contracts": "0.8.14",
+		"@0xmonaco/types": "0.8.14",
 		"@noble/curves": "^1.9.1",
 		"@noble/hashes": "^1.8.0",
 		"http-status-codes": "^2.3.0"