@0xmonaco/types 1.0.60 → 1.0.62

package/dist/applications/requests.d.ts

@@ -9,7 +9,7 @@
  * Query parameters for listing application orders.
  */
 export interface ListAppOrdersParams {
-    /** Page number (starts from 1) */
+    /** Page number (starts from 1, at most 10,000 — the last page the listing counts towards) */
     page?: number;
     /** Items per page (max 100) */
     pageSize?: number;
@@ -43,7 +43,7 @@ export interface ListAppUsersParams {
  * Query parameters for listing application movements.
  */
 export interface ListAppMovementsParams {
-    /** Page number (starts from 1) */
+    /** Page number (starts from 1, at most 10,000 — the last page the listing counts towards) */
     page?: number;
     /** Items per page (max 100) */
     pageSize?: number;

package/dist/applications/responses.d.ts

@@ -162,13 +162,21 @@ export interface AppBalance {
  */
 export interface ListAppOrdersResponse {
     orders: AppOrder[];
-    /** Total matching orders */
+    /**
+     * Matching orders. Exact up to 10,000 pages of the requested page size
+     * (`pageSize` x 10,000 rows) and saturates there, so an application with
+     * more matching orders than the listing can page through reads the cap,
+     * not its lifetime total.
+     */
     total: number;
     /** Current page number */
     page: number;
     /** Items per page */
     pageSize: number;
-    /** Total number of pages */
+    /**
+     * Number of pages at the requested page size. Exact up to 10,000 and
+     * saturates there, the last page this listing can reach.
+     */
     totalPages: number;
 }
 /**
@@ -190,13 +198,21 @@ export interface ListAppUsersResponse {
  */
 export interface ListAppMovementsResponse {
     movements: AppMovement[];
-    /** Total matching movements */
+    /**
+     * Matching movements. Exact up to 10,000 pages of the requested page size
+     * (`pageSize` x 10,000 rows) and saturates there, so an application with
+     * more matching movements than the listing can page through reads the cap,
+     * not its lifetime total.
+     */
     total: number;
     /** Current page number */
     page: number;
     /** Items per page */
     pageSize: number;
-    /** Total number of pages */
+    /**
+     * Number of pages at the requested page size. Exact up to 10,000 and
+     * saturates there, the last page this listing can reach.
+     */
     totalPages: number;
 }
 /**

package/dist/auth/responses.d.ts

@@ -43,6 +43,21 @@ export interface AuthState {
     expiresAt: number;
     /** Information about the authenticated user */
     user: User;
+    /**
+     * True when this verify created the user — the wallet's first-ever sign-in on
+     * this application. Gate first-time UX (e.g. the optional "have a referral
+     * code?" input) on it. Absent on responses from a server that predates the
+     * field.
+     */
+    isNewUser?: boolean;
+    /**
+     * True when a PitPass referral relationship was recorded on this verify: a
+     * valid, non-self TraderCode was presented on the wallet's first-ever sign-in
+     * and resolved to a known referrer. Use it to confirm the referral landed on
+     * the signup-success screen. Absent on responses from a server that predates
+     * the field.
+     */
+    referralApplied?: boolean;
 }
 export interface ApplicationInfo {
     /** Unique identifier for the application */

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

@@ -1,5 +1,5 @@
 import type { BaseAPI } from "../api";
-import type { OrderSide, OrderType, PositionSide } from "../trading";
+import type { MatchResult, OrderSide, OrderType, PositionSide } from "../trading";
 export type MarginMode = "ISOLATED" | "CROSS";
 export interface MarginAccountSummary {
     marginAccountId: string;
@@ -245,6 +245,25 @@ export interface SimulateOrderRiskRequest {
     /** Required for normal orders; optional and ignored for reduce-only. */
     leverage?: string;
     reduceOnly?: boolean;
+    /**
+     * MARKET-only slippage tolerance in basis points, 0..1,000 — the rule the
+     * server applies to a placed MARKET order: a LIMIT preview carrying it is
+     * rejected with the message the order itself would get. It TIGHTENS the walk
+     * the preview runs (merged tighter-wins with the engine's 1,000 bps
+     * protective band), so `expectedMatchResult` and `estimatedFee` price under
+     * the band the real placement will run under. Omit for the placement
+     * default; it never widens the band.
+     *
+     * Carrying a previewed value into placement: the SDK's `placeMarketOrder`
+     * and batch helpers take `slippageTolerance` as a RATIO (`0.05` = 500 bps),
+     * so pass `slippageToleranceBps / 10_000`; a `slippageToleranceBps` key on
+     * those calls is not forwarded.
+     *
+     * On a first-use ISOLATED preview the value is also forwarded to the
+     * bucket's auto-funding for parity with placement; that path floors it at
+     * 1,000 bps, so today it does not change the funded figure.
+     */
+    slippageToleranceBps?: number;
 }
 export type SimulateIsolatedRiskBucketOrderRiskRequest = SimulateOrderRiskRequest & {
     marginMode?: "ISOLATED";
@@ -327,6 +346,51 @@ export interface SimulateOrderRiskResponse {
      * as unavailable, never as zero.
      */
     estimatedLiquidationPrice?: string;
+    /**
+     * The simulated match the engine ran to admit this order — the same
+     * `MatchResult` shape a placement's `matchResult` carries, from the same
+     * walk over the live book at the moment of the preview, under
+     * `slippageToleranceBps` merged tighter-wins with the 1,000 bps protective
+     * band and the caller's own self-trade-prevention default (the preview runs
+     * under the caller's wallet, as placement does). Not a client-side re-walk,
+     * so preflight and placement read the same numbers. What a preview cannot
+     * carry: `postOnly`, TP/SL legs and a per-order self-trade-prevention
+     * override — a post-only order that would cross is refused by placement, not
+     * by this preview.
+     *
+     * Read it as: `totalFilled` is what would execute; `remainingQuantity` what
+     * the band or the depth leaves unfilled (the partial-fill indicator — a
+     * MARKET preview with a non-zero remainder comes back partially filled when
+     * placed); `averageFillPrice` and `executionPriceRange.worstPrice` the fill
+     * levels, `null` when nothing crosses; `status` the status placement would
+     * end in — `FILLED` for a full fill, `CANCELLED` for a MARKET order the band
+     * or the depth cuts short (a MARKET remainder cannot rest, so the fills
+     * execute and the rest is cancelled; read `remainingQuantity` for the
+     * partial fill), `SUBMITTED` for a LIMIT that rests, `PARTIALLY_FILLED` for
+     * a LIMIT that crosses partly and rests the remainder; `actualSlippageBps`
+     * the realized slippage against `referencePrice`
+     * — for a LIMIT or IOC preview, against the limit price, and `null` when
+     * every fill improved on it; `maxSlippageBps` echoes your tolerance.
+     *
+     * Priced against the book RIGHT NOW. A take-profit / stop-loss closes later,
+     * on a different book, under the wider 1,200 bps band a triggered market leg
+     * carries — so for a TP/SL estimate apply `actualSlippageBps` to the TRIGGER
+     * price as an impact figure rather than displaying this absolute average.
+     *
+     * Present only when `accepted` is true. Absent (`null` on the wire, like
+     * `estimatedLiquidationPrice`) on every refused preview, including the
+     * post-match maker-risk rejection; treat absence as unknown, not as a zero
+     * fill.
+     */
+    expectedMatchResult?: MatchResult;
+    /**
+     * The touch on the taking side when a MARKET preview ran (best ask for a
+     * BUY, best bid for a SELL) — what `expectedMatchResult` and its
+     * `actualSlippageBps` are measured from. Present only when `accepted` is
+     * true and the preview is a MARKET order; a LIMIT or IOC preview is measured
+     * against its own limit price and publishes nothing here.
+     */
+    referencePrice?: string;
 }
 export interface MarginAccountsAPI extends BaseAPI {
     listMarginAccounts(params?: ListMarginAccountsParams): Promise<ListMarginAccountsResponse>;

package/dist/market/index.d.ts

@@ -312,23 +312,87 @@ export interface MarketStats {
     /** Life-to-date cumulative number of trades summed across all pairs */
     totalTradeCountLtd: number;
 }
+/**
+ * One notional bracket of a market's margin ladder. Brackets are MARGINAL: a
+ * bracket's rate applies only to the notional inside it, and the deduction
+ * carries the cheaper margin already charged by the brackets below, so margin
+ * is continuous across every bound rather than jumping at it.
+ *
+ * `PerpMarketConfig.riskTiers` lists every bracket ascending by
+ * `lowerBoundNotional`. A position's bracket is the LAST tier whose
+ * `lowerBoundNotional` is at or below its notional, `abs(quantity) x markPrice`.
+ */
 export interface RiskTier {
+    /**
+     * Marginal initial-margin floor rate for notional inside this bracket, as a
+     * decimal fraction. The ladder floor is
+     * `IM_floor(N) = N x initialMarginRatio - initialMarginDeduction`.
+     * A position's requirement is the greater of this floor and its
+     * selected-leverage initial margin scaled to the current mark.
+     */
     initialMarginRatio: string;
+    /**
+     * Marginal maintenance-margin rate for notional inside this bracket, as a
+     * decimal fraction. Maintenance margin for a position of notional N in this
+     * bracket is `MM(N) = N x maintenanceMarginRatio - maintenanceMarginDeduction`.
+     */
     maintenanceMarginRatio: string;
     /** Maximum authoritative absolute base-asset quantity. */
     maxPositionSize?: string;
     /** @deprecated This legacy alias is base quantity, not notional. */
     maxPositionNotional?: string;
+    /** 1-based bracket index within the market's ladder; 1 is the lowest bracket. */
+    tierLevel: number;
+    /** USD notional at which this bracket starts, inclusive; "0" for tier 1. */
+    lowerBoundNotional: string;
+    /**
+     * Maximum leverage available inside this bracket. Absent only for a
+     * single-tier market configured from explicit margin rates rather than
+     * from a leverage.
+     */
+    maxLeverage?: string;
+    /**
+     * Continuity term of the ladder's initial-margin floor formula
+     * `IM_floor(N) = N x initialMarginRatio - initialMarginDeduction`; "0" for tier 1.
+     */
+    initialMarginDeduction: string;
+    /**
+     * Continuity term of the maintenance-margin formula
+     * `MM(N) = N x maintenanceMarginRatio - maintenanceMarginDeduction`; "0" for tier 1.
+     */
+    maintenanceMarginDeduction: string;
 }
 export interface PerpMarketConfig {
     tradingPairId: string;
     symbol: string;
     minLeverage: string;
+    /**
+     * Tier 1 (the lowest bracket) of `riskTiers` — its `maxLeverage`, mirrored
+     * here for backward compatibility. Brackets above tier 1 are described
+     * only by `riskTiers`.
+     */
     maxLeverage: string;
+    /**
+     * Tier 1 (the lowest bracket) of `riskTiers` — its `initialMarginRatio`,
+     * mirrored here for backward compatibility. Brackets above tier 1 are
+     * described only by `riskTiers`. This rate contributes to the ladder floor;
+     * selected leverage can produce a higher position initial-margin requirement.
+     */
     initialMarginRatio: string;
+    /**
+     * Tier 1 (the lowest bracket) of `riskTiers` — its `maintenanceMarginRatio`,
+     * mirrored here for backward compatibility. Brackets above tier 1 are
+     * described only by `riskTiers`.
+     */
     maintenanceMarginRatio: string;
     fundingIntervalSeconds: number;
     liquidationFeeBps?: string;
+    /**
+     * The market's full margin ladder, ascending by `lowerBoundNotional` and
+     * always non-empty (a market with no configured brackets reports a single
+     * tier). A position's bracket is the LAST tier whose `lowerBoundNotional`
+     * is at or below its notional, `abs(quantity) x markPrice`.
+     */
     riskTiers: RiskTier[];
     updatedAt: string;
 }

package/dist/pitpass/index.d.ts

@@ -4,7 +4,7 @@
  * Types for PitPass TraderCode API: code lookup, rewards balance, and transfer.
  */
 import type { BaseAPI } from "../api";
-import type { GetRewardsBalanceResponse, TraderCodeAvailabilityResponse, TraderCodeInfoResponse, TraderCodeResponse, TransferRewardsParams, TransferRewardsResponse } from "./responses";
+import type { GetMyReferralDownlineResponse, GetMyReferralPositionResponse, GetRewardsBalanceResponse, TraderCodeAvailabilityResponse, TraderCodeInfoResponse, TraderCodeResponse, TransferRewardsParams, TransferRewardsResponse } from "./responses";
 /**
  * PitPass TraderCode API interface.
  *
@@ -91,6 +91,30 @@ export interface PitpassAPI extends BaseAPI {
      * @returns Promise resolving to the post-transfer rewards and trading balances
      */
     transferRewards(params: TransferRewardsParams): Promise<TransferRewardsResponse>;
+    /**
+     * Read your own referral position: your direct (L1) referrer, total earned,
+     * and most recent reward rows.
+     *
+     * Self-scoped — the server derives your identity from the session, so you can
+     * only ever read your own chain. `referrer` is the empty string when you were
+     * not referred (use it to gate the "already referred" UX). Every other user is
+     * identified by their public wallet address (with a `display` handle-or-wallet
+     * variant), never an internal id.
+     *
+     * @returns Promise resolving to your referrer, total earned, and recent rewards
+     */
+    getMyReferralPosition(): Promise<GetMyReferralPositionResponse>;
+    /**
+     * Read your own downline: who you earn from and how much (earnings by source
+     * across L1/L2/L3), your L1 direct-referee roster (including referees who have
+     * not traded yet), and a per-level earnings summary.
+     *
+     * Self-scoped and read-only. Every source and referee is a public wallet
+     * address plus a `display` handle-or-wallet variant, never an internal id.
+     *
+     * @returns Promise resolving to earnings-by-source, the direct-referee roster, and a summary
+     */
+    getMyReferralDownline(): Promise<GetMyReferralDownlineResponse>;
 }
-export type { GetRewardsBalanceResponse, RewardsBalanceEntry, SetTraderCodeParams, TraderCodeAvailabilityReason, TraderCodeAvailabilityResponse, TraderCodeInfoResponse, TraderCodeResponse, TransferRewardsParams, TransferRewardsResponse, } from "./responses";
-export { GetRewardsBalanceResponseSchema, RewardsBalanceEntrySchema, SetTraderCodeParamsSchema, TraderCodeAvailabilityReasonSchema, TraderCodeAvailabilityResponseSchema, TraderCodeInfoResponseSchema, TraderCodeResponseSchema, TransferRewardsParamsSchema, TransferRewardsResponseSchema, } from "./responses";
+export type { GetMyReferralDownlineResponse, GetMyReferralPositionResponse, GetRewardsBalanceResponse, ReferralDirectReferee, ReferralEarningsSource, ReferralEarningsSummary, ReferralRewardEntry, RewardsBalanceEntry, SetTraderCodeParams, TraderCodeAvailabilityReason, TraderCodeAvailabilityResponse, TraderCodeInfoResponse, TraderCodeResponse, TransferRewardsParams, TransferRewardsResponse, } from "./responses";
+export { GetMyReferralDownlineResponseSchema, GetMyReferralPositionResponseSchema, GetRewardsBalanceResponseSchema, ReferralDirectRefereeSchema, ReferralEarningsSourceSchema, ReferralEarningsSummarySchema, ReferralRewardEntrySchema, RewardsBalanceEntrySchema, SetTraderCodeParamsSchema, TraderCodeAvailabilityReasonSchema, TraderCodeAvailabilityResponseSchema, TraderCodeInfoResponseSchema, TraderCodeResponseSchema, TransferRewardsParamsSchema, TransferRewardsResponseSchema, } from "./responses";

package/dist/pitpass/index.js

@@ -3,4 +3,4 @@
  *
  * Types for PitPass TraderCode API: code lookup, rewards balance, and transfer.
  */
-export { GetRewardsBalanceResponseSchema, RewardsBalanceEntrySchema, SetTraderCodeParamsSchema, TraderCodeAvailabilityReasonSchema, TraderCodeAvailabilityResponseSchema, TraderCodeInfoResponseSchema, TraderCodeResponseSchema, TransferRewardsParamsSchema, TransferRewardsResponseSchema, } from "./responses";
+export { GetMyReferralDownlineResponseSchema, GetMyReferralPositionResponseSchema, GetRewardsBalanceResponseSchema, ReferralDirectRefereeSchema, ReferralEarningsSourceSchema, ReferralEarningsSummarySchema, ReferralRewardEntrySchema, RewardsBalanceEntrySchema, SetTraderCodeParamsSchema, TraderCodeAvailabilityReasonSchema, TraderCodeAvailabilityResponseSchema, TraderCodeInfoResponseSchema, TraderCodeResponseSchema, TransferRewardsParamsSchema, TransferRewardsResponseSchema, } from "./responses";

package/dist/pitpass/responses.d.ts

@@ -67,6 +67,75 @@ export declare const TransferRewardsResponseSchema: z.ZodObject<{
     rewardsBalance: z.ZodString;
     tradingBalance: z.ZodString;
 }, z.core.$strip>;
+/** A single reward the caller has earned (one row per referred trade × level). */
+export declare const ReferralRewardEntrySchema: z.ZodObject<{
+    source: z.ZodString;
+    sourceDisplay: z.ZodString;
+    level: z.ZodNumber;
+    amount: z.ZodString;
+    token: z.ZodString;
+    rateApplied: z.ZodString;
+    createdAt: z.ZodString;
+}, z.core.$strip>;
+/** The caller's own referral position: who referred them and what they've earned. */
+export declare const GetMyReferralPositionResponseSchema: z.ZodObject<{
+    referrer: z.ZodString;
+    referrerDisplay: z.ZodString;
+    totalEarned: z.ZodString;
+    rewards: z.ZodArray<z.ZodObject<{
+        source: z.ZodString;
+        sourceDisplay: z.ZodString;
+        level: z.ZodNumber;
+        amount: z.ZodString;
+        token: z.ZodString;
+        rateApplied: z.ZodString;
+        createdAt: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+/** One aggregated earnings row per (source trader, level, token) the caller earns from. */
+export declare const ReferralEarningsSourceSchema: z.ZodObject<{
+    source: z.ZodString;
+    sourceDisplay: z.ZodString;
+    level: z.ZodNumber;
+    totalEarned: z.ZodString;
+    token: z.ZodString;
+}, z.core.$strip>;
+/** One direct (L1) referee of the caller, whether or not they have traded yet. */
+export declare const ReferralDirectRefereeSchema: z.ZodObject<{
+    wallet: z.ZodString;
+    display: z.ZodString;
+    referredAt: z.ZodString;
+    totalEarned: z.ZodString;
+}, z.core.$strip>;
+/** Per-level breakdown of the caller's total referral earnings. */
+export declare const ReferralEarningsSummarySchema: z.ZodObject<{
+    totalEarned: z.ZodString;
+    level1Earned: z.ZodString;
+    level2Earned: z.ZodString;
+    level3Earned: z.ZodString;
+}, z.core.$strip>;
+/** The caller's own downline: who they earn from, their L1 roster, and a summary. */
+export declare const GetMyReferralDownlineResponseSchema: z.ZodObject<{
+    earningsBySource: z.ZodArray<z.ZodObject<{
+        source: z.ZodString;
+        sourceDisplay: z.ZodString;
+        level: z.ZodNumber;
+        totalEarned: z.ZodString;
+        token: z.ZodString;
+    }, z.core.$strip>>;
+    directReferees: z.ZodArray<z.ZodObject<{
+        wallet: z.ZodString;
+        display: z.ZodString;
+        referredAt: z.ZodString;
+        totalEarned: z.ZodString;
+    }, z.core.$strip>>;
+    summary: z.ZodObject<{
+        totalEarned: z.ZodString;
+        level1Earned: z.ZodString;
+        level2Earned: z.ZodString;
+        level3Earned: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>;
 export type RewardsBalanceEntry = z.infer<typeof RewardsBalanceEntrySchema>;
 export type GetRewardsBalanceResponse = z.infer<typeof GetRewardsBalanceResponseSchema>;
 export type TraderCodeResponse = z.infer<typeof TraderCodeResponseSchema>;
@@ -76,3 +145,9 @@ export type SetTraderCodeParams = z.infer<typeof SetTraderCodeParamsSchema>;
 export type TraderCodeInfoResponse = z.infer<typeof TraderCodeInfoResponseSchema>;
 export type TransferRewardsParams = z.infer<typeof TransferRewardsParamsSchema>;
 export type TransferRewardsResponse = z.infer<typeof TransferRewardsResponseSchema>;
+export type ReferralRewardEntry = z.infer<typeof ReferralRewardEntrySchema>;
+export type GetMyReferralPositionResponse = z.infer<typeof GetMyReferralPositionResponseSchema>;
+export type ReferralEarningsSource = z.infer<typeof ReferralEarningsSourceSchema>;
+export type ReferralDirectReferee = z.infer<typeof ReferralDirectRefereeSchema>;
+export type ReferralEarningsSummary = z.infer<typeof ReferralEarningsSummarySchema>;
+export type GetMyReferralDownlineResponse = z.infer<typeof GetMyReferralDownlineResponseSchema>;

package/dist/pitpass/responses.js

@@ -101,3 +101,81 @@ export const TransferRewardsResponseSchema = z.object({
     /** Your trading balance for the token after the transfer, RAW atomic units. */
     tradingBalance: z.string(),
 });
+/** A single reward the caller has earned (one row per referred trade × level). */
+export const ReferralRewardEntrySchema = z.object({
+    /** Public wallet address of the trader (taker) whose trade generated this reward. */
+    source: z.string(),
+    /** Human-facing name for the source: their custom handle if claimed, else the wallet. */
+    sourceDisplay: z.string(),
+    /** Referral level (1 = direct/30%, 2 = 15%, 3 = 5%). */
+    level: z.number(),
+    /** Reward amount, in RAW atomic units of the token. */
+    amount: z.string(),
+    /** Reward token contract address (0x-prefixed). */
+    token: z.string(),
+    /** The referral rate applied, as a decimal fraction (e.g. `0.30` for L1). */
+    rateApplied: z.string(),
+    /** RFC 3339 timestamp when the reward row was recorded. */
+    createdAt: z.string(),
+});
+/** The caller's own referral position: who referred them and what they've earned. */
+export const GetMyReferralPositionResponseSchema = z.object({
+    /**
+     * Public wallet address of the caller's direct (L1) referrer. Empty string
+     * when the caller was not referred. Only the direct referrer is exposed.
+     */
+    referrer: z.string(),
+    /** Human-facing name for the referrer: their custom handle if claimed, else the wallet (empty when not referred). */
+    referrerDisplay: z.string(),
+    /** Total reward amount earned across every level and token, in RAW atomic units. */
+    totalEarned: z.string(),
+    /** The caller's most recent reward rows, newest first (bounded server-side). */
+    rewards: z.array(ReferralRewardEntrySchema),
+});
+/** One aggregated earnings row per (source trader, level, token) the caller earns from. */
+export const ReferralEarningsSourceSchema = z.object({
+    /** Public wallet address of the trader (taker) the caller earns from. */
+    source: z.string(),
+    /** Human-facing name for the source: their custom handle if claimed, else the wallet. */
+    sourceDisplay: z.string(),
+    /** Referral level the caller earns from this source at (1/2/3). */
+    level: z.number(),
+    /** Total earned from this source at this level and token, in RAW atomic units. */
+    totalEarned: z.string(),
+    /** Reward token contract address (0x-prefixed). */
+    token: z.string(),
+});
+/** One direct (L1) referee of the caller, whether or not they have traded yet. */
+export const ReferralDirectRefereeSchema = z.object({
+    /** Public wallet address of the direct referee. */
+    wallet: z.string(),
+    /** Human-facing name for the referee: their custom handle if claimed, else the wallet. */
+    display: z.string(),
+    /** RFC 3339 timestamp when the referral relationship was recorded. */
+    referredAt: z.string(),
+    /** Total the caller has earned from this referee's own (L1) trades, RAW units. `0` if they haven't traded. */
+    totalEarned: z.string(),
+});
+/** Per-level breakdown of the caller's total referral earnings. */
+export const ReferralEarningsSummarySchema = z.object({
+    /** Total earned across all levels and tokens, in RAW atomic units. */
+    totalEarned: z.string(),
+    /** Total earned from direct (L1) referees, in RAW atomic units. */
+    level1Earned: z.string(),
+    /** Total earned from L2 downline, in RAW atomic units. */
+    level2Earned: z.string(),
+    /** Total earned from L3 downline, in RAW atomic units. */
+    level3Earned: z.string(),
+});
+/** The caller's own downline: who they earn from, their L1 roster, and a summary. */
+export const GetMyReferralDownlineResponseSchema = z.object({
+    /** One row per (source trader, level, token) the caller earns from, across L1/L2/L3. */
+    earningsBySource: z.array(ReferralEarningsSourceSchema),
+    /** The caller's direct (L1) referees, newest first, including those who haven't traded. */
+    directReferees: z.array(ReferralDirectRefereeSchema),
+    /**
+     * Total earned broken down by level (L1/L2/L3). The server always populates
+     * this — even a brand-new user gets a zeroed summary — so it is required.
+     */
+    summary: ReferralEarningsSummarySchema,
+});

package/dist/trading/index.d.ts

@@ -153,7 +153,10 @@ export interface TradingAPI extends BaseAPI {
      *   partially filled order the replacement rests `total - filled` and locks
      *   collateral for that remainder only (FIX convention: `LeavesQty =
      *   OrderQty - CumQty`); must exceed the filled amount. Omitted, the
-     *   replacement keeps the unfilled remainder.
+     *   replacement keeps the unfilled remainder. Margin reduce-only orders are
+     *   the exception: their quantity is a close size measured against the live
+     *   position, placed as given, so neither the subtraction nor the
+     *   must-exceed-filled rule applies.
      * @param newOrder.useMasterBalance - Whether to use master balance (optional, defaults to false)
      * @param newOrder.postOnly - Re-states post-only intent for the replacement (nothing is inherited from the original order)
      * @returns Promise resolving to a `ReplaceOrderResponse`

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

@@ -99,6 +99,7 @@ export declare const SimulateOrderRiskSchema: z.ZodObject<{
         quantity: z.ZodString;
         leverage: z.ZodOptional<z.ZodString>;
         reduceOnly: z.ZodOptional<z.ZodBoolean>;
+        slippageToleranceBps: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strict>;
 }, z.core.$strip>;
 export declare const SimulateParentMarginOrderRiskSchema: z.ZodObject<{
@@ -121,6 +122,7 @@ export declare const SimulateParentMarginOrderRiskSchema: z.ZodObject<{
         quantity: z.ZodString;
         leverage: z.ZodOptional<z.ZodString>;
         reduceOnly: z.ZodOptional<z.ZodBoolean>;
+        slippageToleranceBps: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strict>;
 }, z.core.$strip>;
 export declare const SimulateRiskBucketOrderRiskSchema: z.ZodObject<{
@@ -148,6 +150,7 @@ export declare const SimulateRiskBucketOrderRiskSchema: z.ZodObject<{
         quantity: z.ZodString;
         leverage: z.ZodOptional<z.ZodString>;
         reduceOnly: z.ZodOptional<z.ZodBoolean>;
+        slippageToleranceBps: z.ZodOptional<z.ZodNumber>;
         tradingPairId: z.ZodUUID;
         strategyKey: z.ZodOptional<z.ZodString>;
         marginMode: z.ZodOptional<z.ZodLiteral<"ISOLATED">>;
@@ -172,6 +175,7 @@ export declare const SimulateRiskBucketOrderRiskSchema: z.ZodObject<{
         quantity: z.ZodString;
         leverage: z.ZodOptional<z.ZodString>;
         reduceOnly: z.ZodOptional<z.ZodBoolean>;
+        slippageToleranceBps: z.ZodOptional<z.ZodNumber>;
         marginMode: z.ZodLiteral<"CROSS">;
         selectedTradingPairIds: z.ZodOptional<z.ZodNever>;
         strategyKey: z.ZodOptional<z.ZodNever>;

package/dist/validation/margin-accounts.js

@@ -2,7 +2,7 @@
  * Margin Account API Validation Schemas
  */
 import { z } from "zod";
-import { OrderSideSchema, OrderTypeSchema, PositionSideSchema, PositiveDecimalStringSchema, UUIDSchema } from "./trading";
+import { MarketSlippageToleranceBpsSchema, OrderSideSchema, OrderTypeSchema, PositionSideSchema, PositiveDecimalStringSchema, UUIDSchema } from "./trading";
 const PaginationSchema = z.object({
     page: z.number().int().min(1, "Page must be at least 1").optional(),
     pageSize: z.number().int().min(1, "Page size must be at least 1").max(100, "Page size cannot exceed 100").optional(),
@@ -132,8 +132,23 @@ const BaseSimulateOrderRiskRequestSchema = z.object({
     quantity: PositiveDecimalStringSchema,
     leverage: PositiveDecimalStringSchema.optional(),
     reduceOnly: z.boolean().optional(),
+    // The server caps a preview's tolerance at 1,000 bps (the same cap
+    // placement enforces on a MARKET order), so 1,001..10,000 fail here rather
+    // than round-trip to a 400 — one shared schema, so the cap lives once.
+    slippageToleranceBps: MarketSlippageToleranceBpsSchema.optional(),
 });
 const validateOneWaySimulationFields = (data, ctx) => {
+    // Mirrors the server (`utils::slippage::validate_slippage_tolerance`, the
+    // rule placement applies): a tolerance is MARKET-only, so a LIMIT preview
+    // carrying one fails client-side with the same complaint the server would
+    // raise instead of round-tripping to a 400.
+    if (data.orderType !== "MARKET" && data.slippageToleranceBps !== undefined) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: "slippageToleranceBps is only supported for MARKET orders",
+            path: ["slippageToleranceBps"],
+        });
+    }
     if (data.positionSide !== undefined) {
         const expected = data.side === "BUY" ? "LONG" : "SHORT";
         if (data.positionSide !== expected) {

package/dist/validation/trading.d.ts

@@ -76,6 +76,13 @@ export declare const ISO8601DateSchema: z.ZodISODateTime;
  */
 export declare const SlippageToleranceSchema: z.ZodOptional<z.ZodNumber>;
 export declare const SlippageToleranceBpsSchema: z.ZodNumber;
+/**
+ * A standalone MARKET order's tolerance, and a MARKET risk preview's: the
+ * server caps it at 1,000 bps — the mandatory protective band, which a client
+ * value can only tighten — so anything wider fails here instead of
+ * round-tripping to a 400. The 10,000 bps schema above is for TP/SL legs.
+ */
+export declare const MarketSlippageToleranceBpsSchema: z.ZodNumber;
 /** TWAP slices cap at 500 bps (5%) — tighter than standalone market orders. */
 export declare const TwapSlippageToleranceBpsSchema: z.ZodNumber;
 export declare const ParentTpSlLegSchema: z.ZodObject<{

package/dist/validation/trading.js

@@ -84,6 +84,17 @@ export const SlippageToleranceBpsSchema = z
     .int()
     .min(0, "Slippage tolerance must be at least 0 bps")
     .max(10000, "Slippage tolerance cannot exceed 10000 bps");
+/**
+ * A standalone MARKET order's tolerance, and a MARKET risk preview's: the
+ * server caps it at 1,000 bps — the mandatory protective band, which a client
+ * value can only tighten — so anything wider fails here instead of
+ * round-tripping to a 400. The 10,000 bps schema above is for TP/SL legs.
+ */
+export const MarketSlippageToleranceBpsSchema = z
+    .number()
+    .int()
+    .min(0, "Slippage tolerance must be at least 0 bps")
+    .max(1000, "Slippage tolerance cannot exceed 1000 bps");
 /** TWAP slices cap at 500 bps (5%) — tighter than standalone market orders. */
 export const TwapSlippageToleranceBpsSchema = z
     .number()