@0xmonaco/types 0.8.8 → 0.8.11

package/dist/trading/responses.d.ts

@@ -74,7 +74,9 @@ export interface CreateOrderResponse {
     match_result?: MatchResult;
     /** Resolved margin account ID for margin/perp orders */
     margin_account_id?: string;
-    /** Resolved hidden strategy bucket key for auto margin buckets */
+    /** Resolved isolated margin bucket ID for bucket-scoped margin orders */
+    margin_bucket_id?: string;
+    /** Client strategy key carried for compatibility */
     strategy_key?: string;
     /** Delegated agent ID when submitted through a delegated session */
     delegation_id?: string;
@@ -286,7 +288,11 @@ export interface BatchCreateOrderParams {
     timeInForce?: Extract<TimeInForce, "GTC" | "IOC" | "FOK">;
     /** Margin account UUID for margin/perp orders */
     marginAccountId?: string;
-    /** Optional strategy bucket key used when marginAccountId is omitted */
+    /** Existing isolated margin bucket UUID for bucket-scoped margin orders */
+    marginBucketId?: string;
+    /** Collateral to allocate into a new isolated margin bucket */
+    marginBucketCollateral?: string;
+    /** Client strategy key carried for compatibility */
     strategyKey?: string;
     /** Position side for margin/perp orders */
     positionSide?: PositionSide;
@@ -308,31 +314,6 @@ export interface BatchReplaceOrderParams {
     /** For sub-accounts: use master's balance (optional) */
     useMasterBalance?: boolean;
 }
-/**
- * Parameters for creating a standalone conditional TP/SL order.
- */
-export interface CreateConditionalOrderParams {
-    tradingPairId: string;
-    marginAccountId: string;
-    conditionType: ConditionalOrderConditionType;
-    triggerPrice: string;
-    triggerSource?: ConditionalOrderTriggerSource;
-    side: OrderSide;
-    positionSide: Exclude<PositionSide, "NONE">;
-    orderType: OrderType;
-    limitPrice?: string;
-    quantity?: string;
-    reduceOnly?: boolean;
-    timeInForce?: Extract<TimeInForce, "GTC" | "IOC">;
-    slippageToleranceBps?: number;
-    expiresAt?: string;
-}
-export interface CreateConditionalOrderResponse {
-    conditional_order_id: string;
-    status: "SUCCESS" | "FAILED";
-    message: string;
-    state: ConditionalOrderState;
-}
 export interface CancelConditionalOrderResponse {
     conditional_order_id: string;
     status: "SUCCESS" | "FAILED";

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

@@ -8,12 +8,9 @@ export declare const ListMarginAccountsSchema: z.ZodObject<{
     state: z.ZodOptional<z.ZodString>;
     tradingPairId: z.ZodOptional<z.ZodUUID>;
 }, z.core.$strip>;
-export declare const CreateMarginAccountSchema: z.ZodOptional<z.ZodObject<{
-    label: z.ZodOptional<z.ZodString>;
-    collateralAsset: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>>;
 export declare const GetMarginAccountSummarySchema: z.ZodObject<{
     marginAccountId: z.ZodUUID;
+    tradingPairId: z.ZodOptional<z.ZodUUID>;
 }, z.core.$strip>;
 export declare const GetAvailableCollateralSchema: z.ZodOptional<z.ZodObject<{
     asset: z.ZodOptional<z.ZodString>;
@@ -23,6 +20,8 @@ export declare const TransferCollateralSchema: z.ZodObject<{
     request: z.ZodObject<{
         asset: z.ZodString;
         amount: z.ZodString;
+        tradingPairId: z.ZodOptional<z.ZodUUID>;
+        strategyKey: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>;
 }, z.core.$strip>;
 export declare const TransferCollateralToAutoMarginAccountSchema: z.ZodObject<{
@@ -43,7 +42,6 @@ export declare const SimulateOrderRiskSchema: z.ZodObject<{
     marginAccountId: z.ZodUUID;
     request: z.ZodObject<{
         tradingPairId: z.ZodUUID;
-        strategyKey: z.ZodOptional<z.ZodString>;
         side: z.ZodEnum<{
             BUY: "BUY";
             SELL: "SELL";
@@ -61,12 +59,10 @@ export declare const SimulateOrderRiskSchema: z.ZodObject<{
         quantity: z.ZodString;
         leverage: z.ZodString;
         reduceOnly: z.ZodOptional<z.ZodBoolean>;
-    }, z.core.$strip>;
+    }, z.core.$strict>;
 }, z.core.$strip>;
 export declare const SimulateAutoMarginOrderRiskSchema: z.ZodObject<{
     request: z.ZodObject<{
-        tradingPairId: z.ZodUUID;
-        strategyKey: z.ZodOptional<z.ZodString>;
         side: z.ZodEnum<{
             BUY: "BUY";
             SELL: "SELL";
@@ -84,5 +80,7 @@ export declare const SimulateAutoMarginOrderRiskSchema: z.ZodObject<{
         quantity: z.ZodString;
         leverage: z.ZodString;
         reduceOnly: z.ZodOptional<z.ZodBoolean>;
-    }, z.core.$strip>;
+        tradingPairId: z.ZodUUID;
+        strategyKey: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
 }, z.core.$strip>;

package/dist/validation/margin-accounts.js

@@ -11,14 +11,9 @@ export const ListMarginAccountsSchema = PaginationSchema.extend({
     state: z.string().trim().min(1, "State cannot be empty").optional(),
     tradingPairId: UUIDSchema.optional(),
 });
-export const CreateMarginAccountSchema = z
-    .object({
-    label: z.string().trim().min(1, "Label cannot be empty").optional(),
-    collateralAsset: z.string().trim().min(1, "Collateral asset cannot be empty").optional(),
-})
-    .optional();
 export const GetMarginAccountSummarySchema = z.object({
     marginAccountId: UUIDSchema,
+    tradingPairId: UUIDSchema.optional(),
 });
 export const GetAvailableCollateralSchema = z
     .object({
@@ -28,6 +23,8 @@ export const GetAvailableCollateralSchema = z
 const TransferCollateralRequestSchema = z.object({
     asset: z.string().trim().min(1, "Asset cannot be empty"),
     amount: PositiveDecimalStringSchema,
+    tradingPairId: UUIDSchema.optional(),
+    strategyKey: z.string().trim().min(1, "Strategy key cannot be empty").optional(),
 });
 const AutoMarginBucketRequestSchema = z.object({
     tradingPairId: UUIDSchema,
@@ -44,9 +41,8 @@ export const GetMarginAccountMovementsSchema = PaginationSchema.extend({
     marginAccountId: UUIDSchema,
     movement_type: z.string().trim().min(1, "Movement type cannot be empty").optional(),
 });
-const SimulateOrderRiskRequestSchema = z.object({
+const BaseSimulateOrderRiskRequestSchema = z.object({
     tradingPairId: UUIDSchema,
-    strategyKey: z.string().trim().min(1, "Strategy key cannot be empty").optional(),
     side: OrderSideSchema,
     positionSide: PositionSideSchema,
     orderType: OrderTypeSchema,
@@ -55,6 +51,8 @@ const SimulateOrderRiskRequestSchema = z.object({
     leverage: PositiveDecimalStringSchema,
     reduceOnly: z.boolean().optional(),
 });
+const SimulateOrderRiskRequestSchema = BaseSimulateOrderRiskRequestSchema.strict();
+const SimulateAutoMarginOrderRiskRequestSchema = BaseSimulateOrderRiskRequestSchema.merge(AutoMarginBucketRequestSchema).strict();
 export const SimulateOrderRiskSchema = z
     .object({
     marginAccountId: UUIDSchema,
@@ -66,7 +64,7 @@ export const SimulateOrderRiskSchema = z
 });
 export const SimulateAutoMarginOrderRiskSchema = z
     .object({
-    request: SimulateOrderRiskRequestSchema,
+    request: SimulateAutoMarginOrderRiskRequestSchema,
 })
     .refine((data) => data.request.orderType !== "LIMIT" || data.request.price !== undefined, {
     message: "price is required for LIMIT risk simulations",

package/dist/validation/profile.d.ts

@@ -67,3 +67,10 @@ export declare const GetUserTradesSchema: z.ZodObject<{
     page_size: z.ZodOptional<z.ZodNumber>;
     trading_pair_id: z.ZodOptional<z.ZodUUID>;
 }, z.core.$strip>;
+export declare const ListFundingPaymentsSchema: z.ZodObject<{
+    page: z.ZodOptional<z.ZodNumber>;
+    page_size: z.ZodOptional<z.ZodNumber>;
+    trading_pair_id: z.ZodOptional<z.ZodUUID>;
+    position_id: z.ZodOptional<z.ZodUUID>;
+    margin_account_id: z.ZodOptional<z.ZodUUID>;
+}, z.core.$strip>;

package/dist/validation/profile.js

@@ -42,3 +42,10 @@ export const GetUserTradesSchema = z.object({
     page_size: z.number().int("Page size must be an integer").min(1, "Page size must be at least 1").max(100, "Page size cannot exceed 100").optional(),
     trading_pair_id: UUIDSchema.optional(),
 });
+export const ListFundingPaymentsSchema = z.object({
+    page: z.number().int("Page must be an integer").min(1, "Page must be at least 1").optional(),
+    page_size: z.number().int("Page size must be an integer").min(1, "Page size must be at least 1").max(100, "Page size cannot exceed 100").optional(),
+    trading_pair_id: UUIDSchema.optional(),
+    position_id: UUIDSchema.optional(),
+    margin_account_id: UUIDSchema.optional(),
+});

package/dist/validation/trading.d.ts

@@ -101,6 +101,8 @@ export declare const PlaceLimitOrderSchema: z.ZodObject<{
             FOK: "FOK";
         }>>;
         marginAccountId: z.ZodOptional<z.ZodUUID>;
+        marginBucketId: z.ZodOptional<z.ZodUUID>;
+        marginBucketCollateral: z.ZodOptional<z.ZodString>;
         strategyKey: z.ZodOptional<z.ZodString>;
         positionSide: z.ZodOptional<z.ZodEnum<{
             LONG: "LONG";
@@ -156,6 +158,8 @@ export declare const PlaceMarketOrderSchema: z.ZodObject<{
         }>>;
         slippageTolerance: z.ZodOptional<z.ZodNumber>;
         marginAccountId: z.ZodOptional<z.ZodUUID>;
+        marginBucketId: z.ZodOptional<z.ZodUUID>;
+        marginBucketCollateral: z.ZodOptional<z.ZodString>;
         strategyKey: z.ZodOptional<z.ZodString>;
         positionSide: z.ZodOptional<z.ZodEnum<{
             LONG: "LONG";
@@ -266,39 +270,6 @@ export declare const ClosePositionSideSchema: z.ZodEnum<{
     LONG: "LONG";
     SHORT: "SHORT";
 }>;
-export declare const CreateConditionalOrderSchema: z.ZodObject<{
-    tradingPairId: z.ZodUUID;
-    marginAccountId: z.ZodUUID;
-    conditionType: z.ZodEnum<{
-        STOP_LOSS: "STOP_LOSS";
-        TAKE_PROFIT: "TAKE_PROFIT";
-    }>;
-    triggerPrice: z.ZodString;
-    triggerSource: z.ZodOptional<z.ZodEnum<{
-        MARK_PRICE: "MARK_PRICE";
-    }>>;
-    side: z.ZodEnum<{
-        BUY: "BUY";
-        SELL: "SELL";
-    }>;
-    positionSide: z.ZodEnum<{
-        LONG: "LONG";
-        SHORT: "SHORT";
-    }>;
-    orderType: z.ZodEnum<{
-        LIMIT: "LIMIT";
-        MARKET: "MARKET";
-    }>;
-    limitPrice: z.ZodOptional<z.ZodString>;
-    quantity: z.ZodOptional<z.ZodString>;
-    reduceOnly: z.ZodOptional<z.ZodBoolean>;
-    timeInForce: z.ZodOptional<z.ZodEnum<{
-        GTC: "GTC";
-        IOC: "IOC";
-    }>>;
-    slippageToleranceBps: z.ZodOptional<z.ZodNumber>;
-    expiresAt: z.ZodOptional<z.ZodISODateTime>;
-}, z.core.$strip>;
 export declare const CancelConditionalOrderSchema: z.ZodObject<{
     conditionalOrderId: z.ZodUUID;
 }, z.core.$strip>;
@@ -349,6 +320,8 @@ export declare const BatchCreateOrderItemSchema: z.ZodObject<{
         FOK: "FOK";
     }>>;
     marginAccountId: z.ZodOptional<z.ZodUUID>;
+    marginBucketId: z.ZodOptional<z.ZodUUID>;
+    marginBucketCollateral: z.ZodOptional<z.ZodString>;
     strategyKey: z.ZodOptional<z.ZodString>;
     positionSide: z.ZodOptional<z.ZodEnum<{
         LONG: "LONG";
@@ -389,6 +362,8 @@ export declare const BatchCreateOrdersSchema: z.ZodObject<{
             FOK: "FOK";
         }>>;
         marginAccountId: z.ZodOptional<z.ZodUUID>;
+        marginBucketId: z.ZodOptional<z.ZodUUID>;
+        marginBucketCollateral: z.ZodOptional<z.ZodString>;
         strategyKey: z.ZodOptional<z.ZodString>;
         positionSide: z.ZodOptional<z.ZodEnum<{
             LONG: "LONG";

package/dist/validation/trading.js

@@ -117,6 +117,8 @@ export const PlaceLimitOrderSchema = z
         expirationDate: ISO8601DateSchema.optional(),
         timeInForce: TimeInForceSchema.optional(),
         marginAccountId: UUIDSchema.optional(),
+        marginBucketId: UUIDSchema.optional(),
+        marginBucketCollateral: PositiveDecimalStringSchema.optional(),
         strategyKey: z.string().min(1).max(128).optional(),
         positionSide: PositionSideSchema.optional(),
         leverage: PositiveDecimalStringSchema.optional(),
@@ -145,6 +147,18 @@ export const PlaceLimitOrderSchema = z
     .refine((data) => !hasParentTpSl(data.options) || data.options?.reduceOnly !== true, {
     message: "Parent TP/SL cannot be attached to reduceOnly orders",
     path: ["options", "reduceOnly"],
+})
+    .refine((data) => data.options?.marginBucketCollateral === undefined || data.options?.tradingMode === "MARGIN", {
+    message: "marginBucketCollateral is only supported for MARGIN orders",
+    path: ["options", "tradingMode"],
+})
+    .refine((data) => data.options?.marginBucketCollateral === undefined || data.options?.marginBucketId === undefined, {
+    message: "marginBucketCollateral creates a new bucket and cannot be combined with marginBucketId",
+    path: ["options", "marginBucketId"],
+})
+    .refine((data) => data.options?.marginBucketCollateral === undefined || data.options?.reduceOnly !== true, {
+    message: "reduceOnly orders cannot create a new margin bucket",
+    path: ["options", "reduceOnly"],
 });
 /**
  * Place Market Order validation schema
@@ -159,6 +173,8 @@ export const PlaceMarketOrderSchema = z
         tradingMode: TradingModeSchema.optional(),
         slippageTolerance: SlippageToleranceSchema,
         marginAccountId: UUIDSchema.optional(),
+        marginBucketId: UUIDSchema.optional(),
+        marginBucketCollateral: PositiveDecimalStringSchema.optional(),
         strategyKey: z.string().min(1).max(128).optional(),
         positionSide: PositionSideSchema.optional(),
         leverage: PositiveDecimalStringSchema.optional(),
@@ -187,6 +203,18 @@ export const PlaceMarketOrderSchema = z
     .refine((data) => !hasParentTpSl(data.options) || data.options?.reduceOnly !== true, {
     message: "Parent TP/SL cannot be attached to reduceOnly orders",
     path: ["options", "reduceOnly"],
+})
+    .refine((data) => data.options?.marginBucketCollateral === undefined || data.options?.tradingMode === "MARGIN", {
+    message: "marginBucketCollateral is only supported for MARGIN orders",
+    path: ["options", "tradingMode"],
+})
+    .refine((data) => data.options?.marginBucketCollateral === undefined || data.options?.marginBucketId === undefined, {
+    message: "marginBucketCollateral creates a new bucket and cannot be combined with marginBucketId",
+    path: ["options", "marginBucketId"],
+})
+    .refine((data) => data.options?.marginBucketCollateral === undefined || data.options?.reduceOnly !== true, {
+    message: "reduceOnly orders cannot create a new margin bucket",
+    path: ["options", "reduceOnly"],
 });
 /**
  * Cancel Order validation schema
@@ -240,39 +268,6 @@ export const ConditionalOrderStateSchema = z.enum(["PENDING_PARENT", "ACTIVE", "
 export const ClosePositionSideSchema = z.enum(["LONG", "SHORT"], {
     message: 'Position side must be "LONG" or "SHORT"',
 });
-export const CreateConditionalOrderSchema = z
-    .object({
-    tradingPairId: UUIDSchema,
-    marginAccountId: UUIDSchema,
-    conditionType: ConditionalOrderConditionTypeSchema,
-    triggerPrice: PositiveDecimalStringSchema,
-    triggerSource: ConditionalOrderTriggerSourceSchema.optional(),
-    side: OrderSideSchema,
-    positionSide: ClosePositionSideSchema,
-    orderType: OrderTypeSchema,
-    limitPrice: PositiveDecimalStringSchema.optional(),
-    quantity: PositiveDecimalStringSchema.optional(),
-    reduceOnly: z.boolean().optional(),
-    timeInForce: ConditionalTimeInForceSchema.optional(),
-    slippageToleranceBps: SlippageToleranceBpsSchema.optional(),
-    expiresAt: ISO8601DateSchema.optional(),
-})
-    .refine((data) => data.orderType !== "LIMIT" || data.limitPrice !== undefined, {
-    message: "limitPrice is required for LIMIT conditional orders",
-    path: ["limitPrice"],
-})
-    .refine((data) => data.orderType !== "MARKET" || data.limitPrice === undefined, {
-    message: "limitPrice must not be provided for MARKET conditional orders",
-    path: ["limitPrice"],
-})
-    .refine((data) => data.orderType !== "MARKET" || data.timeInForce === undefined, {
-    message: "timeInForce is only allowed for LIMIT conditional orders",
-    path: ["timeInForce"],
-})
-    .refine((data) => data.orderType !== "LIMIT" || data.slippageToleranceBps === undefined, {
-    message: "slippageToleranceBps is only allowed for MARKET conditional orders",
-    path: ["slippageToleranceBps"],
-});
 export const CancelConditionalOrderSchema = z.object({
     conditionalOrderId: UUIDSchema,
 });
@@ -303,6 +298,8 @@ export const BatchCreateOrderItemSchema = z
     expirationDate: ISO8601DateSchema.optional(),
     timeInForce: TimeInForceSchema.optional(),
     marginAccountId: UUIDSchema.optional(),
+    marginBucketId: UUIDSchema.optional(),
+    marginBucketCollateral: PositiveDecimalStringSchema.optional(),
     strategyKey: z.string().min(1).max(128).optional(),
     positionSide: PositionSideSchema.optional(),
     leverage: PositiveDecimalStringSchema.optional(),
@@ -315,6 +312,18 @@ export const BatchCreateOrderItemSchema = z
     .refine((data) => data.orderType !== "MARKET" || data.price === undefined, {
     message: "Price must not be provided for MARKET orders",
     path: ["price"],
+})
+    .refine((data) => data.marginBucketCollateral === undefined || data.tradingMode === "MARGIN", {
+    message: "marginBucketCollateral is only supported for MARGIN orders",
+    path: ["tradingMode"],
+})
+    .refine((data) => data.marginBucketCollateral === undefined || data.marginBucketId === undefined, {
+    message: "marginBucketCollateral creates a new bucket and cannot be combined with marginBucketId",
+    path: ["marginBucketId"],
+})
+    .refine((data) => data.marginBucketCollateral === undefined || data.reduceOnly !== true, {
+    message: "reduceOnly orders cannot create a new margin bucket",
+    path: ["reduceOnly"],
 })
     .refine((data) => data.tradingMode !== "MARGIN" || data.positionSide !== undefined, {
     message: "positionSide is required for MARGIN orders",

package/dist/validation/vault.d.ts

@@ -44,6 +44,10 @@ export declare const DepositSchema: z.ZodObject<{
     assetId: z.ZodUUID;
     amount: z.ZodUnion<readonly [z.ZodString, z.ZodBigInt]>;
     autoWait: z.ZodOptional<z.ZodBoolean>;
+    target: z.ZodOptional<z.ZodEnum<{
+        spot: "spot";
+        margin: "margin";
+    }>>;
 }, z.core.$strip>;
 /**
  * Withdraw validation schema.

package/dist/validation/vault.js

@@ -57,6 +57,8 @@ export const DepositSchema = z.object({
     assetId: UUIDSchema,
     amount: PositiveBigIntStringSchema,
     autoWait: z.boolean().optional(),
+    // Destination ledger: "spot" (default) or "margin" to route into margin collateral.
+    target: z.enum(["spot", "margin"]).optional(),
 });
 /**
  * Withdraw validation schema.

package/dist/vault/index.d.ts

@@ -5,6 +5,15 @@
  */
 import type { BaseAPI } from "../api/index";
 import type { Balance, TransactionResult, 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";
 /**
  * Vault API interface.
  * Provides methods for managing token deposits and withdrawals.
@@ -24,9 +33,12 @@ 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

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) */
+    wallet_address: string;
+    /** Applicant email address */
+    email: string;
+    /** Applicant Twitter/X username (1-15 chars) */
+    twitter_username?: string;
+    /** Applicant Telegram username (5-32 chars) */
+    telegram_username?: string;
+}
+/** Response to a whitelist application. */
+export interface SubmitWhitelistResponse {
+    /** Human-readable status message */
+    message: string;
+    /** Created user UUID (pending approval) */
+    user_id: 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 {};