@0xmonaco/core 0.8.8 → 0.8.11

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,
+            margin_bucket_id: options?.marginBucketId,
+            margin_bucket_collateral: options?.marginBucketCollateral,
             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,
+            margin_bucket_id: options?.marginBucketId,
+            margin_bucket_collateral: options?.marginBucketCollateral,
             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,
+                margin_bucket_id: order.marginBucketId,
+                margin_bucket_collateral: order.marginBucketCollateral,
                 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, 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,7 +170,7 @@ 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.

package/dist/api/vault/api.js

@@ -28,6 +28,20 @@ import { ApproveTokenSchema, DepositSchema, validate, WithdrawSchema } from "@0x
 import { erc20Abi, zeroAddress } from "viem";
 import { APIError, ContractError, InvalidConfigError } from "../../errors";
 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 function encodeDepositApplicationData(clientId, target) {
+    return target === "margin" ? JSON.stringify({ clientId, depositTarget: "MARGIN" }) : clientId;
+}
 export class VaultAPIImpl extends BaseAPI {
     publicClient;
     chain;
@@ -196,6 +210,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 +229,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 +247,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 +279,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 +290,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,
             });

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/whitelist/api.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Whitelist API Implementation
+ *
+ * Public (unauthenticated) whitelist/waitlist application submission. The
+ * server validates and de-duplicates by wallet address and email, creating an
+ * inactive user pending manual approval. This is an onboarding endpoint, not a
+ * trading operation.
+ *
+ * @example
+ * ```typescript
+ * const { message, user_id } = await sdk.whitelist.submit({
+ *   wallet_address: "0x...",
+ *   email: "user@example.com",
+ * });
+ * ```
+ */
+import type { SubmitWhitelistRequest, SubmitWhitelistResponse, WhitelistAPI } from "@0xmonaco/types";
+import { BaseAPI } from "../base";
+export declare class WhitelistAPIImpl extends BaseAPI implements WhitelistAPI {
+    /**
+     * Submits a whitelist (waitlist) application. Public — no auth required.
+     *
+     * @param body - Applicant details
+     * @returns Promise resolving to the status message and created user id
+     */
+    submit(body: SubmitWhitelistRequest): Promise<SubmitWhitelistResponse>;
+}

package/dist/api/whitelist/api.js

@@ -0,0 +1,32 @@
+/**
+ * Whitelist API Implementation
+ *
+ * Public (unauthenticated) whitelist/waitlist application submission. The
+ * server validates and de-duplicates by wallet address and email, creating an
+ * inactive user pending manual approval. This is an onboarding endpoint, not a
+ * trading operation.
+ *
+ * @example
+ * ```typescript
+ * const { message, user_id } = await sdk.whitelist.submit({
+ *   wallet_address: "0x...",
+ *   email: "user@example.com",
+ * });
+ * ```
+ */
+import { BaseAPI } from "../base";
+import { perpRoutes } from "../perp/routes";
+export class WhitelistAPIImpl extends BaseAPI {
+    /**
+     * Submits a whitelist (waitlist) application. Public — no auth required.
+     *
+     * @param body - Applicant details
+     * @returns Promise resolving to the status message and created user id
+     */
+    async submit(body) {
+        return await this.makePublicRequest(perpRoutes.whitelist.submit(), {
+            method: "POST",
+            body: JSON.stringify(body),
+        });
+    }
+}

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

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

package/dist/api/whitelist/index.js

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

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

@@ -0,0 +1,15 @@
+import type { InitiateWithdrawalRequest, WithdrawalResponse, WithdrawalsAPI } from "@0xmonaco/types";
+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.
+ */
+export declare class WithdrawalsAPIImpl extends BaseAPI implements WithdrawalsAPI {
+    initiateWithdrawal(request: InitiateWithdrawalRequest): Promise<WithdrawalResponse>;
+    getWithdrawal(withdrawalIndex: number): Promise<WithdrawalResponse>;
+}

package/dist/api/withdrawals/api.js

@@ -0,0 +1,27 @@
+import { BaseAPI } from "../base";
+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.
+ */
+export class WithdrawalsAPIImpl extends BaseAPI {
+    async initiateWithdrawal(request) {
+        return this.makeAuthenticatedRequest(perpRoutes.withdrawals.initiate(), {
+            method: "POST",
+            body: JSON.stringify({
+                asset_id: request.assetId,
+                amount: request.amount,
+                destination: request.destination,
+            }),
+        });
+    }
+    async getWithdrawal(withdrawalIndex) {
+        // Public lookup — no auth required.
+        return this.makePublicRequest(perpRoutes.withdrawals.byIndex(withdrawalIndex));
+    }
+}

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

@@ -0,0 +1 @@
+export * from "./api";

package/dist/api/withdrawals/index.js

@@ -0,0 +1 @@
+export * from "./api";

package/dist/coverage.d.ts

@@ -0,0 +1,86 @@
+/** operationId → the @0xmonaco/core client method that covers it. */
+export declare const COVERED: {
+    add_position_margin: string;
+    attach_position_tp_sl: string;
+    batch_cancel_all: string;
+    batch_cancel_all_by_pair: string;
+    batch_cancel_orders: string;
+    batch_create_orders: string;
+    batch_replace_orders: string;
+    cancel_conditional_order: string;
+    cancel_order: string;
+    close_position: string;
+    create_challenge: string;
+    create_delegated_session: string;
+    create_order: string;
+    create_sub_account_limit: string;
+    delete_sub_account_limit: string;
+    get_application_config: string;
+    get_application_stats: string;
+    get_available_collateral: string;
+    get_candles: string;
+    get_funding_state: string;
+    get_index_price: string;
+    get_margin_account_movements: string;
+    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;
+    get_orders: string;
+    get_perp_market_config: string;
+    get_perp_market_summary: string;
+    get_portfolio_chart: string;
+    get_portfolio_stats: string;
+    get_position: string;
+    get_position_risk: string;
+    get_screener: string;
+    get_sub_account_limits: string;
+    get_trade_by_id: string;
+    get_trades: string;
+    get_trading_pair_by_id: string;
+    get_user_balance_by_asset: string;
+    get_user_balances: string;
+    get_user_movements: string;
+    get_user_profile: string;
+    get_user_trades: string;
+    get_withdrawal: string;
+    initiate_withdrawal: string;
+    list_application_balances: string;
+    list_application_movements: string;
+    list_application_orders: string;
+    list_application_users: string;
+    list_conditional_orders: string;
+    list_delegated_agent_owners: string;
+    list_delegated_agents: string;
+    list_funding_history: string;
+    list_funding_payments: string;
+    list_margin_accounts: string;
+    list_position_history: string;
+    list_positions: string;
+    list_sub_accounts_with_balances: string;
+    list_trading_pairs: string;
+    mint_tokens: string;
+    reduce_position_margin: string;
+    refresh_session: string;
+    replace_order: string;
+    revoke_delegated_agent: string;
+    revoke_session: string;
+    simulate_auto_margin_order_risk: string;
+    simulate_fees: string;
+    simulate_order_risk: string;
+    submit_whitelist: string;
+    transfer_collateral_from_margin_account: string;
+    transfer_collateral_to_auto_margin_account: string;
+    transfer_collateral_to_margin_account: string;
+    update_sub_account_limit: string;
+    upsert_delegated_agent: string;
+    verify_signature: string;
+};
+/** operationId → reason it is intentionally not covered by @0xmonaco/core. */
+export declare const INTENTIONALLY_EXCLUDED: {
+    authenticate_backend: string;
+    health_check: string;
+};

package/dist/coverage.js

@@ -0,0 +1,86 @@
+/** operationId → the @0xmonaco/core client method that covers it. */
+export const COVERED = {
+    add_position_margin: "addPositionMargin",
+    attach_position_tp_sl: "attachPositionTpSl",
+    batch_cancel_all: "batchCancelAll",
+    batch_cancel_all_by_pair: "batchCancelAll (with tradingPairId)",
+    batch_cancel_orders: "batchCancel",
+    batch_create_orders: "batchCreate",
+    batch_replace_orders: "batchReplace",
+    cancel_conditional_order: "cancelConditionalOrder",
+    cancel_order: "cancelOrder",
+    close_position: "closePosition",
+    create_challenge: "createChallenge",
+    create_delegated_session: "createDelegatedSession",
+    create_order: "placeLimitOrder / placeMarketOrder",
+    create_sub_account_limit: "subAccounts.createLimit",
+    delete_sub_account_limit: "subAccounts.deleteLimit",
+    get_application_config: "getApplicationConfig",
+    get_application_stats: "getApplicationStats",
+    get_available_collateral: "getAvailableCollateral",
+    get_candles: "getCandlesticks",
+    get_funding_state: "getFundingState",
+    get_index_price: "getIndexPrice",
+    get_margin_account_movements: "getMarginAccountMovements",
+    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",
+    get_orders: "getPaginatedOrders",
+    get_perp_market_config: "getPerpMarketConfig",
+    get_perp_market_summary: "getPerpMarketSummary",
+    get_portfolio_chart: "getPortfolioChart",
+    get_portfolio_stats: "getPortfolioStats",
+    get_position: "getPosition",
+    get_position_risk: "getPositionRisk",
+    get_screener: "getScreener",
+    get_sub_account_limits: "subAccounts.getLimits",
+    get_trade_by_id: "getTradeById",
+    get_trades: "getTrades",
+    get_trading_pair_by_id: "getTradingPair",
+    get_user_balance_by_asset: "getUserBalanceByAssetId",
+    get_user_balances: "getUserBalances",
+    get_user_movements: "getPaginatedUserMovements",
+    get_user_profile: "getProfile",
+    get_user_trades: "getUserTrades",
+    get_withdrawal: "getWithdrawal",
+    initiate_withdrawal: "initiateWithdrawal",
+    list_application_balances: "listApplicationBalances",
+    list_application_movements: "listApplicationMovements",
+    list_application_orders: "listApplicationOrders",
+    list_application_users: "listApplicationUsers",
+    list_conditional_orders: "listConditionalOrders",
+    list_delegated_agent_owners: "listDelegatedOwners",
+    list_delegated_agents: "listDelegatedAgents",
+    list_funding_history: "listFundingHistory",
+    list_funding_payments: "listFundingPayments",
+    list_margin_accounts: "listMarginAccounts",
+    list_position_history: "listPositionHistory",
+    list_positions: "listPositions",
+    list_sub_accounts_with_balances: "subAccounts.list",
+    list_trading_pairs: "getPaginatedTradingPairs",
+    mint_tokens: "faucet.mint",
+    reduce_position_margin: "reducePositionMargin",
+    refresh_session: "refreshSession",
+    replace_order: "replaceOrder",
+    revoke_delegated_agent: "revokeDelegatedAgent",
+    revoke_session: "revokeSession",
+    simulate_auto_margin_order_risk: "simulateAutoMarginOrderRisk",
+    simulate_fees: "simulateFees",
+    simulate_order_risk: "simulateOrderRisk",
+    submit_whitelist: "whitelist.submit",
+    transfer_collateral_from_margin_account: "transferCollateralFromMarginAccount",
+    transfer_collateral_to_auto_margin_account: "transferCollateralToAutoMarginAccount",
+    transfer_collateral_to_margin_account: "transferCollateralToMarginAccount",
+    update_sub_account_limit: "subAccounts.updateLimit",
+    upsert_delegated_agent: "upsertDelegatedAgent",
+    verify_signature: "verifySignature",
+};
+/** operationId → reason it is intentionally not covered by @0xmonaco/core. */
+export const INTENTIONALLY_EXCLUDED = {
+    authenticate_backend: "Backend auth is header-based via setServerKey()/the x-server-key header, not an endpoint method (MON-1486).",
+    health_check: "Infrastructure liveness probe (GET /health); not part of the data SDK surface.",
+};

package/dist/sdk.d.ts

@@ -1,4 +1,4 @@
-import type { ApplicationsAPI, AuthAPI, AuthState, DelegatedAgentsAPI, FeesAPI, MarginAccountsAPI, MarketAPI, MonacoSDK, Network, PositionsAPI, ProfileAPI, SDKConfig, TradingAPI, VaultAPI } from "@0xmonaco/types";
+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 MonacoWebSocket, OrderbookAPIImpl, TradesAPIImpl } from "./api";
 export declare class MonacoSDKImpl implements MonacoSDK {
@@ -7,10 +7,14 @@ export declare class MonacoSDKImpl implements MonacoSDK {
     applications: ApplicationsAPI;
     fees: FeesAPI;
     vault: VaultAPI;
+    withdrawals: WithdrawalsAPI;
     trading: TradingAPI;
     market: MarketAPI;
     marginAccounts: MarginAccountsAPI;
     positions: PositionsAPI;
+    subAccounts: SubAccountsAPI;
+    faucet: FaucetAPI;
+    whitelist: WhitelistAPI;
     profile: ProfileAPI;
     orderbook: OrderbookAPIImpl;
     trades: TradesAPIImpl;
@@ -25,6 +29,24 @@ export declare class MonacoSDKImpl implements MonacoSDK {
      * the WebSocket client.
      */
     private propagateSession;
+    /**
+     * Set (or clear) the application secret key used for backend-authenticated
+     * requests (those annotated `#[require_backend]` on the gateway, e.g. the
+     * `applications` reporting endpoints).
+     *
+     * The raw `sk_...` key is sent in the `x-server-key` header on each such
+     * request. This is independent of {@link login}/session auth — a client may
+     * hold both a session and a server key at once.
+     *
+     * @param serverKey - The application secret key (`sk_...`), or `undefined` to clear.
+     *
+     * @example
+     * ```typescript
+     * sdk.setServerKey("sk_live_...");
+     * const orders = await sdk.applications.listApplicationOrders({ status: "FILLED" });
+     * ```
+     */
+    setServerKey(serverKey: string | undefined): void;
     /** Extract the session keypair from an auth state. */
     private sessionFromAuthState;
     constructor(cfg: SDKConfig);
@@ -63,6 +85,15 @@ export declare class MonacoSDKImpl implements MonacoSDK {
     login(clientId: string, options?: {
         connectWebSocket?: boolean;
     }): Promise<AuthState>;
+    /**
+     * Create and adopt an owner-scoped delegated session.
+     *
+     * This must be called while authenticated as the agent wallet. The delegated
+     * session uses a fresh ed25519 keypair generated locally; the current agent
+     * session signs the registration request, and subsequent SDK calls use the
+     * delegated session keypair.
+     */
+    loginAsDelegatedOwner(ownerUserId: string): Promise<AuthState>;
     /**
      * Get the current authentication state
      *