@derivexyz/derive-ts 3.0.4

package/dist/index.d.cts

@@ -0,0 +1,1463 @@
+import { R as RegisterDepositAddressResult, a as DepositHistoryResult, I as InstrumentPublicResponse, P as PublicAssetType, G as GetAllInstrumentsResponse, T as TickerSlimSnapshot, b as GetTickersResponse, C as CurrencyResponse, c as GetLatestSignedFeedsResponse, O as OptionSettlementPricesResult, d as GetTransactionResult, e as GetReferralPerformanceResult, f as IndexCandle, g as InterestRateHistoryResult, M as MarginWatchResult, h as TriggerType, i as TriggerPriceType, j as OrderCreatedWireResponse, k as OrderQuoteEdgeRpcResponse, l as OrderWireResponse, m as CancelAllResponse, n as CancelByLabelWireResponse, o as PaginatedOrdersResult, S as SetMmpConfigResponse, p as ResetMmpResponse, D as Direction, q as TransferPositionsWireResponse, r as RFQPrivateWireResponse, Q as QuotePollWireResponse, s as RfqGetBestQuoteWireResponse, t as QuoteResultPublic, u as QuoteExecuteWireResponse, v as QuoteExecuteDebugResult, w as CancelRfqResponse, x as RFQPollWireResponse, y as QuotePrivateWireResponse, z as QuoteSendDebugResult, A as CancelBatchResult, B as CancelBatchRfqsWireResponse, E as QuoteGetWireResponse, F as QuoteReplaceWireResponse, H as PrivateCreateSessionKeyEdgeRPCResponse, J as SessionKeyResponse, K as PrivateTransferSpotEdgeRpcResponse, U as UpdateWhitelistedRecipientsEdgeRpcResponse, L as PrivateTransferSpotExternalEdgeRpcResponse, N as PrivateGetSubaccountRPCResponseFor_OrderWireResponseAnd_VaultDepositHoldResponse, V as PrivateGetAccountEdgeRPCResponse, W as PrivateGetPositionsRPCResponse, X as PrivateChangeSubaccountLabelRPCResponse, Y as PaginatedTradesResult, Z as InterestHistoryResult, _ as TransferHistoryResult, $ as OptionSettlementHistoryResponse, a0 as PaginationInfo, a1 as VaultRequestId, a2 as VaultIdsWireResponse, a3 as VaultCreateWireResponse, a4 as VaultSettleWireResponse, a5 as OffchainAckWireResponse, a6 as MultipleVaultRequestsWireResponse, a7 as VaultRequestAckWireResponse, a8 as VaultForceBurnWireResponse, a9 as VaultSharesWireResponse, aa as PaginatedVaultActionsResult, ab as VaultCancelWireResponse, ac as VaultWireResponse, ad as VaultsWireResponse, ae as PaginatedVaultActionsResult2, af as PerformanceResolution, ag as VaultPerformanceHistoryResult, ah as PrivateWithdrawEdgeRpcResponse, ai as WithdrawalHistoryResult, aj as ChannelSchemaMap } from './generated-DwMaydIF.cjs';
+export { ak as EndpointMap } from './generated-DwMaydIF.cjs';
+import { BaseWallet, Signer } from 'ethers';
+import { D as DecimalLike, P as ProtocolScopeCode, O as OffchainScope } from './scopes-RzGb3xH6.cjs';
+export { a as ProtocolScopeWireString, e as expiresIn, r as randomNonce, t as toE18, b as toScaled } from './scopes-RzGb3xH6.cjs';
+import { R as RpcMethod, P as ParamsOf, a as ResultFor, C as ChannelParamsOf, b as ChannelDataOf } from './endpointMap-BBTkarIm.cjs';
+import { ChannelTemplate } from './types/index.cjs';
+
+declare const SDK_VERSION = "3.0.0";
+
+/**
+ * The minimal signer the auth flow needs: anything that can EIP-191
+ * `signMessage` (an ethers Wallet, an HD wallet, a provider-backed
+ * signer, a hardware-wallet adapter…). Kept structural so any
+ * ethers-compatible signer works, not just this SDK's `ethers` instance.
+ */
+interface AuthSigner {
+    signMessage(message: string): Promise<string>;
+}
+/**
+ * Who a request acts as: the account owner's address plus the wallet
+ * that actually signs (the owner itself, or a registered session key).
+ */
+interface AuthCredentials {
+    ownerAddress: string;
+    signer: BaseWallet;
+}
+/**
+ * The exchange authenticates requests with an EIP-191 personal_sign
+ * over the current unix-millisecond timestamp as a decimal string.
+ * Owner-wallet signatures must be fresh; session-key signatures skip
+ * the freshness window but the key must be registered and unexpired.
+ *
+ * Note: header names are `X-Lyra*` — the live wire format predates the
+ * Derive rebrand.
+ */
+declare function authHeaders(credentials: {
+    ownerAddress: string;
+    signer: AuthSigner;
+}): Promise<Record<string, string>>;
+/** `public/login` takes the same wallet/timestamp/signature triple as the REST headers. */
+declare function loginParams(credentials: {
+    ownerAddress: string;
+    signer: AuthSigner;
+}): Promise<{
+    wallet: string;
+    timestamp: string;
+    signature: string;
+}>;
+
+/** The subset of the WebSocket interface the SDK relies on; satisfied by both `ws` and the browser WebSocket. */
+interface WebSocketLike {
+    readonly readyState: number;
+    send(data: string): void;
+    close(code?: number, reason?: string): void;
+    onopen: ((event?: unknown) => void) | null;
+    onmessage: ((event: {
+        data: unknown;
+    }) => void) | null;
+    onclose: ((event: {
+        code?: number;
+        reason?: unknown;
+    }) => void) | null;
+    onerror: ((event: unknown) => void) | null;
+}
+type WebSocketFactory = (url: string) => WebSocketLike | Promise<WebSocketLike>;
+interface WsTransportOptions {
+    url: string;
+    timeoutMs: number;
+    logger: Logger;
+    wsFactory?: WebSocketFactory;
+}
+/**
+ * WebSocket transport with id-correlated request/response handling and
+ * automatic reconnect. On an unexpected close every in-flight request is
+ * rejected (mutating requests are never silently replayed); after the
+ * socket is re-established `onReconnected` lets the client re-login and
+ * re-subscribe.
+ */
+declare class WsTransport {
+    private readonly options;
+    /** Set by the subscriptions layer; receives every pub/sub notification. */
+    onNotification?: (channel: string, data: unknown) => void;
+    /** Set by the client; runs after an automatic reconnect succeeds. */
+    onReconnected?: () => Promise<void>;
+    private socket?;
+    private nextId;
+    private readonly pending;
+    private intentionallyClosed;
+    private connecting?;
+    constructor(options: WsTransportOptions);
+    get connected(): boolean;
+    connect(): Promise<void>;
+    private open;
+    send<M extends RpcMethod>(method: M, params: ParamsOf<M>): Promise<ResultFor<M>>;
+    close(): Promise<void>;
+    private handleMessage;
+    private handleClose;
+    private rejectAllPending;
+    private reconnect;
+}
+
+/**
+ * Protocol contracts the SDK references. (The EIP-712 verifying contract
+ * is not here — v3 uses a constant Matching address on every network;
+ * see MATCHING_VERIFYING_CONTRACT in signing/eip712.ts.)
+ */
+interface ContractAddresses {
+    actionManager?: string;
+    usdc?: string;
+    cash?: string;
+}
+/**
+ * Addresses of the protocol's action-verification modules. Every signed
+ * action commits to the module that verifies it, so a wrong module
+ * address means a rejected signature. All v3 networks share the
+ * canonical set in signing/modules.ts.
+ */
+interface ModuleAddresses {
+    trade: string;
+    transfer: string;
+    withdrawal: string;
+    rfq: string;
+    externalTransfer: string;
+    whitelistedRecipient: string;
+    vault: string;
+    liquidation: string;
+    createSessionKey: string;
+    deposit?: string;
+}
+/**
+ * Everything network-specific the SDK needs. The EIP-712 domain
+ * separator is not stored — it is computed the canonical part-wise way
+ * from `chainId` + `contracts.matching` (see signing/eip712.ts).
+ */
+interface NetworkConfig {
+    name: string;
+    httpUrl: string;
+    wsUrl: string;
+    /** The chain the protocol verifies signatures for (mainnet: Ethereum L1, testnet: Sepolia, local: anvil). */
+    chainId: number;
+    modules: ModuleAddresses;
+    contracts: ContractAddresses;
+}
+type NetworkName = 'mainnet' | 'testnet' | 'local';
+/** A logging hook; the SDK never logs to console directly and never logs key material. */
+type Logger = (level: 'debug' | 'info' | 'warn' | 'error', message: string, data?: unknown) => void;
+interface DeriveClientOptions {
+    /** Preset name or a full custom config. */
+    network: NetworkName | NetworkConfig;
+    /**
+     * The account owner wallet: a raw private key or an ethers wallet
+     * with a local signing key. Optional when only public endpoints or a
+     * session key are used.
+     */
+    wallet?: string | BaseWallet;
+    /**
+     * A registered session key used for login and request signing in
+     * place of the owner wallet. Recommended for bots and frontends:
+     * scope it narrowly and set an expiry.
+     */
+    sessionKey?: string | BaseWallet;
+    /** The account owner's address; required when a session key is used without the owner wallet. */
+    ownerAddress?: string;
+    logger?: Logger;
+    /** WebSocket constructor override (defaults to `ws` in Node, the global WebSocket in browsers). */
+    wsFactory?: WebSocketFactory;
+    /** Per-request timeout in milliseconds. Default 20_000. */
+    requestTimeoutMs?: number;
+}
+
+/**
+ * What every API namespace needs from the client: the network config,
+ * a typed RPC pipe, and the signing identities. Kept as an interface so
+ * namespaces stay independently testable.
+ */
+interface ClientContext {
+    network: NetworkConfig;
+    logger: Logger;
+    send<M extends RpcMethod>(method: M, params: ParamsOf<M>): Promise<ResultFor<M>>;
+    /**
+     * The acting identity: the account owner's address (the `owner` field
+     * of every signed action) plus the wallet that signs requests and
+     * actions — the session key when configured, otherwise the owner.
+     */
+    credentials(): AuthCredentials;
+}
+
+/**
+ * Deposits are NOT signed actions in v3. Funds enter through one of two
+ * deliberately distinct flows — pick explicitly:
+ *
+ * - `deposits.contractCall.*` — self-custody: YOUR wallet sends the
+ *   on-chain ActionManager transaction (approve + deposit); you provide
+ *   an ethers Signer connected to the chain RPC.
+ * - `deposits.depositAddress.*` — CEX-style: register a deterministic
+ *   deposit address, send funds to it from anywhere, and the exchange
+ *   sweeps and credits them asynchronously.
+ *
+ * `getHistory` and `awaitCredited` cover both flows.
+ */
+declare class DepositsApi {
+    private readonly ctx;
+    readonly contractCall: ContractCallDeposits;
+    readonly depositAddress: DepositAddressDeposits;
+    constructor(ctx: ClientContext);
+    /**
+     * Deposit history rows (up to 1000), regardless of which flow funded
+     * them. Scoped to one subaccount when `subaccountId` is given,
+     * otherwise to the whole owner wallet. Timestamps are unix milliseconds.
+     */
+    getHistory(options?: {
+        subaccountId?: number;
+        startTimestampMs?: number;
+        endTimestampMs?: number;
+    }): Promise<DepositHistoryResult>;
+    /**
+     * Polls `private/get_subaccounts` until a subaccount id outside
+     * `knownSubaccountIds` appears — the signal that a deposit creating a
+     * new subaccount (either flow) was credited — and returns the new id.
+     * Snapshot the ids BEFORE initiating the deposit.
+     */
+    awaitCredited(params: {
+        knownSubaccountIds: number[];
+        timeoutMs?: number;
+        pollIntervalMs?: number;
+    }): Promise<number>;
+}
+interface ContractCallDepositBase {
+    /** Caller-provided ethers signer connected to the chain RPC (the SDK holds no provider). */
+    signer: Signer;
+    /** Protocol asset label the deposit credits (see abis/actionManager.ts), NOT the ERC-20. */
+    asset: string;
+    /** Underlying ERC-20 to approve and pull funds from. Defaults to the network's USDC. */
+    erc20?: string;
+    /**
+     * Amount in human units — scaled by the ERC-20's on-chain `decimals()`
+     * (USDC = 6) — or a bigint of already-raw token units.
+     */
+    amount: DecimalLike;
+}
+/**
+ * Self-custody deposits: the caller's wallet signs on-chain
+ * ActionManager transactions directly.
+ */
+declare class ContractCallDeposits {
+    private readonly ctx;
+    constructor(ctx: ClientContext);
+    /**
+     * Approves (if needed) and deposits into an existing subaccount.
+     * `fallbackRecipient` (default: the signer) receives the funds into
+     * its fallback subaccount if the deposit cannot be applied.
+     * Resolves once the transaction is mined — crediting happens
+     * asynchronously once the deposit is observed on-chain.
+     */
+    deposit(params: ContractCallDepositBase & {
+        subaccountId: number;
+        fallbackRecipient?: string;
+    }): Promise<{
+        txHash: string;
+    }>;
+    /**
+     * Approves (if needed) and deposits into a NEW subaccount under
+     * `managerId`, owned by `owner` (default: the signer). The exchange
+     * assigns the subaccount id asynchronously — discover it with
+     * `deposits.awaitCredited` against a pre-deposit snapshot of the
+     * owner's ids.
+     */
+    depositToNewSubaccount(params: ContractCallDepositBase & {
+        managerId: number;
+        owner?: string;
+    }): Promise<{
+        txHash: string;
+    }>;
+    /** Scales the amount, then ensures the ActionManager may pull it from the ERC-20. */
+    private approveForDeposit;
+}
+/**
+ * CEX-style deposits: send funds to a registered deterministic address
+ * from any wallet or exchange; they are credited asynchronously.
+ */
+declare class DepositAddressDeposits {
+    private readonly ctx;
+    constructor(ctx: ClientContext);
+    /**
+     * Registers (or re-fetches — the address is deterministic per wallet/
+     * subaccount/manager) the deposit address the exchange watches and
+     * sweeps, routing funds to an existing subaccount or, with
+     * `managerId`, a new one. `wallet` defaults to the client's owner.
+     */
+    register(options?: {
+        wallet?: string;
+        subaccountId?: number;
+        managerId?: number;
+    }): Promise<RegisterDepositAddressResult>;
+}
+
+interface InstrumentsQuery {
+    instrumentType: PublicAssetType;
+    currency?: string;
+    /** Include expired instruments. Default false. */
+    expired?: boolean;
+    page?: number;
+    pageSize?: number;
+}
+/** One collateral leg of a `simulateMargin` portfolio; `amount` is a decimal string. */
+interface SimulatedCollateral {
+    assetName: string;
+    amount: string;
+}
+/** One position leg of a `simulateMargin` portfolio; `amount` is a decimal string. */
+interface SimulatedPosition {
+    instrumentName: string;
+    amount: string;
+    /** Perps only — entry price to simulate against; defaults to mark price. */
+    entryPrice?: string;
+}
+interface SimulateMarginParams {
+    marginType: 'PM' | 'PM2' | 'SM';
+    /** Required for portfolio margin. */
+    market?: string;
+    simulatedCollaterals: SimulatedCollateral[];
+    simulatedPositions: SimulatedPosition[];
+    /** Deltas layered on top of `simulatedCollaterals` to model a deposit/withdrawal/spot trade. */
+    simulatedCollateralChanges?: SimulatedCollateral[];
+    /** Deltas layered on top of `simulatedPositions` to model a perp/option trade. */
+    simulatedPositionChanges?: SimulatedPosition[];
+}
+/** Public market data endpoints — no authentication or signing. */
+declare class MarketDataApi {
+    private readonly ctx;
+    constructor(ctx: ClientContext);
+    getInstrument(instrumentName: string): Promise<InstrumentPublicResponse>;
+    /** One page of instruments; the response carries pagination info. */
+    getInstruments(query: InstrumentsQuery): Promise<GetAllInstrumentsResponse>;
+    /** Every currently tradeable instrument name across all currencies. */
+    getAllLiveInstruments(): Promise<string[]>;
+    /**
+     * Latest ticker snapshot: top of book (`b`/`a` prices, `B`/`A`
+     * amounts), mark (`M`) and index (`I`) prices, and match bounds.
+     */
+    getTicker(instrumentName: string): Promise<TickerSlimSnapshot>;
+    /** Ticker snapshots for every instrument of a type, keyed by instrument name. */
+    getTickers(params: {
+        instrumentType: PublicAssetType;
+        currency?: string;
+        expiryDate?: number;
+    }): Promise<GetTickersResponse>;
+    getAllCurrencies(): Promise<CurrencyResponse[]>;
+    getCurrency(currency: string): Promise<CurrencyResponse>;
+    /** Latest signed oracle feeds (spot/perp/option/forward), optionally filtered by currency/expiry. */
+    getLatestSignedFeeds(params?: {
+        currency?: string;
+        expiry?: number;
+    }): Promise<GetLatestSignedFeedsResponse>;
+    /** Settlement prices per expiry for the currency's options. */
+    getOptionSettlementPrices(currency: string): Promise<OptionSettlementPricesResult>;
+    /** On-chain settlement status and hash for a single op by its uuid. */
+    getTransaction(opUuid: string): Promise<GetTransactionResult>;
+    /** Referral fee-share and reward breakdown over a millisecond window. */
+    getReferralPerformance(params: {
+        startMs: number;
+        endMs: number;
+        referralCode?: string;
+        wallet?: string;
+    }): Promise<GetReferralPerformanceResult>;
+    /** Spot index OHLC candles for a currency over a UTC-seconds window; `period` is the bucket size in seconds. */
+    getIndexChartData(params: {
+        currency: string;
+        startTimestamp: number;
+        endTimestamp: number;
+        period: number;
+    }): Promise<IndexCandle[]>;
+    /** Interest-rate candles for a currency's lending pools, optionally scoped to one risk universe. */
+    getInterestRateHistory(params: {
+        currency: string;
+        startTimestamp?: number;
+        endTimestamp?: number;
+        period?: number;
+        riskUniverseId?: number;
+    }): Promise<InterestRateHistoryResult>;
+    /** 24h and lifetime volume/fee/trade statistics for an instrument name or type (`ALL`/`OPTION`/`PERP`/`SPOT`). */
+    getStatistics(params: {
+        instrumentName: string;
+        currency?: string;
+        endTime?: number;
+    }): Promise<unknown>;
+    /** All maker programs, including past/historical epochs. */
+    getMakerPrograms(): Promise<unknown>;
+    /** Per-maker score breakdown for one program epoch. */
+    getMakerProgramScores(params: {
+        programName: string;
+        epochStartTimestamp: number;
+    }): Promise<unknown>;
+    /** Paginated liquidation-auction history across all subaccounts (or one, if `subaccountId` is given). */
+    getLiquidationHistory(params?: {
+        subaccountId?: number;
+        fromTimestamp?: number;
+        toTimestamp?: number;
+        page?: number;
+        pageSize?: number;
+    }): Promise<unknown>;
+    /** Mark-to-market value and maintenance margin for a subaccount. */
+    marginWatch(params: {
+        subaccountId: number;
+        forceOnchain?: boolean;
+        isDelayedLiquidation?: boolean;
+    }): Promise<MarginWatchResult>;
+    /** Margin requirement for a simulated portfolio and optional trade deltas; ignores open-order margin. */
+    simulateMargin(params: SimulateMarginParams): Promise<unknown>;
+}
+
+interface PlaceOrderParams {
+    subaccountId: number;
+    instrumentName: string;
+    direction: 'buy' | 'sell';
+    amount: DecimalLike;
+    limitPrice: DecimalLike;
+    /**
+     * Highest fee per unit the signature allows (the exchange charges its
+     * normal fee regardless — this only caps it). Defaults to 3x the
+     * instrument's current taker cost; pass explicitly for market makers.
+     */
+    maxFee?: DecimalLike;
+    orderType?: 'limit' | 'market';
+    timeInForce?: 'gtc' | 'post_only' | 'fok' | 'ioc';
+    label?: string;
+    /** Count this order against the market-maker-protection limits. */
+    mmp?: boolean;
+    reduceOnly?: boolean;
+    nonce?: string;
+    signatureExpirySec?: number;
+    /** Conditional-order trigger: fires the order when the price condition is met. */
+    triggerType?: TriggerType;
+    triggerPrice?: DecimalLike;
+    triggerPriceType?: TriggerPriceType;
+    /** Referral code recorded against the order's fees. */
+    referralCode?: string;
+    /** Reject (rather than downgrade) a post-only order that would cross. */
+    rejectPostOnly?: boolean;
+    /** Marks the order for the atomic-signing flow. */
+    isAtomicSigning?: boolean;
+    /** Caller-supplied order tag (wire field `client`). */
+    clientOrderId?: string;
+    /** Additional per-unit fee the caller opts to pay (wire field `extra_fee`). */
+    extraFee?: DecimalLike;
+    /** Reject the order if the server clock is past this unix-seconds deadline. */
+    rejectTimestamp?: number;
+    /** Algo-order parameters (e.g. TWAP). */
+    algoType?: string;
+    algoDurationSec?: number;
+    algoNumSlices?: number;
+}
+interface OrderHistoryQuery {
+    subaccountId?: number;
+    fromTimestamp?: number;
+    toTimestamp?: number;
+    page?: number;
+    pageSize?: number;
+}
+interface SetMmpConfigParams {
+    subaccountId: number;
+    currency: string;
+    /** Freeze duration (ms) once tripped; 0 requires a manual `resetMmp`. */
+    mmpFrozenTime: number;
+    /** Rolling protection window (ms) over which fills accumulate. */
+    mmpInterval: number;
+    /** Filled-amount limit within the window (decimal string); omit or 0 for unlimited. */
+    mmpAmountLimit?: DecimalLike;
+    /** Net-delta limit within the window (decimal string); omit or 0 for unlimited. */
+    mmpDeltaLimit?: DecimalLike;
+}
+/** Order placement (signed trade actions) and management. */
+declare class OrdersApi {
+    private readonly ctx;
+    private readonly marketData;
+    /** Asset address/subId per instrument name are immutable — cache the lookups. */
+    private readonly instruments;
+    constructor(ctx: ClientContext, marketData: MarketDataApi);
+    /**
+     * Builds the signed wire payload shared by `place` and `quote`. The trade
+     * action commits only to asset/price/amount/fee/recipient — trigger,
+     * referral, algo and the other flags below are wire-only and never signed.
+     */
+    private buildOrderPayload;
+    place(params: PlaceOrderParams): Promise<OrderCreatedWireResponse>;
+    /**
+     * Prices an order without placing it. Signs like `place` (pass
+     * `{ public: true }` to hit the unauthenticated public estimate instead).
+     */
+    getOrderQuote(params: PlaceOrderParams, options?: {
+        public?: boolean;
+    }): Promise<OrderQuoteEdgeRpcResponse>;
+    /** Cancels one order. Needs only authentication, not a signature. */
+    cancel(params: {
+        subaccountId: number;
+        orderId: string;
+        instrumentName: string;
+    }): Promise<OrderWireResponse>;
+    cancelAll(subaccountId: number, options?: {
+        cancelTriggerOrders?: boolean;
+        cancelAlgoOrders?: boolean;
+    }): Promise<CancelAllResponse>;
+    cancelByLabel(params: {
+        subaccountId: number;
+        label: string;
+        instrumentName?: string;
+    }): Promise<CancelByLabelWireResponse>;
+    getOrder(params: {
+        subaccountId: number;
+        orderId: string;
+    }): Promise<OrderWireResponse>;
+    getOpenOrders(subaccountId: number): Promise<OrderWireResponse[]>;
+    /** Paginated closed/open order history; defaults to all of the wallet's subaccounts. */
+    getOrderHistory(query?: OrderHistoryQuery): Promise<PaginatedOrdersResult>;
+    /** Sets the market-maker-protection limits for a currency; overwrites any existing config. */
+    setMmpConfig(params: SetMmpConfigParams): Promise<SetMmpConfigResponse>;
+    /** Clears a tripped market-maker-protection freeze; scoped to one currency, or all when omitted. */
+    resetMmp(params: {
+        subaccountId: number;
+        currency?: string;
+    }): Promise<ResetMmpResponse>;
+    private instrument;
+    /**
+     * The signed max fee must cover whatever the exchange charges at match
+     * time or the order is rejected. The exchange bounds the per-unit fee at
+     * `2 x taker_fee_rate x max(index, limit) + base_fee`, where `index` is
+     * the underlying SPOT feed (`ticker.I`) — NOT the option mark
+     * (`ticker.M`). We mirror that and apply a 3x headroom for feed moves
+     * between signing and matching.
+     */
+    private defaultMaxFee;
+}
+
+/** One priced position leg shared by both sides of a position transfer. */
+interface PositionTransferLeg {
+    instrumentName: string;
+    amount: DecimalLike;
+    price: DecimalLike;
+    direction: Direction;
+}
+interface TransferPositionsParams {
+    /** Subaccount signing the maker quote. Must differ from `takerSubaccountId`. */
+    makerSubaccountId: number;
+    /** Subaccount signing the taker execute. Must differ from `makerSubaccountId`. */
+    takerSubaccountId: number;
+    /** Maker quote direction. The SDK derives the taker's opposite direction. */
+    makerDirection: Direction;
+    /** The exact priced package both sides authorize. */
+    legs: PositionTransferLeg[];
+    makerNonce?: string;
+    takerNonce?: string;
+    /** Shared signature expiry for both sides. Defaults to 700 seconds from now. */
+    signatureExpirySec?: number;
+}
+/**
+ * Transfers perp/option positions between two subaccounts owned by the same
+ * wallet. The route executes an RFQ internally, so the SDK signs a zero-fee
+ * maker quote and the matching opposite-direction taker execute.
+ */
+declare class PositionTransfersApi {
+    private readonly ctx;
+    private readonly instruments;
+    constructor(ctx: ClientContext);
+    transferPositions(params: TransferPositionsParams): Promise<TransferPositionsWireResponse>;
+    private resolveLegs;
+    private instrument;
+    private signAction;
+}
+
+/** A leg of an RFQ as requested by the taker — unpriced; makers quote the price. */
+interface RfqLeg {
+    instrumentName: string;
+    amount: DecimalLike;
+    direction: Direction;
+}
+/** A priced leg as signed by the maker (`sendQuote`). */
+interface PricedRfqLeg extends RfqLeg {
+    price: DecimalLike;
+}
+/** Maker quote against an open RFQ — see `sendQuote` / `sendQuoteDebug`. */
+interface SendQuoteParams {
+    /** The maker's subaccount. */
+    subaccountId: number;
+    rfqId: string;
+    direction: Direction;
+    legs: PricedRfqLeg[];
+    /** Worst execution fee the maker accepts, in USD. */
+    maxFee: DecimalLike;
+    mmp?: boolean;
+    label?: string;
+    nonce?: string;
+    signatureExpirySec?: number;
+}
+/** Taker execution of a maker quote — see `executeQuote` / `executeQuoteDebug`. */
+interface ExecuteQuoteParams {
+    /** The taker's subaccount. */
+    subaccountId: number;
+    quote: Pick<QuoteResultPublic, 'rfq_id' | 'quote_id' | 'direction' | 'legs'>;
+    /** Worst execution fee the taker accepts, in USD. */
+    maxFee: DecimalLike;
+    /** Reject the fill if the quote is no longer the best available price. */
+    enableTakerProtection?: boolean;
+    label?: string;
+    nonce?: string;
+    signatureExpirySec?: number;
+}
+/**
+ * RFQ trading: takers request quotes on multi-leg packages, makers answer
+ * with signed quotes, and the taker executes one — the only two signed
+ * operations are `sendQuote` (maker) and `executeQuote` (taker), both
+ * against the RFQ module. Requesting, polling and cancelling are auth-only.
+ */
+declare class RfqApi {
+    private readonly ctx;
+    /** Asset address/subId per instrument name are immutable — cache the lookups. */
+    private readonly instruments;
+    constructor(ctx: ClientContext);
+    /** Requests quotes for a package of legs. Unsigned — only the eventual execute is. */
+    sendRfq(params: {
+        subaccountId: number;
+        legs: RfqLeg[];
+        label?: string;
+        /** Reject fills costing the taker more than this (buy-side cap). */
+        maxTotalCost?: DecimalLike;
+        /** Reject fills earning the taker less than this (sell-side floor). */
+        minTotalCost?: DecimalLike;
+        /** Restrict quoting to these maker wallets. */
+        counterparties?: string[];
+        partialFillStep?: DecimalLike;
+    }): Promise<RFQPrivateWireResponse>;
+    /** Polls quotes received for the taker's RFQs (e.g. `status: 'open'`). */
+    pollQuotes(params: {
+        subaccountId: number;
+        rfqId?: string;
+        quoteId?: string;
+        status?: string;
+        fromTimestamp?: number;
+        toTimestamp?: number;
+        page?: number;
+        pageSize?: number;
+    }): Promise<QuotePollWireResponse>;
+    /** The exchange's pick of the best open quote for an RFQ, with margin/cost estimates. */
+    getBestQuote(params: {
+        subaccountId: number;
+        /** The open RFQ whose quotes should be evaluated. */
+        rfqId: string;
+        /** The direction the taker wants to trade. */
+        direction: Direction;
+        legs: RfqLeg[];
+    }): Promise<RfqGetBestQuoteWireResponse>;
+    /**
+     * Executes a maker quote (from `pollQuotes` / `getBestQuote`). The taker
+     * trades opposite the quote's direction and signs a commitment to the
+     * maker's exact leg bundle, so legs and prices come from the quote itself.
+     */
+    executeQuote(params: ExecuteQuoteParams): Promise<QuoteExecuteWireResponse>;
+    /**
+     * Debug helper: signs the execute exactly like `executeQuote` but submits it
+     * to `public/execute_quote_debug`, returning the server-computed encoded data
+     * and hashes instead of filling. Use it to verify your client-side signing.
+     */
+    executeQuoteDebug(params: ExecuteQuoteParams): Promise<QuoteExecuteDebugResult>;
+    private buildExecutePayload;
+    cancelRfq(params: {
+        subaccountId: number;
+        rfqId: string;
+    }): Promise<CancelRfqResponse>;
+    /** Polls RFQs open for quoting (e.g. `status: 'open'`). */
+    pollRfqs(params: {
+        subaccountId: number;
+        rfqId?: string;
+        status?: string;
+        fromTimestamp?: number;
+        toTimestamp?: number;
+        page?: number;
+        pageSize?: number;
+    }): Promise<RFQPollWireResponse>;
+    /**
+     * Signs and sends a quote against an open RFQ. Legs must match the RFQ's
+     * legs with prices added; `direction: 'sell'` quotes the package to a
+     * buying taker.
+     */
+    sendQuote(params: SendQuoteParams): Promise<QuotePrivateWireResponse>;
+    /**
+     * Debug helper: signs the quote exactly like `sendQuote` but submits it to
+     * `public/send_quote_debug`, returning the server-computed encoded data and
+     * hashes instead of posting. Use it to verify your client-side signing.
+     */
+    sendQuoteDebug(params: SendQuoteParams): Promise<QuoteSendDebugResult>;
+    private buildSendQuotePayload;
+    cancelQuote(params: {
+        subaccountId: number;
+        quoteId: string;
+        rfqId?: string;
+    }): Promise<QuotePrivateWireResponse>;
+    /** Cancels all the subaccount's open quotes, optionally scoped to one RFQ. */
+    cancelBatchQuotes(params: {
+        subaccountId: number;
+        rfqId?: string;
+    }): Promise<CancelBatchResult>;
+    /** Cancels all the subaccount's open RFQs, optionally scoped to one RFQ id. */
+    cancelBatchRfqs(params: {
+        subaccountId: number;
+        rfqId?: string;
+    }): Promise<CancelBatchRfqsWireResponse>;
+    /** Paginated quote history/read for the subaccount, filterable by rfq/quote/status. */
+    getQuotes(params: {
+        subaccountId: number;
+        rfqId?: string;
+        quoteId?: string;
+        status?: string;
+        page?: number;
+        pageSize?: number;
+        fromTimestamp?: number;
+        toTimestamp?: number;
+    }): Promise<QuoteGetWireResponse>;
+    /**
+     * Atomically cancels an existing quote and signs+sends a replacement on the
+     * same RFQ. Legs/price/maxFee sign the new quote exactly like `sendQuote`;
+     * identify the quote to cancel by `quoteIdToCancel` or `nonceToCancel`.
+     */
+    replaceQuote(params: {
+        subaccountId: number;
+        rfqId: string;
+        direction: Direction;
+        legs: PricedRfqLeg[];
+        maxFee: DecimalLike;
+        quoteIdToCancel?: string;
+        nonceToCancel?: string;
+        mmp?: boolean;
+        label?: string;
+        nonce?: string;
+        signatureExpirySec?: number;
+    }): Promise<QuoteReplaceWireResponse>;
+    /** Attaches each leg's protocol asset address + sub id and sorts into the canonical signed order. */
+    private resolveLegs;
+    private instrument;
+    private signRfqAction;
+}
+
+interface CreateSessionKeyParams {
+    /** The key being authorized: an address, or an ethers wallet (e.g. `Wallet.createRandom()`). */
+    publicSessionKey: string | BaseWallet;
+    /**
+     * The KEY's lifetime as a unix-seconds timestamp, committed in the signed
+     * data — not to be confused with `signatureExpirySec`, which only bounds
+     * how long this registration request itself stays valid.
+     */
+    expirySec: number;
+    /**
+     * Protocol scopes granted (numeric codes; the wire strings are derived).
+     * Defaults to NONE — the key can then only authenticate and use its
+     * offchain scopes. Grant `ProtocolScopeCode.Admin` deliberately, never
+     * by default.
+     */
+    protocolScopes?: ProtocolScopeCode[];
+    /** Off-chain scopes, e.g. `[OffchainScope.AccountInfo]`. Defaults to account_info. */
+    offchainScopes?: OffchainScope[];
+    /** Subaccounts the key may act on. Omit for ALL current and future subaccounts. */
+    subaccountIds?: number[];
+    label?: string;
+    /** Source IPs the key may be used from; omit for no restriction. */
+    ipWhitelist?: string[];
+    /** Envelope expiry of the registration signature. Defaults to 10 minutes. */
+    signatureExpirySec?: number;
+    nonce?: string;
+}
+interface EditSessionKeyParams {
+    publicSessionKey: string;
+    /** Omitted fields are left unchanged (the endpoint is a patch). */
+    label?: string;
+    /** Requires the request to be authorized by the owner or an admin-scoped key. */
+    ipWhitelist?: string[];
+    /** Requires the request to be authorized by the owner or an admin-scoped key. */
+    offchainScopes?: OffchainScope[];
+}
+/**
+ * Session-key registration and management. Keys are wallet-level: actions
+ * are signed on subaccount 0 and the granted subaccount list lives inside
+ * the signed data, not the envelope.
+ */
+declare class SessionKeysApi {
+    private readonly ctx;
+    constructor(ctx: ClientContext);
+    /**
+     * Registers a scoped session key. The action must be authorized by the
+     * account owner or by a registered session key holding the
+     * `create_session_key` scope — a child key must then be a subset of its
+     * creator (scopes, subaccounts, and expiry no later than the creator's).
+     * Signs with the client's action signer, so a client configured with an
+     * unscoped session key will be rejected server-side.
+     */
+    create(params: CreateSessionKeyParams): Promise<PrivateCreateSessionKeyEdgeRPCResponse>;
+    /** All registered session keys of the owner wallet. */
+    list(): Promise<SessionKeyResponse[]>;
+    /**
+     * Patches a key's OFF-CHAIN attributes. Protocol scopes, subaccounts,
+     * and expiry are committed in the signed registration and cannot be
+     * edited — register a replacement key instead. The public API has no
+     * revoke endpoint: a key stops working at its signed `expiry_sec`.
+     */
+    edit(params: EditSessionKeyParams): Promise<SessionKeyResponse>;
+}
+
+/**
+ * A spot asset as the exchange resolves it: `name` is what the wire takes
+ * as `asset_name`, `address` is what signatures commit to, `decimals` is
+ * the underlying ERC-20 scale withdrawal amounts are signed at.
+ */
+interface SpotAssetInfo {
+    name: string;
+    address: string;
+    decimals: number;
+}
+interface InternalSpotTransferParams {
+    /** Sender subaccount. */
+    subaccountId: number;
+    /** Existing destination subaccount; omit (or 0) when creating one via `newSubaccountManager`. */
+    toSubaccountId?: number;
+    /** Set to a manager id to create a new subaccount as the destination instead of `toSubaccountId`. */
+    newSubaccountManager?: number;
+    /** Currency name (e.g. "USDC") or protocol spot-asset address. */
+    asset: string;
+    subId?: number;
+    amount: DecimalLike;
+    /**
+     * Fee cap in USD, default "0": transfers between existing subaccounts
+     * are free. Creating a subaccount charges a transfer fee (1 USD
+     * standard), so raise the cap when `newSubaccountManager` is set.
+     */
+    maxFeeUsd?: DecimalLike;
+    nonce?: string;
+    signatureExpirySec?: number;
+}
+interface ExternalSpotTransferParams {
+    /** Sender subaccount. */
+    subaccountId: number;
+    /** Destination owner wallet. Must be on the sender's whitelist of recipients. */
+    recipient: string;
+    /** Recipient's existing subaccount; omit (or 0) to create one for them via `newSubaccountManager`. */
+    toSubaccountId?: number;
+    /** Manager id for the recipient's new subaccount when `toSubaccountId` is omitted. */
+    newSubaccountManager?: number;
+    /** Currency name (e.g. "USDC") or protocol spot-asset address. */
+    asset: string;
+    subId?: number;
+    amount: DecimalLike;
+    /**
+     * Fee cap in USD. Required: external transfers always charge a transfer
+     * fee (1 USD standard) plus, when a subaccount is created, the
+     * protocol's subaccount-creation fee on top.
+     */
+    maxFeeUsd: DecimalLike;
+    nonce?: string;
+    signatureExpirySec?: number;
+}
+/**
+ * Spot transfers between subaccounts and to other wallets. Position
+ * transfers are not covered here: `private/transfer_positions` takes a
+ * maker and a taker RFQ-style signed quote, i.e. two signatures over the
+ * RFQ leg encoding.
+ */
+declare class SpotTransfersApi {
+    private readonly ctx;
+    constructor(ctx: ClientContext);
+    /**
+     * Moves a spot balance between the owner's OWN subaccounts
+     * (`private/transfer_spot`). Destination is either an existing
+     * `toSubaccountId` or, when `newSubaccountManager` is set, a freshly
+     * created sender-owned subaccount under that manager. For a transfer
+     * to another wallet use `transferExternal`.
+     */
+    transferInternal(params: InternalSpotTransferParams): Promise<PrivateTransferSpotEdgeRpcResponse>;
+    /**
+     * Adds/removes recipient wallets on the owner's external-transfer
+     * whitelist (`private/update_whitelisted_recipients`). The resulting
+     * list is `(current ∪ add) \ remove`. Required before `transferExternal`
+     * can send to a given wallet.
+     */
+    updateWhitelistedRecipients(params: {
+        add?: string[];
+        remove?: string[];
+        nonce?: string;
+        signatureExpirySec?: number;
+    }): Promise<UpdateWhitelistedRecipientsEdgeRpcResponse>;
+    /**
+     * Moves a spot balance to another owner's wallet
+     * (`private/transfer_spot_external`). The recipient must already be on
+     * the sender's whitelist — call `updateWhitelistedRecipients` first;
+     * otherwise the exchange rejects with RPC error 11033 "Transfer
+     * recipient not whitelisted".
+     */
+    transferExternal(params: ExternalSpotTransferParams): Promise<PrivateTransferSpotExternalEdgeRpcResponse>;
+    private signAction;
+}
+
+interface TradeHistoryQuery {
+    subaccountId?: number;
+    instrumentName?: string;
+    orderId?: string;
+    quoteId?: string;
+    /** UTC-millisecond bounds. */
+    fromTimestamp?: number;
+    toTimestamp?: number;
+    page?: number;
+    pageSize?: number;
+}
+/**
+ * Window over a wallet's history. Omit `subaccountId` to query the whole
+ * authenticated wallet; set it to scope to one subaccount.
+ */
+interface WalletHistoryQuery {
+    subaccountId?: number;
+    /** UTC-millisecond bounds. */
+    startTimestamp?: number;
+    endTimestamp?: number;
+}
+interface LiquidatorHistoryQuery {
+    subaccountId: number;
+    /** UTC-millisecond bounds. */
+    startTimestamp?: number;
+    endTimestamp?: number;
+    page?: number;
+    pageSize?: number;
+}
+/** A single simulated perp/option position change for `getMargin`. Amounts are decimal strings. */
+interface SimulatedPositionChange {
+    instrumentName: string;
+    amount: string;
+    /** Perps only; mark price is used when omitted. */
+    entryPrice?: string;
+}
+/** A single simulated collateral (ERC-20) change for `getMargin`. Amount is a decimal string. */
+interface SimulatedCollateralChange {
+    assetName: string;
+    amount: string;
+}
+interface MarginQuery {
+    subaccountId: number;
+    simulatedPositionChanges?: SimulatedPositionChange[];
+    simulatedCollateralChanges?: SimulatedCollateralChange[];
+}
+/** Margin figures before and after the (optionally simulated) trade. All figures are decimal strings. */
+interface MarginResult {
+    is_valid_trade: boolean;
+    post_initial_margin: string;
+    post_maintenance_margin: string;
+    pre_initial_margin: string;
+    pre_maintenance_margin: string;
+    subaccount_id: number;
+}
+/** One liquidator bid within an auction. Amounts/PnL are decimal strings keyed by asset. */
+interface AuctionBidEvent {
+    amounts_liquidated: Record<string, string>;
+    cash_received: string;
+    discount_pnl: string;
+    percent_liquidated: string;
+    positions_realized_pnl: Record<string, string>;
+    positions_realized_pnl_excl_fees: Record<string, string>;
+    realized_pnl: string;
+    realized_pnl_excl_fees: string;
+    timestamp: number;
+    tx_hash: string;
+}
+/** One auction a subaccount was liquidated in, with the bids that filled it. */
+interface AuctionHistory {
+    auction_id: string;
+    auction_type: 'solvent' | 'insolvent';
+    bids: AuctionBidEvent[];
+    /** Auction end, UTC milliseconds; `null` while still live. */
+    end_timestamp: number | null;
+    fee: string;
+    start_timestamp: number;
+    subaccount_id: number;
+    tx_hash: string;
+}
+interface LiquidatorHistoryResult {
+    bids: AuctionBidEvent[];
+    pagination: PaginationInfo;
+}
+/** Subaccount portfolio and history endpoints — authenticated, no signing. */
+declare class SubaccountsApi {
+    private readonly ctx;
+    constructor(ctx: ClientContext);
+    /** Ids of all subaccounts owned by the authenticated wallet. */
+    list(): Promise<number[]>;
+    /**
+     * Full portfolio snapshot: collaterals, positions, open orders, and
+     * the margin figures (there is no separate margin endpoint).
+     */
+    get(subaccountId: number): Promise<PrivateGetSubaccountRPCResponseFor_OrderWireResponseAnd_VaultDepositHoldResponse>;
+    /** Account-level info for the authenticated wallet: fee tiers, subaccount ids, and rate limits. */
+    getAccount(): Promise<PrivateGetAccountEdgeRPCResponse>;
+    /** Full portfolio snapshot for every subaccount owned by the authenticated wallet. */
+    getAllPortfolios(): Promise<PrivateGetSubaccountRPCResponseFor_OrderWireResponseAnd_VaultDepositHoldResponse[]>;
+    /** Open positions for a subaccount. */
+    getPositions(subaccountId: number): Promise<PrivateGetPositionsRPCResponse>;
+    /** Rename a subaccount. */
+    changeLabel(params: {
+        subaccountId: number;
+        label: string;
+    }): Promise<PrivateChangeSubaccountLabelRPCResponse>;
+    /** Filtered and paginated fills; defaults to all of the wallet's subaccounts. */
+    getTradeHistory(query?: TradeHistoryQuery): Promise<PaginatedTradesResult>;
+    /** Realized interest settlements, newest first; defaults to the whole wallet. Capped at 1000 rows. */
+    getInterestHistory(query?: WalletHistoryQuery): Promise<InterestHistoryResult>;
+    /** Internal ERC-20 transfers touching the wallet's subaccounts; defaults to the whole wallet. Capped at 1000 rows. */
+    getErc20TransferHistory(query?: WalletHistoryQuery): Promise<TransferHistoryResult>;
+    /** Settled option positions; defaults to the whole wallet, pass `subaccountId` to scope to one. */
+    getOptionSettlementHistory(query?: {
+        subaccountId?: number;
+    }): Promise<OptionSettlementHistoryResponse>;
+    /**
+     * Margin figures for a subaccount, optionally under simulated position/collateral changes.
+     * Predates the schema, so it is absent from the generated EndpointMap and sent untyped.
+     */
+    getMargin(query: MarginQuery): Promise<MarginResult>;
+    /**
+     * Auctions in which a subaccount (or the whole wallet) was liquidated.
+     * Predates the schema, so it is absent from the generated EndpointMap and sent untyped.
+     */
+    getLiquidationHistory(query?: WalletHistoryQuery): Promise<AuctionHistory[]>;
+    /**
+     * Paginated auctions a subaccount participated in as the liquidator.
+     * Predates the schema, so it is absent from the generated EndpointMap and sent untyped.
+     */
+    getLiquidatorHistory(query: LiquidatorHistoryQuery): Promise<LiquidatorHistoryResult>;
+}
+
+/** Caller overrides for the signed-action envelope. */
+interface VaultActionOverrides {
+    nonce?: string;
+    signatureExpirySec?: number;
+}
+interface VaultDepositRequest extends VaultActionOverrides {
+    /** The user's source subaccount the deposited funds leave (the action is signed on it). */
+    subaccountId: number;
+    vaultSubaccountId: number;
+    /** Must equal the vault's configured deposit asset (protocol spot-asset address). */
+    depositSpotAsset: string;
+    /** Amount of the deposit asset; max 12 decimal places. */
+    amount: DecimalLike;
+}
+interface VaultWithdrawRequest extends VaultActionOverrides {
+    /** The user's destination subaccount that receives the redeemed funds. */
+    subaccountId: number;
+    vaultSubaccountId: number;
+    /** Vault shares to redeem; max 12 decimal places. */
+    sharesToBurn: DecimalLike;
+}
+interface VaultCancelRequest extends VaultActionOverrides {
+    /** Any subaccount the caller owns (the action is signed on it). */
+    subaccountId: number;
+    vaultSubaccountId: number;
+}
+interface CreateVaultRequest extends VaultActionOverrides {
+    /** The curator's funding subaccount the initial deposit is signed from. */
+    subaccountId: number;
+    managerId: number;
+    depositSpotAsset: string;
+    /** Initial deposit in the vault's deposit asset; max 12 decimal places. */
+    initialDeposit: DecimalLike;
+    managementFeeBps: number;
+    performanceFeeBps: number;
+    maxSlippageBps: number;
+    cooldownSec: number;
+    /** Maximum settlement fee authorised, in USD; max 12 decimal places. */
+    maxFeeUsd: DecimalLike;
+    /** Share price the vault is seeded at, in USD; must lie within the protocol's permitted range. */
+    initialSharePriceUsd: DecimalLike;
+    /** Spot asset to denominate the high-water mark in; omit for the feed-less USD default. */
+    benchmarkAsset?: string;
+}
+interface MintVaultSharesRequest extends VaultActionOverrides {
+    /** The vault subaccount the curator signs the approval on. */
+    vaultSubaccountId: number;
+    /** Quoted share price in USD per share; max 12 decimal places. */
+    sharePrice: DecimalLike;
+    /** keccak256 of the user's exact encoded deposit action (0x hex, 32 bytes). */
+    depositHash: string;
+    /** The queued request being settled, as returned by the vault request reads. */
+    requestId: VaultRequestId;
+}
+interface BurnVaultSharesRequest extends VaultActionOverrides {
+    /** The vault subaccount the curator signs the approval on. */
+    vaultSubaccountId: number;
+    /** Quoted share price in USD per share; max 12 decimal places. */
+    sharePrice: DecimalLike;
+    /** keccak256 of the user's exact encoded withdraw action (0x hex, 32 bytes). */
+    withdrawHash: string;
+    /** The queued request being settled, as returned by the vault request reads. */
+    requestId: VaultRequestId;
+}
+interface UpdateVaultInfoRequest {
+    vaultSubaccountId: number;
+    name?: string;
+    description?: string;
+    /** Advisory mark-to-market cap in USD. */
+    mtmCap?: DecimalLike;
+    whitelistOnly?: boolean;
+}
+/** The share-holding side: queued deposit/withdraw intents plus the wallet's vault reads. */
+declare class ShareholderVaultsApi {
+    private readonly ctx;
+    constructor(ctx: ClientContext);
+    /** The vault subaccount ids the wallet holds shares in. */
+    getShareholderVaults(): Promise<VaultIdsWireResponse>;
+    /** The wallet's share balance plus the full vault row for every vault it holds shares in. */
+    getShares(): Promise<VaultSharesWireResponse>;
+    /** The wallet's queued deposit/withdraw intents still awaiting curator settlement. */
+    getLiveRequests(): Promise<MultipleVaultRequestsWireResponse>;
+    /** The wallet's full vault action history (every lifecycle status). */
+    getRequestHistory(options?: {
+        page?: number;
+        pageSize?: number;
+    }): Promise<PaginatedVaultActionsResult>;
+    /**
+     * Queues a deposit into a vault. The curator later mints shares at a
+     * quoted price committed to this exact signed payload; funds are held
+     * from the source subaccount until then (or until cancelled).
+     */
+    requestDeposit(request: VaultDepositRequest): Promise<VaultRequestAckWireResponse>;
+    /** Queues a share redemption; the curator later burns the shares at a quoted price. */
+    requestWithdraw(request: VaultWithdrawRequest): Promise<VaultRequestAckWireResponse>;
+    /** Cancels ALL of the wallet's pending intents for a vault (deposits and withdrawals). */
+    cancelAllRequests(request: VaultCancelRequest): Promise<VaultCancelWireResponse>;
+}
+/**
+ * The curating side — open to any wallet in v3 (curating is not a
+ * privileged role): vault creation, metadata updates, and the settle
+ * approvals that execute queued shareholder intents at a quoted price.
+ */
+declare class CuratorVaultsApi {
+    private readonly ctx;
+    constructor(ctx: ClientContext);
+    /** The vault subaccount ids this wallet curates. */
+    getCuratedVaults(): Promise<VaultIdsWireResponse>;
+    /**
+     * Creates a vault funded from the signer's subaccount; the signer
+     * becomes its curator. Fee rates and max slippage are immutable
+     * afterwards.
+     */
+    createVault(request: CreateVaultRequest): Promise<VaultCreateWireResponse>;
+    /** Settles one queued shareholder deposit, minting shares at the quoted price. */
+    mintShares(request: MintVaultSharesRequest): Promise<VaultSettleWireResponse>;
+    /** Settles one queued shareholder withdrawal, burning shares at the quoted price. */
+    burnShares(request: BurnVaultSharesRequest): Promise<VaultSettleWireResponse>;
+    /** Updates the vault's advisory metadata (unsigned; an ownership check gates it to the curator). */
+    updateInfo(request: UpdateVaultInfoRequest): Promise<OffchainAckWireResponse>;
+    /** The vault's queued deposit intents awaiting a `mintShares` settlement, FIFO-ordered with the queue total. */
+    getLiveMintRequests(vaultSubaccountId: number, limit?: number): Promise<MultipleVaultRequestsWireResponse>;
+    /** The vault's queued withdraw intents awaiting a `burnShares` settlement, FIFO-ordered with the queue total. */
+    getLiveBurnRequests(vaultSubaccountId: number, limit?: number): Promise<MultipleVaultRequestsWireResponse>;
+    /** Rejects a queued deposit intent, releasing the holder's funds without minting shares. */
+    rejectDepositRequest(requestId: VaultRequestId, reason?: string): Promise<VaultRequestAckWireResponse>;
+    /**
+     * Force-exits a holder at mark-to-market with no curator price quote (unsigned;
+     * an ownership check gates it to the curator of `vaultSubaccountId`).
+     */
+    forceBurn(vaultSubaccountId: number, holder: string): Promise<VaultForceBurnWireResponse>;
+}
+/** Vault discovery and stats, plus the role-scoped `shareholder` and `curator` flows. */
+declare class VaultsApi {
+    private readonly ctx;
+    readonly shareholder: ShareholderVaultsApi;
+    readonly curator: CuratorVaultsApi;
+    constructor(ctx: ClientContext);
+    getVault(vaultSubaccountId: number): Promise<VaultWireResponse>;
+    listVaults(options?: {
+        page?: number;
+        pageSize?: number;
+    }): Promise<VaultsWireResponse>;
+    getActionHistory(vaultSubaccountId: number, options?: {
+        eventType?: string;
+        page?: number;
+        pageSize?: number;
+    }): Promise<PaginatedVaultActionsResult2>;
+    getPerformanceHistory(vaultSubaccountId: number, resolution: PerformanceResolution, options?: {
+        from?: number;
+        to?: number;
+        limit?: number;
+    }): Promise<VaultPerformanceHistoryResult>;
+}
+
+interface WithdrawParams {
+    subaccountId: number;
+    /** Currency name (e.g. "USDC") or protocol spot-asset address. */
+    asset: string;
+    /** Amount in human units. Signed at the ERC-20's native decimals — the protocol's only non-e18 amount. */
+    amount: DecimalLike;
+    /**
+     * Guard for the ERC-20's decimals. The exchange scales the signed amount
+     * with its own asset metadata, so a value differing from the exchange's
+     * is rejected client-side rather than producing a doomed signature.
+     */
+    decimals?: number;
+    /** Fee cap in USD. Defaults to the standard withdrawal fee: 1 USD, or 10 USD with `forceBatch`. */
+    maxFeeUsd?: DecimalLike;
+    /**
+     * Guard for the L1 payout address. The exchange always pays out to the
+     * action signer, so any other value is rejected client-side.
+     */
+    recipient?: string;
+    /** Pay the higher fee to have the batch proven immediately. */
+    forceBatch?: boolean;
+    nonce?: string;
+    signatureExpirySec?: number;
+}
+/**
+ * Withdrawals to L1 (`private/withdraw`).
+ *
+ * The exchange reconstructs the signed payload with the payout recipient
+ * fixed to the action signer's address — withdrawals always pay out to
+ * the key that signs them. NOTE: when a session key signs, funds go to
+ * the session key's address, not the owner's.
+ */
+declare class WithdrawalsApi {
+    private readonly ctx;
+    constructor(ctx: ClientContext);
+    /** Builds the signed wire payload shared by `withdraw` and `withdrawDebug`. */
+    private buildWithdrawPayload;
+    withdraw(params: WithdrawParams): Promise<PrivateWithdrawEdgeRpcResponse>;
+    /**
+     * Debug helper: signs the withdrawal exactly like `withdraw` but submits it
+     * to `public/withdraw_debug`, which returns the server-computed encoded data
+     * and action/typed-data hashes instead of executing. Use it to verify your
+     * client-side signing matches the exchange's.
+     */
+    withdrawDebug(params: WithdrawParams): Promise<unknown>;
+    /**
+     * Withdrawal history rows (up to 1000). Scoped to one subaccount when
+     * `subaccountId` is given, otherwise to the whole owner wallet.
+     * Timestamps are unix milliseconds.
+     */
+    getHistory(options?: {
+        subaccountId?: number;
+        startTimestampMs?: number;
+        endTimestampMs?: number;
+    }): Promise<WithdrawalHistoryResult>;
+}
+
+/**
+ * A concrete channel name carrying its notification payload type as a
+ * phantom parameter, so `Subscriptions.subscribe`/`stream` can type the
+ * data without the caller restating it.
+ */
+interface TypedChannel<Data> {
+    name: string;
+    /** Phantom type marker — never present at runtime. */
+    readonly __data?: Data;
+}
+/**
+ * Builds a concrete channel name from a template in the generated
+ * `ChannelSchemaMap`, e.g.
+ * `channel('orderbook.{instrument_name}.{group}.{depth}', { instrument_name: 'ETH-PERP', group: '1', depth: '10' })`
+ * → `orderbook.ETH-PERP.1.10`. Channel address params are always
+ * strings on the wire, so values are stringified even when numeric.
+ * Missing, empty, and unknown params are rejected.
+ */
+declare function channel<T extends ChannelTemplate>(template: T, params: ChannelParamsOf<ChannelSchemaMap[T]>): TypedChannel<ChannelDataOf<ChannelSchemaMap[T]>>;
+
+/** A live channel subscription; `unsubscribe` is idempotent. */
+interface Subscription {
+    channel: string;
+    unsubscribe(): Promise<void>;
+}
+/**
+ * Pub/sub over the websocket transport. Owns notification routing:
+ * every `subscription` message the transport receives is dispatched to
+ * the handlers registered for its channel. The exchange keys
+ * subscriptions to the connection, so the client calls `resubscribeAll`
+ * from its reconnect hook to restore them on a fresh socket.
+ */
+declare class Subscriptions {
+    private readonly ctx;
+    private readonly ws;
+    private readonly handlers;
+    constructor(ctx: ClientContext, ws: WsTransport);
+    /**
+     * Subscribes to a channel and registers `handler` for its
+     * notifications. Multiple handlers share one wire subscription per
+     * channel: the `subscribe` RPC is sent only for the first handler on a
+     * channel, and `unsubscribe` only when the last is removed.
+     */
+    subscribe<D>(ch: TypedChannel<D>, handler: (data: D) => void): Promise<Subscription>;
+    /**
+     * The channel as an async iterator: subscribes on the first `next()`,
+     * buffers notifications the consumer has not yet read (dropping the
+     * oldest beyond `STREAM_BUFFER_LIMIT`), and unsubscribes when the
+     * loop ends (`break` / `return()` / `throw()`).
+     */
+    stream<D>(ch: TypedChannel<D>): AsyncIterableIterator<D>;
+    /** Re-sends `subscribe` for every active channel; the client calls this after a websocket reconnect. */
+    resubscribeAll(): Promise<void>;
+    /**
+     * `subscribe`/`unsubscribe` exist only over the websocket, so they go
+     * straight to the ws transport (never the client's HTTP fallback). A
+     * per-channel `status` other than 'ok'/'already subscribed' throws.
+     */
+    private sendChannelRpc;
+    private dispatch;
+}
+
+interface HttpTransportOptions {
+    baseUrl: string;
+    timeoutMs: number;
+    logger: Logger;
+    /** Produces auth headers for private methods; absent for public-only clients. */
+    authHeaders?: () => Promise<Record<string, string>>;
+}
+/**
+ * REST transport: each method is POSTed to `<baseUrl>/<method>` with the
+ * params object as the JSON body; the response body is the JSON-RPC
+ * response envelope. Private methods carry signed auth headers.
+ */
+declare class HttpTransport {
+    private readonly options;
+    constructor(options: HttpTransportOptions);
+    send<M extends RpcMethod>(method: M, params: ParamsOf<M>): Promise<ResultFor<M>>;
+}
+
+declare class DeriveClient {
+    readonly network: NetworkConfig;
+    readonly ws: WsTransport;
+    readonly http: HttpTransport;
+    readonly marketData: MarketDataApi;
+    readonly subaccounts: SubaccountsApi;
+    readonly orders: OrdersApi;
+    readonly rfq: RfqApi;
+    readonly spotTransfers: SpotTransfersApi;
+    readonly positionTransfers: PositionTransfersApi;
+    readonly withdrawals: WithdrawalsApi;
+    readonly deposits: DepositsApi;
+    readonly vaults: VaultsApi;
+    readonly sessionKeys: SessionKeysApi;
+    readonly subscriptions: Subscriptions;
+    readonly logger: Logger;
+    private readonly owner?;
+    private readonly sessionKey?;
+    private readonly accountOwner?;
+    private loggedIn;
+    constructor(options: DeriveClientOptions);
+    /**
+     * The identity requests act as: the owner address plus whichever
+     * wallet signs (session key when configured, otherwise the owner).
+     */
+    credentials(): AuthCredentials;
+    /** Opens the websocket. REST-only usage can skip this. */
+    connect(): Promise<void>;
+    /**
+     * Authenticates the websocket connection (REST requests instead carry
+     * signed headers per request). Re-runs automatically after reconnects.
+     */
+    login(): Promise<ResultFor<'public/login'>>;
+    close(): Promise<void>;
+    /**
+     * Typed escape hatch for any public RPC method: uses the websocket
+     * when connected, REST otherwise.
+     */
+    send<M extends RpcMethod>(method: M, params: ParamsOf<M>): Promise<ResultFor<M>>;
+}
+
+/**
+ * Network presets for the v3 API. chainId + contracts.matching are the
+ * inputs to the computed EIP-712 domain separator; the values here
+ * reproduce the separators the deployed contracts accept (unit-tested in
+ * test/unit/eip712.test.ts).
+ *
+ * The EIP-712 domain separator is computed from `chainId` and the
+ * constant Matching verifying contract (signing/eip712.ts).
+ */
+declare const NETWORKS: Record<NetworkName, NetworkConfig>;
+declare function resolveNetwork(network: NetworkName | NetworkConfig): NetworkConfig;
+
+/** An error response returned by the exchange for a JSON-RPC request. */
+declare class DeriveRpcError extends Error {
+    readonly code: number;
+    readonly data: unknown;
+    readonly method: string;
+    constructor(method: string, error: {
+        code: number;
+        message: string;
+        data?: unknown;
+    });
+}
+/** A request that received no response within the transport timeout, or was in flight when the connection dropped. */
+declare class DeriveTimeoutError extends Error {
+    constructor(message: string);
+}
+/** A websocket connection failure (initial connect or reconnect exhaustion). */
+declare class DeriveConnectionError extends Error {
+    constructor(message: string, options?: {
+        cause?: unknown;
+    });
+}
+
+interface ActionFields {
+    subaccountId: number | bigint;
+    /** UTC-nanosecond timestamp as a decimal string; see `randomNonce()`. */
+    nonce: string;
+    /** Address of the protocol module that verifies this action. */
+    module: string;
+    /** ABI-encoded action payload produced by one of the codecs. */
+    data: string;
+    /** Unix-seconds signature expiry. */
+    expirySec: number;
+    owner: string;
+    signer: string;
+}
+/**
+ * The signed-action envelope shared by every protocol operation
+ * (orders, transfers, withdrawals, RFQs, session keys, vault actions).
+ *
+ * The digest is
+ * keccak256(0x1901 ‖ domainSeparator ‖ structHash) where structHash
+ * commits to ACTION_TYPEHASH, the envelope fields, and keccak256(data).
+ * The domain separator comes from `domainSeparator(network)`.
+ */
+declare class SignedAction {
+    readonly fields: Readonly<ActionFields>;
+    private readonly domainSeparator;
+    signature?: string;
+    constructor(fields: ActionFields, domainSeparator: string);
+    actionHash(): string;
+    digest(): string;
+    /**
+     * Signs the digest with a raw signing key. The wallet must be the
+     * declared `signer` (the owner itself, or a registered session key).
+     */
+    sign(wallet: BaseWallet): this;
+}
+
+/**
+ * keccak256("Action(uint256 subaccountId,uint256 nonce,address module,bytes data,uint256 expiry,address owner,address signer)").
+ * Chain-independent protocol constant.
+ */
+declare const ACTION_TYPEHASH = "0x4d7a9f27c403ff9c0f19bce61d76d82f9aa29f8d6d4b0c5474607d9770d1af17";
+/**
+ * The EIP-712 domain separator actions sign under — a standard 4-field
+ * `EIP712Domain` (name "Matching", version "1.0", no salt) computed from
+ * the network's chain id and the constant Matching verifying contract.
+ */
+declare function domainSeparator(network: Pick<NetworkConfig, 'chainId'>): string;
+
+/**
+ * Canonical EIP-712 action module addresses. Every signed action's
+ * `module` field commits to one of these — the same set on every
+ * network (mainnet, testnet, local).
+ */
+declare const V3_MODULE_ADDRESSES: {
+    readonly trade: "0xB8D20c2B7a1Ad2EE33Bc50eF10876eD3035b5e7b";
+    readonly transfer: "0x01259207A40925b794C8ac320456F7F6c8FE2636";
+    readonly withdrawal: "0x9d0E8f5b25384C7310CB8C6aE32C8fbeb645d083";
+    readonly rfq: "0x9371352CCef6f5b36EfDFE90942fFE622Ab77F1D";
+    readonly externalTransfer: "0x8F9B8f12ddA05FB1F0DDDDe8f5af8cECF54f8aC9";
+    readonly whitelistedRecipient: "0xB86D6DE1b76c9839e4BA860848CD98A1dABd6B54";
+    readonly vault: "0x2885c174ebf5524aED9c721d60c12b1537685186";
+    readonly liquidation: "0x66d23e59DaEEF13904eFA2D4B8658aeD05f59a92";
+    readonly createSessionKey: "0xe330CF64ff6EbF41699aad344Cb21d78db1D2bb6";
+};
+
+export { ACTION_TYPEHASH, type ActionFields, type AuthCredentials, type AuthSigner, type BurnVaultSharesRequest, ChannelSchemaMap, ChannelTemplate, type ClientContext, type ContractAddresses, ContractCallDeposits, type CreateSessionKeyParams, type CreateVaultRequest, CuratorVaultsApi, DecimalLike, DepositAddressDeposits, DepositsApi, DeriveClient, type DeriveClientOptions, DeriveConnectionError, DeriveRpcError, DeriveTimeoutError, type ExecuteQuoteParams, type ExternalSpotTransferParams, type InternalSpotTransferParams, type Logger, MarketDataApi, type MintVaultSharesRequest, type ModuleAddresses, NETWORKS, type NetworkConfig, type NetworkName, OffchainScope, OrdersApi, ParamsOf, type PlaceOrderParams, type PositionTransferLeg, PositionTransfersApi, type PricedRfqLeg, ProtocolScopeCode, ResultFor, RfqApi, type RfqLeg, RpcMethod, SDK_VERSION, type SendQuoteParams, SessionKeysApi, ShareholderVaultsApi, SignedAction, type SpotAssetInfo, SpotTransfersApi, SubaccountsApi, type Subscription, Subscriptions, type TransferPositionsParams, type TypedChannel, type UpdateVaultInfoRequest, V3_MODULE_ADDRESSES, type VaultCancelRequest, type VaultDepositRequest, type VaultWithdrawRequest, VaultsApi, type WebSocketFactory, type WebSocketLike, WithdrawalsApi, authHeaders, channel, domainSeparator, loginParams, resolveNetwork };