aftermath-ts-sdk 1.3.28 → 2.0.0

package/dist/packages/perpetuals/perpetualsAccount.d.ts

@@ -1,780 +0,0 @@
-import { Caller } from "../../general/utils/caller";
-import { ApiPerpetualsPreviewPlaceOrderResponse, Balance, PerpetualsAccountCap, PerpetualsAccountObject, PerpetualsMarketId, PerpetualsOrderId, PerpetualsPosition, SdkPerpetualsPlaceLimitOrderInputs, SdkPerpetualsPlaceMarketOrderInputs, SuiAddress, ObjectId, ApiPerpetualsAccountCollateralHistoryResponse, ApiPerpetualsAccountOrderHistoryResponse, PerpetualsAccountId, ApiPerpetualsAccountCollateralHistoryBody, ApiPerpetualsAccountOrderHistoryBody, ApiPerpetualsPreviewCancelOrdersResponse, CallerConfig, SdkPerpetualsCancelOrdersPreviewInputs, PerpetualsStopOrderData, SdkPerpetualsPlaceStopOrdersInputs, ApiPerpetualsEditStopOrdersBody, SdkPerpetualsPlaceSlTpOrdersInputs, ApiPerpetualsWithdrawCollateralResponse, SdkPerpetualsPlaceMarketOrderPreviewInputs, SdkPerpetualsPlaceLimitOrderPreviewInputs, ApiTransactionResponse, ApiPerpetualsAccountMarginHistoryBody, PerpetualsPartialVaultCap, ApiPerpetualsAccountMarginHistoryResponse, ApiPerpetualsStopOrderDatasResponse, PerpetualsOrderData } from "../../types";
-import { Transaction, TransactionObjectArgument } from "@mysten/sui/transactions";
-import { AftermathApi } from "../../general/providers";
-/**
- * Note on “refreshing” account state:
- *
- * This class is a thin wrapper around a snapshot of {@link PerpetualsAccountObject}
- * that is typically fetched via {@link Perpetuals.getAccount}. The transaction builders
- * use the current snapshot to derive fields like `hasPosition` and to construct
- * SL/TP helpers that depend on the position side.
- *
- * If your app is long-lived, you may want to periodically re-fetch the account
- * (and recreate this wrapper) to avoid stale local position/order state. For example:
- * - After placing/canceling orders
- * - After fills/liquidations/funding settlements
- * - After switching markets or wallets
- */
-/**
- * High-level wrapper around a single Perpetuals account or vault account.
- *
- * This class encapsulates:
- *
- * - Transaction builders for:
- *   - Collateral actions (deposit, withdraw, allocate, deallocate, transfer)
- *   - Orders (market/limit, cancel, stop orders, SL/TP, set leverage)
- * - Read-only account helpers:
- *   - Stop-order message signing
- *   - Order & stop-order metadata
- *   - Collateral & trade history
- * - Convenience helpers to:
- *   - Fetch and categorize SL/TP stop orders
- *   - Resolve account/vault identifiers and owner addresses
- *
- * You typically do not construct `PerpetualsAccount` directly. Instead, use
- * {@link Perpetuals.getAccount} or {@link Perpetuals.getAccounts}, which
- * fetch all required on-chain data and wrap it for you:
- *
- * ```ts
- * const afSdk = new Aftermath("MAINNET");
- * await afSdk.init();
- *
- * const perps = afSdk.Perpetuals();
- * const [accountCap] = await perps.getOwnedAccountCaps({
- *   walletAddress: "0x...",
- * });
- *
- * const account = await perps.getAccount({ accountCap });
- *
- * // Build a deposit transaction
- * const depositTx = await account.getDepositCollateralTx({
- *   depositAmount: BigInt("1000000000"),
- * });
- * ```
- */
-export declare class PerpetualsAccount extends Caller {
-    readonly account: PerpetualsAccountObject;
-    readonly accountCap: PerpetualsAccountCap | PerpetualsPartialVaultCap;
-    readonly Provider?: AftermathApi | undefined;
-    /**
-     * If this account is backed by a vault, this holds the vault object ID.
-     * Otherwise, `undefined` for "direct" user accounts.
-     *
-     * This is used primarily to route requests to either:
-     * - `/perpetuals/account/...` endpoints, or
-     * - `/perpetuals/vault/...` endpoints.
-     */
-    private readonly vaultId;
-    /**
-     * Create a new {@link PerpetualsAccount} wrapper.
-     *
-     * @param account - Raw account object with positions and equity data.
-     * @param accountCap - Account cap or partial vault cap object containing
-     *   ownership and collateral metadata.
-     * @param config - Optional {@link CallerConfig} (network, auth, etc.).
-     * @param Provider - Optional shared {@link AftermathApi} provider instance
-     *   used to derive serialized transaction kinds (`txKind`) from
-     *   {@link Transaction} objects.
-     */
-    constructor(account: PerpetualsAccountObject, accountCap: PerpetualsAccountCap | PerpetualsPartialVaultCap, config?: CallerConfig, Provider?: AftermathApi | undefined);
-    /**
-     * Build a `deposit-collateral` transaction for this account.
-     *
-     * For non-vault accounts, this endpoint constructs a transaction that:
-     * - Optionally extends an existing {@link Transaction}, and
-     * - Deposits collateral into the Perpetuals account.
-     *
-     * **Note:** Vault accounts are currently not supported and will throw.
-     *
-     * @param inputs.tx - Optional existing transaction to extend. If omitted,
-     *   a new {@link Transaction} is created under the hood.
-     * @param inputs.isSponsoredTx - Optional flag indicating whether the
-     *   transaction is gas-sponsored.
-     * @param inputs.depositAmount - Amount of collateral to deposit, if paying
-     *   directly from the wallet.
-     * @param inputs.depositCoinArg - Transaction object argument referencing a
-     *   coin to deposit (mutually exclusive with `depositAmount`).
-     *
-     * @returns Transaction response containing a `tx`.
-     *
-     * @example
-     * ```ts
-     * const { tx } = await account.getDepositCollateralTx({
-     *   depositAmount: BigInt("1000000000"),
-     * });
-     * ```
-     */
-    getDepositCollateralTx(inputs: {
-        tx?: Transaction;
-        isSponsoredTx?: boolean;
-    } & ({
-        depositAmount: Balance;
-    } | {
-        depositCoinArg: TransactionObjectArgument;
-    })): Promise<Omit<ApiTransactionResponse, "txKind"> & {
-        tx: Transaction;
-    }>;
-    /**
-     * Build a `withdraw-collateral` transaction for this account.
-     *
-     * For non-vault accounts, this endpoint constructs a transaction to:
-     * - Withdraw collateral from the Perpetuals account, and
-     * - Optionally transfer it to a `recipientAddress` (otherwise coin is left
-     *   as a transaction argument).
-     *
-     * **Note:** Vault accounts are currently not supported and will throw.
-     *
-     * @param inputs.withdrawAmount - Amount of collateral to withdraw.
-     * @param inputs.recipientAddress - Optional address to receive the withdrawn
-     *   coins directly.
-     * @param inputs.tx - Optional transaction to extend (defaults to new `Transaction()`).
-     *
-     * @returns A response containing `tx` and the `coinOutArg` where the
-     *   withdrawn coins end up if `recipientAddress` is not used.
-     *
-     * @example
-     * ```ts
-     * const { tx, coinOutArg } = await account.getWithdrawCollateralTx({
-     *   withdrawAmount: BigInt("1000000000"),
-     * });
-     * ```
-     */
-    getWithdrawCollateralTx(inputs: {
-        withdrawAmount: Balance;
-        recipientAddress?: SuiAddress;
-        tx?: Transaction;
-    }): Promise<Omit<ApiPerpetualsWithdrawCollateralResponse, "txKind"> & {
-        tx: Transaction;
-    }>;
-    /**
-     * Build an `allocate-collateral` transaction, moving collateral from this
-     * account into a specific market (clearing house).
-     *
-     * Works for both account-backed and vault-backed accounts.
-     *
-     * @param inputs.marketId - Market to allocate collateral to.
-     * @param inputs.allocateAmount - Amount of collateral to allocate.
-     * @param inputs.tx - Optional transaction to extend.
-     *
-     * @returns Transaction response containing a `tx`.
-     */
-    getAllocateCollateralTx(inputs: {
-        marketId: PerpetualsMarketId;
-        allocateAmount: Balance;
-        tx?: Transaction;
-    }): Promise<Omit<ApiTransactionResponse, "txKind"> & {
-        tx: Transaction;
-    }>;
-    /**
-     * Build a `deallocate-collateral` transaction, moving collateral from a
-     * specific market back to this account.
-     *
-     * Works for both account-backed and vault-backed accounts.
-     *
-     * @param inputs.marketId - Market to deallocate collateral from.
-     * @param inputs.deallocateAmount - Amount of collateral to deallocate.
-     * @param inputs.tx - Optional transaction to extend.
-     *
-     * @returns Transaction response containing a `tx`.
-     */
-    getDeallocateCollateralTx(inputs: {
-        marketId: PerpetualsMarketId;
-        deallocateAmount: Balance;
-        tx?: Transaction;
-    }): Promise<Omit<ApiTransactionResponse, "txKind"> & {
-        tx: Transaction;
-    }>;
-    /**
-     * Build a `transfer-collateral` transaction between two Perpetuals accounts.
-     *
-     * Only supported for direct accounts, **not** vault-backed accounts.
-     *
-     * @param inputs.transferAmount - Amount of collateral to transfer.
-     * @param inputs.toAccountId - Destination account ID.
-     * @param inputs.tx - Optional transaction to extend.
-     *
-     * @returns Transaction response containing a `tx`.
-     */
-    getTransferCollateralTx(inputs: {
-        transferAmount: Balance;
-        toAccountId: PerpetualsAccountId;
-        toAccountCapId?: ObjectId;
-        tx?: Transaction;
-    }): Promise<Omit<ApiTransactionResponse, "txKind"> & {
-        tx: Transaction;
-    }>;
-    /**
-     * Build a `place-market-order` transaction for this account.
-     *
-     * This is the primary entrypoint for opening/closing positions via market orders.
-     * It automatically:
-     * - Injects the account/vault identity into the payload.
-     * - Derives `hasPosition` based on the current account state for the given market.
-     * - Optionally attaches SL/TP stop orders via the `slTp` input.
-     *
-     * Important behavioral notes:
-     * - `hasPosition` is derived from the local {@link PerpetualsAccountObject} snapshot.
-     *   If the snapshot is stale, consider re-fetching the account first.
-     * - For vault-backed accounts, the API routes to `/perpetuals/vault/...` and uses
-     *   `vaultId` as the identity discriminator. For direct accounts, it uses `accountId`.
-     *
-     * @param inputs - See {@link SdkPerpetualsPlaceMarketOrderInputs} for details.
-     *   Notably:
-     *   - `marketId`, `side`, `size`, `collateralChange`, `reduceOnly`
-     *   - Optional `leverage`
-     *   - Optional `slTp` params
-     *   - Optional `tx` to extend
-     *
-     * @returns Transaction response containing `tx`.
-     *
-     * @example
-     * ```ts
-     * const { tx } = await account.getPlaceMarketOrderTx({
-     *   marketId: "0x...",
-     *   side: PerpetualsOrderSide.Bid,
-     *   size: BigInt("1000000000"),
-     *   collateralChange: 10,
-     *   reduceOnly: false,
-     * });
-     * ```
-     */
-    getPlaceMarketOrderTx(inputs: SdkPerpetualsPlaceMarketOrderInputs): Promise<Omit<ApiTransactionResponse, "txKind"> & {
-        tx: Transaction;
-    }>;
-    /**
-     * Build a `place-limit-order` transaction for this account.
-     *
-     * Similar to {@link getPlaceMarketOrderTx}, but uses limit order semantics:
-     * - Requires `price` and `orderType`.
-     * - Supports reduce-only flags, expiry, optional leverage, and SL/TP stop orders.
-     *
-     * Notes:
-     * - `hasPosition` is derived from local account state; refresh the account if needed.
-     * - This method does not validate tick/lot sizing locally; the API/on-chain
-     *   will enforce market constraints.
-     *
-     * @param inputs - See {@link SdkPerpetualsPlaceLimitOrderInputs}.
-     *
-     * @returns Transaction response containing `tx`.
-     */
-    getPlaceLimitOrderTx(inputs: SdkPerpetualsPlaceLimitOrderInputs): Promise<Omit<ApiTransactionResponse, "txKind"> & {
-        tx: Transaction;
-    }>;
-    /**
-     * Build a `cancel-orders` transaction for this account.
-     *
-     * Each market in `marketIdsToData` supplies:
-     * - `orderIds`: the orders to cancel in that market
-     * - `collateralChange`: collateral adjustment to apply alongside cancellation
-     * - `leverage`: leverage context used for estimating/validating constraints server-side
-     *
-     * Notes:
-     * - Cancels are applied per market; some markets may succeed while others fail
-     *   depending on API/on-chain validation (returned as a transaction failure at execution).
-     * - If you need to understand the effect prior to building a tx, use
-     *   {@link getCancelOrdersPreview}.
-     *
-     * @param inputs.tx - Optional transaction to extend.
-     * @param inputs.marketIdsToData - Mapping from market IDs to cancel payloads.
-     *
-     * @returns Transaction response containing `tx`.
-     */
-    getCancelOrdersTx(inputs: {
-        tx?: Transaction;
-        marketIdsToData: Record<PerpetualsMarketId, {
-            orderIds: PerpetualsOrderId[];
-            collateralChange: number;
-        }>;
-    }): Promise<Omit<ApiTransactionResponse, "txKind"> & {
-        tx: Transaction;
-    }>;
-    /**
-     * Build a `cancel-stop-orders` transaction for this account.
-     *
-     * This cancels stop-order *objects/tickets* by their object IDs. These IDs are
-     * returned by stop-order query endpoints (see {@link getStopOrderDatas}).
-     *
-     * @param inputs.tx - Optional transaction to extend.
-     * @param inputs.stopOrderIds - Array of stop-order ticket IDs to cancel.
-     *
-     * @returns Transaction response containing `tx`.
-     */
-    getCancelStopOrdersTx(inputs: {
-        tx?: Transaction;
-        stopOrderIds: ObjectId[];
-    }): Promise<Omit<ApiTransactionResponse, "txKind"> & {
-        tx: Transaction;
-    }>;
-    /**
-     * Build a `place-stop-orders` transaction for this account.
-     *
-     * This allows placing one or more stop orders in a single transaction,
-     * optionally with a dedicated gas coin and a sponsored gas flag.
-     *
-     * Typical usage:
-     * - Construct stop order payload(s) client-side
-     * - Call this method to build a transaction kind
-     * - Sign/execute the transaction via Sui
-     *
-     * @param inputs - See {@link SdkPerpetualsPlaceStopOrdersInputs}.
-     *
-     * @returns Transaction response containing `tx`.
-     */
-    getPlaceStopOrdersTx(inputs: SdkPerpetualsPlaceStopOrdersInputs): Promise<Omit<ApiTransactionResponse, "txKind"> & {
-        tx: Transaction;
-    }>;
-    /**
-     * Build a `place-sl-tp-orders` transaction for this account.
-     *
-     * This helper constructs SL/TP stop orders for an **existing** position
-     * in a given market. If the account has no position for `marketId`, this
-     * throws an error.
-     *
-     * Implementation details:
-     * - Determines the current position side from the account snapshot.
-     * - Sets `positionSide` for the API so SL/TP orders are bound to closing logic
-     *   (i.e. they should trigger on the opposite side of the open position).
-     *
-     * @param inputs - See {@link SdkPerpetualsPlaceSlTpOrdersInputs}.
-     *
-     * @returns Transaction response containing `tx`.
-     */
-    getPlaceSlTpOrdersTx(inputs: SdkPerpetualsPlaceSlTpOrdersInputs): Promise<Omit<ApiTransactionResponse, "txKind"> & {
-        tx: Transaction;
-    }>;
-    /**
-     * Build an `edit-stop-orders` transaction for this account.
-     *
-     * This endpoint lets you update existing stop orders in batch.
-     *
-     * Notes:
-     * - You must provide the full updated stop-order objects (including object IDs).
-     * - This is typically used to adjust trigger prices, sizes, expiries, or the
-     *   embedded limit-order parameters.
-     *
-     * @param inputs.stopOrders - Full updated stop-order payloads to apply.
-     * @param inputs.tx - Optional transaction to extend.
-     *
-     * @returns Transaction response containing `tx`.
-     */
-    getEditStopOrdersTx(inputs: Omit<ApiPerpetualsEditStopOrdersBody, "txKind" | "accountObjectId"> & {
-        tx?: Transaction;
-    }): Promise<Omit<ApiTransactionResponse, "txKind"> & {
-        tx: Transaction;
-    }>;
-    /**
-     * Build a `set-leverage` transaction for a given market.
-     *
-     * This updates the effective leverage for the position (or potential position)
-     * in `marketId`, and optionally adjusts collateral in tandem.
-     *
-     * Notes:
-     * - Leverage changes may be constrained by protocol risk limits and current
-     *   position state.
-     * - If you want to understand the effect first, use {@link getSetLeveragePreview}.
-     *
-     * @param inputs.tx - Optional transaction to extend.
-     * @param inputs.leverage - Target leverage value.
-     * @param inputs.collateralChange - Net collateral change to apply alongside
-     *   the leverage update.
-     * @param inputs.marketId - Market whose leverage to adjust.
-     *
-     * @returns Transaction response containing `tx`.
-     */
-    getSetLeverageTx(inputs: {
-        tx?: Transaction;
-        leverage: number;
-        collateralChange: number;
-        marketId: PerpetualsMarketId;
-    }): Promise<Omit<ApiTransactionResponse, "txKind"> & {
-        tx: Transaction;
-    }>;
-    /**
-     * Build a deterministic message payload to sign when querying stop orders
-     * from the backend.
-     *
-     * This payload is intended to be signed off-chain and then submitted to
-     * `getStopOrderDatas` as a proof of account ownership.
-     *
-     * Important:
-     * - The returned payload is *not* a Sui transaction; it is an off-chain
-     *   “authentication” message.
-     * - The backend expects `account_id` to be a decimal string. This code
-     *   normalizes the bigint `accountId` by stripping the trailing `n`.
-     *
-     * @param inputs.marketIds - Optional list of market IDs to scope the query.
-     *
-     * @returns An object describing the action and account/market IDs, suitable
-     *   for message signing.
-     *
-     * @example
-     * ```ts
-     * const message = account.getStopOrdersMessageToSign({ marketIds: ["0x..."] });
-     * const { signature } = await wallet.signMessage({
-     *   message: new TextEncoder().encode(JSON.stringify(message)),
-     * });
-     * ```
-     */
-    getStopOrdersMessageToSign(inputs?: {
-        marketIds: PerpetualsMarketId[];
-    }): {
-        action: string;
-        account_id: string;
-        clearing_house_ids: string[];
-    };
-    /**
-     * Preview the effects of placing a market order (without building a tx).
-     *
-     * This is a read-only API call that runs the protocol’s pricing / margin /
-     * slippage logic against the current market state and your account/vault context.
-     *
-     * @param inputs - See {@link SdkPerpetualsPlaceMarketOrderPreviewInputs}.
-     * @param abortSignal - Optional `AbortSignal` to cancel the request.
-     *
-     * @returns Either an error message or a preview including:
-     * - `updatedPosition`
-     * - `priceSlippage`, `percentSlippage`
-     * - `filledSize`, `filledSizeUsd`
-     * - `postedSize`, `postedSizeUsd`
-     * - `collateralChange`
-     * - `executionPrice`
-     */
-    getPlaceMarketOrderPreview(inputs: SdkPerpetualsPlaceMarketOrderPreviewInputs, abortSignal?: AbortSignal): Promise<ApiPerpetualsPreviewPlaceOrderResponse>;
-    /**
-     * Preview the effects of placing a limit order (without building a tx).
-     *
-     * The preview simulates:
-     * - How much size would execute immediately vs post to the book
-     * - Expected slippage and execution price
-     * - Resulting position and margin impact
-     *
-     * @param inputs - See {@link SdkPerpetualsPlaceLimitOrderPreviewInputs}.
-     * @param abortSignal - Optional `AbortSignal` to cancel the request.
-     *
-     * @returns Either an error message or a preview object similar to
-     *   {@link getPlaceMarketOrderPreview}.
-     */
-    getPlaceLimitOrderPreview(inputs: SdkPerpetualsPlaceLimitOrderPreviewInputs, abortSignal?: AbortSignal): Promise<ApiPerpetualsPreviewPlaceOrderResponse>;
-    /**
-     * Preview the effects of canceling orders across one or more markets.
-     *
-     * This is commonly used to:
-     * - Validate that cancels are allowed under current margin constraints
-     * - Estimate how collateral/margin would change after canceling (and applying
-     *   the associated `collateralChange` values)
-     *
-     * If `marketIdsToData` is empty, this returns a trivial preview with:
-     * - `marketIdsToData: {}`
-     *
-     * @param inputs - See {@link SdkPerpetualsCancelOrdersPreviewInputs}.
-     * @param abortSignal - Optional `AbortSignal` to cancel the request.
-     *
-     * @returns Either:
-     * - `{ marketIdsToData }`, or
-     * - `{ error }`.
-     */
-    getCancelOrdersPreview(inputs: SdkPerpetualsCancelOrdersPreviewInputs, abortSignal?: AbortSignal): Promise<ApiPerpetualsPreviewCancelOrdersResponse>;
-    /**
-     * Preview the effects of setting leverage for a given market.
-     *
-     * The preview returns:
-     * - The position after the leverage change (`updatedPosition`)
-     * - The collateral delta required/produced (`collateralChange`)
-     *
-     * @param inputs.marketId - Market whose leverage you want to adjust.
-     * @param inputs.leverage - Target leverage value.
-     * @param abortSignal - Optional `AbortSignal` to cancel the request.
-     *
-     * @returns Either:
-     * - `{ updatedPosition, collateralChange }`, or
-     * - `{ error }`.
-     */
-    getSetLeveragePreview(inputs: {
-        marketId: PerpetualsMarketId;
-        leverage: number;
-    }, abortSignal?: AbortSignal): Promise<{
-        updatedPosition: PerpetualsPosition;
-        collateralChange: number;
-    } | {
-        error: string;
-    }>;
-    /**
-     * Preview the effects of allocating/deallocating collateral for the position in
-     * a given market.
-     *
-     * Semantics:
-     * - Positive `collateralChange` previews allocation (moving collateral into the market).
-     * - Negative `collateralChange` previews deallocation (moving collateral out of the market).
-     *
-     * @param inputs.marketId - Market of whose position you want to allocate/deallocate
-     * collateral to/from.
-     * @param inputs.collateralChange - The target collateral change (a positive number
-     * for allocating collateral, negative for deallocating collateral).
-     * @param abortSignal - Optional `AbortSignal` to cancel the request.
-     *
-     * @returns Either:
-     * - `{ updatedPosition, collateralChange }`, or
-     * - `{ error }`.
-     */
-    getEditCollateralPreview(inputs: {
-        marketId: PerpetualsMarketId;
-        collateralChange: Balance;
-    }, abortSignal?: AbortSignal): Promise<{
-        updatedPosition: PerpetualsPosition;
-        collateralChange: number;
-    } | {
-        error: string;
-    }>;
-    /**
-     * Fetch stop-order ticket data for this account, using an off-chain signed
-     * payload.
-     *
-     * Typical flow:
-     * 1) Call {@link getStopOrdersMessageToSign} to construct a deterministic payload
-     * 2) Sign the payload with the wallet
-     * 3) Provide the signed payload to this method to fetch stop order data
-     *
-     * @param inputs.bytes - Serialized message that was signed (e.g. JSON string).
-     * @param inputs.signature - Signature over `bytes`.
-     * @param inputs.marketIds - Optional subset of markets to filter results by.
-     *
-     * @returns {@link ApiPerpetualsStopOrderDatasResponse} containing `stopOrderDatas`.
-     */
-    getStopOrderDatas(inputs: {
-        bytes: string;
-        signature: string;
-        marketIds?: PerpetualsMarketId[];
-    }): Promise<ApiPerpetualsStopOrderDatasResponse>;
-    /**
-     * Fetch paginated collateral-change history for this account, including
-     * deposits, withdrawals, funding settlements, liquidations, etc.
-     *
-     * Pagination:
-     * - Use `beforeTimestampCursor` to fetch older entries.
-     * - The API returns a `nextBeforeTimestampCursor` to continue pagination.
-     *
-     * @param inputs.beforeTimestampCursor - Optional cursor for pagination.
-     * @param inputs.limit - Optional limit per page.
-     *
-     * @returns {@link ApiPerpetualsAccountCollateralHistoryResponse} containing
-     * an array of changes and a `nextBeforeTimestampCursor`.
-     */
-    getCollateralHistory(inputs: Omit<ApiPerpetualsAccountCollateralHistoryBody, "accountId">): Promise<ApiPerpetualsAccountCollateralHistoryResponse>;
-    /**
-     * Fetch paginated order history for this account.
-     *
-     * This endpoint is distinct from {@link getOrderDatas}:
-     * - `getOrderDatas` resolves current/pending orders based on the snapshot.
-     * - `getOrderHistory` returns historical order events (fills, cancels, etc.)
-     *   over time with cursor-based pagination.
-     *
-     * @param inputs.beforeTimestampCursor - Optional cursor for pagination.
-     * @param inputs.limit - Optional limit per page.
-     *
-     * @returns {@link ApiPerpetualsAccountOrderHistoryResponse} containing a list of
-     * orders and a `nextBeforeTimestampCursor`.
-     */
-    getOrderHistory(inputs: Omit<ApiPerpetualsAccountOrderHistoryBody, "accountId">): Promise<ApiPerpetualsAccountOrderHistoryResponse>;
-    /**
-     * Fetch historical margin snapshots for this account over a time range.
-     *
-     * This endpoint returns time-series margin data suitable for charting UI
-     * such as equity and available collateral over time.
-     *
-     * Notes:
-     * - This is an account-level view (aggregated across markets).
-     *
-     * @param inputs - {@link ApiPerpetualsAccountMarginHistoryBody} without `accountId`.
-     * @returns {@link ApiPerpetualsAccountMarginHistoryResponse} containing `marginHistoryDatas`.
-     */
-    getMarginHistory(inputs: Omit<ApiPerpetualsAccountMarginHistoryBody, "accountId">): Promise<ApiPerpetualsAccountMarginHistoryResponse>;
-    /**
-     * Build a transaction that grants an Agent Wallet (assistant permissions) for this perpetuals account.
-     *
-     * The returned transaction must be signed and submitted by the **account admin** wallet.
-     * After execution, `recipientAddress` can execute supported trading actions on behalf of this account.
-     *
-     * Agent wallets can perform all supported actions **except**:
-     * - withdrawing collateral, and
-     * - granting or revoking other agent wallets.
-     *
-     * @param inputs.recipientAddress Wallet address to receive agent permissions.
-     * @param inputs.tx Optional existing {@link Transaction} to append to. If omitted, a new Transaction is used.
-     * @throws If this instance represents a vault account (agent wallets are account-only).
-     */
-    getGrantAgentWalletTx(inputs: {
-        recipientAddress: SuiAddress;
-        tx?: Transaction;
-    }): Promise<Omit<ApiTransactionResponse, "txKind"> & {
-        tx: Transaction;
-    }>;
-    /**
-     * Build a transaction that revokes an Agent Wallet (assistant capability) from this perpetuals account.
-     *
-     * The returned transaction must be signed and submitted by the **account admin** wallet.
-     * After execution, the revoked wallet immediately loses its delegated permissions.
-     *
-     * @param inputs.accountCapId Object ID of the assistant capability to revoke.
-     * @param inputs.tx Optional existing {@link Transaction} to append to. If omitted, a new Transaction is used.
-     * @throws If this instance represents a vault account (agent wallets are account-only).
-     */
-    getRevokeAgentWalletTx(inputs: {
-        accountCapId: ObjectId;
-        tx?: Transaction;
-    }): Promise<Omit<ApiTransactionResponse, "txKind"> & {
-        tx: Transaction;
-    }>;
-    /**
-     * Find the current position for a given market ID, if any.
-     *
-     * @param inputs.marketId - Market ID to search for.
-     * @returns {@link PerpetualsPosition} if found, otherwise `undefined`.
-     */
-    positionForMarketId(inputs: {
-        marketId: PerpetualsMarketId;
-    }): PerpetualsPosition | undefined;
-    /**
-     * Filter a list of stop orders to only include non-SL/TP orders.
-     *
-     * A stop order is considered SL/TP if it appears in the combined set of
-     * SL/TP orders across **all** markets (see {@link slTpStopOrderDatas}).
-     *
-     * Note:
-     * - This implementation uses JSON string equality to compare objects.
-     *   This is pragmatic but assumes stable field ordering and identical shapes.
-     *
-     * @param inputs.stopOrderDatas - Full array of stop-order ticket data.
-     * @returns An array of non-SL/TP stop orders, or `undefined` if none exist.
-     */
-    nonSlTpStopOrderDatas(inputs: {
-        stopOrderDatas: PerpetualsStopOrderData[];
-    }): PerpetualsStopOrderData[] | undefined;
-    /**
-     * Extract all SL/TP-style stop orders across **all** markets for this
-     * account.
-     *
-     * SL/TP orders are stop orders which:
-     * - Have an `slTp` payload, and
-     * - Target the opposite side of the current position.
-     *
-     * This combines:
-     * - "Full" SL/TP orders (size >= `i64MaxBigInt`)
-     * - "Partial" SL/TP orders (size < `i64MaxBigInt`)
-     *
-     * The "full vs partial" distinction is a protocol convention: some systems
-     * encode “close entire position” using a sentinel max size.
-     *
-     * @param inputs.stopOrderDatas - Full list of stop-order tickets.
-     * @returns Array of SL/TP stop orders, or `undefined` if none exist.
-     */
-    slTpStopOrderDatas(inputs: {
-        stopOrderDatas: PerpetualsStopOrderData[];
-    }): PerpetualsStopOrderData[] | undefined;
-    /**
-     * Filter stop orders for a single market to only include non-SL/TP orders.
-     *
-     * Uses {@link slTpStopOrderDatasForPosition} under the hood.
-     *
-     * @param inputs.marketId - Market ID to filter for.
-     * @param inputs.stopOrderDatas - Full list of stop orders.
-     * @returns Non-SL/TP stop orders for the given market, or `undefined` if none exist.
-     */
-    nonSlTpStopOrderDatasForPosition(inputs: {
-        marketId: PerpetualsMarketId;
-        stopOrderDatas: PerpetualsStopOrderData[];
-    }): PerpetualsStopOrderData[] | undefined;
-    /**
-     * Categorize stop orders for a specific market into:
-     * - A "full" SL/TP order (size >= `i64MaxBigInt`) if any.
-     * - A set of "partial" SL/TP orders (size < `i64MaxBigInt`).
-     *
-     * SL/TP stop orders are defined as:
-     * - Market ID matches the input market.
-     * - `slTp` field is present.
-     * - Order side is opposite of the position side.
-     * - At least a `stopLossIndexPrice` or `takeProfitIndexPrice` is set.
-     *
-     * Notes on matching:
-     * - The side comparison uses the current position side derived from the account snapshot.
-     * - If `baseAssetAmount === 0` (no effective position), the method returns no SL/TP orders.
-     *
-     * @param inputs.marketId - Market to categorize stop orders for.
-     * @param inputs.stopOrderDatas - Full list of stop orders.
-     *
-     * @returns Object containing:
-     * - `fullSlTpOrder` (if any)
-     * - `partialSlTpOrders` (if any, otherwise `undefined`)
-     */
-    slTpStopOrderDatasForPosition(inputs: {
-        marketId: PerpetualsMarketId;
-        stopOrderDatas: PerpetualsStopOrderData[];
-    }): {
-        fullSlTpOrder: PerpetualsStopOrderData | undefined;
-        partialSlTpOrders: PerpetualsStopOrderData[] | undefined;
-    };
-    slTpStopOrderDatasForLimitOrder(inputs: {
-        stopOrderDatas: PerpetualsStopOrderData[];
-        limitOrderId: PerpetualsOrderId;
-    }): {
-        fullSlTpOrder: PerpetualsStopOrderData | undefined;
-        partialSlTpOrders: PerpetualsStopOrderData[] | undefined;
-    };
-    orderDatas(): PerpetualsOrderData[];
-    /**
-     * Convenience accessor for the account's available collateral (in coin units).
-     *
-     * This is the amount of collateral not currently locked/allocated across markets,
-     * as represented by the backend response.
-     *
-     * @returns Available collateral as a `number`.
-     */
-    collateral(): number;
-    /**
-     * Check whether this {@link PerpetualsAccount} is vault-backed.
-     *
-     * @returns `true` if the underlying `accountCap` is a vault cap; otherwise `false`.
-     */
-    isVault(): boolean;
-    /**
-     * Resolve the owner wallet address of this account or vault.
-     *
-     * - For direct accounts, returns the cap's `walletAddress` field.
-     * - For vault-backed accounts, returns the vault cap's `ownerAddress`.
-     *
-     * Naming note:
-     * - Some types use `walletAddress` for direct ownership. For vault-backed accounts
-     *   the analogous field is `ownerAddress`.
-     *
-     * @returns Owner wallet {@link SuiAddress}.
-     */
-    ownerAddress(): SuiAddress;
-    /**
-     * Get the underlying account object ID.
-     *
-     * This is the on-chain object that holds the account's state and positions.
-     *
-     * @returns {@link ObjectId} of the account object.
-     */
-    accountObjectId(): ObjectId;
-    /**
-     * Get the numeric perpetuals account ID.
-     *
-     * This is the protocol-level identifier (bigint-derived) used across API calls.
-     *
-     * @returns {@link PerpetualsAccountId} for this account.
-     */
-    accountId(): PerpetualsAccountId;
-    /**
-     * Get the account cap object ID, if this is a direct account.
-     *
-     * Direct accounts are controlled via an on-chain “cap” object. Vault-backed
-     * accounts are controlled via vault caps and do not expose a direct account-cap ID.
-     *
-     * @throws If called for a vault-backed account.
-     *
-     * @returns {@link ObjectId} of the account cap.
-     */
-    accountCapId(): ObjectId;
-}
-//# sourceMappingURL=perpetualsAccount.d.ts.map