@0xmonaco/types 1.0.58 → 1.0.60

package/dist/auth/index.d.ts

@@ -31,10 +31,24 @@ export interface AuthAPI extends BaseAPI {
     /**
      * Signs a challenge message using the wallet client.
      *
-     * Signs the provided message using the wallet's private key.
-     * This is used in the authentication flow to prove ownership of the wallet.
+     * Asks the connected wallet to authorize the message, proving control of the
+     * address. An EOA signs it with its private key (EIP-191 `personal_sign`). A
+     * smart-contract wallet such as a Safe has no private key and returns a
+     * signature its own contract will accept, which the server checks under
+     * EIP-1271; the wallet client handles that difference, and the returned value
+     * is submitted unchanged either way.
      *
-     * @param message - The message to sign
+     * The returned signature is therefore not guaranteed to be 65 bytes — a
+     * contract signature is usually longer — so callers must not assume the
+     * EOA shape.
+     *
+     * Note the scope. Server-side EIP-1271 verification is deliberately narrow:
+     * it is offered only to a wallet holding a BuilderCodes payout bucket, on a
+     * deployment with the contract-wallet flag on and a chain RPC endpoint
+     * configured. An ordinary smart-contract trading account is not covered — it
+     * still takes the recovery path, which it cannot satisfy.
+     *
+     * @param message - The message to authorize
      * @returns Promise resolving to the signature
      */
     signChallenge(message: string): Promise<string>;

package/dist/buildercodes/index.d.ts

@@ -0,0 +1,71 @@
+/**
+ * BuilderCodes Types
+ *
+ * Types for the BuilderCodes API: reading and claiming an enrolled frontend's
+ * per-trade revenue share.
+ */
+import type { BaseAPI } from "../api";
+import type { ClaimBuildercodeRewardsParams, ClaimBuildercodeRewardsResponse, GetBuildercodePayoutSummaryResponse, GetBuildercodeRewardsBalanceResponse, GetBuildercodesConfigResponse, ListBuildercodePayoutsParams, ListBuildercodePayoutsResponse } from "./responses";
+/**
+ * BuilderCodes payout API interface.
+ *
+ * BuilderCodes is Monaco's per-trade frontend revenue share: an enrolled
+ * frontend earns a configured share of the net take on every fill its users
+ * generate, accruing to a reserved payout bucket owned by the frontend's
+ * configured payout wallet. Accrual is internal accounting only — this API is
+ * how that balance is claimed into a tradeable (and then withdrawable) balance.
+ */
+export interface BuildercodesAPI extends BaseAPI {
+    /** Read this authenticated frontend's enrollment, payout address, and live budget. */
+    getConfig(): Promise<GetBuildercodesConfigResponse>;
+    /** List this authenticated frontend's per-trade BuilderCodes credits. */
+    listPayouts(params?: ListBuildercodePayoutsParams): Promise<ListBuildercodePayoutsResponse>;
+    /** Summarize this authenticated frontend's BuilderCodes credits by token. */
+    getPayoutSummary(): Promise<GetBuildercodePayoutSummaryResponse>;
+    /** Read the authenticated wallet's available reserved reward balances. */
+    getRewardsBalance(): Promise<GetBuildercodeRewardsBalanceResponse>;
+    /**
+     * Claim accrued BuilderCodes payout balance into a trading balance.
+     *
+     * Moves the specified amount of a payout token out of the authenticated
+     * caller's reserved payout bucket and into their trading balance under the
+     * authenticated application, from where the ordinary withdrawal flow applies.
+     * Ledger-only — no on-chain transaction and no gas, and the funds are
+     * immediately tradeable.
+     *
+     * The payout wallet may be an EOA or a smart-contract wallet. An EOA answers
+     * the signature challenge directly; a multisig such as a Safe authenticates by
+     * EIP-1271 contract signature instead. That path is offered only to a wallet
+     * holding a BuilderCodes payout bucket, only while `contract_wallet_auth_enabled`
+     * is on, and only where the deployment has a chain RPC endpoint configured —
+     * otherwise login is EOA-only and a contract payout wallet can neither call
+     * this endpoint nor withdraw afterwards.
+     *
+     * The bucket is resolved from the authenticated caller's own wallet address,
+     * so a caller can only ever claim their own accrued balance. A wallet that
+     * has never been an enrolled frontend's payout address has nothing to claim.
+     * A wallet that *used to be* a payout address keeps what it accrued back then
+     * and can still claim it — payout-address changes are not retroactive.
+     *
+     * Throws 403 when the caller is refused: BuilderCodes is not enabled, or
+     * the session is a delegated agent — which is rejected before the feature is
+     * checked, so it is a permanent restriction on that session type, not a
+     * rollout state. Throws 409 when the payout balance is insufficient for the
+     * requested amount. Throws 503 when the matching engine is unreachable,
+     * restarting, or slow to answer — an UNKNOWN outcome, not a rejection: the
+     * claim is admitted to the sequencer before its reply is sent, so it may
+     * still commit, and with no idempotency key a blind retry can claim twice.
+     * Do not retry automatically: a balance read cannot settle it, because an
+     * admitted claim may still be queued. Ambiguous failures are thrown
+     * with `retryable: false` so retry logic driven off that flag cannot claim
+     * twice. Two pre-admission rejections stay retryable because they committed
+     * nothing: a maintenance block (`OPERATIONS_BLOCKED`) and a sequencer
+     * overload (`OVERLOADED`).
+     *
+     * @param params - Payout token address and raw-unit amount to claim
+     * @returns Promise resolving to the post-claim payout and trading balances
+     */
+    claimBuildercodeRewards(params: ClaimBuildercodeRewardsParams): Promise<ClaimBuildercodeRewardsResponse>;
+}
+export type { BuildercodePayout, BuildercodePayoutTokenTotal, BuildercodeRewardsBalance, ClaimBuildercodeRewardsParams, ClaimBuildercodeRewardsResponse, GetBuildercodePayoutSummaryResponse, GetBuildercodeRewardsBalanceResponse, GetBuildercodesConfigResponse, ListBuildercodePayoutsParams, ListBuildercodePayoutsResponse, } from "./responses";
+export { BuildercodePayoutSchema, BuildercodePayoutTokenTotalSchema, BuildercodeRewardsBalanceSchema, ClaimBuildercodeRewardsParamsSchema, ClaimBuildercodeRewardsResponseSchema, GetBuildercodePayoutSummaryResponseSchema, GetBuildercodeRewardsBalanceResponseSchema, GetBuildercodesConfigResponseSchema, ListBuildercodePayoutsParamsSchema, ListBuildercodePayoutsResponseSchema, } from "./responses";

package/dist/buildercodes/index.js

@@ -0,0 +1,7 @@
+/**
+ * BuilderCodes Types
+ *
+ * Types for the BuilderCodes API: reading and claiming an enrolled frontend's
+ * per-trade revenue share.
+ */
+export { BuildercodePayoutSchema, BuildercodePayoutTokenTotalSchema, BuildercodeRewardsBalanceSchema, ClaimBuildercodeRewardsParamsSchema, ClaimBuildercodeRewardsResponseSchema, GetBuildercodePayoutSummaryResponseSchema, GetBuildercodeRewardsBalanceResponseSchema, GetBuildercodesConfigResponseSchema, ListBuildercodePayoutsParamsSchema, ListBuildercodePayoutsResponseSchema, } from "./responses";

package/dist/buildercodes/responses.d.ts

@@ -0,0 +1,94 @@
+/**
+ * BuilderCodes Response Types
+ *
+ * Types for the BuilderCodes earnings and payout API responses and requests.
+ * All types are derived from Zod schemas for runtime validation.
+ */
+import { z } from "zod";
+/** Schema for this frontend's current BuilderCodes program state. */
+export declare const GetBuildercodesConfigResponseSchema: z.ZodObject<{
+    applicationId: z.ZodString;
+    enrolled: z.ZodBoolean;
+    payoutAddress: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    buildercodesEnabled: z.ZodBoolean;
+    buildercodesBudgetBps: z.ZodNumber;
+}, z.core.$strip>;
+/** Pagination accepted by the per-trade payout history endpoint. */
+export declare const ListBuildercodePayoutsParamsSchema: z.ZodObject<{
+    page: z.ZodOptional<z.ZodNumber>;
+    pageSize: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+/** One per-trade BuilderCodes credit. Amounts are RAW atomic units. */
+export declare const BuildercodePayoutSchema: z.ZodObject<{
+    tradeId: z.ZodString;
+    payoutAddress: z.ZodString;
+    token: z.ZodString;
+    amount: z.ZodString;
+    appliedBps: z.ZodNumber;
+    createdAt: z.ZodString;
+}, z.core.$strip>;
+/** Schema for the paginated per-trade payout history. */
+export declare const ListBuildercodePayoutsResponseSchema: z.ZodObject<{
+    payouts: z.ZodArray<z.ZodObject<{
+        tradeId: z.ZodString;
+        payoutAddress: z.ZodString;
+        token: z.ZodString;
+        amount: z.ZodString;
+        appliedBps: z.ZodNumber;
+        createdAt: z.ZodString;
+    }, z.core.$strip>>;
+    total: z.ZodNumber;
+    page: z.ZodNumber;
+    pageSize: z.ZodNumber;
+    totalPages: z.ZodNumber;
+}, z.core.$strip>;
+/** One token-denominated BuilderCodes earnings total. */
+export declare const BuildercodePayoutTokenTotalSchema: z.ZodObject<{
+    token: z.ZodString;
+    totalAmount: z.ZodString;
+    payoutCount: z.ZodNumber;
+    lastCreditedAt: z.ZodString;
+}, z.core.$strip>;
+/** Schema for this frontend's payout summary. */
+export declare const GetBuildercodePayoutSummaryResponseSchema: z.ZodObject<{
+    totalPayouts: z.ZodNumber;
+    lastCreditedAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    byToken: z.ZodArray<z.ZodObject<{
+        token: z.ZodString;
+        totalAmount: z.ZodString;
+        payoutCount: z.ZodNumber;
+        lastCreditedAt: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+/** One available balance in the reserved BuilderCodes reward bucket. */
+export declare const BuildercodeRewardsBalanceSchema: z.ZodObject<{
+    token: z.ZodString;
+    available: z.ZodString;
+}, z.core.$strip>;
+/** Schema for the caller wallet's reserved BuilderCodes balances. */
+export declare const GetBuildercodeRewardsBalanceResponseSchema: z.ZodObject<{
+    balances: z.ZodArray<z.ZodObject<{
+        token: z.ZodString;
+        available: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+/** Schema for the claim-BuilderCodes-rewards request body. */
+export declare const ClaimBuildercodeRewardsParamsSchema: z.ZodObject<{
+    token: z.ZodString;
+    amount: z.ZodString;
+}, z.core.$strip>;
+/** Schema for the claim-BuilderCodes-rewards response. */
+export declare const ClaimBuildercodeRewardsResponseSchema: z.ZodObject<{
+    payoutBalance: z.ZodString;
+    tradingBalance: z.ZodString;
+}, z.core.$strip>;
+export type ClaimBuildercodeRewardsParams = z.infer<typeof ClaimBuildercodeRewardsParamsSchema>;
+export type ClaimBuildercodeRewardsResponse = z.infer<typeof ClaimBuildercodeRewardsResponseSchema>;
+export type GetBuildercodesConfigResponse = z.infer<typeof GetBuildercodesConfigResponseSchema>;
+export type ListBuildercodePayoutsParams = z.infer<typeof ListBuildercodePayoutsParamsSchema>;
+export type BuildercodePayout = z.infer<typeof BuildercodePayoutSchema>;
+export type ListBuildercodePayoutsResponse = z.infer<typeof ListBuildercodePayoutsResponseSchema>;
+export type BuildercodePayoutTokenTotal = z.infer<typeof BuildercodePayoutTokenTotalSchema>;
+export type GetBuildercodePayoutSummaryResponse = z.infer<typeof GetBuildercodePayoutSummaryResponseSchema>;
+export type BuildercodeRewardsBalance = z.infer<typeof BuildercodeRewardsBalanceSchema>;
+export type GetBuildercodeRewardsBalanceResponse = z.infer<typeof GetBuildercodeRewardsBalanceResponseSchema>;

package/dist/buildercodes/responses.js

@@ -0,0 +1,92 @@
+/**
+ * BuilderCodes Response Types
+ *
+ * Types for the BuilderCodes earnings and payout API responses and requests.
+ * All types are derived from Zod schemas for runtime validation.
+ */
+import { z } from "zod";
+/** Schema for this frontend's current BuilderCodes program state. */
+export const GetBuildercodesConfigResponseSchema = z.object({
+    applicationId: z.string().uuid(),
+    enrolled: z.boolean(),
+    // Nullable, not merely absent: `payout_address` is an `optional` proto field
+    // with no skip-serializing, so the server sends an explicit `null` when no
+    // address is configured. `.optional()` alone accepts `undefined` and would
+    // throw on that valid response. Matches `lastCreditedAt` below.
+    payoutAddress: z.string().nullable().optional(),
+    buildercodesEnabled: z.boolean(),
+    buildercodesBudgetBps: z.number().int().min(0).max(10_000),
+});
+/** Pagination accepted by the per-trade payout history endpoint. */
+export const ListBuildercodePayoutsParamsSchema = z.object({
+    page: z.number().int().min(1).max(10_000).optional(),
+    pageSize: z.number().int().min(1).max(100).optional(),
+});
+/** One per-trade BuilderCodes credit. Amounts are RAW atomic units. */
+export const BuildercodePayoutSchema = z.object({
+    tradeId: z.string().uuid(),
+    payoutAddress: z.string(),
+    token: z.string(),
+    amount: z.string(),
+    appliedBps: z.number().int(),
+    createdAt: z.string(),
+});
+/** Schema for the paginated per-trade payout history. */
+export const ListBuildercodePayoutsResponseSchema = z.object({
+    payouts: z.array(BuildercodePayoutSchema),
+    total: z.number().int().nonnegative(),
+    page: z.number().int().positive(),
+    pageSize: z.number().int().positive(),
+    totalPages: z.number().int().nonnegative(),
+});
+/** One token-denominated BuilderCodes earnings total. */
+export const BuildercodePayoutTokenTotalSchema = z.object({
+    token: z.string(),
+    totalAmount: z.string(),
+    payoutCount: z.number().int().nonnegative(),
+    lastCreditedAt: z.string(),
+});
+/** Schema for this frontend's payout summary. */
+export const GetBuildercodePayoutSummaryResponseSchema = z.object({
+    totalPayouts: z.number().int().nonnegative(),
+    lastCreditedAt: z.string().nullable().optional(),
+    byToken: z.array(BuildercodePayoutTokenTotalSchema),
+});
+/** One available balance in the reserved BuilderCodes reward bucket. */
+export const BuildercodeRewardsBalanceSchema = z.object({
+    token: z.string(),
+    available: z.string(),
+});
+/** Schema for the caller wallet's reserved BuilderCodes balances. */
+export const GetBuildercodeRewardsBalanceResponseSchema = z.object({
+    balances: z.array(BuildercodeRewardsBalanceSchema),
+});
+/** Schema for the claim-BuilderCodes-rewards request body. */
+export const ClaimBuildercodeRewardsParamsSchema = z.object({
+    /**
+     * Payout token contract address (0x-prefixed) to claim. BuilderCodes shares
+     * accrue in the quote token of the traded pair.
+     */
+    token: z
+        .string()
+        .trim()
+        .min(1, "token is required")
+        .regex(/^0x[0-9a-fA-F]{40}$/, "token must be a 0x-prefixed EVM address"),
+    /**
+     * Amount to claim, in RAW atomic units of the token. Must be a positive
+     * integer string and no greater than the accrued payout balance — the server
+     * rejects an over-claim with 409 rather than moving a partial amount.
+     */
+    amount: z
+        .string()
+        .trim()
+        .min(1, "amount is required")
+        .refine((v) => /^\d+$/.test(v) && BigInt(v) > 0n, "amount must be a positive integer string"),
+});
+/** Schema for the claim-BuilderCodes-rewards response. */
+export const ClaimBuildercodeRewardsResponseSchema = z.object({
+    /** Your BuilderCodes payout-bucket balance after the claim, RAW atomic units. */
+    payoutBalance: z.string(),
+    /** Your trading balance for the token after the claim, RAW atomic units. */
+    tradingBalance: z.string(),
+});

package/dist/index.d.ts

@@ -7,10 +7,12 @@
 export * from "./api";
 export * from "./applications";
 export * from "./auth";
+export * from "./buildercodes";
 export * from "./contracts";
 export * from "./delegated-agents";
 export * from "./faucet";
 export * from "./fees";
+export * from "./managed-markets";
 export * from "./margin-accounts";
 export * from "./market";
 export * from "./pitpass";

package/dist/index.js

@@ -8,10 +8,12 @@
 export * from "./api";
 export * from "./applications";
 export * from "./auth";
+export * from "./buildercodes";
 export * from "./contracts";
 export * from "./delegated-agents";
 export * from "./faucet";
 export * from "./fees";
+export * from "./managed-markets";
 export * from "./margin-accounts";
 export * from "./market";
 export * from "./pitpass";

package/dist/managed-markets/index.d.ts

@@ -0,0 +1,63 @@
+import type { BaseAPI } from "../api";
+/** Exact uint64 decimal text. Never convert generation or revision through Number. */
+export type ManagedMarketFence = string;
+export type ManagedMarketPhase = "pending" | "validating" | "registering" | "warming" | "activating" | "live" | "failed" | (string & {});
+export interface ManagedMarketLease {
+    launchId: string;
+    ownerId: string;
+    generation: ManagedMarketFence;
+    quoteRevision: ManagedMarketFence;
+    expiresAt: string;
+    refreshIntervalMs: number;
+    phase: ManagedMarketPhase;
+}
+export interface ManagedMarketAssignment {
+    launchId: string;
+    tradingPairId: string;
+    symbol: string;
+    phase: ManagedMarketPhase;
+    refreshIntervalMs: number;
+    allocationUsdc: string;
+    lease?: ManagedMarketLease;
+    /** False assignments remain expected inventory but cannot claim or quote. */
+    quoteEnabled: boolean;
+}
+export interface ListManagedMarketAssignmentsRequest {
+    page?: number;
+    pageSize?: number;
+}
+export interface ListManagedMarketAssignmentsResponse {
+    items: ManagedMarketAssignment[];
+    total: number;
+    page: number;
+    pageSize: number;
+    inventoryObservedAt: string;
+}
+export interface ClaimManagedMarketLeaseRequest {
+    ownerId: string;
+    /** Required for renewal; omit for initial claim or after expiry. */
+    expectedGeneration?: ManagedMarketFence;
+}
+export interface RefreshManagedMarketQuotesRequest {
+    ownerId: string;
+    generation: ManagedMarketFence;
+    quoteRevision: ManagedMarketFence;
+}
+export interface ManagedMarketQuoteStatus {
+    launchId: string;
+    generation: ManagedMarketFence;
+    quoteRevision: ManagedMarketFence;
+    phase: ManagedMarketPhase;
+    bidNotional: string;
+    askNotional: string;
+    oracleReady: boolean;
+    readyToActivate: boolean;
+    observedAt: string;
+}
+/** Wallet session identity selects assignments; delegated sessions are unsupported. ownerId only fences processes. */
+export interface ManagedMarketsAPI extends BaseAPI {
+    listAssignments(request?: ListManagedMarketAssignmentsRequest): Promise<ListManagedMarketAssignmentsResponse>;
+    claimLease(launchId: string, request: ClaimManagedMarketLeaseRequest): Promise<ManagedMarketLease>;
+    /** On an unknown outcome, reconcile through claimLease before advancing revision. */
+    refreshQuotes(launchId: string, request: RefreshManagedMarketQuotesRequest): Promise<ManagedMarketQuoteStatus>;
+}

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

@@ -251,9 +251,25 @@ export type SimulateIsolatedRiskBucketOrderRiskRequest = SimulateOrderRiskReques
     strategyKey?: string;
     selectedTradingPairIds?: never;
 };
+/**
+ * Preview an order against the account's cross risk bucket, or the
+ * deterministic bucket a first cross order would create. A cross preview names
+ * no pairs: cross scope is derived from trading — a pair joins the bucket when
+ * a cross order on it succeeds and, once its positions close, stays listed
+ * until a later successful cross order on another pair reconciles the bucket —
+ * so the previewed pair is in scope by construction. Read the derived scope
+ * the preview ran against from the response's `selectedTradingPairIds`.
+ */
 export type SimulateCrossRiskBucketOrderRiskRequest = SimulateOrderRiskRequest & {
     marginMode: "CROSS";
-    selectedTradingPairIds: string[];
+    /**
+     * Removed. This used to declare the scope the preview ran against (required,
+     * containing `tradingPairId`, covering every open cross position) while the
+     * server never priced anything from it. The server now ignores the wire
+     * field; the SDK no longer sends it and rejects it here so a caller learns at
+     * compile time that it does nothing.
+     */
+    selectedTradingPairIds?: never;
     strategyKey?: never;
 };
 export type SimulateRiskBucketOrderRiskRequest = SimulateIsolatedRiskBucketOrderRiskRequest | SimulateCrossRiskBucketOrderRiskRequest;
@@ -264,6 +280,16 @@ export interface SimulateOrderRiskResponse {
     strategyKey?: string;
     riskBucketId?: string;
     marginMode?: MarginMode;
+    /**
+     * The cross scope the preview ran against; absent for isolated previews and
+     * never a caller's list. From `simulateRiskBucketOrderRisk` in CROSS mode it
+     * is the DERIVED scope: the active cross bucket's recorded pairs (a pair
+     * whose positions have closed stays recorded until a later cross order on
+     * another pair reconciles the bucket), every pair with an open position in
+     * that bucket, and the previewed pair — the previewed pair alone before the
+     * first cross order. `simulateOrderRisk` and `simulateParentMarginOrderRisk`
+     * report the recorded pairs plus the previewed pair.
+     */
     selectedTradingPairIds?: string[];
     equityAfter: string;
     initialMarginRequiredAfter: string;

package/dist/positions/index.d.ts

@@ -107,6 +107,38 @@ export interface Position {
      * an understated partial.
      */
     cumFees?: string;
+    /**
+     * Opaque, non-negative producer-owned row version for this position
+     * (0XM-2673). Compare only within the same `positionId`; higher is newer.
+     *
+     * The same number the WebSocket `positions` snapshot and a RANKED live
+     * `position_update` frame carry, so this read can be ranked against them.
+     * Some live frames are deliberately unranked and omit `version` even when
+     * their state matches this row.
+     * `0` is the unranked legacy sentinel and never participates in ordering:
+     * treat it exactly as an absent version and fall back to a full field
+     * comparison rather than ranking it as oldest.
+     *
+     * The merge rule is PER FIELD GROUP, never per payload. On an EQUAL version
+     * skip the versioned fields as an idempotent redelivery — EXCEPT
+     * `isolatedMargin`, which the WebSocket positions snapshot overlays from an
+     * independent live matching-engine read rather than from the versioned row,
+     * so it can reflect a later command than the version names and must be
+     * taken from the newer payload. Also still take
+     * `markPrice`, `unrealizedPnl`, `liquidationPrice`, `leverage`,
+     * `maintenanceMarginRequired` and `initialMarginRequired` from the newer
+     * payload: those six are re-derived on every read rather than served from
+     * the versioned row, carry no version, and the version does not advance for
+     * them. Five move with the oracle mark; `leverage` does not, but the live
+     * surfaces derive it while the persisted row serves its stored column, so it
+     * can still disagree at an unchanged version.
+     * Discarding a whole payload on an equal version freezes displayed PnL
+     * until the position's next real mutation.
+     *
+     * A response served from live matching-engine state reports `0`: the engine
+     * holds the state but not the version, so it cannot rank itself.
+     */
+    version?: number;
 }
 export interface ListPositionsParams {
     marginAccountId?: string;

package/dist/sdk/index.d.ts

@@ -1,9 +1,11 @@
 import type { Address, PublicClient, TransactionReceipt, WalletClient } from "viem";
 import type { ApplicationsAPI } from "../applications";
 import type { AuthAPI, AuthState } from "../auth/index";
+import type { BuildercodesAPI } from "../buildercodes";
 import type { DelegatedAgentsAPI } from "../delegated-agents";
 import type { FaucetAPI } from "../faucet";
 import type { FeesAPI } from "../fees";
+import type { ManagedMarketsAPI } from "../managed-markets";
 import type { MarginAccountsAPI } from "../margin-accounts";
 import type { MarketAPI } from "../market";
 import type { PitpassAPI } from "../pitpass";
@@ -111,10 +113,13 @@ export interface MonacoSDK {
     subAccounts: SubAccountsAPI;
     /** PitPass TraderCode referral and rewards API */
     pitpass: PitpassAPI;
+    /** BuilderCodes frontend revenue-share payout API */
+    buildercodes: BuildercodesAPI;
     /** Testnet faucet API */
     faucet: FaucetAPI;
     /** Deposit-address registration (sweeper) API; requires a session */
     sweeper: SweeperAPI;
+    managedMarkets: ManagedMarketsAPI;
     /** Public whitelist (waitlist) submission API */
     whitelist: WhitelistAPI;
     /** Profile operations API */

package/dist/trading/index.d.ts

@@ -260,4 +260,4 @@ export interface TradingAPI extends BaseAPI {
 }
 export type { ConditionalOrderConditionType, ConditionalOrderState, ConditionalOrderTriggerSource, ListedOrderType, Order, OrderRole, OrderSide, OrderStatus, OrderStatusFilter, OrderTerminalReason, OrderType, PositionSide, SelfTradePreventionMode, TimeInForce, TradingMode, TwapExecutionStyle, TwapOrderState, } from "./orders";
 export { ORDER_STATUS_VALUES } from "./orders";
-export type { BatchCancelError, BatchCancelOrdersResponse, BatchCancelResult, BatchCreateOrderParams, BatchCreateOrdersResponse, BatchCreateResult, BatchError, BatchReplaceOrderParams, BatchReplaceOrdersResponse, BatchReplaceResult, CancelConditionalOrderResponse, CancelOrderResponse, CancelTwapOrderResponse, ConditionalOrder, CreateOrderResponse, CreateTwapOrderOptions, CreateTwapOrderResponse, GetOrderResponse, GetPaginatedOrdersParams, GetPaginatedOrdersResponse, GetTwapOrderTcaResponse, ListConditionalOrdersParams, ListConditionalOrdersResponse, ListTwapOrdersParams, ListTwapOrdersResponse, MatchResult, ParentTpSlLegParams, ReplaceOrderResponse, TwapOrder, UpdatedFields, } from "./responses";
+export type { BatchCancelError, BatchCancelOrdersResponse, BatchCancelResult, BatchCreateOrderParams, BatchCreateOrdersResponse, BatchCreateResult, BatchError, BatchReplaceOrderParams, BatchReplaceOrdersResponse, BatchReplaceResult, CancelConditionalOrderResponse, CancelOrderResponse, CancelTwapOrderResponse, ConditionalOrder, CreateOrderResponse, CreateTwapOrderOptions, CreateTwapOrderResponse, GetOrderResponse, GetPaginatedOrdersParams, GetPaginatedOrdersResponse, GetTwapOrderTcaResponse, ListConditionalOrdersParams, ListConditionalOrdersResponse, ListTwapOrdersParams, ListTwapOrdersResponse, MatchResult, ParentTpSlLegParams, ReplaceOrderResponse, TriggeredOrderSummary, TwapOrder, UpdatedFields, } from "./responses";

package/dist/trading/orders.d.ts

@@ -112,6 +112,19 @@ export interface Order {
     conditional?: ConditionalOrder;
     /** Stable cause when status is CANCELLED */
     terminalReason?: OrderTerminalReason;
+    /**
+     * Present only on an order the engine placed for a take-profit or
+     * stop-loss trigger: the conditional order that fired it — the reverse of
+     * `ConditionalOrder.triggeredOrderId`, so a close in order history can be
+     * attributed to the TP/SL that produced it without scanning the
+     * conditional list (0XM-2745).
+     *
+     * Absent on every order you placed yourself, on TWAP slice children (those
+     * carry `parentOrderId` on the wire), and on triggered closes written before
+     * the field existed — there is no backfill, so a missing value on an older
+     * close means unknown, not "placed by hand". Wire: `conditionalOrderId`.
+     */
+    conditionalOrderId?: string;
     /**
      * Opaque, compare-only revision counter for this order's state: a strictly
      * higher value is strictly newer state for that order, and equal values

package/dist/trading/responses.d.ts

@@ -4,7 +4,7 @@
  * Response types for trading operations.
  */
 import type { MarginMode } from "../margin-accounts";
-import type { ConditionalOrderConditionType, ConditionalOrderState, ConditionalOrderTriggerSource, Order, OrderSide, OrderStatus, OrderStatusFilter, OrderType, PositionSide, SelfTradePreventionMode, TimeInForce, TradingMode, TwapExecutionStyle, TwapOrderState } from "./orders";
+import type { ConditionalOrderConditionType, ConditionalOrderState, ConditionalOrderTriggerSource, Order, OrderSide, OrderStatus, OrderStatusFilter, OrderTerminalReason, OrderType, PositionSide, SelfTradePreventionMode, TimeInForce, TradingMode, TwapExecutionStyle, TwapOrderState } from "./orders";
 /**
  * Match result information for order execution.
  * Contains detailed information about trades, fills, and execution quality.
@@ -446,6 +446,46 @@ export interface ListConditionalOrdersParams {
     page?: number;
     pageSize?: number;
 }
+/**
+ * What the order a conditional fired into has done so far — a projection of
+ * that order's own row, read at request time (0XM-2744).
+ *
+ * Trigger price and fill price are different numbers: the trigger fires on the
+ * mark, the leg then trades against the book, so a MARKET leg fills at least
+ * the half-spread (plus its own impact) away from `triggerPrice`, and a LIMIT
+ * leg may rest or fill only partly. Every value here is numerically equal to
+ * what `getOrder` returns for the same order, but the printed decimal scale
+ * can differ between the two reads (this summary is served from the database,
+ * `getOrder` from the cache), so compare numerically rather than byte for byte.
+ */
+export interface TriggeredOrderSummary {
+    /** The triggered order's id — the same value as the parent's `triggeredOrderId`. */
+    orderId: string;
+    /**
+     * The triggered order's CURRENT status: `SETTLED` for a leg that filled in
+     * full (a fully filled order is written as `SETTLED`, so `FILLED` does not
+     * appear here); `SUBMITTED` / `PARTIALLY_FILLED` for a LIMIT leg still
+     * resting; `CANCELLED` when the protective band left nothing fillable (see
+     * `terminalReason`); `EXPIRED` for a LIMIT leg that lapsed. Never
+     * `REJECTED`: a close the engine refused leaves the conditional `FAILED`
+     * with no `triggeredOrderId`, so no summary exists for it.
+     */
+    status: OrderStatus;
+    /** Quantity filled so far, in base units; `"0"` until it fills. */
+    filledQuantity: string;
+    /**
+     * Volume-weighted average fill price. Compare with the parent's
+     * `triggerPrice`: the gap is the half-spread plus the order's own market
+     * impact. Absent until the first fill.
+     */
+    averageFillPrice?: string;
+    /** Total taker fees paid, in quote units. Absent until it fills. */
+    totalTakerFees?: string;
+    /** When the order reached FILLED (ISO 8601). Absent otherwise. */
+    filledAt?: string;
+    /** Stable cause when `status` is `CANCELLED`, same vocabulary as `Order.terminalReason`. */
+    terminalReason?: OrderTerminalReason;
+}
 export interface ConditionalOrder {
     conditionalOrderId: string;
     tradingPairId: string;
@@ -496,6 +536,17 @@ export interface ConditionalOrder {
      * zero. Wire: `version`.
      */
     version?: number;
+    /**
+     * The execution outcome of the order this conditional fired into
+     * (`triggeredOrderId`) — status, filled quantity, average fill price, fees
+     * and fill time — read from that order at request time (0XM-2744).
+     *
+     * Present only when `state` is `TRIGGERED` and the triggered order could be
+     * read. Absent while waiting on the trigger, on the `conditional_orders`
+     * WebSocket frames (snapshot and live), and in the rare case the close
+     * cannot be read. Wire: `triggeredOrder`.
+     */
+    triggeredOrder?: TriggeredOrderSummary;
 }
 export interface ListConditionalOrdersResponse {
     orders: ConditionalOrder[];

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

@@ -124,7 +124,13 @@ export declare const SimulateParentMarginOrderRiskSchema: z.ZodObject<{
     }, z.core.$strict>;
 }, z.core.$strip>;
 export declare const SimulateRiskBucketOrderRiskSchema: z.ZodObject<{
-    request: z.ZodUnion<readonly [z.ZodObject<{
+    request: z.ZodPipe<z.ZodObject<{
+        marginMode: z.ZodOptional<z.ZodEnum<{
+            ISOLATED: "ISOLATED";
+            CROSS: "CROSS";
+        }>>;
+        selectedTradingPairIds: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$loose>, z.ZodUnion<readonly [z.ZodObject<{
         side: z.ZodEnum<{
             BUY: "BUY";
             SELL: "SELL";
@@ -167,7 +173,7 @@ export declare const SimulateRiskBucketOrderRiskSchema: z.ZodObject<{
         leverage: z.ZodOptional<z.ZodString>;
         reduceOnly: z.ZodOptional<z.ZodBoolean>;
         marginMode: z.ZodLiteral<"CROSS">;
-        selectedTradingPairIds: z.ZodArray<z.ZodUUID>;
+        selectedTradingPairIds: z.ZodOptional<z.ZodNever>;
         strategyKey: z.ZodOptional<z.ZodNever>;
-    }, z.core.$strict>]>;
+    }, z.core.$strict>]>>;
 }, z.core.$strip>;