@domfi/sdk 0.1.0

package/dist/types-DJBX-p4X.d.cts

@@ -0,0 +1,780 @@
+import * as viem from 'viem';
+import { DiagnosticsEnvelope } from '@domfi/sdk/errors';
+import { R as ReadOptions, k as OrderLifecycle, l as RemoveCollateralTracking, m as AccountTrade, O as OpenAccountPosition, V as VerifiedPositionRef, a as ReceiptVerifiedOpenTriggerOrderRef, b as VerifiedOpenTriggerOrderRef } from './types-DQft82W7.cjs';
+import { Address, Hex, ClosePercent, Collateral, Leverage, UsdP6, Price, UnsignedP18, SlippagePercent, WholePercent, TradeId, PairIndex, DecimalInput, OrderId } from './units.cjs';
+import { ReferralCodeIdInput } from './referrals.cjs';
+
+/** Trader account whose delegated permissions should be used for a transaction. */
+type DelegationTarget = {
+    trader: Address;
+};
+/** Read controls for delegation helpers. */
+type DelegationReadOptions = Pick<ReadOptions, "signal" | "timeoutMs"> & {
+    readinessPolicy?: never;
+};
+/** Read controls for delegation typed-data generation. */
+type DelegationTypedDataOptions = DelegationReadOptions;
+/** Send controls for delegation transactions. */
+type DelegationSendOptions = Pick<SendOptions, "account" | "gas" | "nonce" | "maxFeePerGas" | "signal"> & {
+    readinessPolicy?: never;
+    timeoutMs?: never;
+    maxOracleFeeWei?: never;
+    skipApprovalCheck?: never;
+    delegation?: never;
+    trader?: never;
+};
+/** Parameters used to build or sign DomFi delegation EIP-712 typed data. */
+type DelegationTypedDataParams = {
+    delegator: Address;
+    delegate: Address;
+    /** Unix timestamp in seconds, matching DomfiTrading's block.timestamp comparison. */
+    expiry: bigint;
+    nonce?: bigint;
+};
+/** DomFi delegation EIP-712 payload for wallet signing. */
+type DelegationTypedData = {
+    domain: {
+        name: "Domination Finance";
+        version: "1";
+        chainId: number;
+        verifyingContract: Address;
+    };
+    primaryType: "Delegation";
+    types: {
+        Delegation: readonly [
+            {
+                readonly name: "delegator";
+                readonly type: "address";
+            },
+            {
+                readonly name: "delegate";
+                readonly type: "address";
+            },
+            {
+                readonly name: "nonce";
+                readonly type: "uint256";
+            },
+            {
+                readonly name: "expiry";
+                readonly type: "uint256";
+            }
+        ];
+    };
+    message: {
+        delegator: Address;
+        delegate: Address;
+        nonce: bigint;
+        expiry: bigint;
+    };
+};
+/** Signed delegation payload accepted by `setDelegateWithSignature`. */
+type SignedDelegation = {
+    delegator: Address;
+    delegate: Address;
+    nonce: bigint;
+    /** Unix timestamp in seconds, matching DomfiTrading's block.timestamp comparison. */
+    expiry: bigint;
+    signature: Hex;
+};
+/** Onchain delegation client for approving a secondary trading wallet. */
+type DelegationClient = {
+    /** Reads the active delegate for a trader, if one is set. */
+    getDelegate(trader: Address, opts?: DelegationReadOptions): Promise<Address | undefined>;
+    /** Checks whether `delegate` is currently authorized for `trader`. */
+    isDelegateFor(trader: Address, delegate: Address, opts?: DelegationReadOptions): Promise<boolean>;
+    /** Reads the current delegation nonce for a trader. */
+    getNonce(trader: Address, opts?: DelegationReadOptions): Promise<bigint>;
+    /** Sends a transaction from the trader to set `delegate` as authorized. */
+    setDelegate(delegate: Address, opts?: DelegationSendOptions): Promise<ReceiptOnlyHandle>;
+    /** Sends a transaction from the trader to remove the active delegate. */
+    removeDelegate(opts?: DelegationSendOptions): Promise<ReceiptOnlyHandle>;
+    /** Builds the EIP-712 typed data for an offchain delegation signature. */
+    typedData(params: DelegationTypedDataParams, opts?: DelegationTypedDataOptions): Promise<DelegationTypedData>;
+    /** Signs a delegation payload with the provided or SDK-configured wallet client. */
+    sign(params: DelegationTypedDataParams, walletClient?: WalletClient, opts?: DelegationTypedDataOptions): Promise<SignedDelegation>;
+    /** Sends a signed delegation payload onchain. */
+    setDelegateWithSignature(signed: SignedDelegation, opts?: DelegationSendOptions): Promise<ReceiptOnlyHandle>;
+};
+
+/** Result returned by a client-side trading constraint check. */
+type ConstraintCheckResult = {
+    status: "ok";
+    code: string;
+    message?: string;
+} | {
+    status: "violation";
+    code: string;
+    message: string;
+    severity: "warning" | "error";
+} | {
+    status: "unchecked";
+    code: string;
+    reason: string;
+    message?: string;
+};
+/** Inputs for checking market min/max leverage bounds. */
+type CheckLeverageBoundsInput = {
+    leverage: Leverage;
+    minLeverage: Leverage;
+    maxLeverage: Leverage;
+};
+/** Inputs for checking a market minimum position size. */
+type CheckMinimumPositionSizeInput = {
+    notionalUsd: UsdP6;
+    minPositionSize: Collateral;
+};
+/** Inputs for checking max allowed collateral. */
+type CheckMaxCollateralInput = {
+    collateral: Collateral;
+    maxAllowedCollateral: Collateral;
+};
+/** Inputs for checking whether a new order would exceed open-interest caps. */
+type CheckOiCapInput = {
+    price: Price;
+    currentSideOi: UnsignedP18;
+    requestedNotional: UsdP6;
+    oiCap: UsdP6;
+};
+/** Inputs for checking market group collateral caps. */
+type CheckGroupCollateralCapInput = {
+    requestedCollateral: Collateral;
+    groupMaxCollateral: Collateral;
+    currentGroupCollateral?: Collateral;
+};
+/** Inputs for checking market slippage bounds. */
+type CheckSlippageBoundsInput = {
+    slippage: SlippagePercent;
+    maxSlP: WholePercent;
+};
+/** Inputs for checking close percentage bounds. */
+type CheckClosePercentBoundsInput = {
+    closePercent: ClosePercent;
+};
+/** Checks whether leverage is within a market's min/max leverage bounds. */
+declare function checkLeverageBounds(input: CheckLeverageBoundsInput): ConstraintCheckResult;
+/** Checks whether notional value satisfies a market's minimum position size. */
+declare function checkMinimumPositionSize(input: CheckMinimumPositionSizeInput): ConstraintCheckResult;
+/** Checks whether collateral is at or below a market's maximum collateral limit. */
+declare function checkMaxCollateral(input: CheckMaxCollateralInput): ConstraintCheckResult;
+/** Checks whether requested notional would exceed side open-interest capacity. */
+declare function checkOiCap(input: CheckOiCapInput): ConstraintCheckResult;
+/** Checks whether requested collateral would exceed a market group's collateral cap. */
+declare function checkGroupCollateralCap(input: CheckGroupCollateralCapInput): ConstraintCheckResult;
+/** Checks whether slippage is within a market's maximum slippage percentage. */
+declare function checkSlippageBounds(input: CheckSlippageBoundsInput): ConstraintCheckResult;
+/** Validates close-percent raw bounds through the `ClosePercent` codec. */
+declare function checkClosePercentBounds(input: CheckClosePercentBoundsInput): ConstraintCheckResult;
+
+/** viem public client type accepted by the SDK. */
+type PublicClient = viem.PublicClient;
+/** viem wallet client type accepted by the SDK. */
+type WalletClient = viem.WalletClient;
+/** viem transaction receipt returned by wait helpers. */
+type TransactionReceipt = viem.TransactionReceipt;
+/** Onchain trading operation name used by prepared transaction and receipt helpers. */
+type TradingVerb = "openMarket" | "openLimit" | "openStop" | "closeMarket" | "updateTakeProfit" | "updateStopLoss" | "topUpCollateral" | "removeCollateral" | "updateOpenLimitOrder" | "cancelOpenLimitOrder" | "handleTradeMarketTimeout";
+/** Position direction for open trades. */
+type TradeDirection = "long" | "short";
+/** Runtime constants for trade direction values. */
+declare const TradeDirection: {
+    readonly Long: "long";
+    readonly Short: "short";
+};
+/** Order kind accepted by open-trade parameters. */
+type TradeOrderKind = "market" | "limit" | "stop";
+/** Normalized order kind used by trading reads and helpers. */
+type OrderKind = TradeOrderKind | "remove_collateral";
+/** Runtime constants for normalized order kind values. */
+declare const OrderKind: {
+    readonly Market: "market";
+    readonly Limit: "limit";
+    readonly Stop: "stop";
+    readonly RemoveCollateral: "remove_collateral";
+};
+/** Price input accepted by low-level trading helpers. */
+type PriceInput = Price | DecimalInput;
+/** Shared parameters for all open-trade variants. */
+type OpenTradeBaseParams = {
+    pairIndex: PairIndex;
+    direction: TradeDirection;
+    collateral: Collateral | DecimalInput;
+    leverage: Leverage | DecimalInput;
+    takeProfit?: Price | DecimalInput;
+    stopLoss?: Price | DecimalInput;
+    referralCodeId?: ReferralCodeIdInput;
+};
+/** Market-open trade parameters. */
+type OpenMarketParams = OpenTradeBaseParams & {
+    orderKind: "market";
+    slippage: SlippagePercent;
+    wantedPrice?: Price | DecimalInput;
+    entryPrice?: never;
+    triggerPrice?: never;
+};
+/** Limit-order open parameters. */
+type OpenLimitParams = OpenTradeBaseParams & {
+    orderKind: "limit";
+    entryPrice: Price | DecimalInput;
+    executionSlippage?: never;
+    slippage?: never;
+    wantedPrice?: never;
+    triggerPrice?: never;
+};
+/** Stop-order open parameters. */
+type OpenStopParams = OpenTradeBaseParams & {
+    orderKind: "stop";
+    triggerPrice: Price | DecimalInput;
+    executionSlippage?: never;
+    slippage?: never;
+    wantedPrice?: never;
+    entryPrice?: never;
+};
+/** Union of all open-trade parameter shapes, discriminated by `orderKind`. */
+type OpenTradeParams = OpenMarketParams | OpenLimitParams | OpenStopParams;
+/** Market-close parameters. */
+type ClosePositionParams = {
+    closePercent?: ClosePercent;
+    slippage: SlippagePercent;
+    wantedPrice?: Price | DecimalInput;
+};
+/** Sentinel value that clears an existing take-profit or stop-loss trigger. */
+type ClearTriggerValue = {
+    clear: true;
+};
+/** Trigger update value, either a concrete price or `{ clear: true }`. */
+type TriggerValueInput = Price | DecimalInput | ClearTriggerValue;
+/** Take-profit update parameters. */
+type UpdateTakeProfitParams = {
+    takeProfit: TriggerValueInput;
+};
+/** Stop-loss update parameters. */
+type UpdateStopLossParams = {
+    stopLoss: TriggerValueInput;
+};
+/** Collateral top-up parameters. */
+type TopUpCollateralParams = {
+    collateral: Collateral | DecimalInput;
+};
+/** Collateral removal parameters. */
+type RemoveCollateralParams = {
+    collateral: Collateral | DecimalInput;
+};
+/** Limit/stop trigger-order update parameters. */
+type UpdateOpenTriggerOrderParams = {
+    targetPrice: Price | DecimalInput;
+    takeProfit?: TriggerValueInput;
+    stopLoss?: TriggerValueInput;
+};
+/** Options for direct, non-delegated transaction preparation. */
+interface DirectPrepareOptions extends ReadOptions {
+    account?: Address;
+    delegation?: never;
+}
+/** Options for delegated transaction preparation. */
+interface DelegatedPrepareOptions extends ReadOptions {
+    account?: Address;
+    delegation: DelegationTarget;
+}
+/** Preparation options for direct or delegated trading transactions. */
+type PrepareOptions = DirectPrepareOptions | DelegatedPrepareOptions;
+/** Simulation options for prepared trading transactions. */
+type SimulateOptions = ReadOptions & {
+    account?: Address;
+    maxOracleFeeWei?: bigint;
+};
+/** Send options for trading transactions. */
+type SendOptions = ReadOptions & {
+    account?: Address;
+    maxOracleFeeWei?: bigint;
+    gas?: bigint;
+    nonce?: number;
+    maxFeePerGas?: bigint;
+    skipApprovalCheck?: boolean;
+};
+/** Direct timeout-handler options. */
+type DirectMarketTimeoutOptions = SendOptions & {
+    delegation?: never;
+};
+/** Delegated timeout-handler options. */
+type DelegatedMarketTimeoutOptions = SendOptions & {
+    delegation: DelegationTarget;
+};
+/** Options for handling a timed-out market order. */
+type MarketTimeoutOptions = DirectMarketTimeoutOptions | DelegatedMarketTimeoutOptions;
+/** Send options for closing a position. */
+type ClosePositionOptions = SendOptions;
+/** Controls for waiting on transaction receipts. */
+type WaitReceiptOptions = ReadOptions & {
+    confirmations?: number;
+    /**
+     * Receipt polling interval in milliseconds. Defaults to half the chain
+     * profile's `blockTimeMs` (1s on Base), falling back to 1s.
+     *
+     * Best-effort hint: concurrent waits on the same handle share one underlying
+     * wait per confirmation count, and the first caller's interval wins.
+     */
+    pollingIntervalMs?: number;
+};
+/** REST/API tracking options for an order. */
+type TrackOrderOptions = ReadOptions & {
+    /**
+     * Expected trader wallet for the order being tracked. When set, tracking
+     * returns `identity_mismatch` if the indexed order belongs to another wallet.
+     * This does not select the RPC sender.
+     */
+    account?: Address;
+    intervalMs?: number;
+    maxAttempts?: number;
+    maxDurationMs?: number;
+    expectedTradeId?: TradeId;
+};
+/** Direct transaction recovery options. */
+interface DirectRecoverTransactionOptions extends WaitReceiptOptions {
+    verb?: TradingVerb;
+    account?: Address;
+    delegation?: never;
+    pairIndex?: PairIndex;
+    initiatedTradeId?: TradeId;
+    terminalTradeId?: TradeId;
+}
+/** Delegated transaction recovery options. */
+interface DelegatedRecoverTransactionOptions extends WaitReceiptOptions {
+    verb?: TradingVerb;
+    account?: never;
+    delegation: DelegationTarget;
+    pairIndex?: PairIndex;
+    initiatedTradeId?: TradeId;
+    terminalTradeId?: TradeId;
+}
+/** Options for recovering a transaction into an SDK handle. */
+type RecoverTransactionOptions = DirectRecoverTransactionOptions | DelegatedRecoverTransactionOptions;
+/** Options for tracking a transaction through receipt recovery and REST order polling. */
+type ReceiptBackedTrackOptions = TrackOrderOptions & RecoverTransactionOptions;
+/** ERC-20 approval state needed before a trading transaction can be sent. */
+type ApprovalNeed = {
+    owner: Address;
+    token: Address;
+    spender: Address;
+    currentAllowance: Collateral;
+    requiredAllowance: Collateral;
+    action: "none" | "approve";
+};
+/** Non-fatal preflight warning produced while preparing a trading transaction. */
+type PreflightWarning = {
+    code: string;
+    message: string;
+    severity: "info" | "warning" | "error";
+};
+/** Computed or externally sourced estimate returned by preflight. */
+type ComputedEstimate<T> = {
+    value: T;
+    source: "computed" | "api" | "rpc";
+    parityTarget?: string;
+};
+
+/** Normalized action subset used by trading preflight reports. */
+type NormalizedActionParams = {
+    kind: "openMarket";
+    params: OpenMarketParams;
+} | {
+    kind: "closePosition";
+    params: ClosePositionParams;
+} | {
+    kind: "removeCollateral";
+    params: RemoveCollateralParams;
+};
+/** Summary of a prepared trading transaction before simulation or send. */
+type PreflightReport = {
+    normalizedParams?: NormalizedActionParams;
+    approvals: ApprovalNeed[];
+    oracleFeeWei?: bigint;
+    maxOracleFeeWei?: bigint;
+    executionPriceBounds?: {
+        min?: Price;
+        max?: Price;
+    };
+    estimatedLiquidationPrice?: Price;
+    estimatedOpeningFee?: ComputedEstimate<Collateral>;
+    estimatedClosingFee?: ComputedEstimate<Collateral>;
+    resultingLeverage?: ComputedEstimate<Leverage>;
+    checks?: ConstraintCheckResult[];
+    warnings: PreflightWarning[];
+};
+/** Simulation result for a prepared trading transaction. */
+type SimResult = {
+    request: {
+        to: Address;
+        data: Hex;
+        value?: bigint;
+        account: Address;
+    };
+    gas?: bigint;
+    result?: unknown;
+    warnings: PreflightWarning[];
+};
+/** Handle for transactions whose terminal state is the transaction receipt itself. */
+type ReceiptOnlyHandle = {
+    kind: "receipt";
+    hash: Hex;
+    /**
+     * @throws TimeoutError when receipt polling exceeds the configured timeout.
+     * @throws AbortError when the caller-provided signal aborts the wait.
+     * @throws TransportError for RPC transport failures.
+     */
+    waitReceipt(opts?: WaitReceiptOptions): Promise<TransactionReceipt>;
+};
+/** Handle for open limit/stop placement transactions that can recover a verified order ref. */
+type TriggerPlacementHandle = {
+    kind: "trigger_order";
+    hash: Hex;
+    /**
+     * @throws TimeoutError when receipt polling exceeds the configured timeout.
+     * @throws AbortError when the caller-provided signal aborts the wait.
+     * @throws TransportError for RPC transport failures.
+     */
+    waitReceipt(opts?: WaitReceiptOptions): Promise<TransactionReceipt>;
+    /**
+     * @throws ValidationError when receipt logs do not contain a valid trigger placement identity.
+     * @throws TimeoutError or AbortError from receipt waiting.
+     */
+    verifiedRef(opts?: WaitReceiptOptions): Promise<ReceiptVerifiedOpenTriggerOrderRef>;
+};
+/** RPC-only handle for async market orders where REST tracking is unavailable. */
+type AsyncOrderHandleNoApi = {
+    kind: "async_order";
+    verb: "openMarket" | "closeMarket" | "removeCollateral";
+    hash: Hex;
+    /**
+     * @throws TimeoutError when receipt polling exceeds the configured timeout.
+     * @throws AbortError when the caller-provided signal aborts the wait.
+     * @throws TransportError for RPC transport failures.
+     */
+    waitReceipt(opts?: WaitReceiptOptions): Promise<TransactionReceipt>;
+    /**
+     * @throws ValidationError when the receipt cannot be mapped to an order id.
+     * @throws TimeoutError or AbortError from receipt waiting.
+     */
+    orderId(opts?: WaitReceiptOptions): Promise<OrderId>;
+};
+/** Order fields shared by REST-backed tracking results. */
+type TrackResultOrderFields = {
+    order: OrderLifecycle;
+    removeCollateral?: RemoveCollateralTracking;
+    diagnostics?: DiagnosticsEnvelope;
+};
+/** Open position returned after tracking an executed open-market order. */
+type OpenedPositionResult = OpenAccountPosition & {
+    verifiedRef: VerifiedPositionRef;
+};
+/** Terminal or intermediate tracking result for a market order. */
+type TrackResult = ({
+    status: "pending_execution";
+} & TrackResultOrderFields) | ({
+    status: "executed";
+    trade?: AccountTrade;
+    openedPosition?: OpenedPositionResult;
+    positionRef?: VerifiedPositionRef;
+} & TrackResultOrderFields) | ({
+    status: "canceled";
+    reason?: number;
+} & TrackResultOrderFields) | ({
+    status: "timeout_available";
+    canHandleTimeout: boolean;
+} & TrackResultOrderFields) | ({
+    status: "timed_out";
+} & TrackResultOrderFields) | ({
+    status: "identity_mismatch";
+    expectedTradeId?: TradeId;
+    actualTradeId?: TradeId;
+    expectedPairIndex?: PairIndex;
+    actualPairIndex?: PairIndex;
+    expectedWallet?: Address;
+    actualWallet?: Address;
+} & TrackResultOrderFields) | {
+    status: "unknown";
+    order?: OrderLifecycle;
+    removeCollateral?: RemoveCollateralTracking;
+    diagnostics?: DiagnosticsEnvelope;
+};
+/** Phases emitted while watching a transaction/order lifecycle. */
+type LifecyclePhase = "submitted" | "mined" | "indexed" | "tracking" | "terminal" | "unknown";
+/** Lifecycle state emitted by `AsyncOrderHandle.watch`. */
+type LifecycleState = {
+    phase: "submitted";
+    hash: Hex;
+} | {
+    phase: "mined";
+    hash: Hex;
+    receipt: TransactionReceipt;
+} | {
+    phase: "indexed";
+    hash: Hex;
+    orderId: OrderId;
+} | {
+    phase: "tracking";
+    hash: Hex;
+    orderId: OrderId;
+    result: TrackResult;
+} | {
+    phase: "terminal";
+    hash: Hex;
+    orderId: OrderId;
+    result: TrackResult;
+} | {
+    phase: "unknown";
+    hash: Hex;
+    orderId?: OrderId;
+    result?: TrackResult;
+};
+/** REST-backed async order handle with tracking and lifecycle watching. */
+type AsyncOrderHandle = AsyncOrderHandleNoApi & {
+    /**
+     * @throws ReadModelNotReadyError when strict readiness rejects order tracking reads.
+     * @throws ValidationError for invalid tracking options or inconsistent transaction identity.
+     * @throws TimeoutError or AbortError when polling is timed out or aborted.
+     * @throws ApiError or TransportError for read/transport failures.
+     */
+    track(opts?: ReceiptBackedTrackOptions): Promise<TrackResult>;
+    /**
+     * @throws ReadModelNotReadyError, ValidationError, TimeoutError, AbortError, ApiError, or TransportError from transaction tracking.
+     */
+    waitTerminal(opts?: ReceiptBackedTrackOptions): Promise<TrackResult>;
+    /**
+     * @throws ValidationError for invalid watch options.
+     */
+    watch(opts?: ReceiptBackedTrackOptions): AsyncIterable<LifecycleState>;
+};
+/** Any transaction handle returned by an API-enabled trading client. */
+type TxHandle = AsyncOrderHandle | TriggerPlacementHandle | ReceiptOnlyHandle;
+/** Any transaction handle returned by an RPC-only trading client. */
+type TxHandleNoApi = AsyncOrderHandleNoApi | TriggerPlacementHandle | ReceiptOnlyHandle;
+/** Transaction handle returned for a specific trading verb on API-enabled clients. */
+type TxHandleForVerb<Verb extends TradingVerb> = Verb extends "openMarket" | "closeMarket" | "removeCollateral" ? AsyncOrderHandle : Verb extends "openLimit" | "openStop" ? TriggerPlacementHandle : ReceiptOnlyHandle;
+/** Transaction handle returned for a specific trading verb on RPC-only clients. */
+type TxHandleForVerbNoApi<Verb extends TradingVerb> = Verb extends "openMarket" | "closeMarket" | "removeCollateral" ? AsyncOrderHandleNoApi : Verb extends "openLimit" | "openStop" ? TriggerPlacementHandle : ReceiptOnlyHandle;
+/** Prepared trading transaction that can be summarized, simulated, or sent. */
+type PreparedTradingTx<Verb extends TradingVerb> = {
+    verb: Verb;
+    to: Address;
+    data: Hex;
+    value?: bigint;
+    preparedAccount?: Address;
+    estimatedOracleFeeWei?: bigint;
+    requiredApprovals: {
+        status: "checked";
+        approvals: ApprovalNeed[];
+    } | {
+        status: "unchecked";
+    };
+    /**
+     * Returns the preflight summary for this prepared transaction.
+     *
+     * @throws ValidationError when prepared transaction parameters cannot be summarized.
+     */
+    summary(): Promise<PreflightReport>;
+    /**
+     * Simulates the prepared transaction.
+     *
+     * @throws ValidationError, MissingPublicClientError, TimeoutError, AbortError, OracleFeeCapExceededError, ContractRevertError, or TransportError during simulation.
+     */
+    simulate(opts?: SimulateOptions): Promise<SimResult>;
+    /**
+     * Sends the prepared transaction with the SDK-configured wallet client.
+     *
+     * @throws ValidationError, MissingWalletClientError, MissingPublicClientError, TimeoutError, AbortError, ContractRevertError, or wallet/transport SDK errors.
+     */
+    send(opts?: SendOptions): Promise<TxHandleForVerb<Verb>>;
+    /**
+     * Sends the prepared transaction with an explicit wallet client.
+     *
+     * @throws ValidationError, MissingWalletClientError, MissingPublicClientError, TimeoutError, AbortError, ContractRevertError, or wallet/transport SDK errors.
+     */
+    send(walletClient: WalletClient, opts?: SendOptions): Promise<TxHandleForVerb<Verb>>;
+};
+/** Prepared trading transaction returned by RPC-only clients. */
+type PreparedTradingTxNoApi<Verb extends TradingVerb> = Omit<PreparedTradingTx<Verb>, "send"> & {
+    /**
+     * Sends the prepared transaction with the SDK-configured wallet client.
+     *
+     * @throws ValidationError, MissingWalletClientError, MissingPublicClientError, TimeoutError, AbortError, ContractRevertError, or wallet/transport SDK errors.
+     */
+    send(opts?: SendOptions): Promise<TxHandleForVerbNoApi<Verb>>;
+    /**
+     * Sends the prepared transaction with an explicit wallet client.
+     *
+     * @throws ValidationError, MissingWalletClientError, MissingPublicClientError, TimeoutError, AbortError, ContractRevertError, or wallet/transport SDK errors.
+     */
+    send(walletClient: WalletClient, opts?: SendOptions): Promise<TxHandleForVerbNoApi<Verb>>;
+};
+/** Order identity needed to call the market-timeout handler. */
+type TrackableMarketOrderRef = {
+    orderId: OrderId;
+    wallet: Address;
+    pairIndex: PairIndex;
+    expectedTradeId?: TradeId;
+    initiatedTxHash?: Hex;
+};
+/** Full trading client with transaction preparation, sending, and REST-backed tracking. */
+type TradingClient = {
+    /**
+     * Prepares a market-open transaction.
+     *
+     * @throws ValidationError, ReadModelNotReadyError, TimeoutError, AbortError, or transport/wallet SDK errors during preflight reads.
+     */
+    prepareOpenTrade(params: OpenMarketParams, opts?: PrepareOptions): Promise<PreparedTradingTx<"openMarket">>;
+    /**
+     * Prepares a limit-open order placement transaction.
+     *
+     * @throws ValidationError, ReadModelNotReadyError, TimeoutError, AbortError, or transport/wallet SDK errors during preflight reads.
+     */
+    prepareOpenTrade(params: OpenLimitParams, opts?: PrepareOptions): Promise<PreparedTradingTx<"openLimit">>;
+    /**
+     * Prepares a stop-open order placement transaction.
+     *
+     * @throws ValidationError, ReadModelNotReadyError, TimeoutError, AbortError, or transport/wallet SDK errors during preflight reads.
+     */
+    prepareOpenTrade(params: OpenStopParams, opts?: PrepareOptions): Promise<PreparedTradingTx<"openStop">>;
+    /**
+     * Prepares a market-close transaction for a verified position.
+     *
+     * @throws ValidationError, ReadModelNotReadyError, TimeoutError, AbortError, or transport/wallet SDK errors during preflight reads.
+     */
+    prepareClosePosition(position: VerifiedPositionRef, params: ClosePositionParams, opts?: PrepareOptions): Promise<PreparedTradingTx<"closeMarket">>;
+    /**
+     * Prepares a take-profit update transaction for a verified position.
+     *
+     * @throws ValidationError, ReadModelNotReadyError, TimeoutError, AbortError, or transport/wallet SDK errors during preflight reads.
+     */
+    prepareUpdateTakeProfit(position: VerifiedPositionRef, params: UpdateTakeProfitParams, opts?: PrepareOptions): Promise<PreparedTradingTx<"updateTakeProfit">>;
+    /**
+     * Prepares a stop-loss update transaction for a verified position.
+     *
+     * @throws ValidationError, ReadModelNotReadyError, TimeoutError, AbortError, or transport/wallet SDK errors during preflight reads.
+     */
+    prepareUpdateStopLoss(position: VerifiedPositionRef, params: UpdateStopLossParams, opts?: PrepareOptions): Promise<PreparedTradingTx<"updateStopLoss">>;
+    /**
+     * Prepares a collateral top-up transaction for a verified position.
+     *
+     * @throws ValidationError, ReadModelNotReadyError, TimeoutError, AbortError, or transport/wallet SDK errors during preflight reads.
+     */
+    prepareTopUpCollateral(position: VerifiedPositionRef, params: TopUpCollateralParams, opts?: PrepareOptions): Promise<PreparedTradingTx<"topUpCollateral">>;
+    /**
+     * Prepares a collateral removal transaction for a verified position.
+     *
+     * @throws ValidationError, ReadModelNotReadyError, TimeoutError, AbortError, or transport/wallet SDK errors during preflight reads.
+     */
+    prepareRemoveCollateral(position: VerifiedPositionRef, params: RemoveCollateralParams, opts?: PrepareOptions): Promise<PreparedTradingTx<"removeCollateral">>;
+    /**
+     * Prepares an open limit/stop trigger-order update transaction.
+     *
+     * @throws ValidationError, ReadModelNotReadyError, TimeoutError, AbortError, or transport/wallet SDK errors during preflight reads.
+     */
+    prepareUpdateOpenLimitOrder(order: VerifiedOpenTriggerOrderRef, params: UpdateOpenTriggerOrderParams, opts?: PrepareOptions): Promise<PreparedTradingTx<"updateOpenLimitOrder">>;
+    /**
+     * Prepares an open limit/stop trigger-order cancellation transaction.
+     *
+     * @throws ValidationError, ReadModelNotReadyError, TimeoutError, AbortError, or transport/wallet SDK errors during preflight reads.
+     */
+    prepareCancelOpenLimitOrder(order: VerifiedOpenTriggerOrderRef, opts?: PrepareOptions): Promise<PreparedTradingTx<"cancelOpenLimitOrder">>;
+    /**
+     * Handles a market order whose timeout is available.
+     *
+     * @throws ValidationError, TimeoutError, AbortError, ContractRevertError, or transport/wallet SDK errors.
+     */
+    handleTradeMarketTimeout(order: TrackableMarketOrderRef, opts?: MarketTimeoutOptions): Promise<ReceiptOnlyHandle>;
+    /**
+     * Tracks an order lifecycle by order id.
+     *
+     * @throws ReadModelNotReadyError, ValidationError, TimeoutError, AbortError, ApiError, or TransportError.
+     */
+    trackOrder(orderId: OrderId, opts?: TrackOrderOptions): Promise<TrackResult>;
+    /**
+     * Recovers an SDK transaction handle from a transaction hash.
+     *
+     * @throws ValidationError, TimeoutError, AbortError, or TransportError while recovering receipt-backed state.
+     */
+    recoverTransaction(hash: Hex, opts?: RecoverTransactionOptions): Promise<TxHandle>;
+    /**
+     * Recovers and tracks a transaction hash through REST order state.
+     *
+     * @throws ReadModelNotReadyError, ValidationError, TimeoutError, AbortError, ApiError, or TransportError.
+     */
+    trackTransaction(hash: Hex, opts?: ReceiptBackedTrackOptions): Promise<TrackResult>;
+};
+/** RPC-only trading client without REST order tracking helpers. */
+type TradingClientNoApi = {
+    /**
+     * Prepares a market-open transaction without REST tracking support.
+     *
+     * @throws ValidationError, MissingPublicClientError, TimeoutError, AbortError, or transport SDK errors during preflight reads.
+     */
+    prepareOpenTrade(params: OpenMarketParams, opts?: PrepareOptions): Promise<PreparedTradingTxNoApi<"openMarket">>;
+    /**
+     * Prepares a limit-open order placement transaction without REST tracking support.
+     *
+     * @throws ValidationError, MissingPublicClientError, TimeoutError, AbortError, or transport SDK errors during preflight reads.
+     */
+    prepareOpenTrade(params: OpenLimitParams, opts?: PrepareOptions): Promise<PreparedTradingTxNoApi<"openLimit">>;
+    /**
+     * Prepares a stop-open order placement transaction without REST tracking support.
+     *
+     * @throws ValidationError, MissingPublicClientError, TimeoutError, AbortError, or transport SDK errors during preflight reads.
+     */
+    prepareOpenTrade(params: OpenStopParams, opts?: PrepareOptions): Promise<PreparedTradingTxNoApi<"openStop">>;
+    /**
+     * Prepares a market-close transaction without REST tracking support.
+     *
+     * @throws ValidationError, MissingPublicClientError, TimeoutError, AbortError, or transport SDK errors during preflight reads.
+     */
+    prepareClosePosition(position: VerifiedPositionRef, params: ClosePositionParams, opts?: PrepareOptions): Promise<PreparedTradingTxNoApi<"closeMarket">>;
+    /**
+     * Prepares a take-profit update transaction without REST tracking support.
+     *
+     * @throws ValidationError, MissingPublicClientError, TimeoutError, AbortError, or transport SDK errors during preflight reads.
+     */
+    prepareUpdateTakeProfit(position: VerifiedPositionRef, params: UpdateTakeProfitParams, opts?: PrepareOptions): Promise<PreparedTradingTxNoApi<"updateTakeProfit">>;
+    /**
+     * Prepares a stop-loss update transaction without REST tracking support.
+     *
+     * @throws ValidationError, MissingPublicClientError, TimeoutError, AbortError, or transport SDK errors during preflight reads.
+     */
+    prepareUpdateStopLoss(position: VerifiedPositionRef, params: UpdateStopLossParams, opts?: PrepareOptions): Promise<PreparedTradingTxNoApi<"updateStopLoss">>;
+    /**
+     * Prepares a collateral top-up transaction without REST tracking support.
+     *
+     * @throws ValidationError, MissingPublicClientError, TimeoutError, AbortError, or transport SDK errors during preflight reads.
+     */
+    prepareTopUpCollateral(position: VerifiedPositionRef, params: TopUpCollateralParams, opts?: PrepareOptions): Promise<PreparedTradingTxNoApi<"topUpCollateral">>;
+    /**
+     * Prepares a collateral removal transaction without REST tracking support.
+     *
+     * @throws ValidationError, MissingPublicClientError, TimeoutError, AbortError, or transport SDK errors during preflight reads.
+     */
+    prepareRemoveCollateral(position: VerifiedPositionRef, params: RemoveCollateralParams, opts?: PrepareOptions): Promise<PreparedTradingTxNoApi<"removeCollateral">>;
+    /**
+     * Prepares an open limit/stop trigger-order update without REST tracking support.
+     *
+     * @throws ValidationError, MissingPublicClientError, TimeoutError, AbortError, or transport SDK errors during preflight reads.
+     */
+    prepareUpdateOpenLimitOrder(order: VerifiedOpenTriggerOrderRef, params: UpdateOpenTriggerOrderParams, opts?: PrepareOptions): Promise<PreparedTradingTxNoApi<"updateOpenLimitOrder">>;
+    /**
+     * Prepares an open limit/stop trigger-order cancellation without REST tracking support.
+     *
+     * @throws ValidationError, MissingPublicClientError, TimeoutError, AbortError, or transport SDK errors during preflight reads.
+     */
+    prepareCancelOpenLimitOrder(order: VerifiedOpenTriggerOrderRef, opts?: PrepareOptions): Promise<PreparedTradingTxNoApi<"cancelOpenLimitOrder">>;
+    /**
+     * Handles a market order timeout without REST tracking support.
+     *
+     * @throws ValidationError, MissingWalletClientError, MissingPublicClientError, TimeoutError, AbortError, ContractRevertError, or transport/wallet SDK errors.
+     */
+    handleTradeMarketTimeout(order: TrackableMarketOrderRef, opts?: MarketTimeoutOptions): Promise<ReceiptOnlyHandle>;
+    /**
+     * Recovers an RPC-only SDK transaction handle from a transaction hash.
+     *
+     * @throws ValidationError, MissingPublicClientError, TimeoutError, AbortError, or TransportError while recovering receipt-backed state.
+     */
+    recoverTransaction(hash: Hex, opts?: RecoverTransactionOptions): Promise<TxHandleNoApi>;
+};
+
+export { type TradingVerb as $, type ApprovalNeed as A, type PrepareOptions as B, type ClearTriggerValue as C, type DelegationTarget as D, type PreparedTradingTx as E, type PreparedTradingTxNoApi as F, type PriceInput as G, type ReceiptBackedTrackOptions as H, type RecoverTransactionOptions as I, type RemoveCollateralParams as J, type SimResult as K, type LifecyclePhase as L, type MarketTimeoutOptions as M, type NormalizedActionParams as N, type OpenLimitParams as O, type PublicClient as P, type SimulateOptions as Q, type ReceiptOnlyHandle as R, type SendOptions as S, type TransactionReceipt as T, type TopUpCollateralParams as U, type TrackOrderOptions as V, type WaitReceiptOptions as W, type TrackResultOrderFields as X, type TrackableMarketOrderRef as Y, TradeDirection as Z, type TradeOrderKind as _, type TrackResult as a, type TriggerPlacementHandle as a0, type TriggerValueInput as a1, type TxHandle as a2, type TxHandleForVerb as a3, type TxHandleForVerbNoApi as a4, type TxHandleNoApi as a5, type UpdateOpenTriggerOrderParams as a6, type UpdateStopLossParams as a7, type UpdateTakeProfitParams as a8, type CheckClosePercentBoundsInput as a9, type CheckGroupCollateralCapInput as aa, type CheckLeverageBoundsInput as ab, type CheckMaxCollateralInput as ac, type CheckMinimumPositionSizeInput as ad, type CheckOiCapInput as ae, type CheckSlippageBoundsInput as af, checkClosePercentBounds as ag, checkGroupCollateralCap as ah, checkLeverageBounds as ai, checkMaxCollateral as aj, checkMinimumPositionSize as ak, checkOiCap as al, checkSlippageBounds as am, type DelegationReadOptions as an, type DelegationSendOptions as ao, type DelegationTypedData as ap, type DelegationTypedDataOptions as aq, type DelegationTypedDataParams as ar, type SignedDelegation as as, type WalletClient as b, type DelegationClient as c, type TradingClient as d, type TradingClientNoApi as e, type AsyncOrderHandle as f, type AsyncOrderHandleNoApi as g, type ClosePositionOptions as h, type ClosePositionParams as i, type ComputedEstimate as j, type ConstraintCheckResult as k, type DelegatedMarketTimeoutOptions as l, type DelegatedPrepareOptions as m, type DelegatedRecoverTransactionOptions as n, type DirectMarketTimeoutOptions as o, type DirectPrepareOptions as p, type DirectRecoverTransactionOptions as q, type LifecycleState as r, type OpenMarketParams as s, type OpenStopParams as t, type OpenTradeBaseParams as u, type OpenTradeParams as v, type OpenedPositionResult as w, OrderKind as x, type PreflightReport as y, type PreflightWarning as z };