@0xmonaco/types 0.8.5 → 0.8.7-develop.0f12336

package/dist/vault/index.d.ts

@@ -3,8 +3,25 @@
  *
  * Types for vault operations including deposits, withdrawals, and balance management.
  */
+import type { Address } from "viem";
 import type { BaseAPI } from "../api/index";
-import type { Balance, TransactionResult, WithdrawResult } from "./responses";
+import type { Balance, TransactionResult, WithdrawalRetryOptions, WithdrawResult } from "./responses";
+/**
+ * Destination ledger for a deposit.
+ * - `"spot"` (default): credit the spot/main wallet — unchanged behavior.
+ * - `"margin"`: route the deposit straight into the parent margin account's
+ *   collateral (auto-creating the account if it does not exist yet). A deposit
+ *   that cannot be routed to margin (unsupported asset, etc.) safely falls back
+ *   to spot — funds are never lost.
+ */
+export type DepositTarget = "spot" | "margin";
+/**
+ * Source ledger for an external withdrawal.
+ * - `"spot"` (default): withdraw from the spot/main wallet.
+ * - `"margin"`: directly withdraw from the parent margin account's
+ *   withdrawable collateral.
+ */
+export type WithdrawalSource = "spot" | "margin";
 /**
  * Vault API interface.
  * Provides methods for managing token deposits and withdrawals.
@@ -24,31 +41,47 @@ export interface VaultAPI extends BaseAPI {
      * @param assetId - Asset identifier (UUID) to deposit
      * @param amount - Amount to deposit
      * @param autoWait - Whether to automatically wait for transaction confirmation (defaults to true)
+     * @param target - Destination ledger: `"spot"` (default) or `"margin"` to
+     *   route the deposit into the parent margin account's collateral. Margin
+     *   deposits that cannot be routed fall back to spot.
      * @returns Promise resolving to the transaction result
      */
-    deposit(assetId: string, amount: bigint, autoWait?: boolean): Promise<TransactionResult>;
+    deposit(assetId: string, amount: bigint, autoWait?: boolean, target?: DepositTarget): Promise<TransactionResult>;
     /**
-     * Initiates a withdrawal: allocates a `withdrawalIndex` via the API Gateway,
-     * receives pre-signed calldata for `executeSignedWithdrawal(...)`, and
-     * submits it on-chain through the connected wallet.
+     * Initiates a withdrawal and submits its `executeWithdrawal(...)` calldata
+     * on-chain through the connected wallet.
+     *
+     * The API Gateway allocates a `withdrawalIndex` and debits the balance, but
+     * the executable calldata requires the withdrawal's merkle proof, which only
+     * exists once its root is confirmed on-chain (a process that can take a
+     * while). This method polls `GET /withdrawals/{index}` until the calldata is
+     * available — retrying while the gateway reports it is not yet confirmed —
+     * then submits it.
      *
      * @param assetId - Asset identifier (UUID) to withdraw
      * @param amount - Raw token amount (smallest unit, as bigint)
      * @param autoWait - Whether to await on-chain confirmation (defaults to true)
+     * @param source - Source ledger: `"spot"` (default) or `"margin"` to source
+     *   funds directly from the parent margin account's withdrawable collateral
+     * @param retry - Polling cadence/timeout while waiting for the proof
      * @returns Promise resolving to `{ withdrawalIndex, transaction }`
      */
-    withdraw(assetId: string, amount: bigint, autoWait?: boolean): Promise<WithdrawResult>;
+    withdraw(assetId: string, amount: bigint, autoWait?: boolean, source?: WithdrawalSource, retry?: WithdrawalRetryOptions): Promise<WithdrawResult>;
+    withdraw(assetId: string, amount: bigint, autoWait?: boolean, retry?: WithdrawalRetryOptions): Promise<WithdrawResult>;
     /**
-     * Retries a previously-initiated withdrawal whose on-chain submission never
-     * landed (wallet rejected, page reloaded before receipt, stuck mempool).
-     * Re-fetches the same signed calldata and resubmits via the connected wallet
-     * — does NOT initiate a new withdrawal.
+     * Submits (or resubmits) a previously-initiated withdrawal on-chain. Polls
+     * for the `executeWithdrawal` calldata the same way as `withdraw` — useful
+     * when the original submission never landed (wallet rejected, page reloaded
+     * before receipt, stuck mempool) or when the proof was not yet available at
+     * the time of the original `withdraw()` call. Does NOT initiate a new
+     * withdrawal.
      *
      * @param withdrawalIndex - 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 }`
      */
-    retryWithdrawal(withdrawalIndex: number, autoWait?: boolean): Promise<WithdrawResult>;
+    retryWithdrawal(withdrawalIndex: number, autoWait?: boolean, retry?: WithdrawalRetryOptions): Promise<WithdrawResult>;
     /**
      * Gets the balance of a token in the vault.
      * @param assetId - Asset identifier (UUID) to check
@@ -73,7 +106,7 @@ export interface VaultAPI extends BaseAPI {
      * Gets the address of the vault.
      * @returns Promise resolving to the address of the vault
      */
-    getVaultAddress(): Promise<string>;
+    getVaultAddress(): Promise<Address>;
     /**
      * Sets the wallet client for signing transactions.
      * Used when the wallet becomes available after SDK initialization.
@@ -81,4 +114,4 @@ export interface VaultAPI extends BaseAPI {
      */
     setWalletClient(walletClient: unknown): void;
 }
-export type { Balance, TransactionResult, WithdrawResult } from "./responses";
+export type { Balance, TransactionResult, WithdrawalRetryOptions, WithdrawResult } from "./responses";

package/dist/vault/responses.d.ts

@@ -3,6 +3,7 @@
  *
  * Response types for vault operations.
  */
+import type { Address } from "viem";
 /**
  * Response from a transaction.
  */
@@ -17,29 +18,66 @@ export interface TransactionResult {
     receipt?: import("viem").TransactionReceipt;
 }
 /**
- * Result of initiating a withdrawal.
+ * Result of a withdrawal.
  *
  * The API gateway allocates a `withdrawalIndex` via the matching engine and
- * returns pre-signed calldata for the vault contract's
- * `executeSignedWithdrawal(...)` function. The SDK submits that calldata on
- * behalf of the connected wallet — the user is the on-chain caller, but the
- * `WITHDRAWAL_SIGNER` signature embedded in the calldata is what the contract
- * authenticates against.
+ * debits the balance immediately. The executable `executeWithdrawal(...)`
+ * calldata only exists once the withdrawal's root is confirmed on-chain and its
+ * merkle proof is persisted; the SDK polls for it and submits it through the
+ * connected wallet.
  *
- * Extends [`TransactionResult`] so callers can read `hash`, `status`, `nonce`
- * (and `receipt` when `autoWait` is true) directly off the result, just like
- * `approve` / `deposit`.
+ * `withdrawalIndex` is therefore ALWAYS present — even when the proof did not
+ * become available within the poll window. In that case `status` is
+ * `"awaiting_proof"` and no transaction was submitted (`hash`, `nonce`, and
+ * `receipt` are absent); the caller keeps `withdrawalIndex` and finishes the
+ * withdrawal later with `retryWithdrawal(withdrawalIndex)`. This is why the
+ * transaction fields are optional rather than inherited as required from
+ * [`TransactionResult`]: a debited-but-unproven withdrawal must never strand the
+ * index inside a thrown error.
  */
-export interface WithdrawResult extends TransactionResult {
-    /** Allocated withdrawal index — matches `executeSignedWithdrawal.index`. */
+export interface WithdrawResult {
+    /** Allocated withdrawal index — matches `executeWithdrawal.index`. Always present. */
     withdrawalIndex: number;
+    /**
+     * Outcome of the withdrawal:
+     * - `"awaiting_proof"` — index allocated and balance debited, but the merkle
+     *   proof was not available within the poll window, so nothing was submitted
+     *   on-chain. Call `retryWithdrawal(withdrawalIndex)` once the root confirms.
+     * - `"pending" | "confirmed" | "failed"` — the calldata was submitted on-chain;
+     *   semantics match [`TransactionResult.status`].
+     */
+    status: TransactionResult["status"] | "awaiting_proof";
+    /** Transaction hash — absent when `status === "awaiting_proof"`. */
+    hash?: string;
+    /** Nonce used for the on-chain submission — absent when `status === "awaiting_proof"`. */
+    nonce?: bigint;
+    /** Transaction receipt (only when `autoWait` is enabled and the tx was submitted). */
+    receipt?: import("viem").TransactionReceipt;
+}
+/**
+ * Controls how the SDK polls for a withdrawal's `executeWithdrawal` calldata
+ * while its merkle proof is not yet available (the withdrawal root has not been
+ * confirmed on-chain). The gateway returns 404 (row not persisted yet) or 409
+ * (proof not confirmed yet) until ready; the SDK retries on both.
+ */
+export interface WithdrawalRetryOptions {
+    /** Delay between polls, in milliseconds. Defaults to 5000. */
+    pollIntervalMs?: number;
+    /**
+     * Maximum total time to wait for the proof, in milliseconds. Defaults to
+     * 300_000 (5 minutes). On timeout the SDK does not throw — `withdraw` /
+     * `retryWithdrawal` return `{ status: "awaiting_proof", withdrawalIndex }` so
+     * the caller can retry later. Pass `Infinity` to poll indefinitely until the
+     * proof is available.
+     */
+    timeoutMs?: number;
 }
 /**
  * Token balance information.
  */
 export interface Balance {
     /** Token address */
-    token: string;
+    token: Address;
     /** Balance amount */
     amount: bigint;
     /** Formatted balance string */

package/dist/websocket/events/balance-events.d.ts

@@ -4,6 +4,7 @@
  * Types for real-time user balance update events.
  * This is an authenticated channel - requires JWT token.
  */
+import type { Address } from "viem";
 /**
  * Reason for the balance update
  */
@@ -13,7 +14,7 @@ export type BalanceUpdateReason = "lock" | "unlock" | "deposit" | "withdrawal" |
  */
 export interface UserBalanceEventData {
     /** Token contract address */
-    tokenAddress: string;
+    tokenAddress: Address;
     /** Token symbol */
     tokenSymbol: string | null;
     /** Available balance for trading (normalized) */

package/dist/websocket/events/movement-events.d.ts

@@ -4,6 +4,7 @@
  * Types for real-time user ledger movement events (deposits, withdrawals, transfers).
  * This is an authenticated channel - requires JWT token.
  */
+import type { Address } from "viem";
 /**
  * User movement event data containing ledger entry details
  */
@@ -15,7 +16,7 @@ export interface UserMovementEventData {
     /** Transaction type (e.g., "deposit", "withdrawal", "trade") */
     transactionType: string;
     /** Token contract address */
-    tokenAddress: string;
+    tokenAddress: Address;
     /** Token symbol */
     symbol?: string;
     /** Token decimals */

package/dist/whitelist/index.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Whitelist Types
+ *
+ * Types for the public whitelist (waitlist) application endpoint. Wire shapes
+ * are snake_case.
+ *
+ * NOTE: This endpoint is **public (unauthenticated)** and creates an inactive
+ * user pending manual approval — it is an onboarding/waitlist submission, not a
+ * trading operation.
+ */
+import type { BaseAPI } from "../api";
+/** Body for a whitelist application. */
+export interface SubmitWhitelistRequest {
+    /** Applicant wallet address (0x-prefixed, 40 hex chars) */
+    walletAddress: string;
+    /** Applicant email address */
+    email: string;
+    /** Applicant Twitter/X username (1-15 chars) */
+    twitterUsername?: string;
+    /** Applicant Telegram username (5-32 chars) */
+    telegramUsername?: string;
+}
+/** Response to a whitelist application. */
+export interface SubmitWhitelistResponse {
+    /** Human-readable status message */
+    message: string;
+    /** Created user UUID (pending approval) */
+    userId: string | null;
+}
+/**
+ * Whitelist API interface. The submit endpoint is public (no auth required).
+ */
+export interface WhitelistAPI extends BaseAPI {
+    /**
+     * Submits a whitelist (waitlist) application.
+     *
+     * Public/unauthenticated. The server validates and de-duplicates by wallet
+     * address and email, creating an inactive user pending approval.
+     *
+     * @param body - Applicant details
+     * @returns Promise resolving to the status message and created user id
+     */
+    submit(body: SubmitWhitelistRequest): Promise<SubmitWhitelistResponse>;
+}

package/dist/whitelist/index.js

@@ -0,0 +1,10 @@
+/**
+ * Whitelist Types
+ *
+ * Types for the public whitelist (waitlist) application endpoint. Wire shapes
+ * are snake_case.
+ *
+ * NOTE: This endpoint is **public (unauthenticated)** and creates an inactive
+ * user pending manual approval — it is an onboarding/waitlist submission, not a
+ * trading operation.
+ */

package/dist/wire/assert.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Compile-time helpers that tie the hand-written ergonomic SDK types to the
+ * generated wire schema in `./schema.ts`.
+ *
+ * Everything here lives purely at the type level — there is no runtime output —
+ * so a field the OpenAPI spec gains but an ergonomic type forgot to declare
+ * becomes a `tsc` error. This is the type-checking half of the MON-1476 drift
+ * tripwire (the other half is the CI fail-on-diff check on the generated
+ * `schema.ts`). See `./README.md` for how to register a new type.
+ */
+import type { components } from "./schema";
+/** All schema component types generated from the OpenAPI spec. */
+export type WireSchemas = components["schemas"];
+/** A single generated wire schema, addressed by its OpenAPI component name. */
+export type WireSchema<K extends keyof WireSchemas> = WireSchemas[K];
+/** Strip every `_` from a string-literal type: `a_b_c` -> `abc`. */
+type StripUnderscores<S extends string> = S extends `${infer Head}_${infer Tail}` ? `${Head}${StripUnderscores<Tail>}` : S;
+/**
+ * Canonical form of a field name: lower-cased and underscore-free, so that
+ * snake_case (`available_balance`) and camelCase (`availableBalance`) names
+ * collapse to the same key. This lets the coverage check ignore the casing
+ * convention a given ergonomic domain happens to use.
+ *
+ * Caveat: names that differ only by case (e.g. `T` vs `t`) collapse together —
+ * do not register types that rely on such a distinction.
+ */
+type CanonicalKey<S extends string> = Lowercase<StripUnderscores<S>>;
+/** Re-key an object type by the canonical form of each of its string keys. */
+type CanonicalKeys<T> = {
+    [K in keyof T as K extends string ? CanonicalKey<K> : never]: true;
+};
+/** Canonical wire field names that the ergonomic type `Ergo` does not declare. */
+export type MissingWireFields<Ergo, Wire> = Exclude<keyof CanonicalKeys<Wire>, keyof CanonicalKeys<Ergo>>;
+/**
+ * Resolves to `true` when `Ergo` declares every field the wire schema `Wire`
+ * has (comparing canonical names, so casing/underscore style is irrelevant and
+ * ergonomic enrichments — extra fields, bigint/branded value types — are
+ * allowed). Otherwise resolves to an error object naming the missing fields, so
+ * a failing {@link Expect} points straight at the drift.
+ */
+export type WireCovered<Ergo, Wire> = [MissingWireFields<Ergo, Wire>] extends [never] ? true : {
+    __MISSING_WIRE_FIELDS__: MissingWireFields<Ergo, Wire>;
+};
+/**
+ * Assertion sink. `Expect<WireCovered<Ergo, Wire>>` is a type alias that only
+ * type-checks when its argument is exactly `true`, emitting no runtime code:
+ *
+ *   type _Balance = Expect<WireCovered<AccountBalance, WireSchema<"AccountBalance">>>;
+ *
+ * If `WireCovered` resolves to the error object, `T extends true` fails and
+ * `tsc` reports the missing wire fields at this line.
+ */
+export type Expect<T extends true> = T;
+export {};

package/dist/wire/audit.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Endpoint-coverage audit (MON-1489 gate logic).
+ *
+ * Each hand-written SDK surface (`@0xmonaco/core`, `@0xmonaco/react`,
+ * `@0xmonaco/mcp-server`) maintains a `coverage.ts` with two registries: a
+ * `COVERED` map (operationId → the ergonomic method/hook/tool that implements
+ * it) and an `INTENTIONALLY_EXCLUDED` map (operationId → reason it is
+ * deliberately not surfaced). {@link auditSurface} checks those two registries
+ * against the full {@link OPERATION_IDS} list and reports any operationId that
+ * is left unclassified (in neither), double-classified (in both), or stale (a
+ * registry key that is no longer a real operationId).
+ *
+ * This is the runtime counterpart to the `satisfies Partial<Record<keyof
+ * operations, string>>` constraint each registry already carries: that
+ * constraint makes every *key* a compile-time-checked operationId, while this
+ * audit makes the *set* of keys provably exhaustive. A new proto REST endpoint
+ * forces a new operationId into the generated `OPERATION_IDS`, and the surface
+ * build/CI fails here until a developer either implements it or excludes it
+ * with a reason — mirroring the MON-1475 route↔spec allowlist UX.
+ */
+import { type OperationId } from "./operations";
+import type { operations } from "./schema";
+/** A surface's coverage registries (the two maps exported by its `coverage.ts`). */
+export interface SurfaceClassification {
+    /** operationId → the SDK symbol (method/hook/tool) that covers it. */
+    covered: Partial<Record<keyof operations, string>>;
+    /** operationId → the reason it is intentionally not covered. */
+    excluded: Partial<Record<keyof operations, string>>;
+}
+/** Result of auditing one surface's classification against the spec. */
+export interface CoverageAudit {
+    /** operationIds in the spec that appear in neither `covered` nor `excluded`. */
+    unclassified: OperationId[];
+    /** operationIds listed in BOTH `covered` and `excluded`. */
+    duplicated: string[];
+    /** Registry keys that are not (or no longer) real operationIds. */
+    unknown: string[];
+    /** True when the surface classifies every operationId exactly once. */
+    ok: boolean;
+}
+/**
+ * Audit one surface: assert `covered ∪ excluded == operationIds` and that the
+ * two sets are disjoint and free of stale keys. `operationIds` defaults to the
+ * generated {@link OPERATION_IDS}; it is injectable so the gate's own tests can
+ * exercise synthetic op sets.
+ */
+export declare function auditSurface(classification: SurfaceClassification, operationIds?: readonly string[]): CoverageAudit;

package/dist/wire/audit.js

@@ -0,0 +1,43 @@
+/**
+ * Endpoint-coverage audit (MON-1489 gate logic).
+ *
+ * Each hand-written SDK surface (`@0xmonaco/core`, `@0xmonaco/react`,
+ * `@0xmonaco/mcp-server`) maintains a `coverage.ts` with two registries: a
+ * `COVERED` map (operationId → the ergonomic method/hook/tool that implements
+ * it) and an `INTENTIONALLY_EXCLUDED` map (operationId → reason it is
+ * deliberately not surfaced). {@link auditSurface} checks those two registries
+ * against the full {@link OPERATION_IDS} list and reports any operationId that
+ * is left unclassified (in neither), double-classified (in both), or stale (a
+ * registry key that is no longer a real operationId).
+ *
+ * This is the runtime counterpart to the `satisfies Partial<Record<keyof
+ * operations, string>>` constraint each registry already carries: that
+ * constraint makes every *key* a compile-time-checked operationId, while this
+ * audit makes the *set* of keys provably exhaustive. A new proto REST endpoint
+ * forces a new operationId into the generated `OPERATION_IDS`, and the surface
+ * build/CI fails here until a developer either implements it or excludes it
+ * with a reason — mirroring the MON-1475 route↔spec allowlist UX.
+ */
+import { OPERATION_IDS } from "./operations";
+/**
+ * Audit one surface: assert `covered ∪ excluded == operationIds` and that the
+ * two sets are disjoint and free of stale keys. `operationIds` defaults to the
+ * generated {@link OPERATION_IDS}; it is injectable so the gate's own tests can
+ * exercise synthetic op sets.
+ */
+export function auditSurface(classification, operationIds = OPERATION_IDS) {
+    const covered = Object.keys(classification.covered);
+    const excluded = Object.keys(classification.excluded);
+    const all = new Set(operationIds);
+    const classified = new Set([...covered, ...excluded]);
+    const excludedSet = new Set(excluded);
+    const unclassified = operationIds.filter((op) => !classified.has(op));
+    const duplicated = covered.filter((op) => excludedSet.has(op)).sort();
+    const unknown = [...new Set([...covered, ...excluded].filter((op) => !all.has(op)))].sort();
+    return {
+        unclassified: unclassified,
+        duplicated,
+        unknown,
+        ok: unclassified.length === 0 && duplicated.length === 0 && unknown.length === 0,
+    };
+}

package/dist/wire/coverage.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/wire/index.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Generated wire-types layer (MON-1476 drift tripwire).
+ *
+ * `schema.ts` is generated from `docs/src/proto-openapi/api/openapi.yaml` by
+ * `make ts-wire-gen` — do not edit it by hand. This barrel re-exports the
+ * generated `paths` / `components` / `operations` interfaces plus the
+ * {@link WireSchema} / {@link WireCovered} helpers the ergonomic types use to
+ * stay in sync with the spec.
+ *
+ * Consumers import the raw spec types from the `@0xmonaco/types/wire` subpath;
+ * the ergonomic types in the rest of the package are the supported surface.
+ *
+ * It also exports the generated runtime `OPERATION_IDS` list and the
+ * `auditSurface` helper that power the MON-1489 endpoint-coverage gate.
+ */
+export type { Expect, MissingWireFields, WireCovered, WireSchema, WireSchemas } from "./assert";
+export type { CoverageAudit, SurfaceClassification } from "./audit";
+export { auditSurface } from "./audit";
+export type { OperationId } from "./operations";
+export { OPERATION_IDS } from "./operations";
+export type { components, operations, paths } from "./schema";

package/dist/wire/index.js

@@ -0,0 +1,2 @@
+export { auditSurface } from "./audit";
+export { OPERATION_IDS } from "./operations";

package/dist/wire/operations.d.ts

@@ -0,0 +1,15 @@
+/**
+ * GENERATED — DO NOT EDIT BY HAND.
+ *
+ * Runtime list of every OpenAPI operationId in the canonical spec
+ * (docs/src/proto-openapi/api/openapi.yaml), emitted by `make ts-wire-gen`
+ * (scripts/gen-operation-ids.ts) alongside the type-only `schema.ts`.
+ *
+ * The MON-1489 endpoint-coverage gate iterates this list to assert that every
+ * operationId is classified (covered or intentionally excluded) on each
+ * hand-written SDK surface. CI regenerates it and fails on a diff, identical to
+ * the `schema.ts` wire-types tripwire (MON-1476), so it can never go stale.
+ */
+export declare const OPERATION_IDS: readonly ["add_position_margin", "attach_position_tp_sl", "authenticate_backend", "batch_cancel_all", "batch_cancel_all_by_pair", "batch_cancel_orders", "batch_close_all_positions", "batch_create_orders", "batch_replace_orders", "cancel_conditional_order", "cancel_order", "close_position", "create_challenge", "create_delegated_session", "create_order", "create_sub_account_limit", "delete_sub_account_limit", "get_application_config", "get_application_stats", "get_available_collateral", "get_candles", "get_funding_state", "get_index_price", "get_margin_account_movements", "get_margin_account_summary", "get_mark_price", "get_market_metadata", "get_market_stats", "get_open_interest", "get_order_by_id", "get_orderbook_snapshot", "get_orders", "get_parent_margin_account_movements", "get_parent_margin_account_summary", "get_perp_market_config", "get_perp_market_summary", "get_portfolio_chart", "get_portfolio_stats", "get_position", "get_position_risk", "get_screener", "get_sub_account_limits", "get_trade_by_id", "get_trades", "get_trading_pair_by_id", "get_user_balance_by_asset", "get_user_balances", "get_user_movements", "get_user_profile", "get_user_trades", "get_withdrawal", "health_check", "initiate_withdrawal", "list_application_balances", "list_application_movements", "list_application_orders", "list_application_users", "list_conditional_orders", "list_delegated_agent_owners", "list_delegated_agents", "list_funding_history", "list_funding_payments", "list_margin_accounts", "list_pending_withdrawals", "list_position_history", "list_positions", "list_sub_accounts_with_balances", "list_trading_pairs", "mint_tokens", "reduce_position_margin", "refresh_session", "replace_order", "revoke_delegated_agent", "revoke_session", "simulate_fees", "simulate_order_risk", "simulate_parent_margin_order_risk", "simulate_risk_bucket_order_risk", "submit_whitelist", "transfer_collateral_from_margin_account", "transfer_collateral_from_parent_margin_account", "transfer_collateral_to_margin_account", "transfer_collateral_to_parent_margin_account", "transfer_collateral_to_risk_bucket", "update_sub_account_limit", "upsert_delegated_agent", "verify_signature"];
+/** Union of every OpenAPI operationId in the spec. */
+export type OperationId = (typeof OPERATION_IDS)[number];

package/dist/wire/operations.js

@@ -0,0 +1,101 @@
+/**
+ * GENERATED — DO NOT EDIT BY HAND.
+ *
+ * Runtime list of every OpenAPI operationId in the canonical spec
+ * (docs/src/proto-openapi/api/openapi.yaml), emitted by `make ts-wire-gen`
+ * (scripts/gen-operation-ids.ts) alongside the type-only `schema.ts`.
+ *
+ * The MON-1489 endpoint-coverage gate iterates this list to assert that every
+ * operationId is classified (covered or intentionally excluded) on each
+ * hand-written SDK surface. CI regenerates it and fails on a diff, identical to
+ * the `schema.ts` wire-types tripwire (MON-1476), so it can never go stale.
+ */
+export const OPERATION_IDS = [
+    "add_position_margin",
+    "attach_position_tp_sl",
+    "authenticate_backend",
+    "batch_cancel_all",
+    "batch_cancel_all_by_pair",
+    "batch_cancel_orders",
+    "batch_close_all_positions",
+    "batch_create_orders",
+    "batch_replace_orders",
+    "cancel_conditional_order",
+    "cancel_order",
+    "close_position",
+    "create_challenge",
+    "create_delegated_session",
+    "create_order",
+    "create_sub_account_limit",
+    "delete_sub_account_limit",
+    "get_application_config",
+    "get_application_stats",
+    "get_available_collateral",
+    "get_candles",
+    "get_funding_state",
+    "get_index_price",
+    "get_margin_account_movements",
+    "get_margin_account_summary",
+    "get_mark_price",
+    "get_market_metadata",
+    "get_market_stats",
+    "get_open_interest",
+    "get_order_by_id",
+    "get_orderbook_snapshot",
+    "get_orders",
+    "get_parent_margin_account_movements",
+    "get_parent_margin_account_summary",
+    "get_perp_market_config",
+    "get_perp_market_summary",
+    "get_portfolio_chart",
+    "get_portfolio_stats",
+    "get_position",
+    "get_position_risk",
+    "get_screener",
+    "get_sub_account_limits",
+    "get_trade_by_id",
+    "get_trades",
+    "get_trading_pair_by_id",
+    "get_user_balance_by_asset",
+    "get_user_balances",
+    "get_user_movements",
+    "get_user_profile",
+    "get_user_trades",
+    "get_withdrawal",
+    "health_check",
+    "initiate_withdrawal",
+    "list_application_balances",
+    "list_application_movements",
+    "list_application_orders",
+    "list_application_users",
+    "list_conditional_orders",
+    "list_delegated_agent_owners",
+    "list_delegated_agents",
+    "list_funding_history",
+    "list_funding_payments",
+    "list_margin_accounts",
+    "list_pending_withdrawals",
+    "list_position_history",
+    "list_positions",
+    "list_sub_accounts_with_balances",
+    "list_trading_pairs",
+    "mint_tokens",
+    "reduce_position_margin",
+    "refresh_session",
+    "replace_order",
+    "revoke_delegated_agent",
+    "revoke_session",
+    "simulate_fees",
+    "simulate_order_risk",
+    "simulate_parent_margin_order_risk",
+    "simulate_risk_bucket_order_risk",
+    "submit_whitelist",
+    "transfer_collateral_from_margin_account",
+    "transfer_collateral_from_parent_margin_account",
+    "transfer_collateral_to_margin_account",
+    "transfer_collateral_to_parent_margin_account",
+    "transfer_collateral_to_risk_bucket",
+    "update_sub_account_limit",
+    "upsert_delegated_agent",
+    "verify_signature",
+];