@0xmonaco/types 0.8.7-develop.34bd452 → 0.8.7-develop.5d0e403

package/dist/market/index.d.ts

@@ -46,6 +46,10 @@ export interface TradingPair {
     max_order_size: string;
     /** Tick size for price increments */
     tick_size: string;
+    /** Minimum supported leverage for margin markets (optional, margin only) */
+    min_leverage?: string | null;
+    /** Maximum supported leverage for margin markets (optional, margin only) */
+    max_leverage?: string | null;
 }
 /**
  * OHLCV candlestick data point (matches API response format)
@@ -139,6 +143,71 @@ export interface GetTradingPairsResponse {
 export interface GetTradingPairResponse {
     trading_pair: TradingPair;
 }
+/**
+ * Query parameters for the market screener
+ */
+export interface GetScreenerParams {
+    /** Page number (min 1, default 1) */
+    page?: number;
+    /** Items per page (min 1, max 100, default 50) */
+    page_size?: number;
+    /** Filter by market type: SPOT or MARGIN */
+    market_type?: string;
+    /** Filter by active status */
+    is_active?: boolean;
+}
+/**
+ * One UTC-day bucket in a pair's 7-day screener snapshot
+ */
+export interface ScreenerSnapshotPoint {
+    /** UTC day boundary (ms since epoch, as string) */
+    bucket_start: string;
+    /** Quote-token volume for the day */
+    quote_volume: string;
+    /** Percent price change (close - open) / open * 100 for the day */
+    price_change_percent: string;
+}
+/**
+ * Per-pair screener row. Window fields are null when there is insufficient history.
+ */
+export interface ScreenerItem {
+    /** Trading pair UUID */
+    trading_pair_id: string;
+    /** Trading pair symbol (e.g. "BTC/USDC") */
+    symbol: string;
+    /** Base token icon URL */
+    base_icon_url: string;
+    /** Quote token icon URL */
+    quote_icon_url: string;
+    /** Most recent close price (null if no trades yet) */
+    last_price: string | null;
+    /** Timestamp of the last candle (ms since epoch, as string; null if no trades yet) */
+    last_price_timestamp: string | null;
+    /** Quote-token volume in the last 1 hour (null if <1h history) */
+    quote_volume_1h: string | null;
+    /** Quote-token volume in the last 24 hours (null if <24h history) */
+    quote_volume_24h: string | null;
+    /** Quote-token volume in the last 7 days (null if <7d history) */
+    quote_volume_7d: string | null;
+    /** Percent price change over the last 1 hour (null if <1h history) */
+    price_change_percent_1h: string | null;
+    /** Percent price change over the last 24 hours (null if <24h history) */
+    price_change_percent_24h: string | null;
+    /** Percent price change over the last 7 days (null if <7d history) */
+    price_change_percent_7d: string | null;
+    /** Up to 7 UTC-day buckets (oldest first); empty when <1 day of history */
+    snapshot_7d: ScreenerSnapshotPoint[];
+}
+/**
+ * Paginated screener response, sorted by quote_volume_24h desc (nulls last)
+ */
+export interface GetScreenerResponse {
+    items: ScreenerItem[];
+    page: number;
+    page_size: number;
+    total: number;
+    total_pages: number;
+}
 /**
  * API response wrapper for single trading pair
  */
@@ -275,12 +344,26 @@ export interface MarketAPI extends BaseAPI {
      * @returns Promise resolving to paginated response with trading pairs
      */
     getPaginatedTradingPairs(params?: GetTradingPairsParams): Promise<GetTradingPairsResponse>;
+    /**
+     * Fetch a single trading pair by its UUID.
+     * @param tradingPairId - Trading pair UUID
+     * @returns Promise resolving to the trading pair
+     * @throws {APIError} If the pair is not found
+     */
+    getTradingPair(tradingPairId: string): Promise<TradingPair>;
     /**
      * Fetch metadata for a single trading pair by its symbol (e.g. BTC-USDC).
      * @param symbol - Trading pair symbol
      * @returns Promise resolving to trading pair or undefined if not found
      */
     getTradingPairBySymbol(symbol: string): Promise<TradingPair | undefined>;
+    /**
+     * Fetch the paginated market screener: per-pair price/volume/change windows
+     * (1h, 24h, 7d) plus a 7-day daily snapshot, sorted by 24h quote volume.
+     * @param params - Optional pagination and filter parameters
+     * @returns Promise resolving to the paginated screener response
+     */
+    getScreener(params?: GetScreenerParams): Promise<GetScreenerResponse>;
     /**
      * Fetch historical candlestick data for a trading pair.
      *

package/dist/positions/index.d.ts

@@ -5,6 +5,7 @@ export type ClosePositionType = "MARKET" | "LIMIT" | "IOC";
 export interface Position {
     position_id: string;
     margin_account_id: string;
+    margin_bucket_id?: string;
     trading_pair_id: string;
     side: PositionSide;
     size: string;

package/dist/profile/index.d.ts

@@ -76,6 +76,12 @@ export interface LedgerMovement {
     block_number: number | null;
     /** Transaction timestamp */
     created_at: string | null;
+    /** Asset UUID this movement affects */
+    asset_id?: string | null;
+    /** User UUID who owns this movement */
+    user_id?: string | null;
+    /** Balance UUID this movement affects */
+    balance_id?: string | null;
 }
 /**
  * Ledger entry type for filtering movements.
@@ -190,7 +196,7 @@ export interface AccountBalance {
     available_balance: string;
     /** Locked balance (in orders or pending operations, normalized) */
     locked_balance: string;
-    /** Total balance (available + locked + margin collateral, normalized) */
+    /** Total balance (available + locked, normalized) */
     total_balance: string;
     /** Available balance in raw format (wei) */
     available_balance_raw: string;
@@ -315,6 +321,10 @@ export interface UserProfile {
     maker_fee_bps: number;
     /** Account creation timestamp (ISO string) */
     created_at: string;
+    /** Additional taker fee in basis points contributed by the application (if any) */
+    application_taker_fee_bps?: number;
+    /** Additional maker fee in basis points contributed by the application (if any) */
+    application_maker_fee_bps?: number;
 }
 /**
  * Profile API interface.

package/dist/sdk/index.d.ts

@@ -2,14 +2,18 @@ import type { PublicClient, TransactionReceipt, WalletClient } from "viem";
 import type { ApplicationsAPI } from "../applications";
 import type { AuthAPI, AuthState, SessionCredentials } from "../auth/index";
 import type { DelegatedAgentsAPI } from "../delegated-agents";
+import type { FaucetAPI } from "../faucet";
 import type { FeesAPI } from "../fees";
 import type { MarginAccountsAPI } from "../margin-accounts";
 import type { Interval, MarketAPI } from "../market";
 import type { PositionsAPI } from "../positions";
 import type { ProfileAPI } from "../profile";
+import type { SubAccountsAPI } from "../sub-accounts";
 import type { TradingAPI, TradingMode } from "../trading";
 import type { VaultAPI } from "../vault";
 import type { ConditionalOrderEvent, OHLCVEvent, OrderbookEvent, OrderbookQuotationMode, OrderEvent, TradeEvent, UserBalanceEvent, UserMovementEvent } from "../websocket";
+import type { WhitelistAPI } from "../whitelist";
+import type { WithdrawalsAPI } from "../withdrawals";
 import type { Network } from "./network";
 /**
  * Configuration options for the Monaco SDK.
@@ -65,6 +69,8 @@ export interface MonacoSDK {
     delegatedAgents: DelegatedAgentsAPI;
     /** Vault operations API */
     vault: VaultAPI;
+    /** Low-level withdrawals API (initiate + fetch signed calldata) */
+    withdrawals: WithdrawalsAPI;
     /** Trading operations API */
     trading: TradingAPI;
     /** Market metadata API */
@@ -73,6 +79,12 @@ export interface MonacoSDK {
     marginAccounts: MarginAccountsAPI;
     /** Perp position operations API */
     positions: PositionsAPI;
+    /** Sub-account management API */
+    subAccounts: SubAccountsAPI;
+    /** Testnet faucet API */
+    faucet: FaucetAPI;
+    /** Public whitelist (waitlist) submission API */
+    whitelist: WhitelistAPI;
     /** Profile operations API */
     profile: ProfileAPI;
     /** Orderbook REST API for fetching orderbook snapshots */

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

@@ -0,0 +1,145 @@
+/**
+ * Sub-Accounts Types
+ *
+ * Types for managing sub-accounts and their per-asset spending limits. All
+ * endpoints are session-authenticated; the limit mutations additionally
+ * require the caller to be a master account with the `ManageSubAccounts`
+ * permission (enforced server-side). Wire shapes are snake_case; optional
+ * fields are `null` rather than omitted.
+ */
+import type { BaseAPI } from "../api";
+import type { AccountBalance } from "../profile";
+/**
+ * A sub-account owned by the authenticated master account, with its balances.
+ */
+export interface SubAccount {
+    /** Sub-account UUID */
+    id: string;
+    /** Sub-account wallet address */
+    address: string;
+    /** Sub-account display username */
+    username: string | null;
+    /** Whether the sub-account is allowed to withdraw */
+    can_withdraw: boolean;
+    /** Account creation timestamp (ISO 8601) */
+    created_at: string;
+    /** Per-asset balances held by the sub-account */
+    balances: AccountBalance[];
+}
+/**
+ * A per-asset spending limit on a sub-account.
+ */
+export interface SubAccountLimit {
+    /** Limit UUID */
+    id: string;
+    /** Sub-account UUID this limit applies to */
+    sub_account_id: string;
+    /** Token contract address */
+    token: string;
+    /** Maximum daily spending limit in token units */
+    daily_limit: string | null;
+    /** Amount used today against the limit */
+    used_today: string;
+    /** Limit creation timestamp (ISO 8601) */
+    created_at: string;
+    /** Last update timestamp (ISO 8601) */
+    updated_at: string | null;
+    /** Master account UUID that owns this sub-account */
+    master_account_id: string;
+    /** Maximum amount allowed in token units */
+    max_amount: string;
+    /** Last reset timestamp for the daily limit (ISO 8601) */
+    last_reset_at: string | null;
+    /** Whether the limit is active */
+    is_active: boolean;
+}
+/**
+ * Body for creating a sub-account limit.
+ */
+export interface CreateSubAccountLimitRequest {
+    /** Sub-account UUID to create the limit for */
+    sub_account_id: string;
+    /** Asset UUID to limit */
+    asset_id: string;
+    /** Maximum amount allowed in token units */
+    max_amount: string;
+    /** Maximum daily spending limit in token units */
+    daily_limit?: string;
+}
+/**
+ * Body for updating a sub-account limit. The sub-account and asset are taken
+ * from the path; all body fields are optional (partial update).
+ */
+export interface UpdateSubAccountLimitBody {
+    /** New maximum amount allowed in token units */
+    max_amount?: string;
+    /** New maximum daily spending limit in token units */
+    daily_limit?: string;
+    /** Whether the limit is active */
+    is_active?: boolean;
+}
+/** Paginated list of the master account's sub-accounts. */
+export interface ListSubAccountsResponse {
+    sub_accounts: SubAccount[];
+    /** Total number of sub-accounts */
+    total: number;
+}
+/** Response wrapping a single created limit. */
+export interface CreateSubAccountLimitResponse {
+    limit: SubAccountLimit;
+}
+/** Response wrapping a single updated limit. */
+export interface UpdateSubAccountLimitResponse {
+    limit: SubAccountLimit;
+}
+/** Response wrapping a sub-account's limits. */
+export interface GetSubAccountLimitsResponse {
+    limits: SubAccountLimit[];
+}
+/**
+ * Sub-accounts API interface.
+ *
+ * `list` and `getLimits` need only session auth; `createLimit`, `updateLimit`,
+ * and `deleteLimit` additionally require the master account to hold the
+ * `ManageSubAccounts` permission (enforced server-side — a non-master or
+ * unpermissioned caller gets a 403).
+ */
+export interface SubAccountsAPI extends BaseAPI {
+    /**
+     * Lists the authenticated master account's sub-accounts with balances.
+     *
+     * @returns Promise resolving to the sub-accounts and total count
+     */
+    list(): Promise<ListSubAccountsResponse>;
+    /**
+     * Creates a per-asset spending limit on a sub-account.
+     *
+     * @param body - Sub-account, asset, max amount, and optional daily limit
+     * @returns Promise resolving to the created limit
+     */
+    createLimit(body: CreateSubAccountLimitRequest): Promise<CreateSubAccountLimitResponse>;
+    /**
+     * Gets the limits configured for a sub-account.
+     *
+     * @param subAccountId - Sub-account UUID
+     * @returns Promise resolving to the sub-account's limits
+     */
+    getLimits(subAccountId: string): Promise<GetSubAccountLimitsResponse>;
+    /**
+     * Updates a sub-account's per-asset limit (partial update).
+     *
+     * @param subAccountId - Sub-account UUID
+     * @param assetId - Asset UUID
+     * @param body - Fields to update
+     * @returns Promise resolving to the updated limit
+     */
+    updateLimit(subAccountId: string, assetId: string, body: UpdateSubAccountLimitBody): Promise<UpdateSubAccountLimitResponse>;
+    /**
+     * Deletes a sub-account's per-asset limit.
+     *
+     * @param subAccountId - Sub-account UUID
+     * @param assetId - Asset UUID
+     * @returns Promise resolving when the limit is deleted
+     */
+    deleteLimit(subAccountId: string, assetId: string): Promise<void>;
+}

package/dist/sub-accounts/index.js

@@ -0,0 +1,9 @@
+/**
+ * Sub-Accounts Types
+ *
+ * Types for managing sub-accounts and their per-asset spending limits. All
+ * endpoints are session-authenticated; the limit mutations additionally
+ * require the caller to be a master account with the `ManageSubAccounts`
+ * permission (enforced server-side). Wire shapes are snake_case; optional
+ * fields are `null` rather than omitted.
+ */

package/dist/trading/index.d.ts

@@ -29,6 +29,8 @@ export interface TradingAPI extends BaseAPI {
         expirationDate?: string;
         timeInForce?: TimeInForce;
         marginAccountId?: string;
+        marginBucketId?: string;
+        marginBucketCollateral?: string;
         strategyKey?: string;
         positionSide?: PositionSide;
         leverage?: string;
@@ -50,6 +52,8 @@ export interface TradingAPI extends BaseAPI {
         tradingMode?: TradingMode;
         slippageTolerance?: number;
         marginAccountId?: string;
+        marginBucketId?: string;
+        marginBucketCollateral?: string;
         strategyKey?: string;
         positionSide?: PositionSide;
         leverage?: string;

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;

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

@@ -8,7 +8,7 @@ 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<{
+export declare const EnsureParentMarginAccountSchema: z.ZodOptional<z.ZodObject<{
     label: z.ZodOptional<z.ZodString>;
     collateralAsset: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>>;

package/dist/validation/margin-accounts.js

@@ -11,7 +11,7 @@ export const ListMarginAccountsSchema = PaginationSchema.extend({
     state: z.string().trim().min(1, "State cannot be empty").optional(),
     tradingPairId: UUIDSchema.optional(),
 });
-export const CreateMarginAccountSchema = z
+export const EnsureParentMarginAccountSchema = 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(),

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";
@@ -349,6 +353,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 +395,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
@@ -303,6 +331,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 +345,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/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/coverage.d.ts

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

package/dist/wire/index.d.ts

@@ -0,0 +1,14 @@
+/**
+ * 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.
+ */
+export type { Expect, MissingWireFields, WireCovered, WireSchema, WireSchemas } from "./assert";
+export type { components, operations, paths } from "./schema";