aftermath-ts-sdk 2.0.1 → 2.1.0

package/dist/index.d.ts

@@ -6,7 +6,42 @@ import { MultiSigPublicKey } from '@mysten/sui/multisig';
 import { BcsType } from '@mysten/sui/bcs';
 import { Keypair } from '@mysten/sui/cryptography';
 
-type SuiNetwork = "DEVNET" | "TESTNET" | "LOCAL" | "MAINNET" | "INTERNAL" | (string & {});
+/**
+ * Represents the body payload sent to the dynamic gas service,
+ * which includes the serialized transaction and any user-provided
+ * gas configuration (e.g., coin type).
+ */
+interface ApiDynamicGasBody {
+    /**
+     * The serialized transaction block in base64 or similar format.
+     */
+    serializedTx: SerializedTransaction;
+    /**
+     * The address of the user for whom the dynamic gas is being set.
+     */
+    walletAddress: SuiAddress;
+    /**
+     * The coin type to be used for gas payment (e.g., "0x2::sui::SUI").
+     */
+    gasCoinType: CoinType;
+}
+/**
+ * Represents the response from the dynamic gas service, typically returning
+ * updated transaction bytes and possibly a sponsored signature if the
+ * transaction gas is being partially or fully sponsored.
+ */
+interface ApiDynamicGasResponse {
+    /**
+     * The modified transaction bytes that incorporate a gas coin or sponsor information.
+     */
+    txBytes: SerializedTransaction;
+    /**
+     * A signature used to sponsor or verify the updated transaction, if applicable.
+     */
+    sponsoredSignature: string;
+}
+
+type SuiNetwork = "DEVNET" | "TESTNET" | "LOCAL" | "MAINNET";
 
 /**
  * Represents a token or currency balance in the system, defined as a bigint.
@@ -339,13 +374,27 @@ interface IndexerDataWithCursorQueryParams {
  */
 interface CallerConfig {
     /**
-     * The target Sui network (e.g., "MAINNET", "TESTNET").
+     * The target Sui network (e.g., "MAINNET", "TESTNET"). Determines the
+     * default API host when `baseUrl` is not supplied.
      */
     network?: SuiNetwork;
+    /**
+     * Explicit override for the API host (e.g. `"http://localhost:8080"`).
+     * Takes precedence over the network-derived default. Use this to point
+     * the SDK at a custom or local backend.
+     */
+    baseUrl?: string;
     /**
      * Access token used for authenticated requests, if required.
      */
     accessToken?: string;
+    /**
+     * URL path segment placed between the host and the package prefix when
+     * building API call URLs (`{host}/{apiEndpoint}/{package}/...`).
+     * Defaults to `"api"`. Override only when targeting a backend that
+     * mounts the Aftermath API under a different path.
+     */
+    apiEndpoint?: string;
 }
 interface ApiTransactionResponse {
     txKind: SerializedTransaction;
@@ -355,6 +404,51 @@ interface SdkTransactionResponse {
     tx: Transaction;
 }
 
+interface KioskOwnerCapObject extends Object$1 {
+    kioskObjectId: ObjectId;
+}
+interface KioskObject extends Object$1 {
+    kioskOwnerCapId: ObjectId;
+    nfts: Nft[];
+    isPersonal: boolean;
+}
+interface Nft {
+    info: NftInfo;
+    display: NftDisplay;
+}
+interface NftInfo {
+    objectId: ObjectId;
+    objectType: AnyObjectType;
+}
+interface NftDisplay {
+    suggested: NftDisplaySuggested;
+    other: NftDisplayOther;
+}
+interface NftDisplaySuggested {
+    name?: string;
+    link?: Url;
+    imageUrl?: Url;
+    description?: string;
+    projectUrl?: Url;
+    creator?: string;
+}
+type NftDisplayOther = Record<string, string>;
+
+type CoinGeckoChain = Lowercase<"Ethereum" | "Arbitrum" | "Bsc" | "Solana" | "Sui" | "Polygon" | "Avalanche" | "Optimism" | "Base">;
+type CoinGeckoCoinApiId = string;
+interface CoinGeckoCoinData {
+    chain: CoinGeckoChain | "";
+    apiId: CoinGeckoCoinApiId;
+    name: string;
+    symbol: CoinSymbol;
+    coinType: CoinType;
+}
+interface CoinGeckoCoinSymbolData {
+    apiId: CoinGeckoCoinApiId;
+    name: string;
+    symbol: CoinSymbol;
+}
+
 type RpcEndpoint = string;
 interface ConfigAddresses {
     faucet?: FaucetAddresses;
@@ -529,84 +623,19 @@ interface NftsAddresses {
     };
 }
 
-interface KioskOwnerCapObject extends Object$1 {
-    kioskObjectId: ObjectId;
-}
-interface KioskObject extends Object$1 {
-    kioskOwnerCapId: ObjectId;
-    nfts: Nft[];
-    isPersonal: boolean;
-}
-interface Nft {
-    info: NftInfo;
-    display: NftDisplay;
-}
-interface NftInfo {
-    objectId: ObjectId;
-    objectType: AnyObjectType;
-}
-interface NftDisplay {
-    suggested: NftDisplaySuggested;
-    other: NftDisplayOther;
-}
-interface NftDisplaySuggested {
-    name?: string;
-    link?: Url;
-    imageUrl?: Url;
-    description?: string;
-    projectUrl?: Url;
-    creator?: string;
-}
-type NftDisplayOther = Record<string, string>;
-
-/**
- * Represents the body payload sent to the dynamic gas service,
- * which includes the serialized transaction and any user-provided
- * gas configuration (e.g., coin type).
- */
-interface ApiDynamicGasBody {
-    /**
-     * The serialized transaction block in base64 or similar format.
-     */
-    serializedTx: SerializedTransaction;
-    /**
-     * The address of the user for whom the dynamic gas is being set.
-     */
-    walletAddress: SuiAddress;
-    /**
-     * The coin type to be used for gas payment (e.g., "0x2::sui::SUI").
-     */
-    gasCoinType: CoinType;
-}
-/**
- * Represents the response from the dynamic gas service, typically returning
- * updated transaction bytes and possibly a sponsored signature if the
- * transaction gas is being partially or fully sponsored.
- */
-interface ApiDynamicGasResponse {
-    /**
-     * The modified transaction bytes that incorporate a gas coin or sponsor information.
-     */
-    txBytes: SerializedTransaction;
-    /**
-     * A signature used to sponsor or verify the updated transaction, if applicable.
-     */
-    sponsoredSignature: string;
+interface MoveErrorsInterface {
+    readonly moveErrors: MoveErrors;
 }
-
-type CoinGeckoChain = Lowercase<"Ethereum" | "Arbitrum" | "Bsc" | "Solana" | "Sui" | "Polygon" | "Avalanche" | "Optimism" | "Base">;
-type CoinGeckoCoinApiId = string;
-interface CoinGeckoCoinData {
-    chain: CoinGeckoChain | "";
-    apiId: CoinGeckoCoinApiId;
-    name: string;
-    symbol: CoinSymbol;
-    coinType: CoinType;
+type MoveErrors = Record<PackageId, Record<"ANY" | ModuleName, Record<MoveErrorCode, string>>>;
+/** Parsed location of a Move abort, the output of `Helpers.parseMoveErrorMessage`. */
+interface ParsedMoveError {
+    errorCode: MoveErrorCode;
+    packageId: ObjectId;
+    module: ModuleName;
 }
-interface CoinGeckoCoinSymbolData {
-    apiId: CoinGeckoCoinApiId;
-    name: string;
-    symbol: CoinSymbol;
+/** Parsed Move abort plus the human-readable message resolved from the registry. */
+interface TranslatedMoveError extends ParsedMoveError {
+    error: string;
 }
 
 /**
@@ -1380,7 +1409,7 @@ type ApiFarmsTopUpStakingPoolRewardsBody = {
 /**
  * Request body for increasing the emissions for specified reward coins in a pool (owner only).
  */
-type ApiFarmsIncreaseStakingPoolRewardsEmissionsBody = {
+interface ApiFarmsIncreaseStakingPoolRewardsEmissionsBody {
     ownerCapId: ObjectId;
     stakingPoolId: ObjectId;
     stakeCoinType: CoinType;
@@ -1390,7 +1419,7 @@ type ApiFarmsIncreaseStakingPoolRewardsEmissionsBody = {
         emissionRate: bigint;
     }[];
     walletAddress: SuiAddress;
-};
+}
 /**
  * Request body for fetching staking pool owner caps owned by a user.
  */
@@ -1406,13 +1435,13 @@ interface ApiFarmsOwnedStakingPoolOneTimeAdminCapsBody {
 /**
  * Request body for granting a one-time admin cap of a particular reward coin to another user.
  */
-type ApiFarmsGrantOneTimeAdminCapBody = {
+interface ApiFarmsGrantOneTimeAdminCapBody {
     ownerCapId: ObjectId;
     recipientAddress: SuiAddress;
     rewardCoinType: CoinType;
     walletAddress: SuiAddress;
     isSponsoredTx?: boolean;
-};
+}
 
 interface FaucetMintCoinEvent extends Event$1 {
     minter: SuiAddress;
@@ -2380,7 +2409,7 @@ type ApiPerpetualsAccountCollateralHistoryResponse = ApiPerpetualsHistoricalData
  * - Funding settlements
  * - Trading fees
  */
-type PerpetualsAccountCollateralChange = {
+interface PerpetualsAccountCollateralChange {
     /** When the change occurred. */
     timestamp: Timestamp;
     /** Sui transaction digest that produced this change. */
@@ -2405,7 +2434,7 @@ type PerpetualsAccountCollateralChange = {
     } | {
         netFeesUsd: number;
     };
-};
+}
 /**
  * Cursor-based response wrapping a list of orders for an account.
  */
@@ -2443,7 +2472,7 @@ interface PerpetualsAccountMarginHistoryData {
 /**
  * Individual order affecting an account.
  */
-type PerpetualsAccountOrderHistoryData = {
+interface PerpetualsAccountOrderHistoryData {
     /** Timestamp of the order. */
     timestamp: Timestamp;
     /** Sui transaction digest. */
@@ -2480,7 +2509,7 @@ type PerpetualsAccountOrderHistoryData = {
     pnl?: number;
     /** Fees charged for this order event, if applicable. */
     fees?: number;
-};
+}
 /**
  * Event emitted when collateral is deposited into an account.
  */
@@ -3671,13 +3700,13 @@ type ApiPerpetualsDepositCollateralBody = {
 /**
  * Request body for withdrawing collateral from an account.
  */
-type ApiPerpetualsWithdrawCollateralBody = {
+interface ApiPerpetualsWithdrawCollateralBody {
     accountId: PerpetualsAccountId;
     withdrawAmount: Balance;
     recipientAddress?: SuiAddress;
     txKind?: SerializedTransaction;
     sponsor?: PerpetualsSponsorConfig;
-};
+}
 /**
  * Response body for withdraw-collateral transactions.
  *
@@ -3778,7 +3807,7 @@ type ApiPerpetualsPlaceStopOrdersBody = {
  * SDK-level inputs for placing stop-loss / take-profit orders bound to a
  * specific market and position side.
  */
-type SdkPerpetualsPlaceSlTpOrdersInputs = {
+interface SdkPerpetualsPlaceSlTpOrdersInputs {
     marketId: PerpetualsMarketId;
     /** Optional target size for SL/TP orders (scaled base units). */
     size?: bigint;
@@ -3796,7 +3825,7 @@ type SdkPerpetualsPlaceSlTpOrdersInputs = {
     isSponsoredTx?: boolean;
     /** Optional gas pool sponsorship configuration. */
     sponsor?: PerpetualsSponsorConfig;
-};
+}
 /**
  * API request body for placing SL/TP orders bound to a position.
  */
@@ -3986,14 +4015,14 @@ type ApiPerpetualsScaleOrderBody = {
 /**
  * A single order to place as part of a cancel-and-place batch.
  */
-type ApiPerpetualsOrderToPlace = {
+interface ApiPerpetualsOrderToPlace {
     /** Order side: `0` = bid (long), `1` = ask (short). */
     side: PerpetualsOrderSide;
     /** Limit price (scaled bigint). */
     price: bigint;
     /** Order size in scaled base units. */
     size: bigint;
-};
+}
 /**
  * API request body for atomically canceling existing orders and placing
  * new ones in a single transaction.
@@ -4238,14 +4267,14 @@ interface ApiPerpetualsMarketsPricesResponse {
  * - **Method 2 (composed flow)**: Provide `deferred` with argument references
  *   from a deferred `getCreateAccountTx` call.
  */
-type ApiPerpetualsGrantAgentWalletTxBody = {
+interface ApiPerpetualsGrantAgentWalletTxBody {
     recipientAddress: SuiAddress;
     /** Perpetuals account ID (Method 1). */
     accountId?: PerpetualsAccountId;
     /** Composed PTB args from deferred create-account (Method 2). */
     deferred?: DeferredAccountArgs;
     txKind?: SerializedTransaction;
-};
+}
 /**
  * Request body for revoking an Agent Wallet from a perpetuals account.
  *
@@ -4254,12 +4283,12 @@ type ApiPerpetualsGrantAgentWalletTxBody = {
  * The resulting on-chain transaction must be signed by the **account admin** wallet.
  * `accountCapId` is the object ID of the assistant capability to revoke.
  */
-type ApiPerpetualsRevokeAgentWalletTxBody = {
+interface ApiPerpetualsRevokeAgentWalletTxBody {
     accountId: PerpetualsAccountId;
     accountCapId: ObjectId;
     txKind?: SerializedTransaction;
-};
-type ApiPerpetualsTransferCapTxBody = {
+}
+interface ApiPerpetualsTransferCapTxBody {
     /**
      * Recipient wallet address that should receive the capability object.
      *
@@ -4285,7 +4314,7 @@ type ApiPerpetualsTransferCapTxBody = {
      */
     txKind?: SerializedTransaction;
     sponsor?: PerpetualsSponsorConfig;
-};
+}
 /**
  * Request body for sharing a Perpetuals account that was created with deferred sharing.
  *
@@ -6999,19 +7028,33 @@ interface ApiOwnedStakedSuiFrensBody {
     walletAddress: SuiAddress;
 }
 
-type ResponseWithTxKind = {
+interface ResponseWithTxKind {
     txKind: SerializedTransaction;
     sponsorSignature?: string;
-} & (Record<string, unknown> | {});
+}
 declare class Caller {
-    config: CallerConfig;
-    private readonly apiUrlPrefix;
     protected readonly apiBaseUrl?: Url;
     protected readonly apiEndpoint: Url;
+    config: CallerConfig;
+    private readonly apiUrlPrefix;
     constructor(config?: CallerConfig, apiUrlPrefix?: Url);
     private static fetchResponseToType;
-    private static apiBaseUrlForNetwork;
-    private urlForApiCall;
+    private static readonly TRAILING_SLASHES_REGEX;
+    private static readonly HTTP_PROTOCOL_REGEX;
+    private static readonly NETWORK_API_BASE_URLS;
+    private static readonly NETWORK_FULLNODE_URLS;
+    /**
+     * Resolves the canonical Aftermath API base URL for a given network.
+     * To target a non-canonical host (custom deployment, local backend, etc.)
+     * pass `baseUrl` on `CallerConfig` instead.
+     */
+    static apiBaseUrlForNetwork(network: SuiNetwork): Url;
+    /**
+     * Resolves the canonical Sui fullnode URL for a given network. Falls back
+     * to the mainnet fullnode when `network` is undefined.
+     */
+    static defaultFullnodeUrl(network: SuiNetwork | undefined): Url;
+    private readonly urlForApiCall;
     protected fetchApi<Output, BodyType = undefined>(url: Url, body?: BodyType, signal?: AbortSignal, options?: {
         disableBigIntJsonParsing?: boolean;
     }): Promise<Output>;
@@ -7194,8 +7237,7 @@ declare class Auth extends Caller {
  * @example
  * ```typescript
  *
- * const afSdk = new Aftermath("MAINNET");
- * await afSdk.init(); // initialize provider
+ * const afSdk = await Aftermath.create({ network: "MAINNET" });
  *
  * const coin = afSdk.Coin("0x2::sui::SUI");
  *
@@ -7204,7 +7246,7 @@ declare class Auth extends Caller {
  */
 declare class Coin extends Caller {
     readonly coinType: CoinType | undefined;
-    readonly Provider?: AftermathApi | undefined;
+    readonly api?: AftermathApi | undefined;
     /**
      * Static configuration and defaults for Sui coin types, including the standard
      * SUI coin type, default decimals, and coin object type path.
@@ -7264,9 +7306,9 @@ declare class Coin extends Caller {
      *
      * @param coinType - The coin's type string (e.g., "0x2::sui::SUI"). If omitted, methods that require a type will need it passed in manually.
      * @param config - Optional caller configuration (network, access token).
-     * @param Provider - An optional `AftermathApi` instance for coin-specific API calls.
+     * @param api - An optional `AftermathApi` instance for coin-specific API calls.
      */
-    constructor(coinType?: CoinType | undefined, config?: CallerConfig, Provider?: AftermathApi | undefined);
+    constructor(coinType?: CoinType | undefined, config?: CallerConfig, api?: AftermathApi | undefined);
     /**
      * Retrieves the decimals for multiple coins by calling the Aftermath API for metadata
      * and extracting the `decimals` property.
@@ -7495,11 +7537,6 @@ declare class Coin extends Caller {
         coinType: CoinType;
         coinSymbolToCoinTypes: CoinSymbolToCoinTypes;
     }) => CoinSymbol | undefined;
-    /**
-     * Internal method to retrieve a specialized coin-related API from `AftermathApi`.
-     * Throws an error if no provider is set.
-     */
-    private useProvider;
 }
 
 /**
@@ -7511,15 +7548,15 @@ declare class Coin extends Caller {
  */
 declare class FarmsStakingPool extends Caller {
     stakingPool: FarmsStakingPoolObject;
-    readonly Provider?: AftermathApi | undefined;
+    readonly api?: AftermathApi | undefined;
     /**
      * Creates a `FarmsStakingPool` instance based on on-chain pool data.
      *
      * @param stakingPool - The on-chain data object describing the pool.
      * @param config - An optional `CallerConfig` for network settings.
-     * @param Provider - An optional `AftermathApi` for transaction building.
+     * @param api - An optional `AftermathApi` for transaction building.
      */
-    constructor(stakingPool: FarmsStakingPoolObject, config?: CallerConfig, Provider?: AftermathApi | undefined);
+    constructor(stakingPool: FarmsStakingPoolObject, config?: CallerConfig, api?: AftermathApi | undefined);
     /**
      * Fetches the total value locked (TVL) for this staking pool alone.
      *
@@ -7780,7 +7817,7 @@ declare class FarmsStakingPool extends Caller {
     /**
      * Provides access to the farm-specific provider methods for building transactions.
      */
-    private useProvider;
+    private readonly farmsApi;
 }
 
 /**
@@ -7791,7 +7828,7 @@ declare class FarmsStakingPool extends Caller {
  */
 declare class FarmsStakedPosition extends Caller {
     stakedPosition: FarmsStakedPositionObject;
-    readonly Provider?: AftermathApi | undefined;
+    readonly api?: AftermathApi | undefined;
     /**
      * The timestamp (in ms) when rewards were last harvested for this position, possibly overriding the
      * on-chain data if provided in the constructor.
@@ -7803,9 +7840,9 @@ declare class FarmsStakedPosition extends Caller {
      * @param stakedPosition - The on-chain data object representing the user's staked position.
      * @param trueLastHarvestRewardsTimestamp - Optionally overrides the last harvest time from the on-chain data.
      * @param config - Optional configuration for the underlying `Caller`.
-     * @param Provider - Optional `AftermathApi` instance for transaction building.
+     * @param api - Optional `AftermathApi` instance for transaction building.
      */
-    constructor(stakedPosition: FarmsStakedPositionObject, trueLastHarvestRewardsTimestamp?: Timestamp | undefined, config?: CallerConfig, Provider?: AftermathApi | undefined);
+    constructor(stakedPosition: FarmsStakedPositionObject, trueLastHarvestRewardsTimestamp?: Timestamp | undefined, config?: CallerConfig, api?: AftermathApi | undefined);
     /**
      * Returns the version of the farm system that this position belongs to (1 or 2).
      */
@@ -8001,11 +8038,11 @@ declare class FarmsStakedPosition extends Caller {
      * Determines if this position is unlocked based on the lock end timestamp, the emission end timestamp,
      * or a forced unlock condition in the pool.
      */
-    private isUnlocked;
+    private readonly isUnlocked;
     /**
      * Provides access to the `Farms` provider in the `AftermathApi`.
      */
-    private useProvider;
+    private readonly farmsApi;
 }
 
 /**
@@ -8016,7 +8053,7 @@ declare class FarmsStakedPosition extends Caller {
  * with the farming system.
  */
 declare class Farms extends Caller {
-    readonly Provider?: AftermathApi | undefined;
+    readonly api?: AftermathApi | undefined;
     /**
      * Contains constants relevant to farming, including minimum rewards to claim
      * and maximum lock multipliers.
@@ -8036,9 +8073,9 @@ declare class Farms extends Caller {
      * farm-related transactions.
      *
      * @param config - Optional configuration, including network and access token.
-     * @param Provider - An optional `AftermathApi` instance for advanced transaction building.
+     * @param api - An optional `AftermathApi` instance for advanced transaction building.
      */
-    constructor(config?: CallerConfig, Provider?: AftermathApi | undefined);
+    constructor(config?: CallerConfig, api?: AftermathApi | undefined);
     /**
      * Fetches a single staking pool by its `objectId` from the farm API/indexer.
      *
@@ -8220,81 +8257,219 @@ declare class Farms extends Caller {
      * Retrieves an instance of the `Farms` provider from the passed `AftermathApi`,
      * throwing an error if not available.
      */
-    private useProvider;
+    private readonly farmsApi;
 }
 
 declare class Faucet extends Caller {
-    readonly Provider?: AftermathApi | undefined;
+    readonly api?: AftermathApi | undefined;
     static readonly constants: {
         defaultRequestAmountUsd: number;
     };
-    constructor(config?: CallerConfig, Provider?: AftermathApi | undefined);
+    constructor(config?: CallerConfig, api?: AftermathApi | undefined);
     getSupportedCoins(): Promise<CoinType[]>;
-    getRequestCoinTransaction(inputs: ApiFaucetRequestBody): Promise<Transaction>;
-    getMintSuiFrenTransaction(inputs: ApiFaucetMintSuiFrenBody): Promise<Transaction>;
-    private useProvider;
+    getRequestCoinTransaction(inputs: ApiFaucetRequestBody): Promise<_mysten_sui_transactions.Transaction>;
+    getMintSuiFrenTransaction(inputs: ApiFaucetMintSuiFrenBody): Promise<_mysten_sui_transactions.Transaction>;
+    private readonly faucetApi;
 }
 
 /**
- * The `Pool` class encapsulates all the functionality needed to interact
- * with a specific AMM pool on the Aftermath platform. It allows you to
- * calculate trade amounts, deposit/withdraw amounts, fetch transactions,
- * and retrieve on-chain statistics and event data.
+ * The `GasPools` class provides methods for interacting with shared gas pool
+ * endpoints on the Aftermath platform. This includes querying pool details
+ * and building transactions for creating, depositing into, withdrawing from,
+ * sponsoring, granting access to, and revoking access from gas pools.
  *
  * @example
  * ```typescript
- * const afSdk = new Aftermath("MAINNET");
- * await afSdk.init(); // initialize provider
+ * const gasPools = new GasPools({ network: "MAINNET" });
  *
- * const pools = afSdk.Pools();
- * const pool = await pools.getPool({ objectId: "0x..." });
+ * // Get gas pool details
+ * const pool = await gasPools.getPool({
+ *   walletAddress: "0x..."
+ * });
  *
- * const stats = await pool.getStats();
- * const tradeTx = await pool.getTradeTransaction({
+ * // Build a deposit transaction
+ * const { tx } = await gasPools.getDepositTx({
  *   walletAddress: "0x...",
- *   coinInType: "0x2::sui::SUI",
- *   coinInAmount: BigInt(1e9),
- *   coinOutType: "0x<yourCoin>",
- *   slippage: 0.01,
+ *   depositAmount: 100_000_000n
  * });
  * ```
  */
-declare class Pool extends Caller {
-    readonly pool: PoolObject;
-    readonly Provider?: AftermathApi | undefined;
-    /**
-     * Internal margin of error used in trade calculations to prevent
-     * exceeding maximum allowed percentages of pool balances.
-     */
-    private static readonly constants;
-    /**
-     * An optional cached object containing statistical data about the pool
-     * (volume, fees, APR, etc.).
-     */
-    stats: PoolStats | undefined;
+declare class GasPools extends Caller {
+    readonly api?: AftermathApi | undefined;
+    constructor(config?: CallerConfig, api?: AftermathApi | undefined);
     /**
-     * Creates a new instance of the `Pool` class for on-chain interaction.
+     * Fetches the gas pool details for a given wallet address.
      *
-     * @param pool - The fetched `PoolObject` from Aftermath API or on-chain query.
-     * @param config - Optional caller configuration (e.g., network, access token).
-     * @param Provider - An optional `AftermathApi` instance for advanced transaction usage.
+     * @param inputs - {@link ApiGasPoolBody}
+     * @returns {@link ApiGasPoolResponse} containing pool ID, balance, and whitelisted addresses.
      */
-    constructor(pool: PoolObject, config?: CallerConfig, Provider?: AftermathApi | undefined);
+    getPool(inputs: ApiGasPoolBody): Promise<ApiGasPoolResponse>;
     /**
-     * Builds or fetches a deposit transaction to add liquidity to this pool.
-     * The resulting `Transaction` can be signed and submitted by the user.
+     * Builds a transaction to create a new gas pool for the given wallet.
      *
-     * @param inputs - The deposit parameters including coin amounts, slippage, etc.
-     * @returns A `Transaction` to deposit funds into the pool.
+     * When `deferShare` is `true`, the response includes `gasPoolArg` and
+     * `sharePolicyArg` so you can compose additional commands (e.g. deposit,
+     * grant) before calling {@link getShareTx} to finalize.
      *
-     * @example
-     * ```typescript
-     * const depositTx = await pool.getDepositTransaction({
-     *   walletAddress: "0x...",
-     *   amountsIn: { "0x<coin>": BigInt(1000000) },
-     *   slippage: 0.01,
-     * });
-     * ```
+     * @param inputs.walletAddress - Wallet address to create the gas pool for.
+     * @param inputs.initialDepositAmount - Optional initial deposit amount in MIST.
+     * @param inputs.deferShare - When true, returns args without sharing yet.
+     * @param inputs.tx - Optional transaction to extend.
+     * @returns `tx` plus optional `gasPoolArg` and `sharePolicyArg` when deferred.
+     */
+    getCreateTx(inputs: Omit<ApiGasPoolCreateBody, "txKind"> & {
+        tx?: Transaction;
+    }): Promise<Omit<ApiGasPoolCreateResponse, "txKind"> & {
+        tx: Transaction;
+    }>;
+    /**
+     * Builds a transaction to deposit into the gas pool.
+     *
+     * Supports SUI and non-SUI deposits. For non-SUI deposits, the input coin
+     * is swapped into SUI via the Aftermath router before depositing.
+     *
+     * @param inputs.walletAddress - Wallet address submitting the deposit.
+     * @param inputs.isSponsoredTx - Whether to build the transaction for sponsored gas. Defaults to false.
+     * @param inputs.coinType - Coin type to deposit. Defaults to SUI.
+     * @param inputs.amount - Amount to deposit (required when sourcing from wallet or for non-SUI).
+     * @param inputs.coinArg - PTB coin argument to use as input (if omitted, sourced from wallet).
+     * @param inputs.slippage - Slippage tolerance for non-SUI swaps (defaults to 0.01).
+     * @param inputs.gasPoolArg - Optional gas pool argument from a previously-built PTB command.
+     * @param inputs.tx - Optional transaction to extend.
+     * @returns {@link SdkTransactionResponse} with `tx`.
+     */
+    getDepositTx(inputs: Omit<ApiGasPoolDepositBody, "txKind"> & {
+        tx?: Transaction;
+    }): Promise<SdkTransactionResponse>;
+    /**
+     * Builds a transaction to withdraw SUI from the gas pool.
+     *
+     * When `deferTransfer` is `true`, the withdrawn coin is not transferred.
+     * Instead, `withdrawnCoinArg` is returned for further PTB composition.
+     *
+     * @param inputs.walletAddress - Wallet address submitting the withdrawal.
+     * @param inputs.amount - Amount of SUI to withdraw in MIST.
+     * @param inputs.recipientAddress - Optional recipient (defaults to `walletAddress`).
+     * @param inputs.deferTransfer - When true, returns the withdrawn coin arg instead of transferring.
+     * @param inputs.gasPoolArg - Optional gas pool argument from a previously-built PTB command.
+     * @param inputs.tx - Optional transaction to extend.
+     * @returns `tx` plus optional `withdrawnCoinArg` when deferred.
+     */
+    getWithdrawTx(inputs: Omit<ApiGasPoolWithdrawBody, "txKind"> & {
+        tx?: Transaction;
+    }): Promise<Omit<ApiGasPoolWithdrawResponse, "txKind"> & {
+        tx: Transaction;
+    }>;
+    /**
+     * Builds a transaction to sponsor (rebate) the transaction sender
+     * using SUI from the gas pool.
+     *
+     * @param inputs.walletAddress - Wallet address submitting the sponsor transaction.
+     * @param inputs.amount - Amount of SUI to rebate in MIST.
+     * @param inputs.tx - Optional transaction to extend.
+     * @returns {@link SdkTransactionResponse} with `tx`.
+     */
+    getSponsorTx(inputs: Omit<ApiGasPoolSponsorBody, "txKind"> & {
+        tx?: Transaction;
+    }): Promise<SdkTransactionResponse>;
+    /**
+     * Builds a transaction to grant another wallet access to the gas pool.
+     *
+     * @param inputs.walletAddress - Owner wallet address.
+     * @param inputs.targetWalletAddress - Wallet address to grant access to.
+     * @param inputs.gasPoolArg - Optional gas pool argument from a previously-built PTB command.
+     * @param inputs.tx - Optional transaction to extend.
+     * @returns {@link SdkTransactionResponse} with `tx`.
+     */
+    getGrantTx(inputs: Omit<ApiGasPoolGrantBody, "txKind"> & {
+        tx?: Transaction;
+    }): Promise<SdkTransactionResponse>;
+    /**
+     * Builds a transaction to revoke another wallet's access to the gas pool.
+     *
+     * @param inputs.walletAddress - Owner wallet address.
+     * @param inputs.targetWalletAddress - Wallet address to revoke access from.
+     * @param inputs.tx - Optional transaction to extend.
+     * @returns {@link SdkTransactionResponse} with `tx`.
+     */
+    getRevokeTx(inputs: Omit<ApiGasPoolRevokeBody, "txKind"> & {
+        tx?: Transaction;
+    }): Promise<SdkTransactionResponse>;
+    /**
+     * Builds a transaction to share a gas pool that was created with `deferShare: true`.
+     *
+     * Use this after composing additional commands (deposit, grant, etc.) with
+     * the `gasPoolArg` returned by {@link getCreateTx}.
+     *
+     * @param inputs.gasPoolArg - Gas pool argument from a deferred create.
+     * @param inputs.sharePolicyArg - Share policy argument from a deferred create.
+     * @param inputs.tx - Optional transaction to extend.
+     * @returns {@link SdkTransactionResponse} with `tx`.
+     */
+    getShareTx(inputs: Omit<ApiGasPoolShareBody, "txKind"> & {
+        tx?: Transaction;
+    }): Promise<SdkTransactionResponse>;
+}
+
+/**
+ * The `Pool` class encapsulates all the functionality needed to interact
+ * with a specific AMM pool on the Aftermath platform. It allows you to
+ * calculate trade amounts, deposit/withdraw amounts, fetch transactions,
+ * and retrieve on-chain statistics and event data.
+ *
+ * @example
+ * ```typescript
+ * const afSdk = await Aftermath.create({ network: "MAINNET" });
+ *
+ * const pools = afSdk.Pools();
+ * const pool = await pools.getPool({ objectId: "0x..." });
+ *
+ * const stats = await pool.getStats();
+ * const tradeTx = await pool.getTradeTransaction({
+ *   walletAddress: "0x...",
+ *   coinInType: "0x2::sui::SUI",
+ *   coinInAmount: BigInt(1e9),
+ *   coinOutType: "0x<yourCoin>",
+ *   slippage: 0.01,
+ * });
+ * ```
+ */
+declare class Pool extends Caller {
+    readonly pool: PoolObject;
+    readonly api?: AftermathApi | undefined;
+    /**
+     * Internal margin of error used in trade calculations to prevent
+     * exceeding maximum allowed percentages of pool balances.
+     */
+    private static readonly constants;
+    /**
+     * An optional cached object containing statistical data about the pool
+     * (volume, fees, APR, etc.).
+     */
+    stats: PoolStats | undefined;
+    /**
+     * Creates a new instance of the `Pool` class for on-chain interaction.
+     *
+     * @param pool - The fetched `PoolObject` from Aftermath API or on-chain query.
+     * @param config - Optional caller configuration (e.g., network, access token).
+     * @param api - An optional `AftermathApi` instance for advanced transaction usage.
+     */
+    constructor(pool: PoolObject, config?: CallerConfig, api?: AftermathApi | undefined);
+    /**
+     * Builds or fetches a deposit transaction to add liquidity to this pool.
+     * The resulting `Transaction` can be signed and submitted by the user.
+     *
+     * @param inputs - The deposit parameters including coin amounts, slippage, etc.
+     * @returns A `Transaction` to deposit funds into the pool.
+     *
+     * @example
+     * ```typescript
+     * const depositTx = await pool.getDepositTransaction({
+     *   walletAddress: "0x...",
+     *   amountsIn: { "0x<coin>": BigInt(1000000) },
+     *   slippage: 0.01,
+     * });
+     * ```
      */
     getDepositTransaction(inputs: ApiPoolDepositBody): Promise<Transaction>;
     /**
@@ -8674,7 +8849,7 @@ declare class Pool extends Caller {
      * @param inputs - Contains `amount` as a bigint.
      * @returns The post-fee amount as a bigint.
      */
-    private getAmountWithDAOFee;
+    private readonly getAmountWithDAOFee;
     /**
      * The inverse operation of `getAmountWithDAOFee`, used in internal calculations
      * when we need to back out how much input was needed prior to the fee cut.
@@ -8682,12 +8857,12 @@ declare class Pool extends Caller {
      * @param inputs - Contains `amount` as a bigint.
      * @returns The pre-fee amount as a bigint.
      */
-    private getAmountWithoutDAOFee;
+    private readonly getAmountWithoutDAOFee;
     /**
      * Provides an instance of the Pools provider from `AftermathApi`.
      * Throws an error if not defined.
      */
-    private useProvider;
+    private readonly poolsApi;
 }
 
 /**
@@ -8698,8 +8873,7 @@ declare class Pool extends Caller {
  *
  * @example
  * ```typescript
- * const afSdk = new Aftermath("MAINNET");
- * await afSdk.init(); // initialize provider
+ * const afSdk = await Aftermath.create({ network: "MAINNET" });
  *
  * const pools = afSdk.Pools();
  *
@@ -8711,7 +8885,7 @@ declare class Pool extends Caller {
  * ```
  */
 declare class Pools extends Caller {
-    readonly Provider?: AftermathApi | undefined;
+    readonly api?: AftermathApi | undefined;
     /**
      * Static constants relevant to the pool logic, such as protocol fees,
      * referral percentages, and bounds for trading/withdrawal percentages.
@@ -8801,9 +8975,9 @@ declare class Pools extends Caller {
      * Creates a new `Pools` instance for querying and managing AMM pools on Aftermath.
      *
      * @param config - Optional configuration object specifying network or access token.
-     * @param Provider - An optional `AftermathApi` instance providing advanced transaction building.
+     * @param api - An optional `AftermathApi` instance providing advanced transaction building.
      */
-    constructor(config?: CallerConfig, Provider?: AftermathApi | undefined);
+    constructor(config?: CallerConfig, api?: AftermathApi | undefined);
     /**
      * Fetches a single pool by its on-chain `objectId` and returns a new `Pool` instance.
      *
@@ -9088,15 +9262,14 @@ declare class Pools extends Caller {
      * Provides a typed reference to the `Pools` part of the `AftermathApi`,
      * throwing an error if not defined.
      */
-    private useProvider;
+    private readonly poolsApi;
 }
 
 declare class NftAmmMarket extends Caller {
     readonly market: NftAmmMarketObject;
-    private readonly Provider?;
-    private static readonly constants;
+    private readonly api?;
     pool: Pool;
-    constructor(market: NftAmmMarketObject, config?: CallerConfig, Provider?: AftermathApi | undefined);
+    constructor(market: NftAmmMarketObject, config?: CallerConfig, api?: AftermathApi | undefined);
     getNfts(inputs: {
         cursor?: ObjectId;
         limit?: number;
@@ -9137,13 +9310,13 @@ declare class NftAmmMarket extends Caller {
         lpCoinAmount: Balance;
         referral?: boolean;
     }) => bigint;
-    private useProvider;
+    private readonly nftAmmApi;
 }
 
 declare class NftAmm extends Caller {
-    readonly Provider?: AftermathApi | undefined;
+    readonly api?: AftermathApi | undefined;
     static readonly constants: {};
-    constructor(config?: CallerConfig, Provider?: AftermathApi | undefined);
+    constructor(config?: CallerConfig, api?: AftermathApi | undefined);
     getMarket(inputs: {
         objectId: ObjectId;
     }): Promise<NftAmmMarket>;
@@ -9151,1216 +9324,1203 @@ declare class NftAmm extends Caller {
         objectIds: ObjectId[];
     }): Promise<NftAmmMarket[]>;
     getAllMarkets(): Promise<NftAmmMarket[]>;
-    private useProvider;
 }
 
 /**
- * High-level wrapper around a single perpetuals market.
+ * Note on “refreshing” account state:
  *
- * This class provides:
+ * 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.
  *
- * - Lightweight accessors for immutable market properties:
- *   - `marketId`, `indexPrice`, `collateralPrice`, `collateralCoinType`
- *   - `marketParams`, `marketState`
- * - Read endpoints for:
- *   - Orderbook snapshots
- *   - 24h stats and order history
- *   - Market prices and derived funding metrics
- * - Helpers for:
- *   - Order sizing (max size, lot/tick rounding)
- *   - Margin and collateral calculations
- *   - Constructing an “empty” position for a market
+ * 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.
  *
- * Typical usage:
+ * 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 perps = new Perpetuals(config);
- * const { markets } = await perps.getMarkets({ marketIds: ["0x..."] });
- * const market = markets[0];
+ * const afSdk = await Aftermath.create({ network: "MAINNET" });
  *
- * const { orderbook } = await market.getOrderbook();
- * const stats = await market.get24hrStats();
- * const { basePrice, collateralPrice } = await market.getPrices();
+ * 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"),
+ * });
  * ```
  */
-declare class PerpetualsMarket extends Caller {
-    marketData: PerpetualsMarketData;
-    readonly Provider?: AftermathApi | undefined;
-    /** Unique identifier for this perpetuals market (object ID on chain). */
-    readonly marketId: PerpetualsMarketId;
+declare class PerpetualsAccount extends Caller {
+    readonly account: PerpetualsAccountObject;
+    readonly accountCap: PerpetualsAccountCap | PerpetualsPartialVaultCap;
+    readonly api?: AftermathApi | undefined;
     /**
-     * Current oracle/index price for the market's underlying asset, quoted in
-     * the index unit (typically USD).
+     * 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.
      */
-    readonly indexPrice: number;
+    private readonly vaultId;
     /**
-     * Current price of the collateral asset in USD (or the platform's base
-     * pricing unit).
+     * 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 api - Optional shared {@link AftermathApi} provider instance
+     *   used to derive serialized transaction kinds (`txKind`) from
+     *   {@link Transaction} objects.
      */
-    readonly collateralPrice: number;
-    /** Sui type of the collateral coin (e.g. `"0x2::sui::SUI"`). */
-    readonly collateralCoinType: CoinType;
-    /** Static market configuration parameters (lot size, tick size, margins, etc.). */
-    readonly marketParams: PerpetualsMarketParams;
-    /** Dynamic market state (funding rates, open interest, etc.). */
-    readonly marketState: PerpetualsMarketState;
+    constructor(account: PerpetualsAccountObject, accountCap: PerpetualsAccountCap | PerpetualsPartialVaultCap, config?: CallerConfig, api?: AftermathApi | undefined);
     /**
-     * Create a new {@link PerpetualsMarket} wrapper from raw market data.
-     *
-     * @param marketData - Snapshot of market configuration and state.
-     * @param config - Optional {@link CallerConfig} (network, base URL, etc.).
-     * @param Provider - Optional shared {@link AftermathApi} provider instance.
+     * Build a `deposit-collateral` transaction for this account.
      *
-     * @remarks
-     * This class extends {@link Caller} with the `"perpetuals"` route prefix, meaning
-     * all HTTP requests resolve under `/perpetuals/...`.
-     */
-    constructor(marketData: PerpetualsMarketData, config?: CallerConfig, Provider?: AftermathApi | undefined);
-    /**
-     * Fetch the 24-hour volume and price change statistics for this market.
-     *
-     * Under the hood, this calls {@link Perpetuals.getMarkets24hrStats} and
-     * returns the first (and only) entry.
+     * For non-vault accounts, this endpoint constructs a transaction that:
+     * - Optionally extends an existing {@link Transaction}, and
+     * - Deposits collateral into the Perpetuals account.
      *
-     * @returns {@link PerpetualsMarket24hrStats}.
+     * **Note:** Vault accounts are currently not supported and will throw.
      *
-     * @remarks
-     * This method creates a new {@link Perpetuals} instance using `this.config`.
-     * If you need shared Provider behavior, prefer calling `perps.getMarkets24hrStats`
-     * directly with the same Provider you initialized.
-     */
-    get24hrStats(): Promise<PerpetualsMarket24hrStats>;
-    /**
-     * Fetch the full orderbook snapshot for this market.
+     * @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 Object containing `orderbook`.
+     * @returns Transaction response containing a `tx`.
      *
      * @example
      * ```ts
-     * const { orderbook } = await market.getOrderbook();
-     * console.log(orderbook.bids[0], orderbook.asks[0]);
+     * const { tx } = await account.getDepositCollateralTx({
+     *   depositAmount: BigInt("1000000000"),
+     * });
      * ```
      */
-    getOrderbook(): Promise<{
-        orderbook: PerpetualsOrderbook;
+    getDepositCollateralTx(inputs: {
+        tx?: Transaction;
+        isSponsoredTx?: boolean;
+        sponsor?: PerpetualsSponsorConfig;
+    } & ({
+        depositAmount: Balance;
+    } | {
+        depositCoinArg: TransactionObjectArgument;
+    })): Promise<Omit<ApiTransactionResponse, "txKind"> & {
+        tx: Transaction;
     }>;
     /**
-     * Compute the maximum order size that can be placed by a given account
-     * in this market, under optional leverage and price assumptions.
+     * Build a `withdraw-collateral` transaction for this account.
      *
-     * This is a common frontend helper for:
-     * - "max size" buttons
-     * - input validation against risk limits
+     * 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:** This is routed through the `account` namespace because it depends on
-     * the account's collateral and positions.
+     * **Note:** Vault accounts are currently not supported and will throw.
      *
-     * @param inputs.accountId - Perpetuals account ID.
-     * @param inputs.side - Order side (Bid/Ask).
-     * @param inputs.leverage - Optional assumed leverage.
-     * @param inputs.price - Optional assumed price (e.g. for limit orders).
+     * @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 `{ maxOrderSize }` in base units (scaled integer as `bigint`).
+     * @returns A response containing `tx` and the `coinOutArg` where the
+     *   withdrawn coins end up if `recipientAddress` is not used.
      *
      * @example
      * ```ts
-     * const { maxOrderSize } = await market.getMaxOrderSize({
-     *   accountId: 123n,
-     *   side: PerpetualsOrderSide.Bid,
-     *   leverage: 5,
+     * const { tx, coinOutArg } = await account.getWithdrawCollateralTx({
+     *   withdrawAmount: BigInt("1000000000"),
      * });
      * ```
      */
-    getMaxOrderSize: (inputs: Omit<ApiPerpetualsMaxOrderSizeBody, "marketId">) => Promise<{
-        maxOrderSize: bigint;
+    getWithdrawCollateralTx(inputs: {
+        withdrawAmount: Balance;
+        recipientAddress?: SuiAddress;
+        sponsor?: PerpetualsSponsorConfig;
+        tx?: Transaction;
+    }): Promise<Omit<ApiPerpetualsWithdrawCollateralResponse, "txKind"> & {
+        tx: Transaction;
     }>;
     /**
-     * Market-level preview of placing a market order.
+     * Build an `allocate-collateral` transaction, moving collateral from this
+     * account into a specific market (clearing house).
      *
-     * Unlike {@link PerpetualsAccount.getPlaceMarketOrderPreview}, this version:
-     * - Calls `account/previews/place-market-order`
-     * - Explicitly sets `accountId: undefined`, allowing a “generic” preview that
-     *   doesn’t rely on a specific account’s on-chain positions/collateral.
+     * Works for both account-backed and vault-backed accounts.
      *
-     * @param inputs - {@link SdkPerpetualsPlaceMarketOrderPreviewInputs}.
-     * @param abortSignal - Optional abort signal to cancel the request.
+     * @param inputs.marketId - Market to allocate collateral to.
+     * @param inputs.allocateAmount - Amount of collateral to allocate.
+     * @param inputs.tx - Optional transaction to extend.
      *
-     * @returns Either `{ error }` or a preview containing the simulated updated position,
-     * slippage, filled/posted sizes, collateral change, and execution price.
+     * @returns Transaction response containing a `tx`.
      */
-    getPlaceMarketOrderPreview(inputs: SdkPerpetualsPlaceMarketOrderPreviewInputs, abortSignal?: AbortSignal): Promise<ApiPerpetualsPreviewPlaceOrderResponse>;
+    getAllocateCollateralTx(inputs: {
+        marketId: PerpetualsMarketId;
+        allocateAmount: Balance;
+        sponsor?: PerpetualsSponsorConfig;
+        tx?: Transaction;
+    }): Promise<Omit<ApiTransactionResponse, "txKind"> & {
+        tx: Transaction;
+    }>;
     /**
-     * Market-level preview of placing a limit order.
+     * Build a `deallocate-collateral` transaction, moving collateral from a
+     * specific market back to this account.
      *
-     * Similar to {@link getPlaceMarketOrderPreview}, this uses:
-     * - `account/previews/place-limit-order`
-     * - `accountId: undefined`
+     * Works for both account-backed and vault-backed accounts.
      *
-     * @param inputs - {@link SdkPerpetualsPlaceLimitOrderPreviewInputs}.
-     * @param abortSignal - Optional abort signal to cancel the request.
+     * @param inputs.marketId - Market to deallocate collateral from.
+     * @param inputs.deallocateAmount - Amount of collateral to deallocate.
+     * @param inputs.tx - Optional transaction to extend.
      *
-     * @returns Either `{ error }` or a preview describing the simulated post-order state.
+     * @returns Transaction response containing a `tx`.
      */
-    getPlaceLimitOrderPreview(inputs: SdkPerpetualsPlaceLimitOrderPreviewInputs, abortSignal?: AbortSignal): Promise<ApiPerpetualsPreviewPlaceOrderResponse>;
+    getDeallocateCollateralTx(inputs: {
+        marketId: PerpetualsMarketId;
+        deallocateAmount: Balance;
+        sponsor?: PerpetualsSponsorConfig;
+        tx?: Transaction;
+    }): Promise<Omit<ApiTransactionResponse, "txKind"> & {
+        tx: Transaction;
+    }>;
     /**
-     * Market-level preview of placing a scale order.
+     * Build a `transfer-collateral` transaction between two Perpetuals accounts.
      *
-     * Similar to {@link getPlaceLimitOrderPreview}, this uses:
-     * - `account/previews/place-scale-order`
-     * - `accountId: undefined`
+     * Only supported for direct accounts, **not** vault-backed accounts.
      *
-     * @param inputs - {@link SdkPerpetualsPlaceScaleOrderPreviewInputs}.
-     * @param abortSignal - Optional abort signal to cancel the request.
+     * @param inputs.transferAmount - Amount of collateral to transfer.
+     * @param inputs.toAccountId - Destination account ID.
+     * @param inputs.tx - Optional transaction to extend.
      *
-     * @returns Either `{ error }` or a preview describing the simulated post-order state.
+     * @returns Transaction response containing a `tx`.
      */
-    getPlaceScaleOrderPreview(inputs: SdkPerpetualsPlaceScaleOrderPreviewInputs, abortSignal?: AbortSignal): Promise<ApiPerpetualsPreviewPlaceOrderResponse>;
+    getTransferCollateralTx(inputs: {
+        transferAmount: Balance;
+        toAccountId: PerpetualsAccountId;
+        toAccountCapId?: ObjectId;
+        sponsor?: PerpetualsSponsorConfig;
+        tx?: Transaction;
+    }): Promise<Omit<ApiTransactionResponse, "txKind"> & {
+        tx: Transaction;
+    }>;
     /**
-     * Fetch paginated order history for this market.
+     * Build a `place-market-order` transaction for this account.
      *
-     * This is market-wide (public) history, not scoped to any 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.
      *
-     * @param inputs.beforeTimestampCursor - Optional pagination cursor.
-     * @param inputs.limit - Optional page size.
+     * 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`.
      *
-     * @returns {@link ApiPerpetualsMarketOrderHistoryResponse} containing:
-     * - `orders`
-     * - `nextBeforeTimestampCursor`
+     * @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,
+     * });
+     * ```
      */
-    getOrderHistory(inputs: Omit<ApiPerpetualsMarketOrderHistoryBody, "marketId">): Promise<ApiPerpetualsMarketOrderHistoryResponse>;
+    getPlaceMarketOrderTx(inputs: SdkPerpetualsPlaceMarketOrderInputs): Promise<Omit<ApiTransactionResponse, "txKind"> & {
+        tx: Transaction;
+    }>;
     /**
-     * Fetch the current prices for this market.
+     * Build a `place-limit-order` transaction for this account.
      *
-     * Internally calls {@link Perpetuals.getPrices} and returns the first result.
+     * 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.
      *
-     * @returns `{ marketId, basePrice, collateralPrice, midPrice, markPrice }`.
+     * 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.
      *
-     * @remarks
-     * This method instantiates a new {@link Perpetuals} client using `this.config`.
-     * If you rely on a shared Provider, call `perps.getPrices(...)` directly instead.
+     * @param inputs - See {@link SdkPerpetualsPlaceLimitOrderInputs}.
+     *
+     * @returns Transaction response containing `tx`.
      */
-    getPrices(): Promise<{
-        marketId: PerpetualsMarketId;
-        basePrice: number;
-        collateralPrice: number;
-        midPrice: number | undefined;
-        markPrice: number;
+    getPlaceLimitOrderTx(inputs: SdkPerpetualsPlaceLimitOrderInputs): Promise<Omit<ApiTransactionResponse, "txKind"> & {
+        tx: Transaction;
     }>;
     /**
-     * Compute the remaining time until the next funding event, in milliseconds.
+     * Build a `place-scale-order` transaction for this account.
      *
-     * @returns `nextFundingTimeMs() - Date.now()`.
+     * A scale order distributes a total size across multiple limit orders
+     * evenly spaced between a start and end price. An optional `sizeSkew`
+     * parameter controls whether the distribution is uniform or weighted.
      *
-     * @remarks
-     * If the next funding timestamp does not fit safely into a JS `number`,
-     * {@link nextFundingTimeMs} returns `Number.MAX_SAFE_INTEGER`, and the
-     * difference may be very large.
+     * @param inputs - See {@link SdkPerpetualsPlaceScaleOrderInputs}.
+     *
+     * @returns Transaction response containing `tx`.
      */
-    timeUntilNextFundingMs: () => Timestamp;
+    getPlaceScaleOrderTx(inputs: SdkPerpetualsPlaceScaleOrderInputs): Promise<Omit<ApiTransactionResponse, "txKind"> & {
+        tx: Transaction;
+    }>;
     /**
-     * Get the scheduled timestamp for the next funding event, in milliseconds.
+     * Build a `cancel-and-place-orders` transaction for this account.
      *
-     * Safety behavior:
-     * - If `marketData.nextFundingTimestampMs` exceeds `Number.MAX_SAFE_INTEGER`,
-     *   this returns `Number.MAX_SAFE_INTEGER`.
+     * Atomically cancels existing orders and places new ones in a single
+     * transaction. Useful for rebalancing order grids or replacing stale
+     * orders without intermediate exposure.
      *
-     * @returns Next funding timestamp (ms) as a JS `number`.
+     * @param inputs - See {@link SdkPerpetualsCancelAndPlaceOrdersInputs}.
+     *
+     * @returns Transaction response containing `tx`.
      */
-    nextFundingTimeMs: () => Timestamp;
+    getCancelAndPlaceOrdersTx(inputs: SdkPerpetualsCancelAndPlaceOrdersInputs): Promise<Omit<ApiTransactionResponse, "txKind"> & {
+        tx: Transaction;
+    }>;
     /**
-     * Estimated funding rate per period for this market.
+     * Build a `cancel-orders` transaction for this account.
      *
-     * This is read directly from `marketData.estimatedFundingRate`.
-     *
-     * @returns Estimated funding rate as a fraction (e.g. `0.01` = 1%).
-     */
-    estimatedFundingRate: () => Percentage;
-    /**
-     * Calculate the collateral required to support an order given leverage and prices.
-     *
-     * The computed collateral is based on the *remaining* unfilled size:
-     * `remaining = initialSize - filledSize`.
+     * 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
      *
-     * USD requirement:
-     * ```text
-     * remainingBase * indexPrice * initialMarginRatio
-     * ```
-     * where `initialMarginRatio = 1 / leverage` (or 1 if leverage is falsy).
+     * 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.leverage - Target leverage for the order (>= 1).
-     * @param inputs.orderData - Order data containing `initialSize` and `filledSize`.
-     * @param inputs.indexPrice - Index/oracle price of the base asset.
-     * @param inputs.collateralPrice - Price of the collateral asset.
+     * @param inputs.tx - Optional transaction to extend.
+     * @param inputs.marketIdsToData - Mapping from market IDs to cancel payloads.
      *
-     * @returns Object with:
-     * - `collateralUsd`: required collateral in USD
-     * - `collateral`: required collateral in collateral coin units
+     * @returns Transaction response containing `tx`.
      */
-    calcCollateralUsedForOrder: (inputs: {
-        leverage: number;
-        orderData: PerpetualsOrderData;
-        indexPrice: number;
-        collateralPrice: number;
-    }) => {
-        collateral: number;
-        collateralUsd: number;
-    };
+    getCancelOrdersTx(inputs: {
+        tx?: Transaction;
+        sponsor?: PerpetualsSponsorConfig;
+        marketIdsToData: Record<PerpetualsMarketId, {
+            orderIds: PerpetualsOrderId[];
+            collateralChange: number;
+        }>;
+    }): Promise<Omit<ApiTransactionResponse, "txKind"> & {
+        tx: Transaction;
+    }>;
     /**
-     * Get the base-asset lot size for this market as a `number`.
-     *
-     * Order sizes must be multiples of this lot size.
+     * Build a `cancel-stop-orders` transaction for this account.
      *
-     * @returns Lot size in base asset units.
-     */
-    lotSize(): number;
-    /**
-     * Get the minimal price tick size for this market as a `number`.
+     * This cancels stop-order *objects/tickets* by their object IDs. These IDs are
+     * returned by stop-order query endpoints (see {@link getStopOrderDatas}).
      *
-     * Limit prices must be multiples of this tick size.
+     * @param inputs.tx - Optional transaction to extend.
+     * @param inputs.stopOrderIds - Array of stop-order ticket IDs to cancel.
      *
-     * @returns Tick size in quote units (e.g. USD).
+     * @returns Transaction response containing `tx`.
      */
-    tickSize(): number;
+    getCancelStopOrdersTx(inputs: {
+        tx?: Transaction;
+        sponsor?: PerpetualsSponsorConfig;
+        stopOrderIds: ObjectId[];
+    }): Promise<Omit<ApiTransactionResponse, "txKind"> & {
+        tx: Transaction;
+    }>;
     /**
-     * Get the maximum theoretical leverage for this market.
+     * Build a `place-stop-orders` transaction for this account.
      *
-     * Computed as:
-     * ```ts
-     * 1 / marginRatioInitial
-     * ```
+     * This allows placing one or more stop orders in a single transaction,
+     * optionally with a dedicated gas coin and a sponsored gas flag.
      *
-     * @returns Maximum leverage.
-     */
-    maxLeverage(): number;
-    /**
-     * Get the initial margin ratio for this market.
+     * Typical usage:
+     * - Construct stop order payload(s) client-side
+     * - Call this method to build a transaction kind
+     * - Sign/execute the transaction via Sui
      *
-     * This is the minimum margin required when opening a position.
+     * @param inputs - See {@link SdkPerpetualsPlaceStopOrdersInputs}.
      *
-     * @returns Initial margin ratio as a fraction (e.g. 0.05 = 20x).
+     * @returns Transaction response containing `tx`.
      */
-    initialMarginRatio(): number;
+    getPlaceStopOrdersTx(inputs: SdkPerpetualsPlaceStopOrdersInputs): Promise<Omit<ApiTransactionResponse, "txKind"> & {
+        tx: Transaction;
+    }>;
     /**
-     * Get the maintenance margin ratio for this market.
+     * Build a `place-sl-tp-orders` transaction for this account.
      *
-     * Falling below this ratio may trigger liquidation.
+     * 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.
      *
-     * @returns Maintenance margin ratio as a fraction.
-     */
-    maintenanceMarginRatio(): number;
-    /**
-     * Round a price to the nearest valid tick for this market.
+     * 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).
      *
-     * Rounding mode:
-     * - `floor: true` => round down
-     * - `ceil: true`  => round up
-     * - neither       => nearest tick (`Math.round`)
+     * @param inputs - See {@link SdkPerpetualsPlaceSlTpOrdersInputs}.
      *
-     * @param inputs.price - Raw price to round.
-     * @param inputs.floor - Force floor rounding.
-     * @param inputs.ceil - Force ceil rounding.
-     * @returns Price snapped to the market tick size.
+     * @returns Transaction response containing `tx`.
      */
-    roundToValidPrice: (inputs: {
-        price: number;
-        floor?: boolean;
-        ceil?: boolean;
-    }) => number;
+    getPlaceSlTpOrdersTx(inputs: SdkPerpetualsPlaceSlTpOrdersInputs): Promise<Omit<ApiTransactionResponse, "txKind"> & {
+        tx: Transaction;
+    }>;
     /**
-     * Round a price to the nearest valid tick as a fixed-point `bigint` (1e9 precision).
-     *
-     * This is helpful when you need the on-chain representation directly
-     * (e.g. order price fields stored in 9-decimal fixed).
+     * Build an `edit-stop-orders` transaction for this account.
      *
-     * @param inputs.price - Raw price as a JS number.
-     * @param inputs.floor - Force floor rounding.
-     * @param inputs.ceil - Force ceil rounding.
-     * @returns Tick-snapped price scaled by `1e9`.
-     */
-    roundToValidPriceBigInt: (inputs: {
-        price: number;
-        floor?: boolean;
-        ceil?: boolean;
-    }) => bigint;
-    /**
-     * Round a base-asset size to the nearest valid lot size for this market.
+     * This endpoint lets you update existing stop orders in batch.
      *
-     * Rounding mode:
-     * - `floor: true` => round down
-     * - `ceil: true`  => round up
-     * - neither       => nearest lot (`Math.round`)
+     * 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.size - Raw size in base asset units.
-     * @param inputs.floor - Force floor rounding.
-     * @param inputs.ceil - Force ceil rounding.
-     * @returns Size snapped to the market lot size.
-     */
-    roundToValidSize: (inputs: {
-        size: number;
-        floor?: boolean;
-        ceil?: boolean;
-    }) => number;
-    /**
-     * Round a base-asset size to the nearest valid lot as a fixed-point `bigint` (1e9 precision).
+     * @param inputs.stopOrders - Full updated stop-order payloads to apply.
+     * @param inputs.tx - Optional transaction to extend.
      *
-     * @param inputs.size - Raw base size as a JS number.
-     * @param inputs.floor - Force floor rounding.
-     * @param inputs.ceil - Force ceil rounding.
-     * @returns Lot-snapped size scaled by `1e9`.
+     * @returns Transaction response containing `tx`.
      */
-    roundToValidSizeBigInt: (inputs: {
-        size: number;
-        floor?: boolean;
-        ceil?: boolean;
-    }) => bigint;
+    getEditStopOrdersTx(inputs: Omit<ApiPerpetualsEditStopOrdersBody, "txKind" | "accountObjectId"> & {
+        tx?: Transaction;
+    }): Promise<Omit<ApiTransactionResponse, "txKind"> & {
+        tx: Transaction;
+    }>;
     /**
-     * Construct an "empty" position object for this market.
+     * Build a `set-leverage` transaction for a given market.
      *
-     * Useful when an account has no open position but downstream UI/calculations
-     * expect a {@link PerpetualsPosition}-shaped object.
+     * This updates the effective leverage for the position (or potential position)
+     * in `marketId`, and optionally adjusts collateral in tandem.
      *
-     * @returns A zeroed-out {@link PerpetualsPosition} for `this.marketId`.
-     */
-    emptyPosition: () => PerpetualsPosition;
-}
-
-/**
- * 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"),
- * });
- * ```
- */
-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.
+     * 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}.
      *
-     * 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 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.
      *
-     * @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.
+     * @returns Transaction response containing `tx`.
      */
-    constructor(account: PerpetualsAccountObject, accountCap: PerpetualsAccountCap | PerpetualsPartialVaultCap, config?: CallerConfig, Provider?: AftermathApi | undefined);
+    getSetLeverageTx(inputs: {
+        tx?: Transaction;
+        leverage: number;
+        collateralChange: number;
+        marketId: PerpetualsMarketId;
+        sponsor?: PerpetualsSponsorConfig;
+    }): Promise<Omit<ApiTransactionResponse, "txKind"> & {
+        tx: Transaction;
+    }>;
     /**
-     * Build a `deposit-collateral` transaction for this account.
+     * Build a deterministic message payload to sign when querying stop orders
+     * from the backend.
      *
-     * For non-vault accounts, this endpoint constructs a transaction that:
-     * - Optionally extends an existing {@link Transaction}, and
-     * - Deposits collateral into the Perpetuals account.
+     * This payload is intended to be signed off-chain and then submitted to
+     * `getStopOrderDatas` as a proof of account ownership.
      *
-     * **Note:** Vault accounts are currently not supported and will throw.
+     * 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.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`).
+     * @param inputs.marketIds - Optional list of market IDs to scope the query.
      *
-     * @returns Transaction response containing a `tx`.
+     * @returns An object describing the action and account/market IDs, suitable
+     *   for message signing.
      *
      * @example
      * ```ts
-     * const { tx } = await account.getDepositCollateralTx({
-     *   depositAmount: BigInt("1000000000"),
+     * const message = account.getStopOrdersMessageToSign({ marketIds: ["0x..."] });
+     * const { signature } = await wallet.signMessage({
+     *   message: new TextEncoder().encode(JSON.stringify(message)),
      * });
      * ```
      */
-    getDepositCollateralTx(inputs: {
-        tx?: Transaction;
-        isSponsoredTx?: boolean;
-        sponsor?: PerpetualsSponsorConfig;
-    } & ({
-        depositAmount: Balance;
-    } | {
-        depositCoinArg: TransactionObjectArgument;
-    })): Promise<Omit<ApiTransactionResponse, "txKind"> & {
-        tx: Transaction;
-    }>;
+    getStopOrdersMessageToSign(inputs?: {
+        marketIds: PerpetualsMarketId[];
+    }): {
+        action: string;
+        account_id: string;
+        clearing_house_ids: string[];
+    };
     /**
-     * Build a `withdraw-collateral` transaction for this account.
+     * Preview the effects of placing a market order (without building a tx).
      *
-     * 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).
+     * 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
      *
-     * **Note:** Vault accounts are currently not supported and will throw.
+     * @param inputs - See {@link SdkPerpetualsPlaceLimitOrderPreviewInputs}.
+     * @param abortSignal - Optional `AbortSignal` to cancel the request.
      *
-     * @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 Either an error message or a preview object similar to
+     *   {@link getPlaceMarketOrderPreview}.
+     */
+    getPlaceLimitOrderPreview(inputs: SdkPerpetualsPlaceLimitOrderPreviewInputs, abortSignal?: AbortSignal): Promise<ApiPerpetualsPreviewPlaceOrderResponse>;
+    /**
+     * Preview the effects of placing a scale order (without building a tx).
      *
-     * @returns A response containing `tx` and the `coinOutArg` where the
-     *   withdrawn coins end up if `recipientAddress` is not used.
+     * A scale order distributes total size across multiple limit orders
+     * spaced between a start and end price. The preview simulates:
+     * - How much size would execute immediately vs post to the book
+     * - Expected slippage and execution price
+     * - Resulting position and margin impact
      *
-     * @example
-     * ```ts
-     * const { tx, coinOutArg } = await account.getWithdrawCollateralTx({
-     *   withdrawAmount: BigInt("1000000000"),
-     * });
-     * ```
+     * @param inputs - See {@link SdkPerpetualsPlaceScaleOrderPreviewInputs}.
+     * @param abortSignal - Optional `AbortSignal` to cancel the request.
+     *
+     * @returns Either an error message or a preview object similar to
+     *   {@link getPlaceMarketOrderPreview}.
      */
-    getWithdrawCollateralTx(inputs: {
-        withdrawAmount: Balance;
-        recipientAddress?: SuiAddress;
-        sponsor?: PerpetualsSponsorConfig;
-        tx?: Transaction;
-    }): Promise<Omit<ApiPerpetualsWithdrawCollateralResponse, "txKind"> & {
-        tx: Transaction;
-    }>;
+    getPlaceScaleOrderPreview(inputs: SdkPerpetualsPlaceScaleOrderPreviewInputs, abortSignal?: AbortSignal): Promise<ApiPerpetualsPreviewPlaceOrderResponse>;
     /**
-     * Build an `allocate-collateral` transaction, moving collateral from this
-     * account into a specific market (clearing house).
+     * Preview the effects of canceling orders across one or more markets.
      *
-     * Works for both account-backed and vault-backed accounts.
+     * 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)
      *
-     * @param inputs.marketId - Market to allocate collateral to.
-     * @param inputs.allocateAmount - Amount of collateral to allocate.
-     * @param inputs.tx - Optional transaction to extend.
+     * If `marketIdsToData` is empty, this returns a trivial preview with:
+     * - `marketIdsToData: {}`
      *
-     * @returns Transaction response containing a `tx`.
+     * @param inputs - See {@link SdkPerpetualsCancelOrdersPreviewInputs}.
+     * @param abortSignal - Optional `AbortSignal` to cancel the request.
+     *
+     * @returns Either:
+     * - `{ marketIdsToData }`, or
+     * - `{ error }`.
      */
-    getAllocateCollateralTx(inputs: {
-        marketId: PerpetualsMarketId;
-        allocateAmount: Balance;
-        sponsor?: PerpetualsSponsorConfig;
-        tx?: Transaction;
-    }): Promise<Omit<ApiTransactionResponse, "txKind"> & {
-        tx: Transaction;
-    }>;
+    getCancelOrdersPreview(inputs: SdkPerpetualsCancelOrdersPreviewInputs, abortSignal?: AbortSignal): Promise<ApiPerpetualsPreviewCancelOrdersResponse>;
     /**
-     * Build a `deallocate-collateral` transaction, moving collateral from a
-     * specific market back to this account.
+     * Preview the effects of setting leverage for a given market.
      *
-     * Works for both account-backed and vault-backed accounts.
+     * The preview returns:
+     * - The position after the leverage change (`updatedPosition`)
+     * - The collateral delta required/produced (`collateralChange`)
      *
-     * @param inputs.marketId - Market to deallocate collateral from.
-     * @param inputs.deallocateAmount - Amount of collateral to deallocate.
-     * @param inputs.tx - Optional transaction to extend.
+     * @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 Transaction response containing a `tx`.
+     * @returns Either:
+     * - `{ updatedPosition, collateralChange }`, or
+     * - `{ error }`.
      */
-    getDeallocateCollateralTx(inputs: {
+    getSetLeveragePreview(inputs: {
         marketId: PerpetualsMarketId;
-        deallocateAmount: Balance;
-        sponsor?: PerpetualsSponsorConfig;
-        tx?: Transaction;
-    }): Promise<Omit<ApiTransactionResponse, "txKind"> & {
-        tx: Transaction;
+        leverage: number;
+    }, abortSignal?: AbortSignal): Promise<{
+        updatedPosition: PerpetualsPosition;
+        collateralChange: number;
+    } | {
+        error: string;
     }>;
     /**
-     * Build a `transfer-collateral` transaction between two Perpetuals accounts.
+     * Preview the effects of allocating/deallocating collateral for the position in
+     * a given market.
      *
-     * Only supported for direct accounts, **not** vault-backed accounts.
+     * Semantics:
+     * - Positive `collateralChange` previews allocation (moving collateral into the market).
+     * - Negative `collateralChange` previews deallocation (moving collateral out of the market).
      *
-     * @param inputs.transferAmount - Amount of collateral to transfer.
-     * @param inputs.toAccountId - Destination account ID.
-     * @param inputs.tx - Optional transaction to extend.
+     * @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 Transaction response containing a `tx`.
+     * @returns Either:
+     * - `{ updatedPosition, collateralChange }`, or
+     * - `{ error }`.
      */
-    getTransferCollateralTx(inputs: {
-        transferAmount: Balance;
-        toAccountId: PerpetualsAccountId;
-        toAccountCapId?: ObjectId;
-        sponsor?: PerpetualsSponsorConfig;
-        tx?: Transaction;
-    }): Promise<Omit<ApiTransactionResponse, "txKind"> & {
-        tx: Transaction;
+    getEditCollateralPreview(inputs: {
+        marketId: PerpetualsMarketId;
+        collateralChange: Balance;
+    }, abortSignal?: AbortSignal): Promise<{
+        updatedPosition: PerpetualsPosition;
+        collateralChange: number;
+    } | {
+        error: string;
     }>;
     /**
-     * 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`.
+     * Fetch stop-order ticket data for this account, using an off-chain signed
+     * payload.
      *
-     * @param inputs - See {@link SdkPerpetualsPlaceMarketOrderInputs} for details.
-     *   Notably:
-     *   - `marketId`, `side`, `size`, `collateralChange`, `reduceOnly`
-     *   - Optional `leverage`
-     *   - Optional `slTp` params
-     *   - Optional `tx` to extend
+     * 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
      *
-     * @returns Transaction response containing `tx`.
+     * @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.
      *
-     * @example
-     * ```ts
-     * const { tx } = await account.getPlaceMarketOrderTx({
-     *   marketId: "0x...",
-     *   side: PerpetualsOrderSide.Bid,
-     *   size: BigInt("1000000000"),
-     *   collateralChange: 10,
-     *   reduceOnly: false,
-     * });
-     * ```
+     * @returns {@link ApiPerpetualsStopOrderDatasResponse} containing `stopOrderDatas`.
      */
-    getPlaceMarketOrderTx(inputs: SdkPerpetualsPlaceMarketOrderInputs): Promise<Omit<ApiTransactionResponse, "txKind"> & {
-        tx: Transaction;
-    }>;
+    getStopOrderDatas(inputs: {
+        bytes: string;
+        signature: string;
+        marketIds?: PerpetualsMarketId[];
+    }): Promise<ApiPerpetualsStopOrderDatasResponse>;
     /**
-     * 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.
+     * Fetch paginated collateral-change history for this account, including
+     * deposits, withdrawals, funding settlements, liquidations, etc.
      *
-     * 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.
+     * Pagination:
+     * - Use `beforeTimestampCursor` to fetch older entries.
+     * - The API returns a `nextBeforeTimestampCursor` to continue pagination.
      *
-     * @param inputs - See {@link SdkPerpetualsPlaceLimitOrderInputs}.
+     * @param inputs.beforeTimestampCursor - Optional cursor for pagination.
+     * @param inputs.limit - Optional limit per page.
      *
-     * @returns Transaction response containing `tx`.
+     * @returns {@link ApiPerpetualsAccountCollateralHistoryResponse} containing
+     * an array of changes and a `nextBeforeTimestampCursor`.
      */
-    getPlaceLimitOrderTx(inputs: SdkPerpetualsPlaceLimitOrderInputs): Promise<Omit<ApiTransactionResponse, "txKind"> & {
-        tx: Transaction;
-    }>;
+    getCollateralHistory(inputs: Omit<ApiPerpetualsAccountCollateralHistoryBody, "accountId">): Promise<ApiPerpetualsAccountCollateralHistoryResponse>;
     /**
-     * Build a `place-scale-order` transaction for this account.
+     * Fetch paginated order history for this account.
      *
-     * A scale order distributes a total size across multiple limit orders
-     * evenly spaced between a start and end price. An optional `sizeSkew`
-     * parameter controls whether the distribution is uniform or weighted.
+     * 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 - See {@link SdkPerpetualsPlaceScaleOrderInputs}.
+     * @param inputs.beforeTimestampCursor - Optional cursor for pagination.
+     * @param inputs.limit - Optional limit per page.
      *
-     * @returns Transaction response containing `tx`.
+     * @returns {@link ApiPerpetualsAccountOrderHistoryResponse} containing a list of
+     * orders and a `nextBeforeTimestampCursor`.
      */
-    getPlaceScaleOrderTx(inputs: SdkPerpetualsPlaceScaleOrderInputs): Promise<Omit<ApiTransactionResponse, "txKind"> & {
-        tx: Transaction;
-    }>;
+    getOrderHistory(inputs: Omit<ApiPerpetualsAccountOrderHistoryBody, "accountId">): Promise<ApiPerpetualsAccountOrderHistoryResponse>;
     /**
-     * Build a `cancel-and-place-orders` transaction for this account.
+     * Fetch historical margin snapshots for this account over a time range.
      *
-     * Atomically cancels existing orders and places new ones in a single
-     * transaction. Useful for rebalancing order grids or replacing stale
-     * orders without intermediate exposure.
+     * This endpoint returns time-series margin data suitable for charting UI
+     * such as equity and available collateral over time.
      *
-     * @param inputs - See {@link SdkPerpetualsCancelAndPlaceOrdersInputs}.
+     * Notes:
+     * - This is an account-level view (aggregated across markets).
      *
-     * @returns Transaction response containing `tx`.
+     * @param inputs - {@link ApiPerpetualsAccountMarginHistoryBody} without `accountId`.
+     * @returns {@link ApiPerpetualsAccountMarginHistoryResponse} containing `marginHistoryDatas`.
      */
-    getCancelAndPlaceOrdersTx(inputs: SdkPerpetualsCancelAndPlaceOrdersInputs): Promise<Omit<ApiTransactionResponse, "txKind"> & {
-        tx: Transaction;
-    }>;
+    getMarginHistory(inputs: Omit<ApiPerpetualsAccountMarginHistoryBody, "accountId">): Promise<ApiPerpetualsAccountMarginHistoryResponse>;
     /**
-     * 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
+     * Build a transaction that grants an Agent Wallet (assistant permissions) for this perpetuals account.
      *
-     * 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}.
+     * 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.
      *
-     * @param inputs.tx - Optional transaction to extend.
-     * @param inputs.marketIdsToData - Mapping from market IDs to cancel payloads.
+     * Agent wallets can perform all supported actions **except**:
+     * - withdrawing collateral, and
+     * - granting or revoking other agent wallets.
      *
-     * @returns Transaction response containing `tx`.
+     * @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).
      */
-    getCancelOrdersTx(inputs: {
+    getGrantAgentWalletTx(inputs: {
+        recipientAddress: SuiAddress;
         tx?: Transaction;
-        sponsor?: PerpetualsSponsorConfig;
-        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}).
+     * Build a transaction that revokes an Agent Wallet (assistant capability) from this perpetuals account.
      *
-     * @param inputs.tx - Optional transaction to extend.
-     * @param inputs.stopOrderIds - Array of stop-order ticket IDs to cancel.
+     * The returned transaction must be signed and submitted by the **account admin** wallet.
+     * After execution, the revoked wallet immediately loses its delegated permissions.
      *
-     * @returns Transaction response containing `tx`.
+     * @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).
      */
-    getCancelStopOrdersTx(inputs: {
+    getRevokeAgentWalletTx(inputs: {
+        accountCapId: ObjectId;
         tx?: Transaction;
-        sponsor?: PerpetualsSponsorConfig;
-        stopOrderIds: ObjectId[];
     }): Promise<Omit<ApiTransactionResponse, "txKind"> & {
         tx: Transaction;
     }>;
     /**
-     * Build a `place-stop-orders` transaction for this account.
+     * Find the current position for a given market ID, if any.
      *
-     * This allows placing one or more stop orders in a single transaction,
-     * optionally with a dedicated gas coin and a sponsored gas flag.
+     * @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.
      *
-     * Typical usage:
-     * - Construct stop order payload(s) client-side
-     * - Call this method to build a transaction kind
-     * - Sign/execute the transaction via Sui
+     * A stop order is considered SL/TP if it appears in the combined set of
+     * SL/TP orders across **all** markets (see {@link slTpStopOrderDatas}).
      *
-     * @param inputs - See {@link SdkPerpetualsPlaceStopOrdersInputs}.
+     * Note:
+     * - This implementation uses JSON string equality to compare objects.
+     *   This is pragmatic but assumes stable field ordering and identical shapes.
      *
-     * @returns Transaction response containing `tx`.
+     * @param inputs.stopOrderDatas - Full array of stop-order ticket data.
+     * @returns An array of non-SL/TP stop orders, or `undefined` if none exist.
      */
-    getPlaceStopOrdersTx(inputs: SdkPerpetualsPlaceStopOrdersInputs): Promise<Omit<ApiTransactionResponse, "txKind"> & {
-        tx: Transaction;
-    }>;
+    nonSlTpStopOrderDatas(inputs: {
+        stopOrderDatas: PerpetualsStopOrderData[];
+    }): PerpetualsStopOrderData[] | undefined;
     /**
-     * Build a `place-sl-tp-orders` transaction for this account.
+     * Extract all SL/TP-style stop orders across **all** markets 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.
+     * SL/TP orders are stop orders which:
+     * - Have an `slTp` payload, and
+     * - Target the opposite side of the current position.
      *
-     * 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).
+     * This combines:
+     * - "Full" SL/TP orders (size >= `i64MaxBigInt`)
+     * - "Partial" SL/TP orders (size < `i64MaxBigInt`)
      *
-     * @param inputs - See {@link SdkPerpetualsPlaceSlTpOrdersInputs}.
+     * The "full vs partial" distinction is a protocol convention: some systems
+     * encode “close entire position” using a sentinel max size.
      *
-     * @returns Transaction response containing `tx`.
+     * @param inputs.stopOrderDatas - Full list of stop-order tickets.
+     * @returns Array of SL/TP stop orders, or `undefined` if none exist.
      */
-    getPlaceSlTpOrdersTx(inputs: SdkPerpetualsPlaceSlTpOrdersInputs): Promise<Omit<ApiTransactionResponse, "txKind"> & {
-        tx: Transaction;
-    }>;
+    slTpStopOrderDatas(inputs: {
+        stopOrderDatas: PerpetualsStopOrderData[];
+    }): PerpetualsStopOrderData[] | undefined;
     /**
-     * Build an `edit-stop-orders` transaction for this account.
+     * Filter stop orders for a single market to only include non-SL/TP orders.
      *
-     * This endpoint lets you update existing stop orders in batch.
+     * Uses {@link slTpStopOrderDatasForPosition} under the hood.
      *
-     * 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.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`).
      *
-     * @param inputs.stopOrders - Full updated stop-order payloads to apply.
-     * @param inputs.tx - Optional transaction to extend.
+     * 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.
      *
-     * @returns Transaction response containing `tx`.
+     * 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`)
      */
-    getEditStopOrdersTx(inputs: Omit<ApiPerpetualsEditStopOrdersBody, "txKind" | "accountObjectId"> & {
-        tx?: Transaction;
-    }): Promise<Omit<ApiTransactionResponse, "txKind"> & {
-        tx: Transaction;
-    }>;
+    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[];
     /**
-     * Build a `set-leverage` transaction for a given market.
+     * Convenience accessor for the account's available collateral (in coin units).
      *
-     * This updates the effective leverage for the position (or potential position)
-     * in `marketId`, and optionally adjusts collateral in tandem.
+     * This is the amount of collateral not currently locked/allocated across markets,
+     * as represented by the backend response.
      *
-     * 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}.
+     * @returns Available collateral as a `number`.
+     */
+    collateral(): number;
+    /**
+     * Check whether this {@link PerpetualsAccount} is vault-backed.
      *
-     * @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 `true` if the underlying `accountCap` is a vault cap; otherwise `false`.
+     */
+    isVault(): boolean;
+    /**
+     * Resolve the owner wallet address of this account or vault.
      *
-     * @returns Transaction response containing `tx`.
+     * - 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}.
      */
-    getSetLeverageTx(inputs: {
-        tx?: Transaction;
-        leverage: number;
-        collateralChange: number;
-        marketId: PerpetualsMarketId;
-        sponsor?: PerpetualsSponsorConfig;
-    }): Promise<Omit<ApiTransactionResponse, "txKind"> & {
-        tx: Transaction;
-    }>;
+    ownerAddress(): SuiAddress;
     /**
-     * Build a deterministic message payload to sign when querying stop orders
-     * from the backend.
+     * Get the underlying account object ID.
      *
-     * This payload is intended to be signed off-chain and then submitted to
-     * `getStopOrderDatas` as a proof of account ownership.
+     * This is the on-chain object that holds the account's state and positions.
      *
-     * 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`.
+     * @returns {@link ObjectId} of the account object.
+     */
+    accountObjectId(): ObjectId;
+    /**
+     * Get the numeric perpetuals account ID.
      *
-     * @param inputs.marketIds - Optional list of market IDs to scope the query.
+     * This is the protocol-level identifier (bigint-derived) used across API calls.
      *
-     * @returns An object describing the action and account/market IDs, suitable
-     *   for message signing.
+     * @returns {@link PerpetualsAccountId} for this account.
+     */
+    accountId(): PerpetualsAccountId;
+    /**
+     * Get the account cap object ID, if this is a direct account.
      *
-     * @example
-     * ```ts
-     * const message = account.getStopOrdersMessageToSign({ marketIds: ["0x..."] });
-     * const { signature } = await wallet.signMessage({
-     *   message: new TextEncoder().encode(JSON.stringify(message)),
-     * });
-     * ```
+     * 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.
      */
-    getStopOrdersMessageToSign(inputs?: {
-        marketIds: PerpetualsMarketId[];
-    }): {
-        action: string;
-        account_id: string;
-        clearing_house_ids: string[];
-    };
+    accountCapId(): ObjectId;
+}
+
+/**
+ * High-level wrapper around a single perpetuals market.
+ *
+ * This class provides:
+ *
+ * - Lightweight accessors for immutable market properties:
+ *   - `marketId`, `indexPrice`, `collateralPrice`, `collateralCoinType`
+ *   - `marketParams`, `marketState`
+ * - Read endpoints for:
+ *   - Orderbook snapshots
+ *   - 24h stats and order history
+ *   - Market prices and derived funding metrics
+ * - Helpers for:
+ *   - Order sizing (max size, lot/tick rounding)
+ *   - Margin and collateral calculations
+ *   - Constructing an “empty” position for a market
+ *
+ * Typical usage:
+ *
+ * ```ts
+ * const perps = new Perpetuals(config);
+ * const { markets } = await perps.getMarkets({ marketIds: ["0x..."] });
+ * const market = markets[0];
+ *
+ * const { orderbook } = await market.getOrderbook();
+ * const stats = await market.get24hrStats();
+ * const { basePrice, collateralPrice } = await market.getPrices();
+ * ```
+ */
+declare class PerpetualsMarket extends Caller {
+    marketData: PerpetualsMarketData;
+    readonly api?: AftermathApi | undefined;
+    /** Unique identifier for this perpetuals market (object ID on chain). */
+    readonly marketId: PerpetualsMarketId;
     /**
-     * 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`
+     * Current oracle/index price for the market's underlying asset, quoted in
+     * the index unit (typically USD).
      */
-    getPlaceMarketOrderPreview(inputs: SdkPerpetualsPlaceMarketOrderPreviewInputs, abortSignal?: AbortSignal): Promise<ApiPerpetualsPreviewPlaceOrderResponse>;
+    readonly indexPrice: number;
     /**
-     * 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}.
+     * Current price of the collateral asset in USD (or the platform's base
+     * pricing unit).
      */
-    getPlaceLimitOrderPreview(inputs: SdkPerpetualsPlaceLimitOrderPreviewInputs, abortSignal?: AbortSignal): Promise<ApiPerpetualsPreviewPlaceOrderResponse>;
+    readonly collateralPrice: number;
+    /** Sui type of the collateral coin (e.g. `"0x2::sui::SUI"`). */
+    readonly collateralCoinType: CoinType;
+    /** Static market configuration parameters (lot size, tick size, margins, etc.). */
+    readonly marketParams: PerpetualsMarketParams;
+    /** Dynamic market state (funding rates, open interest, etc.). */
+    readonly marketState: PerpetualsMarketState;
     /**
-     * Preview the effects of placing a scale order (without building a tx).
-     *
-     * A scale order distributes total size across multiple limit orders
-     * spaced between a start and end price. The preview simulates:
-     * - How much size would execute immediately vs post to the book
-     * - Expected slippage and execution price
-     * - Resulting position and margin impact
+     * Create a new {@link PerpetualsMarket} wrapper from raw market data.
      *
-     * @param inputs - See {@link SdkPerpetualsPlaceScaleOrderPreviewInputs}.
-     * @param abortSignal - Optional `AbortSignal` to cancel the request.
+     * @param marketData - Snapshot of market configuration and state.
+     * @param config - Optional {@link CallerConfig} (network, base URL, etc.).
+     * @param api - Optional shared {@link AftermathApi} provider instance.
      *
-     * @returns Either an error message or a preview object similar to
-     *   {@link getPlaceMarketOrderPreview}.
+     * @remarks
+     * This class extends {@link Caller} with the `"perpetuals"` route prefix, meaning
+     * all HTTP requests resolve under `/perpetuals/...`.
      */
-    getPlaceScaleOrderPreview(inputs: SdkPerpetualsPlaceScaleOrderPreviewInputs, abortSignal?: AbortSignal): Promise<ApiPerpetualsPreviewPlaceOrderResponse>;
+    constructor(marketData: PerpetualsMarketData, config?: CallerConfig, api?: AftermathApi | undefined);
     /**
-     * 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)
+     * Fetch the 24-hour volume and price change statistics for this market.
      *
-     * If `marketIdsToData` is empty, this returns a trivial preview with:
-     * - `marketIdsToData: {}`
+     * Under the hood, this calls {@link Perpetuals.getMarkets24hrStats} and
+     * returns the first (and only) entry.
      *
-     * @param inputs - See {@link SdkPerpetualsCancelOrdersPreviewInputs}.
-     * @param abortSignal - Optional `AbortSignal` to cancel the request.
+     * @returns {@link PerpetualsMarket24hrStats}.
      *
-     * @returns Either:
-     * - `{ marketIdsToData }`, or
-     * - `{ error }`.
+     * @remarks
+     * This method creates a new {@link Perpetuals} instance using `this.config`.
+     * If you need shared api behavior, prefer calling `perps.getMarkets24hrStats`
+     * directly with the same api you initialized.
      */
-    getCancelOrdersPreview(inputs: SdkPerpetualsCancelOrdersPreviewInputs, abortSignal?: AbortSignal): Promise<ApiPerpetualsPreviewCancelOrdersResponse>;
+    get24hrStats(): Promise<PerpetualsMarket24hrStats>;
     /**
-     * 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`)
+     * Fetch the full orderbook snapshot for this market.
      *
-     * @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 Object containing `orderbook`.
      *
-     * @returns Either:
-     * - `{ updatedPosition, collateralChange }`, or
-     * - `{ error }`.
+     * @example
+     * ```ts
+     * const { orderbook } = await market.getOrderbook();
+     * console.log(orderbook.bids[0], orderbook.asks[0]);
+     * ```
      */
-    getSetLeveragePreview(inputs: {
-        marketId: PerpetualsMarketId;
-        leverage: number;
-    }, abortSignal?: AbortSignal): Promise<{
-        updatedPosition: PerpetualsPosition;
-        collateralChange: number;
-    } | {
-        error: string;
+    getOrderbook(): Promise<{
+        orderbook: PerpetualsOrderbook;
     }>;
     /**
-     * Preview the effects of allocating/deallocating collateral for the position in
-     * a given market.
+     * Compute the maximum order size that can be placed by a given account
+     * in this market, under optional leverage and price assumptions.
      *
-     * Semantics:
-     * - Positive `collateralChange` previews allocation (moving collateral into the market).
-     * - Negative `collateralChange` previews deallocation (moving collateral out of the market).
+     * This is a common frontend helper for:
+     * - "max size" buttons
+     * - input validation against risk limits
      *
-     * @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.
+     * **Note:** This is routed through the `account` namespace because it depends on
+     * the account's collateral and positions.
      *
-     * @returns Either:
-     * - `{ updatedPosition, collateralChange }`, or
-     * - `{ error }`.
+     * @param inputs.accountId - Perpetuals account ID.
+     * @param inputs.side - Order side (Bid/Ask).
+     * @param inputs.leverage - Optional assumed leverage.
+     * @param inputs.price - Optional assumed price (e.g. for limit orders).
+     *
+     * @returns `{ maxOrderSize }` in base units (scaled integer as `bigint`).
+     *
+     * @example
+     * ```ts
+     * const { maxOrderSize } = await market.getMaxOrderSize({
+     *   accountId: 123n,
+     *   side: PerpetualsOrderSide.Bid,
+     *   leverage: 5,
+     * });
+     * ```
      */
-    getEditCollateralPreview(inputs: {
-        marketId: PerpetualsMarketId;
-        collateralChange: Balance;
-    }, abortSignal?: AbortSignal): Promise<{
-        updatedPosition: PerpetualsPosition;
-        collateralChange: number;
-    } | {
-        error: string;
+    getMaxOrderSize: (inputs: Omit<ApiPerpetualsMaxOrderSizeBody, "marketId">) => Promise<{
+        maxOrderSize: bigint;
     }>;
     /**
-     * Fetch stop-order ticket data for this account, using an off-chain signed
-     * payload.
+     * Market-level preview of placing a market order.
      *
-     * 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
+     * Unlike {@link PerpetualsAccount.getPlaceMarketOrderPreview}, this version:
+     * - Calls `account/previews/place-market-order`
+     * - Explicitly sets `accountId: undefined`, allowing a “generic” preview that
+     *   doesn’t rely on a specific account’s on-chain positions/collateral.
      *
-     * @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.
+     * @param inputs - {@link SdkPerpetualsPlaceMarketOrderPreviewInputs}.
+     * @param abortSignal - Optional abort signal to cancel the request.
      *
-     * @returns {@link ApiPerpetualsStopOrderDatasResponse} containing `stopOrderDatas`.
+     * @returns Either `{ error }` or a preview containing the simulated updated position,
+     * slippage, filled/posted sizes, collateral change, and execution price.
      */
-    getStopOrderDatas(inputs: {
-        bytes: string;
-        signature: string;
-        marketIds?: PerpetualsMarketId[];
-    }): Promise<ApiPerpetualsStopOrderDatasResponse>;
+    getPlaceMarketOrderPreview(inputs: SdkPerpetualsPlaceMarketOrderPreviewInputs, abortSignal?: AbortSignal): Promise<ApiPerpetualsPreviewPlaceOrderResponse>;
     /**
-     * Fetch paginated collateral-change history for this account, including
-     * deposits, withdrawals, funding settlements, liquidations, etc.
+     * Market-level preview of placing a limit order.
      *
-     * Pagination:
-     * - Use `beforeTimestampCursor` to fetch older entries.
-     * - The API returns a `nextBeforeTimestampCursor` to continue pagination.
+     * Similar to {@link getPlaceMarketOrderPreview}, this uses:
+     * - `account/previews/place-limit-order`
+     * - `accountId: undefined`
      *
-     * @param inputs.beforeTimestampCursor - Optional cursor for pagination.
-     * @param inputs.limit - Optional limit per page.
+     * @param inputs - {@link SdkPerpetualsPlaceLimitOrderPreviewInputs}.
+     * @param abortSignal - Optional abort signal to cancel the request.
      *
-     * @returns {@link ApiPerpetualsAccountCollateralHistoryResponse} containing
-     * an array of changes and a `nextBeforeTimestampCursor`.
+     * @returns Either `{ error }` or a preview describing the simulated post-order state.
      */
-    getCollateralHistory(inputs: Omit<ApiPerpetualsAccountCollateralHistoryBody, "accountId">): Promise<ApiPerpetualsAccountCollateralHistoryResponse>;
+    getPlaceLimitOrderPreview(inputs: SdkPerpetualsPlaceLimitOrderPreviewInputs, abortSignal?: AbortSignal): Promise<ApiPerpetualsPreviewPlaceOrderResponse>;
     /**
-     * Fetch paginated order history for this account.
+     * Market-level preview of placing a scale order.
      *
-     * 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.
+     * Similar to {@link getPlaceLimitOrderPreview}, this uses:
+     * - `account/previews/place-scale-order`
+     * - `accountId: undefined`
      *
-     * @param inputs.beforeTimestampCursor - Optional cursor for pagination.
-     * @param inputs.limit - Optional limit per page.
+     * @param inputs - {@link SdkPerpetualsPlaceScaleOrderPreviewInputs}.
+     * @param abortSignal - Optional abort signal to cancel the request.
      *
-     * @returns {@link ApiPerpetualsAccountOrderHistoryResponse} containing a list of
-     * orders and a `nextBeforeTimestampCursor`.
+     * @returns Either `{ error }` or a preview describing the simulated post-order state.
      */
-    getOrderHistory(inputs: Omit<ApiPerpetualsAccountOrderHistoryBody, "accountId">): Promise<ApiPerpetualsAccountOrderHistoryResponse>;
+    getPlaceScaleOrderPreview(inputs: SdkPerpetualsPlaceScaleOrderPreviewInputs, abortSignal?: AbortSignal): Promise<ApiPerpetualsPreviewPlaceOrderResponse>;
     /**
-     * Fetch historical margin snapshots for this account over a time range.
+     * Fetch paginated order history for this market.
      *
-     * This endpoint returns time-series margin data suitable for charting UI
-     * such as equity and available collateral over time.
+     * This is market-wide (public) history, not scoped to any account.
      *
-     * Notes:
-     * - This is an account-level view (aggregated across markets).
+     * @param inputs.beforeTimestampCursor - Optional pagination cursor.
+     * @param inputs.limit - Optional page size.
      *
-     * @param inputs - {@link ApiPerpetualsAccountMarginHistoryBody} without `accountId`.
-     * @returns {@link ApiPerpetualsAccountMarginHistoryResponse} containing `marginHistoryDatas`.
+     * @returns {@link ApiPerpetualsMarketOrderHistoryResponse} containing:
+     * - `orders`
+     * - `nextBeforeTimestampCursor`
      */
-    getMarginHistory(inputs: Omit<ApiPerpetualsAccountMarginHistoryBody, "accountId">): Promise<ApiPerpetualsAccountMarginHistoryResponse>;
+    getOrderHistory(inputs: Omit<ApiPerpetualsMarketOrderHistoryBody, "marketId">): Promise<ApiPerpetualsMarketOrderHistoryResponse>;
     /**
-     * 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.
+     * Fetch the current prices for this market.
      *
-     * Agent wallets can perform all supported actions **except**:
-     * - withdrawing collateral, and
-     * - granting or revoking other agent wallets.
+     * Internally calls {@link Perpetuals.getPrices} and returns the first result.
      *
-     * @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).
+     * @returns `{ marketId, basePrice, collateralPrice, midPrice, markPrice }`.
+     *
+     * @remarks
+     * This method instantiates a new {@link Perpetuals} client using `this.config`.
+     * If you rely on a shared api, call `perps.getPrices(...)` directly instead.
      */
-    getGrantAgentWalletTx(inputs: {
-        recipientAddress: SuiAddress;
-        tx?: Transaction;
-    }): Promise<Omit<ApiTransactionResponse, "txKind"> & {
-        tx: Transaction;
+    getPrices(): Promise<{
+        marketId: PerpetualsMarketId;
+        basePrice: number;
+        collateralPrice: number;
+        midPrice: number | undefined;
+        markPrice: number;
     }>;
     /**
-     * Build a transaction that revokes an Agent Wallet (assistant capability) from this perpetuals account.
+     * Compute the remaining time until the next funding event, in milliseconds.
      *
-     * The returned transaction must be signed and submitted by the **account admin** wallet.
-     * After execution, the revoked wallet immediately loses its delegated permissions.
+     * @returns `nextFundingTimeMs() - Date.now()`.
      *
-     * @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).
+     * @remarks
+     * If the next funding timestamp does not fit safely into a JS `number`,
+     * {@link nextFundingTimeMs} returns `Number.MAX_SAFE_INTEGER`, and the
+     * difference may be very large.
      */
-    getRevokeAgentWalletTx(inputs: {
-        accountCapId: ObjectId;
-        tx?: Transaction;
-    }): Promise<Omit<ApiTransactionResponse, "txKind"> & {
-        tx: Transaction;
-    }>;
+    timeUntilNextFundingMs: () => Timestamp;
     /**
-     * Find the current position for a given market ID, if any.
+     * Get the scheduled timestamp for the next funding event, in milliseconds.
      *
-     * @param inputs.marketId - Market ID to search for.
-     * @returns {@link PerpetualsPosition} if found, otherwise `undefined`.
+     * Safety behavior:
+     * - If `marketData.nextFundingTimestampMs` exceeds `Number.MAX_SAFE_INTEGER`,
+     *   this returns `Number.MAX_SAFE_INTEGER`.
+     *
+     * @returns Next funding timestamp (ms) as a JS `number`.
      */
-    positionForMarketId(inputs: {
-        marketId: PerpetualsMarketId;
-    }): PerpetualsPosition | undefined;
+    nextFundingTimeMs: () => Timestamp;
     /**
-     * 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}).
+     * Estimated funding rate per period for this market.
      *
-     * Note:
-     * - This implementation uses JSON string equality to compare objects.
-     *   This is pragmatic but assumes stable field ordering and identical shapes.
+     * This is read directly from `marketData.estimatedFundingRate`.
      *
-     * @param inputs.stopOrderDatas - Full array of stop-order ticket data.
-     * @returns An array of non-SL/TP stop orders, or `undefined` if none exist.
+     * @returns Estimated funding rate as a fraction (e.g. `0.01` = 1%).
      */
-    nonSlTpStopOrderDatas(inputs: {
-        stopOrderDatas: PerpetualsStopOrderData[];
-    }): PerpetualsStopOrderData[] | undefined;
+    estimatedFundingRate: () => Percentage;
     /**
-     * Extract all SL/TP-style stop orders across **all** markets for this
-     * account.
+     * Calculate the collateral required to support an order given leverage and prices.
      *
-     * SL/TP orders are stop orders which:
-     * - Have an `slTp` payload, and
-     * - Target the opposite side of the current position.
+     * The computed collateral is based on the *remaining* unfilled size:
+     * `remaining = initialSize - filledSize`.
      *
-     * This combines:
-     * - "Full" SL/TP orders (size >= `i64MaxBigInt`)
-     * - "Partial" SL/TP orders (size < `i64MaxBigInt`)
+     * USD requirement:
+     * ```text
+     * remainingBase * indexPrice * initialMarginRatio
+     * ```
+     * where `initialMarginRatio = 1 / leverage` (or 1 if leverage is falsy).
      *
-     * The "full vs partial" distinction is a protocol convention: some systems
-     * encode “close entire position” using a sentinel max size.
+     * @param inputs.leverage - Target leverage for the order (>= 1).
+     * @param inputs.orderData - Order data containing `initialSize` and `filledSize`.
+     * @param inputs.indexPrice - Index/oracle price of the base asset.
+     * @param inputs.collateralPrice - Price of the collateral asset.
      *
-     * @param inputs.stopOrderDatas - Full list of stop-order tickets.
-     * @returns Array of SL/TP stop orders, or `undefined` if none exist.
+     * @returns Object with:
+     * - `collateralUsd`: required collateral in USD
+     * - `collateral`: required collateral in collateral coin units
      */
-    slTpStopOrderDatas(inputs: {
-        stopOrderDatas: PerpetualsStopOrderData[];
-    }): PerpetualsStopOrderData[] | undefined;
+    calcCollateralUsedForOrder: (inputs: {
+        leverage: number;
+        orderData: PerpetualsOrderData;
+        indexPrice: number;
+        collateralPrice: number;
+    }) => {
+        collateral: number;
+        collateralUsd: number;
+    };
     /**
-     * Filter stop orders for a single market to only include non-SL/TP orders.
+     * Get the base-asset lot size for this market as a `number`.
      *
-     * Uses {@link slTpStopOrderDatasForPosition} under the hood.
+     * Order sizes must be multiples of this lot size.
      *
-     * @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.
+     * @returns Lot size in base asset units.
      */
-    nonSlTpStopOrderDatasForPosition(inputs: {
-        marketId: PerpetualsMarketId;
-        stopOrderDatas: PerpetualsStopOrderData[];
-    }): PerpetualsStopOrderData[] | undefined;
+    lotSize(): number;
     /**
-     * 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`).
+     * Get the minimal price tick size for this market as a `number`.
      *
-     * 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.
+     * Limit prices must be multiples of this tick size.
      *
-     * 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.
+     * @returns Tick size in quote units (e.g. USD).
+     */
+    tickSize(): number;
+    /**
+     * Get the maximum theoretical leverage for this market.
      *
-     * @param inputs.marketId - Market to categorize stop orders for.
-     * @param inputs.stopOrderDatas - Full list of stop orders.
+     * Computed as:
+     * ```ts
+     * 1 / marginRatioInitial
+     * ```
      *
-     * @returns Object containing:
-     * - `fullSlTpOrder` (if any)
-     * - `partialSlTpOrders` (if any, otherwise `undefined`)
+     * @returns Maximum leverage.
      */
-    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[];
+    maxLeverage(): number;
     /**
-     * Convenience accessor for the account's available collateral (in coin units).
+     * Get the initial margin ratio for this market.
      *
-     * This is the amount of collateral not currently locked/allocated across markets,
-     * as represented by the backend response.
+     * This is the minimum margin required when opening a position.
      *
-     * @returns Available collateral as a `number`.
+     * @returns Initial margin ratio as a fraction (e.g. 0.05 = 20x).
      */
-    collateral(): number;
+    initialMarginRatio(): number;
     /**
-     * Check whether this {@link PerpetualsAccount} is vault-backed.
+     * Get the maintenance margin ratio for this market.
      *
-     * @returns `true` if the underlying `accountCap` is a vault cap; otherwise `false`.
+     * Falling below this ratio may trigger liquidation.
+     *
+     * @returns Maintenance margin ratio as a fraction.
      */
-    isVault(): boolean;
+    maintenanceMarginRatio(): number;
     /**
-     * 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`.
+     * Round a price to the nearest valid tick for this market.
      *
-     * Naming note:
-     * - Some types use `walletAddress` for direct ownership. For vault-backed accounts
-     *   the analogous field is `ownerAddress`.
+     * Rounding mode:
+     * - `floor: true` => round down
+     * - `ceil: true`  => round up
+     * - neither       => nearest tick (`Math.round`)
      *
-     * @returns Owner wallet {@link SuiAddress}.
+     * @param inputs.price - Raw price to round.
+     * @param inputs.floor - Force floor rounding.
+     * @param inputs.ceil - Force ceil rounding.
+     * @returns Price snapped to the market tick size.
      */
-    ownerAddress(): SuiAddress;
+    roundToValidPrice: (inputs: {
+        price: number;
+        floor?: boolean;
+        ceil?: boolean;
+    }) => number;
     /**
-     * Get the underlying account object ID.
+     * Round a price to the nearest valid tick as a fixed-point `bigint` (1e9 precision).
      *
-     * This is the on-chain object that holds the account's state and positions.
+     * This is helpful when you need the on-chain representation directly
+     * (e.g. order price fields stored in 9-decimal fixed).
      *
-     * @returns {@link ObjectId} of the account object.
+     * @param inputs.price - Raw price as a JS number.
+     * @param inputs.floor - Force floor rounding.
+     * @param inputs.ceil - Force ceil rounding.
+     * @returns Tick-snapped price scaled by `1e9`.
      */
-    accountObjectId(): ObjectId;
+    roundToValidPriceBigInt: (inputs: {
+        price: number;
+        floor?: boolean;
+        ceil?: boolean;
+    }) => bigint;
     /**
-     * Get the numeric perpetuals account ID.
+     * Round a base-asset size to the nearest valid lot size for this market.
      *
-     * This is the protocol-level identifier (bigint-derived) used across API calls.
+     * Rounding mode:
+     * - `floor: true` => round down
+     * - `ceil: true`  => round up
+     * - neither       => nearest lot (`Math.round`)
      *
-     * @returns {@link PerpetualsAccountId} for this account.
+     * @param inputs.size - Raw size in base asset units.
+     * @param inputs.floor - Force floor rounding.
+     * @param inputs.ceil - Force ceil rounding.
+     * @returns Size snapped to the market lot size.
      */
-    accountId(): PerpetualsAccountId;
+    roundToValidSize: (inputs: {
+        size: number;
+        floor?: boolean;
+        ceil?: boolean;
+    }) => number;
     /**
-     * Get the account cap object ID, if this is a direct account.
+     * Round a base-asset size to the nearest valid lot as a fixed-point `bigint` (1e9 precision).
      *
-     * 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.
+     * @param inputs.size - Raw base size as a JS number.
+     * @param inputs.floor - Force floor rounding.
+     * @param inputs.ceil - Force ceil rounding.
+     * @returns Lot-snapped size scaled by `1e9`.
+     */
+    roundToValidSizeBigInt: (inputs: {
+        size: number;
+        floor?: boolean;
+        ceil?: boolean;
+    }) => bigint;
+    /**
+     * Construct an "empty" position object for this market.
      *
-     * @throws If called for a vault-backed account.
+     * Useful when an account has no open position but downstream UI/calculations
+     * expect a {@link PerpetualsPosition}-shaped object.
      *
-     * @returns {@link ObjectId} of the account cap.
+     * @returns A zeroed-out {@link PerpetualsPosition} for `this.marketId`.
      */
-    accountCapId(): ObjectId;
-}
-
-declare class PerpetualsOrderUtils {
-    static orderId: (price: bigint, counter: bigint, side: PerpetualsOrderSide) => PerpetualsOrderId;
-    private static orderIdAsk;
-    private static orderIdBid;
-    static price: (orderId: PerpetualsOrderId) => bigint;
-    private static priceAsk;
-    private static priceBid;
-    static counter: (orderId: PerpetualsOrderId) => bigint;
-    static isAsk: (orderId: PerpetualsOrderId) => boolean;
+    emptyPosition: () => PerpetualsPosition;
 }
 
 /**
@@ -10399,7 +10559,7 @@ declare class PerpetualsOrderUtils {
  */
 declare class PerpetualsVault extends Caller {
     readonly vaultObject: PerpetualsVaultObject;
-    readonly Provider?: AftermathApi | undefined;
+    readonly api?: AftermathApi | undefined;
     /**
      * Vault-level protocol limits and UI-friendly constraints.
      *
@@ -10442,10 +10602,10 @@ declare class PerpetualsVault extends Caller {
      *
      * @param vaultObject - Raw on-chain vault object snapshot.
      * @param config - Optional {@link CallerConfig} (network, auth, base URL).
-     * @param Provider - Optional shared {@link AftermathApi} provider. When provided,
+     * @param api - Optional shared {@link AftermathApi} provider. When provided,
      *   transaction builders will serialize {@link Transaction}s into `txKind`.
      */
-    constructor(vaultObject: PerpetualsVaultObject, config?: CallerConfig, Provider?: AftermathApi | undefined);
+    constructor(vaultObject: PerpetualsVaultObject, config?: CallerConfig, api?: AftermathApi | undefined);
     /**
      * Build a `process-force-withdraw-request` transaction.
      *
@@ -10843,6 +11003,17 @@ declare class PerpetualsVault extends Caller {
     }) => number;
 }
 
+declare class PerpetualsOrderUtils {
+    static orderId: (price: bigint, counter: bigint, side: PerpetualsOrderSide) => PerpetualsOrderId;
+    private static orderIdAsk;
+    private static orderIdBid;
+    static price: (orderId: PerpetualsOrderId) => bigint;
+    private static priceAsk;
+    private static priceBid;
+    static counter: (orderId: PerpetualsOrderId) => bigint;
+    static isAsk: (orderId: PerpetualsOrderId) => boolean;
+}
+
 /**
  * High-level client for interacting with Aftermath Perpetuals.
  *
@@ -10863,8 +11034,7 @@ declare class PerpetualsVault extends Caller {
  * ```ts
  * import { Aftermath } from "@aftermath/sdk";
  *
- * const afSdk = new Aftermath("MAINNET");
- * await afSdk.init();
+ * const afSdk = await Aftermath.create({ network: "MAINNET" });
  *
  * const perps = afSdk.Perpetuals();
  *
@@ -10888,7 +11058,7 @@ declare class PerpetualsVault extends Caller {
  * ```
  */
 declare class Perpetuals extends Caller {
-    readonly Provider?: AftermathApi | undefined;
+    readonly api?: AftermathApi | undefined;
     /**
      * Helper namespace for order-specific utilities such as parsing order IDs,
      * extracting price bits, etc.
@@ -10900,16 +11070,16 @@ declare class Perpetuals extends Caller {
      * Creates a new Perpetuals client.
      *
      * @param config - Optional caller configuration (network, auth token, etc.).
-     * @param Provider - Optional shared {@link AftermathApi} provider instance. When
+     * @param api - Optional shared {@link AftermathApi} provider instance. When
      *   provided, transaction-building helpers can derive serialized `txKind`
-     *   from a {@link Transaction} object via `Provider.Transactions().fetchBase64TxKindFromTx`.
+     *   from a {@link Transaction} object via `api.Transactions().fetchBase64TxKindFromTx`.
      *
      * @remarks
      * This class extends {@link Caller} with the `"perpetuals"` route prefix, meaning:
      * - HTTP calls resolve under `/perpetuals/...`
      * - Websocket calls resolve under `/perpetuals/ws/...`
      */
-    constructor(config?: CallerConfig, Provider?: AftermathApi | undefined);
+    constructor(config?: CallerConfig, api?: AftermathApi | undefined);
     /**
      * Fetch all perpetual markets for a given collateral coin type.
      *
@@ -11720,7 +11890,7 @@ declare class Perpetuals extends Caller {
         onClose?: (ev: CloseEvent) => void;
     }): {
         ws: WebSocket;
-        subscribeMarket: ({ marketId, }: {
+        subscribeMarket: ({ marketId }: {
             marketId: PerpetualsMarketId;
         }) => void;
         unsubscribeMarket: ({ marketId, }: {
@@ -11742,7 +11912,7 @@ declare class Perpetuals extends Caller {
                 signature: string;
             } | undefined;
         }) => void;
-        subscribeOracle: ({ marketId, }: {
+        subscribeOracle: ({ marketId }: {
             marketId: PerpetualsMarketId;
         }) => void;
         unsubscribeOracle: ({ marketId, }: {
@@ -11841,7 +12011,7 @@ declare class ReferralVault extends Caller {
      *
      * @deprecated Use `Referral` class instead
      * @param config - Optional caller configuration, including Sui network and access token.
-     * @param Provider - An optional `AftermathApi` provider instance for referral-specific methods.
+     * @param api - An optional `AftermathApi` provider instance for referral-specific methods.
      */
     constructor(config?: CallerConfig);
     /**
@@ -11853,8 +12023,7 @@ declare class ReferralVault extends Caller {
      *
      * @example
      * ```typescript
-     * const afSdk = new Aftermath("MAINNET");
-     * await afSdk.init(); // initialize provider
+     * const afSdk = await Aftermath.create({ network: "MAINNET" });
      *
      * const referralVault = afSdk.ReferralVault();
      *
@@ -11876,7 +12045,7 @@ declare class ReferralVault extends Caller {
  * @example
  * ```typescript
  * // Create provider
- * const router = (new Aftermath("MAINNET")).Router();
+ * const router = (await Aftermath.create({ network: "MAINNET" })).Router();
  * // Retrieve 24h volume
  * const volume24h = await router.getVolume24hrs();
  * // Get supported coins
@@ -11904,8 +12073,7 @@ declare class Router extends Caller {
      *
      * @example
      * ```typescript
-     * const afSdk = new Aftermath("MAINNET");
-     * await afSdk.init(); // initialize provider
+     * const afSdk = await Aftermath.create({ network: "MAINNET" });
      *
      * const router = afSdk.Router();
      * ```
@@ -12097,8 +12265,7 @@ declare class Router extends Caller {
  * @example
  * ```typescript
  * // Instantiate Staking
- * const sdk = new Aftermath("MAINNET");
- * await sdk.init();
+ * const sdk = await Aftermath.create({ network: "MAINNET" });
  * const staking = sdk.Staking();
  *
  * // Get active validators
@@ -12113,7 +12280,7 @@ declare class Router extends Caller {
  * ```
  */
 declare class Staking extends Caller {
-    readonly Provider?: AftermathApi | undefined;
+    readonly api?: AftermathApi | undefined;
     /**
      * Contains constants for staking, including protocol fees, default validator
      * fee, and staking/unstaking bounds. Also defines the maximum external fee
@@ -12167,9 +12334,9 @@ declare class Staking extends Caller {
      * staking contracts.
      *
      * @param config - Optional configuration containing the Sui network and/or access token.
-     * @param Provider - Optional instance of `AftermathApi` for building transactions.
+     * @param api - Optional instance of `AftermathApi` for building transactions.
      */
-    constructor(config?: CallerConfig, Provider?: AftermathApi | undefined);
+    constructor(config?: CallerConfig, api?: AftermathApi | undefined);
     /**
      * Fetches the list of currently active validators on the Sui network.
      *
@@ -12461,151 +12628,12 @@ declare class Staking extends Caller {
     }): Percentage;
     /**
      * Returns a provider instance for building transactions. Throws an error
-     * if `Provider` is not defined.
+     * if `api` is not defined.
      *
      * @returns An instance of `AftermathApi.Staking`.
-     * @throws Will throw if the `Provider` is undefined.
-     */
-    private useProvider;
-}
-
-/**
- * The `GasPools` class provides methods for interacting with shared gas pool
- * endpoints on the Aftermath platform. This includes querying pool details
- * and building transactions for creating, depositing into, withdrawing from,
- * sponsoring, granting access to, and revoking access from gas pools.
- *
- * @example
- * ```typescript
- * const gasPools = new GasPools({ network: "MAINNET" });
- *
- * // Get gas pool details
- * const pool = await gasPools.getPool({
- *   walletAddress: "0x..."
- * });
- *
- * // Build a deposit transaction
- * const { tx } = await gasPools.getDepositTx({
- *   walletAddress: "0x...",
- *   depositAmount: 100_000_000n
- * });
- * ```
- */
-declare class GasPools extends Caller {
-    readonly Provider?: AftermathApi | undefined;
-    constructor(config?: CallerConfig, Provider?: AftermathApi | undefined);
-    /**
-     * Fetches the gas pool details for a given wallet address.
-     *
-     * @param inputs - {@link ApiGasPoolBody}
-     * @returns {@link ApiGasPoolResponse} containing pool ID, balance, and whitelisted addresses.
-     */
-    getPool(inputs: ApiGasPoolBody): Promise<ApiGasPoolResponse>;
-    /**
-     * Builds a transaction to create a new gas pool for the given wallet.
-     *
-     * When `deferShare` is `true`, the response includes `gasPoolArg` and
-     * `sharePolicyArg` so you can compose additional commands (e.g. deposit,
-     * grant) before calling {@link getShareTx} to finalize.
-     *
-     * @param inputs.walletAddress - Wallet address to create the gas pool for.
-     * @param inputs.initialDepositAmount - Optional initial deposit amount in MIST.
-     * @param inputs.deferShare - When true, returns args without sharing yet.
-     * @param inputs.tx - Optional transaction to extend.
-     * @returns `tx` plus optional `gasPoolArg` and `sharePolicyArg` when deferred.
-     */
-    getCreateTx(inputs: Omit<ApiGasPoolCreateBody, "txKind"> & {
-        tx?: Transaction;
-    }): Promise<Omit<ApiGasPoolCreateResponse, "txKind"> & {
-        tx: Transaction;
-    }>;
-    /**
-     * Builds a transaction to deposit into the gas pool.
-     *
-     * Supports SUI and non-SUI deposits. For non-SUI deposits, the input coin
-     * is swapped into SUI via the Aftermath router before depositing.
-     *
-     * @param inputs.walletAddress - Wallet address submitting the deposit.
-     * @param inputs.isSponsoredTx - Whether to build the transaction for sponsored gas. Defaults to false.
-     * @param inputs.coinType - Coin type to deposit. Defaults to SUI.
-     * @param inputs.amount - Amount to deposit (required when sourcing from wallet or for non-SUI).
-     * @param inputs.coinArg - PTB coin argument to use as input (if omitted, sourced from wallet).
-     * @param inputs.slippage - Slippage tolerance for non-SUI swaps (defaults to 0.01).
-     * @param inputs.gasPoolArg - Optional gas pool argument from a previously-built PTB command.
-     * @param inputs.tx - Optional transaction to extend.
-     * @returns {@link SdkTransactionResponse} with `tx`.
-     */
-    getDepositTx(inputs: Omit<ApiGasPoolDepositBody, "txKind"> & {
-        tx?: Transaction;
-    }): Promise<SdkTransactionResponse>;
-    /**
-     * Builds a transaction to withdraw SUI from the gas pool.
-     *
-     * When `deferTransfer` is `true`, the withdrawn coin is not transferred.
-     * Instead, `withdrawnCoinArg` is returned for further PTB composition.
-     *
-     * @param inputs.walletAddress - Wallet address submitting the withdrawal.
-     * @param inputs.amount - Amount of SUI to withdraw in MIST.
-     * @param inputs.recipientAddress - Optional recipient (defaults to `walletAddress`).
-     * @param inputs.deferTransfer - When true, returns the withdrawn coin arg instead of transferring.
-     * @param inputs.gasPoolArg - Optional gas pool argument from a previously-built PTB command.
-     * @param inputs.tx - Optional transaction to extend.
-     * @returns `tx` plus optional `withdrawnCoinArg` when deferred.
-     */
-    getWithdrawTx(inputs: Omit<ApiGasPoolWithdrawBody, "txKind"> & {
-        tx?: Transaction;
-    }): Promise<Omit<ApiGasPoolWithdrawResponse, "txKind"> & {
-        tx: Transaction;
-    }>;
-    /**
-     * Builds a transaction to sponsor (rebate) the transaction sender
-     * using SUI from the gas pool.
-     *
-     * @param inputs.walletAddress - Wallet address submitting the sponsor transaction.
-     * @param inputs.amount - Amount of SUI to rebate in MIST.
-     * @param inputs.tx - Optional transaction to extend.
-     * @returns {@link SdkTransactionResponse} with `tx`.
-     */
-    getSponsorTx(inputs: Omit<ApiGasPoolSponsorBody, "txKind"> & {
-        tx?: Transaction;
-    }): Promise<SdkTransactionResponse>;
-    /**
-     * Builds a transaction to grant another wallet access to the gas pool.
-     *
-     * @param inputs.walletAddress - Owner wallet address.
-     * @param inputs.targetWalletAddress - Wallet address to grant access to.
-     * @param inputs.gasPoolArg - Optional gas pool argument from a previously-built PTB command.
-     * @param inputs.tx - Optional transaction to extend.
-     * @returns {@link SdkTransactionResponse} with `tx`.
-     */
-    getGrantTx(inputs: Omit<ApiGasPoolGrantBody, "txKind"> & {
-        tx?: Transaction;
-    }): Promise<SdkTransactionResponse>;
-    /**
-     * Builds a transaction to revoke another wallet's access to the gas pool.
-     *
-     * @param inputs.walletAddress - Owner wallet address.
-     * @param inputs.targetWalletAddress - Wallet address to revoke access from.
-     * @param inputs.tx - Optional transaction to extend.
-     * @returns {@link SdkTransactionResponse} with `tx`.
-     */
-    getRevokeTx(inputs: Omit<ApiGasPoolRevokeBody, "txKind"> & {
-        tx?: Transaction;
-    }): Promise<SdkTransactionResponse>;
-    /**
-     * Builds a transaction to share a gas pool that was created with `deferShare: true`.
-     *
-     * Use this after composing additional commands (deposit, grant, etc.) with
-     * the `gasPoolArg` returned by {@link getCreateTx}.
-     *
-     * @param inputs.gasPoolArg - Gas pool argument from a deferred create.
-     * @param inputs.sharePolicyArg - Share policy argument from a deferred create.
-     * @param inputs.tx - Optional transaction to extend.
-     * @returns {@link SdkTransactionResponse} with `tx`.
+     * @throws Will throw if the `api` is undefined.
      */
-    getShareTx(inputs: Omit<ApiGasPoolShareBody, "txKind"> & {
-        tx?: Transaction;
-    }): Promise<SdkTransactionResponse>;
+    private readonly stakingApi;
 }
 
 /**
@@ -12614,7 +12642,7 @@ declare class GasPools extends Caller {
  * related to the Sui network package IDs.
  */
 declare class Sui extends Caller {
-    readonly Provider?: AftermathApi | undefined;
+    readonly api?: AftermathApi | undefined;
     /**
      * Static constants containing important addresses on the Sui network:
      *  - `zero`: The zero address (commonly used as a null placeholder).
@@ -12634,9 +12662,9 @@ declare class Sui extends Caller {
      * Creates a new instance of the `Sui` class for fetching chain-level info.
      *
      * @param config - Optional configuration, including the Sui network and an access token.
-     * @param Provider - An optional `AftermathApi` instance for advanced transaction building or data fetching.
+     * @param api - An optional `AftermathApi` instance for advanced transaction building or data fetching.
      */
-    constructor(config?: CallerConfig, Provider?: AftermathApi | undefined);
+    constructor(config?: CallerConfig, api?: AftermathApi | undefined);
     /**
      * Fetches the Sui system state summary object, which contains details
      * about the current epoch, validator set, and other protocol-level data.
@@ -12645,8 +12673,7 @@ declare class Sui extends Caller {
      *
      * @example
      * ```typescript
-     * const afSdk = new Aftermath("MAINNET");
-     * await afSdk.init(); // initialize provider
+     * const afSdk = await Aftermath.create({ network: "MAINNET" });
      *
      * const sui = afSdk.Sui();
      *
@@ -12661,8 +12688,8 @@ declare class SuiFren extends Caller {
     readonly suiFren: SuiFrenObject;
     readonly isStaked: boolean;
     readonly isOwned: boolean;
-    readonly Provider?: AftermathApi | undefined;
-    constructor(suiFren: SuiFrenObject, config?: CallerConfig, isStaked?: boolean, isOwned?: boolean, Provider?: AftermathApi | undefined);
+    readonly api?: AftermathApi | undefined;
+    constructor(suiFren: SuiFrenObject, config?: CallerConfig, isStaked?: boolean, isOwned?: boolean, api?: AftermathApi | undefined);
     suiFrenType(): AnyObjectType;
     properties(): Record<string, string>;
     dynamicFields(): Record<string, string>;
@@ -12683,15 +12710,15 @@ declare class SuiFren extends Caller {
         accessoryType: SuiFrenAccessoryType;
         walletAddress: SuiAddress;
     }): Promise<_mysten_sui_transactions.Transaction>;
-    private useProvider;
+    private suiFrensApi;
 }
 
 declare class StakedSuiFren extends Caller {
     readonly info: StakedSuiFrenInfo;
     readonly isOwned: boolean;
-    readonly Provider?: AftermathApi | undefined;
+    readonly api?: AftermathApi | undefined;
     readonly suiFren: SuiFren;
-    constructor(info: StakedSuiFrenInfo, config?: CallerConfig, isOwned?: boolean, Provider?: AftermathApi | undefined);
+    constructor(info: StakedSuiFrenInfo, config?: CallerConfig, isOwned?: boolean, api?: AftermathApi | undefined);
     mixFee(): Balance;
     suiFrenId(): ObjectId;
     clone(): StakedSuiFren;
@@ -12710,11 +12737,11 @@ declare class StakedSuiFren extends Caller {
         accessoryType: SuiFrenAccessoryType;
         walletAddress: SuiAddress;
     }): Promise<_mysten_sui_transactions.Transaction>;
-    private useProvider;
+    private suiFrensApi;
 }
 
 declare class SuiFrens extends Caller {
-    readonly Provider?: AftermathApi | undefined;
+    readonly api?: AftermathApi | undefined;
     static readonly constants: {
         mixingFeeCoinType: string;
         protocolFees: {
@@ -12727,7 +12754,7 @@ declare class SuiFrens extends Caller {
             mint: bigint;
         };
     };
-    constructor(config?: CallerConfig, Provider?: AftermathApi | undefined);
+    constructor(config?: CallerConfig, api?: AftermathApi | undefined);
     static calcTotalInternalMixFee(inputs: {
         mixFee1: Balance | undefined;
         mixFee2: Balance | undefined;
@@ -12761,7 +12788,7 @@ declare class SuiFrens extends Caller {
     static suiFrenId(suiFren: SuiFren | StakedSuiFren | undefined): ObjectId | undefined;
     static mixFee(suiFren: SuiFren | StakedSuiFren | undefined): Balance | undefined;
     private static createStakedSuiFrensQueryString;
-    private useProvider;
+    private suiFrensApi;
 }
 
 /**
@@ -13078,8 +13105,7 @@ interface ApiDCAsOwnedBody {
  *
  * @example
  * ```typescript
- * const afSdk = new Aftermath("MAINNET");
- * await afSdk.init(); // initialize provider
+ * const afSdk = await Aftermath.create({ network: "MAINNET" });
  *
  * const dca = afSdk.Dca();
  * ```
@@ -13421,8 +13447,7 @@ interface ApiLimitOrdersActiveOrdersOwnedBody {
  *
  * @example
  * ```typescript
- * const afSdk = new Aftermath("MAINNET");
- * await afSdk.init(); // initialize provider
+ * const afSdk = await Aftermath.create({ network: "MAINNET" });
  *
  * const limitOrders = afSdk.LimitOrders();
  * ```
@@ -13582,14 +13607,14 @@ interface MultisigData {
  * such as retrieving a multisig address and associated public key for a user.
  */
 declare class Multisig extends Caller {
-    readonly Provider?: AftermathApi | undefined;
+    readonly api?: AftermathApi | undefined;
     /**
      * Creates a new instance of `Multisig`.
      *
      * @param config - Optional configuration for the `Caller`, including network and access token.
-     * @param Provider - An optional instance of `AftermathApi` to build or fetch multisig data.
+     * @param api - An optional instance of `AftermathApi` to build or fetch multisig data.
      */
-    constructor(config?: CallerConfig, Provider?: AftermathApi | undefined);
+    constructor(config?: CallerConfig, api?: AftermathApi | undefined);
     /**
      * Retrieves a multisig address and corresponding public key for a user based on their
      * provided single public key.
@@ -13600,8 +13625,7 @@ declare class Multisig extends Caller {
      * @example
      * ```typescript
      *
-     * const afSdk = new Aftermath("MAINNET");
-     * await afSdk.init(); // initialize provider
+     * const afSdk = await Aftermath.create({ network: "MAINNET" });
      *
      * const multisig = afSdk.Multisig();
      *
@@ -13616,7 +13640,7 @@ declare class Multisig extends Caller {
      * Internal helper to get the configured `Multisig` provider from `AftermathApi`.
      * Throws an error if the provider is not available.
      */
-    private useProvider;
+    private readonly multisigApi;
 }
 
 declare class Referrals extends Caller {
@@ -13645,8 +13669,8 @@ declare class Referrals extends Caller {
 }
 
 declare class Rewards extends Caller {
-    readonly Provider?: AftermathApi | undefined;
-    constructor(config?: CallerConfig, Provider?: AftermathApi | undefined);
+    readonly api?: AftermathApi | undefined;
+    constructor(config?: CallerConfig, api?: AftermathApi | undefined);
     getPoints(inputs: ApiRewardsGetPointsBody): Promise<ApiRewardsGetPointsResponse>;
     getHistory(inputs: ApiRewardsGetHistoryBody): Promise<ApiRewardsGetHistoryResponse>;
     getClaimable(inputs: ApiRewardsGetClaimableBody): Promise<ApiRewardsGetClaimableResponse>;
@@ -13708,8 +13732,7 @@ declare class UserData extends Caller {
      *
      * @example
      * ```typescript
-     * const afSdk = new Aftermath("MAINNET");
-     * await afSdk.init(); // initialize provider
+     * const afSdk = await Aftermath.create({ network: "MAINNET" });
      *
      * const userData = afSdk.UserData();
      *
@@ -13797,8 +13820,7 @@ declare class DynamicGas extends Caller {
      *
      * @example
      * ```typescript
-     * const afSdk = new Aftermath("MAINNET");
-     * await afSdk.init(); // initialize provider
+     * const afSdk = await Aftermath.create({ network: "MAINNET" });
      *
      * const dynamicGas = afSdk.DynamicGas();
      *
@@ -13839,8 +13861,7 @@ declare class Prices extends Caller {
      * @example
      * ```typescript
      *
-     * const afSdk = new Aftermath("MAINNET");
-     * await afSdk.init(); // initialize provider
+     * const afSdk = await Aftermath.create({ network: "MAINNET" });
      *
      * const prices = afSdk.Prices();
      *
@@ -14867,8 +14888,8 @@ declare class Casting {
 }
 
 declare class CoinApi {
-    private readonly Provider;
-    constructor(Provider: AftermathApi);
+    private readonly api;
+    constructor(api: AftermathApi);
     fetchCoinWithAmountTx: (inputs: {
         tx: Transaction;
         walletAddress: SuiAddress;
@@ -14896,7 +14917,7 @@ declare class CoinApi {
 }
 
 declare class DcaApi {
-    private readonly Provider;
+    private readonly api;
     private static readonly constants;
     readonly addresses: DcaAddresses;
     readonly eventTypes: {
@@ -14905,26 +14926,21 @@ declare class DcaApi {
         closedOrder: AnyObjectType;
         executedTrade: AnyObjectType;
     };
-    constructor(Provider: AftermathApi);
+    constructor(api: AftermathApi);
     createCloseOrderTx: (inputs: {
         tx: Transaction;
         allocateCoinType: CoinType;
         buyCoinType: CoinType;
         orderId: ObjectId | TransactionArgument;
     }) => _mysten_sui_transactions.TransactionResult;
-    private createdOrderEventType;
-    private createdOrderEventTypeV2;
-    private closedOrderEventType;
-    private executedOrderEventType;
-}
-
-interface MoveErrorsInterface {
-    readonly moveErrors: MoveErrors;
+    private readonly createdOrderEventType;
+    private readonly createdOrderEventTypeV2;
+    private readonly closedOrderEventType;
+    private readonly executedOrderEventType;
 }
-type MoveErrors = Record<PackageId, Record<"ANY" | ModuleName, Record<MoveErrorCode, string>>>;
 
 declare class FarmsApi implements MoveErrorsInterface {
-    private readonly Provider;
+    private readonly api;
     private static readonly constants;
     readonly addresses: FarmsAddresses;
     readonly objectTypes: {
@@ -14961,10 +14977,10 @@ declare class FarmsApi implements MoveErrorsInterface {
     readonly moveErrors: MoveErrors;
     /**
      * Constructor for FarmsApi
-     * @param Provider The AftermathApi provider instance
+     * @param api The AftermathApi provider instance
      * @throws Error if not all required addresses have been set in provider
      */
-    constructor(Provider: AftermathApi);
+    constructor(api: AftermathApi);
     /**
      * @deprecated Use the new API method in Farms class instead.
      * Fetches the owner caps for staking pools owned by a specific wallet address
@@ -15840,67 +15856,67 @@ declare class FarmsApi implements MoveErrorsInterface {
         recipientAddress: SuiAddress;
         rewardCoinType: CoinType;
     }, "tx">) => Transaction;
-    private eventWrapperType;
+    private readonly eventWrapperType;
     /**
      * Creates the event type for vault creation events
      * @returns Fully qualified event type string
      */
-    private createdVaultEventType;
+    private readonly createdVaultEventType;
     /**
      * Creates the event type for reward initialization events
      * @returns Fully qualified event type string
      */
-    private initializedRewardEventType;
+    private readonly initializedRewardEventType;
     /**
      * Creates the event type for reward addition events
      * @returns Fully qualified event type string
      */
-    private addedRewardEventType;
+    private readonly addedRewardEventType;
     /**
      * Creates the event type for emission increase events
      * @returns Fully qualified event type string
      */
-    private increasedEmissionsEventType;
+    private readonly increasedEmissionsEventType;
     /**
      * Creates the event type for emission update events
      * @returns Fully qualified event type string
      */
-    private updatedEmissionsEventType;
+    private readonly updatedEmissionsEventType;
     /**
      * Creates the event type for strict staking events
      * @returns Fully qualified event type string
      */
-    private stakedEventType;
+    private readonly stakedEventType;
     /**
      * Creates the event type for relaxed staking events
      * @returns Fully qualified event type string
      */
-    private stakedRelaxedEventType;
+    private readonly stakedRelaxedEventType;
     /**
      * Creates the event type for position locking events
      * @returns Fully qualified event type string
      */
-    private lockedEventType;
+    private readonly lockedEventType;
     /**
      * Creates the event type for position unlocking events
      * @returns Fully qualified event type string
      */
-    private unlockedEventType;
+    private readonly unlockedEventType;
     /**
      * Creates the event type for principal deposit events
      * @returns Fully qualified event type string
      */
-    private depositedPrincipalEventType;
+    private readonly depositedPrincipalEventType;
     /**
      * Creates the event type for principal withdrawal events
      * @returns Fully qualified event type string
      */
-    private withdrewPrincipalEventType;
+    private readonly withdrewPrincipalEventType;
     /**
      * Creates the event type for reward harvesting events
      * @returns Fully qualified event type string
      */
-    private harvestedRewardsEventType;
+    private readonly harvestedRewardsEventType;
     /**
      * Checks if the input contains a one-time admin cap ID
      * @param inputs FarmOwnerOrOneTimeAdminCap object
@@ -15916,14 +15932,14 @@ declare class FarmsApi implements MoveErrorsInterface {
 }
 
 declare class FaucetApi {
-    private readonly Provider;
+    private readonly api;
     private static readonly constants;
     readonly addresses: FaucetAddresses;
     readonly eventTypes: {
         mintCoin: AnyObjectType;
         addCoin: AnyObjectType;
     };
-    constructor(Provider: AftermathApi);
+    constructor(api: AftermathApi);
     fetchSupportedCoins: () => Promise<CoinType[]>;
     requestCoinTx: (inputs: {
         tx: Transaction;
@@ -15943,32 +15959,32 @@ declare class FaucetApi {
     fetchBuildMintSuiFrenTx: (inputs: ApiFaucetMintSuiFrenBody) => Promise<Transaction>;
     fetchMintCoinEvents: (inputs: EventsInputs) => Promise<EventsWithCursor<FaucetMintCoinEvent>>;
     fetchAddCoinEvents: (inputs: EventsInputs) => Promise<EventsWithCursor<FaucetAddCoinEvent>>;
-    private mintCoinEventType;
-    private addCoinEventType;
+    private readonly mintCoinEventType;
+    private readonly addCoinEventType;
 }
 
 declare class LimitOrdersApi {
-    private readonly Provider;
+    private readonly api;
     readonly addresses: LimitAddresses;
     readonly eventTypes: {
         createdOrder: AnyObjectType;
     };
-    constructor(Provider: AftermathApi);
-    private createdOrderEventType;
+    constructor(api: AftermathApi);
+    private readonly createdOrderEventType;
 }
 
 declare class MultisigApi {
+    private readonly api;
     readonly sharedCustodyAddresses: SharedCustodyAddresses;
-    private readonly Provider;
-    constructor(Provider: AftermathApi);
+    constructor(api: AftermathApi);
     getMultisigForUser(inputs: ApiMultisigUserBody): MultisigData;
 }
 
 declare class NftAmmApi {
-    private readonly Provider;
+    private readonly api;
     private static readonly constants;
     readonly addresses: NftAmmAddresses;
-    constructor(Provider: AftermathApi);
+    constructor(api: AftermathApi);
     fetchNftsInMarketTable: (inputs: {
         marketTableObjectId: ObjectId;
         cursor?: ObjectId;
@@ -16053,7 +16069,7 @@ declare class NftAmmApi {
 }
 
 declare class PerpetualsApi implements MoveErrorsInterface {
-    private readonly Provider;
+    private readonly api;
     private static readonly constants;
     readonly addresses: PerpetualsAddresses;
     readonly eventTypes: {
@@ -16086,11 +16102,11 @@ declare class PerpetualsApi implements MoveErrorsInterface {
         performedAdl: AnyObjectType;
     };
     readonly moveErrors: MoveErrors;
-    constructor(Provider: AftermathApi);
+    constructor(api: AftermathApi);
     getAccountCapType: (inputs: {
         collateralCoinType: CoinType;
     }) => string;
-    private eventType;
+    private readonly eventType;
 }
 
 /**
@@ -16101,6 +16117,7 @@ declare class PerpetualsApi implements MoveErrorsInterface {
  * Provides methods to interact with the Pools API.
  */
 declare class PoolsApi implements MoveErrorsInterface {
+    private readonly api;
     /**
      * Constants used in the pools API.
      */
@@ -16127,13 +16144,12 @@ declare class PoolsApi implements MoveErrorsInterface {
         withdrawV2: AnyObjectType;
     };
     readonly moveErrors: MoveErrors;
-    private readonly Provider;
     /**
      * Creates an instance of PoolsApi.
-     * @param {AftermathApi} Provider - An instance of AftermathApi.
+     * @param {AftermathApi} api - An instance of AftermathApi.
      * @throws {Error} Throws an error if not all required addresses have been set in AfSdk
      */
-    constructor(Provider: AftermathApi);
+    constructor(api: AftermathApi);
     fetchOwnedDaoFeePoolOwnerCaps: (inputs: ApiPoolsOwnedDaoFeePoolOwnerCapsBody) => Promise<DaoFeePoolOwnerCapObject[]>;
     /**
      * Executes a trade transaction on the specified pool.
@@ -16430,10 +16446,10 @@ declare class PoolsApi implements MoveErrorsInterface {
 }
 
 declare class ReferralVaultApi {
-    private readonly Provider;
+    private readonly api;
     private static readonly constants;
     readonly addresses: ReferralVaultAddresses;
-    constructor(Provider: AftermathApi);
+    constructor(api: AftermathApi);
     updateReferrerTx: (inputs: {
         tx: Transaction;
         referrer: SuiAddress;
@@ -16470,7 +16486,7 @@ declare class ReferralVaultApi {
  * @class
  */
 declare class RouterApi implements MoveErrorsInterface {
-    private readonly Provider;
+    private readonly api;
     static readonly constants: {
         moduleNames: {
             router: string;
@@ -16491,14 +16507,14 @@ declare class RouterApi implements MoveErrorsInterface {
     /**
      * Creates an instance of RouterApi.
      * @constructor
-     * @param {AftermathApi} Provider - The Aftermath API instance.
+     * @param {AftermathApi} api - The Aftermath API instance.
      */
-    constructor(Provider: AftermathApi);
-    private routerTradeEventType;
+    constructor(api: AftermathApi);
+    private readonly routerTradeEventType;
 }
 
 declare class StakingApi implements MoveErrorsInterface {
-    private readonly Provider;
+    private readonly api;
     private static readonly constants;
     readonly addresses: StakingAddresses;
     readonly eventTypes: {
@@ -16514,7 +16530,7 @@ declare class StakingApi implements MoveErrorsInterface {
         unverifiedValidatorOperationCap: AnyObjectType;
     };
     readonly moveErrors: MoveErrors;
-    constructor(Provider: AftermathApi);
+    constructor(api: AftermathApi);
     /**
      * Adds move call to tx for liquid staking of SUI for afSUI.
      *
@@ -16609,10 +16625,10 @@ declare class StakingApi implements MoveErrorsInterface {
     } & Omit<{
         tx: Transaction;
     }, "tx">) => Transaction;
-    private stakedEventType;
-    private unstakeRequestedEventType;
-    private unstakedEventType;
-    private epochWasChangedEventType;
+    private readonly stakedEventType;
+    private readonly unstakeRequestedEventType;
+    private readonly unstakedEventType;
+    private readonly epochWasChangedEventType;
     static updateStakingPositionsFromEvent: (inputs: {
         stakingPositions: StakingPosition[];
         event: StakeEvent | UnstakeEvent;
@@ -16622,15 +16638,14 @@ declare class StakingApi implements MoveErrorsInterface {
 }
 
 declare class SuiApi {
-    private readonly Provider;
-    constructor(Provider: AftermathApi);
+    private readonly api;
+    constructor(api: AftermathApi);
     /**
      * @deprecated Use `getSystemState()` method instead.
      * This method will be removed in a future release.
      * @example
      * ```typescript
-     * const afSdk = new Aftermath("MAINNET");
-     * await afSdk.init(); // initialize provider
+     * const afSdk = await Aftermath.create({ network: "MAINNET" });
      *
      * const sui = afSdk.Sui();
      *
@@ -16641,7 +16656,7 @@ declare class SuiApi {
 }
 
 declare class SuiFrensApi {
-    private readonly Provider;
+    private readonly api;
     private static readonly constants;
     readonly addresses: SuiFrensAddresses;
     readonly objectTypes: {
@@ -16658,7 +16673,7 @@ declare class SuiFrensApi {
         stakeSuiFren: AnyObjectType;
         unstakeSuiFren: AnyObjectType;
     };
-    constructor(Provider: AftermathApi);
+    constructor(api: AftermathApi);
     fetchMixingLimitsAndLastEpochMixeds: (inputs: {
         suiFrenIds: ObjectId[];
         suiFrenType: AnyObjectType;
@@ -16841,9 +16856,9 @@ declare class SuiFrensApi {
 }
 
 declare class EventsApiHelpers {
-    private readonly Provider;
+    private readonly api;
     private static readonly constants;
-    constructor(Provider: AftermathApi);
+    constructor(api: AftermathApi);
     /**
      * @deprecated `subscribeEvent` was removed from `SuiJsonRpcClient` in
      * `@mysten/sui` v2. Poll `queryEvents` instead or use a WebSocket transport.
@@ -16884,11 +16899,11 @@ declare class EventsApiHelpers {
 }
 
 declare class InspectionsApiHelpers {
-    private readonly Provider;
+    private readonly api;
     static constants: {
         devInspectSigner: string;
     };
-    constructor(Provider: AftermathApi);
+    constructor(api: AftermathApi);
     fetchFirstBytesFromTxOutput: (inputs: {
         tx: Transaction;
         sender?: SuiAddress;
@@ -16908,9 +16923,9 @@ declare class InspectionsApiHelpers {
 }
 
 declare class ObjectsApiHelpers {
-    private readonly Provider;
+    private readonly api;
     private static readonly constants;
-    constructor(Provider: AftermathApi);
+    constructor(api: AftermathApi);
     fetchDoesObjectExist: (objectId: ObjectId | PackageId) => Promise<boolean>;
     fetchIsObjectOwnedByAddress: (inputs: {
         objectId: ObjectId;
@@ -16980,8 +16995,8 @@ declare class ObjectsApiHelpers {
 }
 
 declare class TransactionsApiHelpers {
-    private readonly Provider;
-    constructor(Provider: AftermathApi);
+    private readonly api;
+    constructor(api: AftermathApi);
     fetchTransactionsWithCursor: (inputs: {
         query: SuiTransactionBlockResponseQuery;
         cursor?: TransactionDigest;
@@ -17026,12 +17041,12 @@ declare class TransactionsApiHelpers {
 }
 
 declare class NftsApi {
-    private readonly Provider;
+    private readonly api;
     readonly addresses: NftsAddresses;
     readonly objectTypes: {
         personalKioskCap: AnyObjectType;
     };
-    constructor(Provider: AftermathApi);
+    constructor(api: AftermathApi);
     fetchOwnedNfts: (inputs: {
         walletAddress: SuiAddress;
     }) => Promise<Nft[]>;
@@ -17059,8 +17074,8 @@ declare class NftsApi {
 }
 
 declare class WalletApi {
-    private readonly Provider;
-    constructor(Provider: AftermathApi);
+    private readonly api;
+    constructor(api: AftermathApi);
     fetchCoinBalance: (inputs: {
         walletAddress: SuiAddress;
         coin: CoinType;
@@ -17098,7 +17113,7 @@ declare class WalletApi {
  * ```
  */
 declare class AftermathApi {
-    readonly provider: SuiJsonRpcClient;
+    readonly client: SuiJsonRpcClient;
     readonly addresses: ConfigAddresses;
     /**
      * Static helper references for quick usage without instantiating the class.
@@ -17125,10 +17140,10 @@ declare class AftermathApi {
      * Constructs a new instance of the `AftermathApi`, binding the given Sui client
      * to the known `addresses`.
      *
-     * @param provider - A `SuiJsonRpcClient` for on-chain queries and transactions.
+     * @param client - A `SuiJsonRpcClient` for on-chain queries and transactions.
      * @param addresses - The config addresses (object IDs, package IDs, etc.) for the Aftermath protocol.
      */
-    constructor(provider: SuiJsonRpcClient, addresses: ConfigAddresses);
+    constructor(client: SuiJsonRpcClient, addresses: ConfigAddresses);
     /**
      * Creates a new `DynamicFieldsApiHelpers` instance for complex object field queries.
      */
@@ -17228,20 +17243,15 @@ declare class AftermathApi {
      * }
      * ```
      */
-    translateMoveErrorMessage: <T extends MoveErrorsInterface>(inputs: {
+    translateMoveErrorMessage(inputs: {
         errorMessage: string;
-    }) => {
-        errorCode: MoveErrorCode;
-        packageId: ObjectId;
-        module: ModuleName;
-        error: string;
-    } | undefined;
+    }): TranslatedMoveError | undefined;
 }
 
 declare class DynamicFieldsApiHelpers {
-    private readonly Provider;
+    private readonly api;
     private static readonly constants;
-    constructor(Provider: AftermathApi);
+    constructor(api: AftermathApi);
     fetchCastDynamicFieldsOfTypeWithCursor: <ObjectType>(inputs: {
         parentObjectId: ObjectId;
         objectsFromObjectIds: (objectIds: ObjectId[]) => Promise<ObjectType[]>;
@@ -17640,11 +17650,7 @@ declare class Helpers {
      */
     static parseMoveErrorMessage(inputs: {
         errorMessage: string;
-    }): {
-        errorCode: MoveErrorCode;
-        packageId: ObjectId;
-        module: ModuleName;
-    } | undefined;
+    }): ParsedMoveError | undefined;
     /**
      * Translates a Move abort error message into a known error string if it matches
      * entries in a given `moveErrors` table. This is used to map on-chain error codes
@@ -17656,12 +17662,7 @@ declare class Helpers {
     static translateMoveErrorMessage(inputs: {
         errorMessage: string;
         moveErrors: MoveErrors;
-    }): {
-        errorCode: MoveErrorCode;
-        packageId: ObjectId;
-        module: ModuleName;
-        error: string;
-    } | undefined;
+    }): TranslatedMoveError | undefined;
     /**
      * Constructs a `Keypair` instance from a private key string. The `privateKey`
      * may indicate the signing scheme (ED25519, Secp256k1, or Secp256r1) via prefix,
@@ -17681,15 +17682,15 @@ declare class Helpers {
  */
 declare class Wallet extends Caller {
     readonly address: SuiAddress;
-    readonly Provider?: AftermathApi | undefined;
+    readonly api?: AftermathApi | undefined;
     /**
      * Creates a new `Wallet` instance for a specific address.
      *
      * @param address - The Sui address for this wallet (e.g., "0x<address>").
      * @param config - An optional caller configuration including network and authentication.
-     * @param Provider - An optional `AftermathApi` instance for wallet-specific methods.
+     * @param api - An optional `AftermathApi` instance for wallet-specific methods.
      */
-    constructor(address: SuiAddress, config?: CallerConfig, Provider?: AftermathApi | undefined);
+    constructor(address: SuiAddress, config?: CallerConfig, api?: AftermathApi | undefined);
     /**
      * Fetches the balance for a single coin type in this wallet.
      *
@@ -17699,8 +17700,7 @@ declare class Wallet extends Caller {
      * @example
      * ```typescript
      *
-     * const afSdk = new Aftermath("MAINNET");
-     * await afSdk.init(); // initialize provider
+     * const afSdk = await Aftermath.create({ network: "MAINNET" });
      *
      * const wallet = afSdk.Wallet("0x<address>");
      *
@@ -17760,181 +17760,160 @@ declare class Wallet extends Caller {
 }
 
 /**
- * The `Aftermath` class serves as the primary entry point for interacting with
+ * Options accepted by {@link Aftermath.create}. All fields are optional —
+ * pass `{}` for the canonical mainnet setup.
+ */
+interface AftermathOptions {
+    /**
+     * The target Sui network. Determines the canonical API host and
+     * Sui fullnode URL when no explicit overrides are supplied.
+     * @default "MAINNET"
+     */
+    network?: SuiNetwork;
+    /**
+     * Explicit override for the Aftermath API host (e.g.
+     * `"http://localhost:8080"`). Useful for staging or local backends.
+     */
+    baseUrl?: Url;
+    /**
+     * Explicit override for the Sui fullnode URL.
+     */
+    fullnodeUrl?: Url;
+    /**
+     * Override for the API path segment between host and package prefix.
+     * Defaults to `"api"`. Override only when targeting a backend that
+     * mounts the Aftermath API under a different path.
+     */
+    apiEndpoint?: string;
+    /**
+     * Preloaded on-chain addresses. When supplied, `create` skips the
+     * network round-trip that normally fetches them.
+     */
+    addresses?: ConfigAddresses;
+    /**
+     * Pre-built `AftermathApi` instance. When supplied, `create` uses it
+     * directly and skips address discovery and Sui client setup entirely.
+     */
+    api?: AftermathApi;
+}
+/**
+ * The `Aftermath` class is the primary entry point for interacting with
  * the Aftermath Finance protocols and utilities on the Sui blockchain.
- * It provides various sub-providers (e.g. `Router`, `Staking`, `Farms`)
- * initialized under the specified network environment (MAINNET, TESTNET, etc).
+ * It exposes sub-providers (e.g. `Router`, `Staking`, `Farms`) configured
+ * for the chosen network.
+ *
+ * Instances are created through the async {@link Aftermath.create} factory
+ * — direct construction is not supported.
  *
  * @example
  * ```typescript
- * // Create provider
- * const aftermath = new Aftermath("MAINNET");
- * // Create package provider
- * const router = aftermath.Router();
- * // Call sdk from package provider
- * const supportedCoins = await router.getSupportedCoins();
- *
- * // Or do it all in one go
- * const supportedCoins = await (new Aftermath("MAINNET")).Router().getSupportedCoins();
+ * const aftermath = await Aftermath.create({ network: "MAINNET" });
+ * const supportedCoins = await aftermath.Router().getSupportedCoins();
  * ```
  */
 declare class Aftermath extends Caller {
-    private readonly network?;
-    private Provider?;
     /**
-     * Creates an `Aftermath` provider instance to call the Aftermath Finance APIs
-     * and interact with Sui-based protocols.
+     * Constructs and fully initializes an `Aftermath` instance.
      *
-     * @param network - The target Sui network ("MAINNET", "TESTNET", "DEVNET", or "LOCAL").
-     * @param Provider - Optionally pass a custom `AftermathApi` instance if you already have one.
+     * Resolves on-chain addresses, configures the Sui fullnode client, and
+     * returns a ready-to-use instance. Pass `addresses` or `api` to skip
+     * the corresponding bootstrap steps.
      */
-    constructor(network?: SuiNetwork | undefined, Provider?: AftermathApi | undefined);
+    static create(options?: AftermathOptions): Promise<Aftermath>;
+    private readonly options;
+    private constructor();
     /**
-     * Initializes the Aftermath provider by fetching addresses from the backend
-     * and configuring the Sui fullnode client. This method must be called before
-     * performing many API operations.
-     *
-     * @param inputs - Optional object allowing you to override the default `fullnodeUrl`.
-     * @example
-     * ```typescript
-     * const afSdk = new Aftermath("MAINNET");
-     * await afSdk.init(); // sets up internal providers
-     * ```
+     * Resolves addresses and wires up the internal `AftermathApi`. Called
+     * exactly once by the {@link Aftermath.create} factory.
      */
-    init(inputs?: {
-        fullnodeUrl: Url;
-    }): Promise<void>;
+    private bootstrap;
     /**
-     * Retrieves the Aftermath-specific on-chain addresses (object IDs, packages, etc.).
-     *
-     * @returns A `ConfigAddresses` object containing relevant addresses for the protocol.
-     *
-     * @example
-     * ```typescript
-     * const addresses = await aftermath.getAddresses();
-     * console.log(addresses); // { routerPackageId: "...", someOtherPackageId: "..." }
-     * ```
+     * The fully-bootstrapped low-level API provider. Set by `bootstrap()`
+     * before any accessor is callable.
      */
-    getAddresses(): Promise<ConfigAddresses>;
+    private api;
     /**
-     * Returns the base URL used for Aftermath API calls.
-     *
-     * @returns The base URL for this instance's API.
-     *
-     * @example
-     * ```typescript
-     * const apiBaseUrl = aftermath.getApiBaseUrl();
-     * console.log(apiBaseUrl); // "https://api.after..."
-     * ```
+     * The Sui network this provider is configured for (e.g. "MAINNET").
      */
-    getApiBaseUrl(): string | undefined;
+    get network(): SuiNetwork;
     /**
-     * Returns an instance of the `Pools` class, which handles DEX pool operations
-     * within the Aftermath platform (if supported).
+     * The resolved API base URL for this instance.
      */
-    Pools: () => Pools;
+    getApiBaseUrl(): Url | undefined;
     /**
-     * Returns an instance of the `Staking` class for Aftermath's staking and unstaking features.
+     * Fetches the Aftermath on-chain addresses (object IDs, packages, etc.)
+     * directly from the API. Typically you don't need to call this — the
+     * `create` factory handles it. Useful for cache warmers or tooling.
      */
-    Staking: () => Staking;
+    getAddresses(): Promise<ConfigAddresses>;
     /**
-     * Returns an instance of `SuiFrens`, a specialized package for social or utility services.
+     * Attempts to decode a raw Move abort/error string into a structured
+     * error code, package ID, module name, and human-readable message.
+     * Returns `undefined` when no registered package recognizes the error.
+     *
+     * Thin pass-through to the underlying {@link AftermathApi} so consumers
+     * don't need to reach into the private `api` field.
      */
+    translateMoveErrorMessage(inputs: {
+        errorMessage: string;
+    }): TranslatedMoveError | undefined;
+    /** DEX pool operations. */
+    Pools: () => Pools;
+    /** Liquid staking and unstaking. */
+    Staking: () => Staking;
+    /** SuiFrens — specialized social/utility package. */
     SuiFrens: () => SuiFrens;
-    /**
-     * Returns an instance of `Faucet`, allowing test/dev networks to dispense tokens.
-     */
+    /** Test-network faucet for dispensing tokens. */
     Faucet: () => Faucet;
-    /**
-     * Returns an instance of the `Router` class, which handles smart order routing
-     * across multiple DEX protocols.
-     */
+    /** Smart order router across DEX protocols. */
     Router: () => Router;
-    /**
-     * Returns an instance of `NftAmm`, which supports NFT AMM (automated market maker) features.
-     */
+    /** NFT AMM operations. */
     NftAmm: () => NftAmm;
     /**
-     * Returns an instance of `ReferralVault` for referral-based interactions in the protocol.
-     * @deprecated Use `Referrals` instead
+     * Referral vault interactions.
+     * @deprecated Use `Referrals` instead.
      */
     ReferralVault: () => ReferralVault;
-    /**
-     * Returns an instance of `Referrals` for referral-based interactions in the protocol.
-     */
+    /** Referral-program interactions. */
     Referrals: () => Referrals;
-    /**
-     * Returns an instance of `GasPools` for shared gas pool interactions.
-     */
+    /** Shared gas pool interactions. */
     GasPools: () => GasPools;
-    /**
-     * Returns an instance of `Perpetuals` for futures or perpetual contract interactions.
-     */
+    /** Perpetual / futures contracts. */
     Perpetuals: () => Perpetuals;
-    /**
-     * Returns an instance of `Rewards` for querying user reward points.
-     */
+    /** User reward-point queries. */
     Rewards: () => Rewards;
-    /**
-     * Returns an instance of `Farms` for yield farming or liquidity mining functionalities.
-     */
+    /** Yield farming / liquidity mining. */
     Farms: () => Farms;
-    /**
-     * Returns an instance of the `Dca` class, supporting dollar-cost averaging logic.
-     */
+    /** Dollar-cost averaging. */
     Dca: () => Dca;
-    /**
-     * Returns an instance of `Multisig`, enabling multi-signature address creation and management.
-     */
+    /** Multi-signature address creation and management. */
     Multisig: () => Multisig;
-    /**
-     * Returns an instance of `LimitOrders`, supporting limit order placement on certain DEX protocols.
-     */
+    /** Limit orders on supported DEX protocols. */
     LimitOrders: () => LimitOrders;
-    /**
-     * Returns an instance of `UserData` for creating and managing user-specific data or key storage.
-     */
+    /** User-specific data / key storage. */
     UserData: () => UserData;
-    /**
-     * Returns an instance of `Sui` for low-level Sui chain information and utilities.
-     */
+    /** Low-level Sui chain utilities. */
     Sui: () => Sui;
-    /**
-     * Returns an instance of `Prices`, which provides coin price data from external or internal feeds.
-     */
+    /** Coin price feeds. */
     Prices: () => Prices;
     /**
-     * Creates a new `Wallet` instance for a specific user address, enabling you to fetch balances,
-     * transaction history, etc.
-     *
-     * @param address - The Sui address of the wallet (e.g., "0x<32_byte_hex>").
+     * Creates a `Wallet` instance scoped to a specific user address.
+     * @param address - The Sui address (e.g., `"0x..."`).
      */
     Wallet: (address: SuiAddress) => Wallet;
     /**
-     * Returns an instance of the `Coin` class, which handles coin metadata, decimal conversions,
-     * and other coin-related utilities for a specified `CoinType`.
-     *
-     * @param coinType - Optionally specify a coin type for immediate usage in coin methods.
+     * Returns a `Coin` helper for the given coin type. Pass `undefined`
+     * for generic coin-metadata utilities.
      */
     Coin: (coinType?: CoinType) => Coin;
-    /**
-     * Returns an instance of `DynamicGas`, enabling dynamic assignment of gas
-     * objects or sponsored transactions for user operations.
-     */
+    /** Dynamic gas-object assignment for sponsored transactions. */
     DynamicGas: () => DynamicGas;
-    /**
-     * Returns an instance of `Auth`, handling user authentication or token-based flows (if applicable).
-     */
+    /** Authentication / token-based flows. */
     Auth: () => Auth;
-    /**
-     * Exposes a set of helper functions for general-purpose usage across
-     * the Aftermath ecosystem. Includes utilities for math, logging, etc.
-     */
+    /** General-purpose helpers (math, logging, etc.). */
     static helpers: typeof Helpers;
-    /**
-     * Exposes a set of casting utilities for data type conversions (e.g., BigInt <-> fixed).
-     */
+    /** Casting utilities for data type conversions (BigInt <-> IFixed, etc.). */
     static casting: typeof Casting;
 }
 
-export { type AfSuiRouterPoolObject, Aftermath, AftermathApi, type AllocatedCollateralEvent, type AmountInCoinAndUsd, type AnyObjectType, type ApiAccessoriesForSuiFrenBody, type ApiAddSuiFrenAccessoryBody, type ApiCreateAuthAccountBody, type ApiCreatePoolBody, type ApiDataWithCursorBody, type ApiDelegatedStakesBody, type ApiDynamicFieldsBody, type ApiDynamicGasBody, type ApiDynamicGasResponse, type ApiEventsBody, type ApiFarmsCreateStakingPoolBody, type ApiFarmsCreateStakingPoolBodyV1, type ApiFarmsDepositPrincipalBody, type ApiFarmsGrantOneTimeAdminCapBody, type ApiFarmsIncreaseStakingPoolRewardsEmissionsBody, type ApiFarmsInitializeStakingPoolRewardBody, type ApiFarmsLockBody, type ApiFarmsOwnedStakedPositionsBody, type ApiFarmsOwnedStakingPoolOneTimeAdminCapsBody, type ApiFarmsOwnedStakingPoolOwnerCapsBody, type ApiFarmsRenewLockBody, type ApiFarmsStakeBody, type ApiFarmsStakeBodyV1, type ApiFarmsTopUpStakingPoolRewardsBody, type ApiFarmsUnlockBody, type ApiFarmsUnstakeBody, type ApiFaucetMintSuiFrenBody, type ApiFaucetRequestBody, type ApiGasPoolBody, type ApiGasPoolCreateBody, type ApiGasPoolCreateResponse, type ApiGasPoolDepositBody, type ApiGasPoolGrantBody, type ApiGasPoolResponse, type ApiGasPoolRevokeBody, type ApiGasPoolShareBody, type ApiGasPoolSponsorBody, type ApiGasPoolWithdrawBody, type ApiGasPoolWithdrawResponse, type ApiGetAccessTokenBody, type ApiGetAccessTokenResponse, type ApiHarvestFarmsRewardsBody, type ApiHarvestSuiFrenFeesBody, type ApiIndexerEventsBody, type ApiIndexerUserEventsBody, type ApiMixSuiFrensBody, type ApiNftAmmBuyBody, type ApiNftAmmDepositBody, type ApiNftAmmSellBody, type ApiNftAmmWithdrawBody, type ApiOwnedStakedSuiFrensBody, type ApiOwnedSuiFrenAccessoriesBody, type ApiOwnedSuiFrensBody, type ApiPerpetualsAccountCollateralHistoryBody, type ApiPerpetualsAccountCollateralHistoryResponse, type ApiPerpetualsAccountMarginHistoryBody, type ApiPerpetualsAccountMarginHistoryResponse, type ApiPerpetualsAccountOrderHistoryBody, type ApiPerpetualsAccountOrderHistoryResponse, type ApiPerpetualsAccountPositionsBody, type ApiPerpetualsAccountPositionsResponse, type ApiPerpetualsAdminAccountCapsBody, type ApiPerpetualsAdminAccountCapsResponse, type ApiPerpetualsAllMarketsBody, type ApiPerpetualsAllMarketsResponse, type ApiPerpetualsAllocateCollateralBody, type ApiPerpetualsBuilderCodesClaimIntegratorVaultFeesTxBody, type ApiPerpetualsBuilderCodesClaimIntegratorVaultFeesTxResponse, type ApiPerpetualsBuilderCodesCreateIntegratorConfigTxBody, type ApiPerpetualsBuilderCodesCreateIntegratorVaultTxBody, type ApiPerpetualsBuilderCodesIntegratorConfigBody, type ApiPerpetualsBuilderCodesIntegratorConfigResponse, type ApiPerpetualsBuilderCodesIntegratorVaultsBody, type ApiPerpetualsBuilderCodesIntegratorVaultsResponse, type ApiPerpetualsBuilderCodesRemoveIntegratorConfigTxBody, type ApiPerpetualsCancelAndPlaceOrdersBody, type ApiPerpetualsCancelOrdersBody, type ApiPerpetualsCancelStopOrdersBody, type ApiPerpetualsCreateAccountBody, type ApiPerpetualsCreateAccountResponse, type ApiPerpetualsCreateCsvRebatesBody, type ApiPerpetualsCreateCsvRebatesResponse, type ApiPerpetualsCreateReferralCsvRebatesBody, type ApiPerpetualsCreateReferralCsvRebatesResponse, type ApiPerpetualsCreateVaultBody, type ApiPerpetualsCreateVaultCapBody, type ApiPerpetualsCurrentRebateRewardsBody, type ApiPerpetualsCurrentRebateRewardsResponse, type ApiPerpetualsDeallocateCollateralBody, type ApiPerpetualsDepositCollateralBody, type ApiPerpetualsEditStopOrdersBody, type ApiPerpetualsExecutionPriceBody, type ApiPerpetualsExecutionPriceResponse, type ApiPerpetualsGrantAgentWalletTxBody, type ApiPerpetualsHistoricalDataWithCursorBody, type ApiPerpetualsHistoricalDataWithCursorResponse, type ApiPerpetualsLimitOrderBody, type ApiPerpetualsMarketCandleHistoryBody, type ApiPerpetualsMarketCandleHistoryResponse, type ApiPerpetualsMarketFundingHistoryBody, type ApiPerpetualsMarketFundingHistoryResponse, type ApiPerpetualsMarketOrderBody, type ApiPerpetualsMarketOrderHistoryBody, type ApiPerpetualsMarketOrderHistoryResponse, type ApiPerpetualsMarkets24hrStatsResponse, type ApiPerpetualsMarketsBody, type ApiPerpetualsMarketsPricesBody, type ApiPerpetualsMarketsPricesResponse, type ApiPerpetualsMarketsResponse, type ApiPerpetualsMaxOrderSizeBody, type ApiPerpetualsOrderToPlace, type ApiPerpetualsOrderbooksBody, type ApiPerpetualsOrderbooksResponse, type ApiPerpetualsOwnedAccountCapsBody, type ApiPerpetualsOwnedAccountCapsResponse, type ApiPerpetualsOwnedVaultAssistantCapsBody, type ApiPerpetualsOwnedVaultAssistantCapsResponse, type ApiPerpetualsOwnedVaultCapsBody, type ApiPerpetualsOwnedVaultCapsResponse, type ApiPerpetualsPlaceSlTpOrdersBody, type ApiPerpetualsPlaceStopOrdersBody, type ApiPerpetualsPreviewCancelOrdersBody, type ApiPerpetualsPreviewCancelOrdersResponse, type ApiPerpetualsPreviewEditCollateralBody, type ApiPerpetualsPreviewEditCollateralResponse, type ApiPerpetualsPreviewPlaceLimitOrderBody, type ApiPerpetualsPreviewPlaceMarketOrderBody, type ApiPerpetualsPreviewPlaceOrderResponse, type ApiPerpetualsPreviewPlaceScaleOrderBody, type ApiPerpetualsPreviewSetLeverageBody, type ApiPerpetualsPreviewSetLeverageResponse, type ApiPerpetualsRevokeAgentWalletTxBody, type ApiPerpetualsScaleOrderBody, type ApiPerpetualsSetLeverageTxBody, type ApiPerpetualsShareAccountBody, type ApiPerpetualsStopOrderDatasBody, type ApiPerpetualsStopOrderDatasResponse, type ApiPerpetualsTransferCapTxBody, type ApiPerpetualsTransferCollateralBody, type ApiPerpetualsVaultCancelWithdrawRequestTxBody, type ApiPerpetualsVaultCreateWithdrawRequestTxBody, type ApiPerpetualsVaultDepositTxBody, type ApiPerpetualsVaultLpCoinPricesBody, type ApiPerpetualsVaultLpCoinPricesResponse, type ApiPerpetualsVaultOwnedLpCoinsBody, type ApiPerpetualsVaultOwnedLpCoinsResponse, type ApiPerpetualsVaultOwnedWithdrawRequestsBody, type ApiPerpetualsVaultOwnedWithdrawRequestsResponse, type ApiPerpetualsVaultOwnerProcessWithdrawRequestsTxBody, type ApiPerpetualsVaultOwnerUpdateForceWithdrawDelayTxBody, type ApiPerpetualsVaultOwnerUpdateLockPeriodTxBody, type ApiPerpetualsVaultOwnerUpdatePerformanceFeeTxBody, type ApiPerpetualsVaultOwnerWithdrawCollateralTxBody, type ApiPerpetualsVaultOwnerWithdrawCollateralTxResponse, type ApiPerpetualsVaultOwnerWithdrawLockedLiquidityTxBody, type ApiPerpetualsVaultOwnerWithdrawLockedLiquidityTxResponse, type ApiPerpetualsVaultOwnerWithdrawPerformanceFeesTxBody, type ApiPerpetualsVaultOwnerWithdrawPerformanceFeesTxResponse, type ApiPerpetualsVaultPauseVaultForForceWithdrawRequestTxBody, type ApiPerpetualsVaultPreviewCreateWithdrawRequestBody, type ApiPerpetualsVaultPreviewCreateWithdrawRequestResponse, type ApiPerpetualsVaultPreviewDepositBody, type ApiPerpetualsVaultPreviewDepositResponse, type ApiPerpetualsVaultPreviewOwnerProcessWithdrawRequestsBody, type ApiPerpetualsVaultPreviewOwnerProcessWithdrawRequestsResponse, type ApiPerpetualsVaultPreviewOwnerWithdrawCollateralBody, type ApiPerpetualsVaultPreviewOwnerWithdrawCollateralResponse, type ApiPerpetualsVaultPreviewOwnerWithdrawLockedLiquidityBody, type ApiPerpetualsVaultPreviewOwnerWithdrawLockedLiquidityResponse, type ApiPerpetualsVaultPreviewOwnerWithdrawPerformanceFeesBody, type ApiPerpetualsVaultPreviewOwnerWithdrawPerformanceFeesResponse, type ApiPerpetualsVaultPreviewPauseVaultForForceWithdrawRequestBody, type ApiPerpetualsVaultPreviewPauseVaultForForceWithdrawRequestResponse, type ApiPerpetualsVaultPreviewProcessForceWithdrawRequestBody, type ApiPerpetualsVaultPreviewProcessForceWithdrawRequestResponse, type ApiPerpetualsVaultProcessForceWithdrawRequestTxBody, type ApiPerpetualsVaultProcessForceWithdrawRequestTxResponse, type ApiPerpetualsVaultUpdateWithdrawRequestSlippageTxBody, type ApiPerpetualsVaultsBody, type ApiPerpetualsVaultsResponse, type ApiPerpetualsVaultsWithdrawRequestsBody, type ApiPerpetualsVaultsWithdrawRequestsResponse, type ApiPerpetualsWithdrawCollateralBody, type ApiPerpetualsWithdrawCollateralResponse, type ApiPoolAllCoinWithdrawBody, type ApiPoolDepositBody, type ApiPoolObjectIdForLpCoinTypeBody, type ApiPoolSpotPriceBody, type ApiPoolTradeBody, type ApiPoolWithdrawBody, type ApiPoolsOwnedDaoFeePoolOwnerCapsBody, type ApiPoolsStatsBody, type ApiPublishLpCoinBody, type ApiReferralsCreateReferralLinkBody, type ApiReferralsCreateReferralLinkResponse, type ApiReferralsGetLinkedRefCodeBody, type ApiReferralsGetLinkedRefCodeResponse, type ApiReferralsGetRefCodeBody, type ApiReferralsGetRefCodeResponse, type ApiReferralsGetRefereesBody, type ApiReferralsGetRefereesResponse, type ApiReferralsIsRefCodeTakenBody, type ApiReferralsIsRefCodeTakenResponse, type ApiReferralsSetReferrerBody, type ApiReferralsSetReferrerResponse, type ApiRemoveSuiFrenAccessoryBody, type ApiRewardsClaimRequestTxBody, type ApiRewardsClaimRequestTxResponse, type ApiRewardsGetClaimableBody, type ApiRewardsGetClaimableResponse, type ApiRewardsGetHistoryBody, type ApiRewardsGetHistoryResponse, type ApiRewardsGetPointsBody, type ApiRewardsGetPointsResponse, type ApiRouterAddTransactionForCompleteTradeRouteBody, type ApiRouterAddTransactionForCompleteTradeRouteResponse, type ApiRouterCompleteTradeRouteBody, type ApiRouterDynamicGasBody, type ApiRouterPartialCompleteTradeRouteBody, type ApiRouterTradeEventsBody, type ApiRouterTransactionForCompleteTradeRouteBody, type ApiStakeBody, type ApiStakeStakedSuiBody, type ApiStakeSuiFrenBody, type ApiStakingEventsBody, type ApiStakingPositionsBody, type ApiTransactionResponse, type ApiTransactionsBody, type ApiUnstakeBody, type ApiUnstakeSuiFrenBody, type ApiUpdateValidatorFeeBody, type ApiValidatorOperationCapsBody, type Apr, type Apy, Auth, type Balance, type BigIntAsString, type Byte, type CallerConfig, type CanceledOrderEvent, type CapyLabsAppObject, Casting, Coin, type CoinDecimal, type CoinGeckoChain, type CoinGeckoCoinApiId, type CoinGeckoCoinData, type CoinGeckoCoinSymbolData, type CoinGeckoHistoricalTradeData, type CoinGeckoTickerData, type CoinMetadaWithInfo, type CoinPriceInfo, type CoinSymbol, type CoinSymbolToCoinTypes, type CoinSymbolsToPriceInfo, type CoinType, type CoinWithAmount, type CoinWithAmountOrUndefined, type CoinsToBalance, type CoinsToBalanceOrUndefined, type CoinsToDecimals, type CoinsToPrice, type CoinsToPriceInfo, type CollateralEvent, type Color, type ComposedTransferArgs, type ConfigAddresses, type CreatedAccountEvent, type CreatedDaoFeePoolEvent, type CreatedStopOrderTicketEvent, type DaoFeePoolObject, type DaoFeePoolOwnerCapObject, type DaoFeePoolsAddresses, type DcaAddresses, type DeallocatedCollateralEvent, type DecimalsScalar, type DeferredAccountArgs, type DeletedStopOrderTicketEvent, type DepositedCollateralEvent, type DynamicFieldObjectsWithCursor, type DynamicFieldsInputs, type DynamicFieldsWithCursor, type DynamicGasAddresses, type EditedStopOrderTicketDetailsEvent, type EditedStopOrderTicketExecutorEvent, type EpochWasChangedEvent, type Event$1 as Event, type EventsInputs, type EventsWithCursor, type ExecutedStopOrderTicketEvent, type ExternalFee, type FarmEvent, type FarmOwnerOrOneTimeAdminCap, type FarmUserEvent, Farms, type FarmsAddedRewardEvent, type FarmsAddresses, type FarmsCreatedVaultEvent, type FarmsDepositedPrincipalEvent, type FarmsDestroyedStakedPositionEvent, type FarmsHarvestedRewardsEvent, type FarmsIncreasedEmissionsEvent, type FarmsInitializedRewardEvent, type FarmsJoinedEvent, type FarmsLockEnforcement, type FarmsLockedEvent, type FarmsMultiplier, type FarmsSplitEvent, type FarmsStakedEvent, FarmsStakedPosition, type FarmsStakedPositionObject, type FarmsStakedPositionRewardCoin, type FarmsStakedRelaxedEvent, FarmsStakingPool, type FarmsStakingPoolObject, type FarmsStakingPoolRewardCoin, type FarmsUnlockedEvent, type FarmsVersion, type FarmsWithdrewPrincipalEvent, Faucet, type FaucetAddCoinEvent, type FaucetAddresses, type FaucetMintCoinEvent, type FilePath, type FilledMakerOrderEventFields, type FilledMakerOrdersEvent, type FilledTakerOrderEvent, type FunctionName, type GasBudget, GasPools, type HarvestSuiFrenFeesEvent, Helpers, type IFixed, type IFixedAsBytes, type IFixedAsString, type IFixedAsStringBytes, type IdAsStringBytes, type IndexerDataWithCursorQueryParams, type IndexerEventsWithCursor, type KeyType, type KioskObject, type KioskOwnerCapObject, type LimitAddresses, type LiquidatedEvent, type LocalUrl, type MixSuiFrensEvent, type ModuleName, type MoveErrorCode, type Nft, NftAmm, type NftAmmAddresses, type NftAmmInterfaceGenericTypes, type NftAmmMarketObject, type NftDisplay, type NftDisplayOther, type NftDisplaySuggested, type NftInfo, type NftsAddresses, type NormalizedBalance, type NumberAsString, type Object$1 as Object, type ObjectDigest, type ObjectId, type ObjectVersion, type OrderbookFillReceiptEvent, type PackageId, type PartialFarmsStakedPositionObject, type PartialSuiFrenObject, type Percentage, Perpetuals, PerpetualsAccount, type PerpetualsAccountCap, type PerpetualsAccountCollateralChange, type PerpetualsAccountData, type PerpetualsAccountId, type PerpetualsAccountMarginHistoryData, type PerpetualsAccountMarginHistoryTimeframeKey, type PerpetualsAccountObject, type PerpetualsAccountOrderHistoryData, type PerpetualsAddresses, type PerpetualsBuilderCodeParamaters, type PerpetualsCalculationVariables, type PerpetualsCapType, type PerpetualsExecutionInfo, type PerpetualsFilledOrderData, type PerpetualsIntegratorVaultData, type PerpetualsMakerData, PerpetualsMarket, type PerpetualsMarket24hrStats, type PerpetualsMarketCandleDataPoint, type PerpetualsMarketData, type PerpetualsMarketFundingHistoryPoint, type PerpetualsMarketId, type PerpetualsMarketOrderHistoryData, type PerpetualsMarketParams, type PerpetualsMarketState, type PerpetualsOrderData, type PerpetualsOrderEvent, type PerpetualsOrderId, type PerpetualsOrderIdAsString, type PerpetualsOrderInfo, type PerpetualsOrderPrice, PerpetualsOrderSide, type PerpetualsOrderState, PerpetualsOrderType, type PerpetualsOrderbook, type PerpetualsOrderbookDeltas, type PerpetualsOrderbookItem, type PerpetualsPartialVaultCap, type PerpetualsPosition, type PerpetualsRewardData, type PerpetualsSponsorConfig, type PerpetualsStopOrderData, PerpetualsStopOrderType, type PerpetualsTakerData, type PerpetualsTopOfOrderbook, type PerpetualsTopOfOrderbookDataPoint, type PerpetualsTwapEvent, PerpetualsVault, type PerpetualsVaultCap, type PerpetualsVaultLpCoin, type PerpetualsVaultMetatada, type PerpetualsVaultObject, type PerpetualsVaultWithdrawRequest, type PerpetualsVaultsAddresses, type PerpetualsWsCandleResponseMessage, type PerpetualsWsUpdatesMarketOrdersPayload, type PerpetualsWsUpdatesMarketOrdersSubscriptionType, type PerpetualsWsUpdatesMarketSubscriptionType, type PerpetualsWsUpdatesOraclePayload, type PerpetualsWsUpdatesOracleSubscriptionType, type PerpetualsWsUpdatesOrderbookPayload, type PerpetualsWsUpdatesOrderbookSubscriptionType, type PerpetualsWsUpdatesResponseMessage, type PerpetualsWsUpdatesSubscriptionAction, type PerpetualsWsUpdatesSubscriptionMessage, type PerpetualsWsUpdatesSubscriptionType, type PerpetualsWsUpdatesTopOfOrderbookPayload, type PerpetualsWsUpdatesTopOfOrderbookSubscriptionType, type PerpetualsWsUpdatesUserCollateralChangesPayload, type PerpetualsWsUpdatesUserCollateralChangesSubscriptionType, type PerpetualsWsUpdatesUserOrdersPayload, type PerpetualsWsUpdatesUserOrdersSubscriptionType, type PerpetualsWsUpdatesUserPayload, type PerpetualsWsUpdatesUserSubscriptionType, Pool, type PoolCoin, type PoolCoins, type PoolCreationCoinInfo, type PoolCreationLpCoinMetadata, type PoolDataPoint, type PoolDepositEvent, type PoolDepositFee, type PoolFlatness, type PoolGraphDataTimeUnit, type PoolGraphDataTimeframe, type PoolGraphDataTimeframeKey, type PoolLpInfo, type PoolName, type PoolObject, type PoolStats, type PoolTradeEvent, type PoolTradeFee, type PoolWeight, type PoolWithdrawEvent, type PoolWithdrawFee, Pools, type PoolsAddresses, type PostedOrderEvent, type RateLimit, type ReceivedCollateralEvent, type ReducedOrderEvent, ReferralVault, type ReferralVaultAddresses, type ReferralsRefereeInfo, type RewardsClaimableReward, type RewardsHistoryEntry, type RewardsHistoryEventType, type RewardsPaginationInfo, Router, type RouterAddresses, type RouterCompleteTradeRoute, type RouterCompleteTradeRouteWithFee, type RouterExternalFee, type RouterProtocolName, type RouterTradeCoin, type RouterTradeEvent, type RouterTradeInfo, type RouterTradePath, type RouterTradeRoute, type RpcEndpoint, type ScallopAddresses, type SdkPerpetualsCancelAndPlaceOrdersInputs, type SdkPerpetualsCancelOrdersPreviewInputs, type SdkPerpetualsPlaceLimitOrderInputs, type SdkPerpetualsPlaceLimitOrderPreviewInputs, type SdkPerpetualsPlaceMarketOrderInputs, type SdkPerpetualsPlaceMarketOrderPreviewInputs, type SdkPerpetualsPlaceScaleOrderInputs, type SdkPerpetualsPlaceScaleOrderPreviewInputs, type SdkPerpetualsPlaceSlTpOrdersInputs, type SdkPerpetualsPlaceStopOrdersInputs, type SdkTransactionResponse, type SerializedTransaction, type ServiceCoinData, type ServiceCoinDataV2, type SetPositionInitialMarginRatioEvent, type SettledFundingEvent, type SharedCustodyAddresses, type SignMessageCallback, type Slippage, type StakeBalanceDynamicField, type StakeEvent, type StakePosition, type StakeSuiFrenEvent, type StakedEvent, StakedSuiFren, type StakedSuiFrenInfo, type StakedSuiFrenMetadataV1Object, type StakedSuiFrenPositionObject, type StakedSuiVaultStateObject, Staking, type StakingAddresses, type StakingApyDataPoint, type StakingApyTimeframeKey, type StakingPoolOneTimeAdminCapObject, type StakingPoolOwnerCapObject, type StakingPosition, type StringByte, Sui, type SuiAddress, type SuiCheckpoint, type SuiDelegatedStake, type SuiDelegatedStakeState, SuiFren, type SuiFrenAccessoryName, type SuiFrenAccessoryObject, type SuiFrenAccessoryType, type SuiFrenAttributes, type SuiFrenObject, type SuiFrenStats, type SuiFrenVaultStateV1Object, SuiFrens, type SuiFrensAddresses, SuiFrensSortOption, type SuiNetwork, type Timestamp, type TransactionDigest, type TransactionsWithCursor, type TransferredDeallocatedCollateralEvent, type TxBytes, type UniqueId, type UnstakeEvent, type UnstakePosition, type UnstakePositionState, type UnstakeRequestedEvent, type UnstakeSuiFrenEvent, type UnstakedEvent, type UpdatedFeeBpsEvent, type UpdatedFeeRecipientEvent, type UpdatedFundingEvent, type UpdatedMarketVersionEvent, type UpdatedPremiumTwapEvent, type UpdatedSpreadTwapEvent, type Url, type UserEventsInputs, type UserHistoryEventType, type ValidatorConfigObject, type ValidatorOperationCapObject, type WithdrewCollateralEvent, isAllocatedCollateralEvent, isCanceledOrderEvent, isDeallocatedCollateralEvent, isDepositedCollateralEvent, isFarmsDepositedPrincipalEvent, isFarmsHarvestedRewardsEvent, isFarmsLockedEvent, isFarmsStakedEvent, isFarmsUnlockedEvent, isFarmsWithdrewPrincipalEvent, isFilledMakerOrdersEvent, isFilledTakerOrderEvent, isLiquidatedEvent, isPostedOrderEvent, isReducedOrderEvent, isSettledFundingEvent, isStakeEvent, isStakePosition, isSuiDelegatedStake, isUnstakeEvent, isUnstakePosition, isUpdatedFundingEvent, isUpdatedMarketVersion, isUpdatedPremiumTwapEvent, isUpdatedSpreadTwapEvent, isWithdrewCollateralEvent };
+export { type AfSuiRouterPoolObject, Aftermath, AftermathApi, type AftermathOptions, type AllocatedCollateralEvent, type AmountInCoinAndUsd, type AnyObjectType, type ApiAccessoriesForSuiFrenBody, type ApiAddSuiFrenAccessoryBody, type ApiCreateAuthAccountBody, type ApiCreatePoolBody, type ApiDataWithCursorBody, type ApiDelegatedStakesBody, type ApiDynamicFieldsBody, type ApiDynamicGasBody, type ApiDynamicGasResponse, type ApiEventsBody, type ApiFarmsCreateStakingPoolBody, type ApiFarmsCreateStakingPoolBodyV1, type ApiFarmsDepositPrincipalBody, type ApiFarmsGrantOneTimeAdminCapBody, type ApiFarmsIncreaseStakingPoolRewardsEmissionsBody, type ApiFarmsInitializeStakingPoolRewardBody, type ApiFarmsLockBody, type ApiFarmsOwnedStakedPositionsBody, type ApiFarmsOwnedStakingPoolOneTimeAdminCapsBody, type ApiFarmsOwnedStakingPoolOwnerCapsBody, type ApiFarmsRenewLockBody, type ApiFarmsStakeBody, type ApiFarmsStakeBodyV1, type ApiFarmsTopUpStakingPoolRewardsBody, type ApiFarmsUnlockBody, type ApiFarmsUnstakeBody, type ApiFaucetMintSuiFrenBody, type ApiFaucetRequestBody, type ApiGasPoolBody, type ApiGasPoolCreateBody, type ApiGasPoolCreateResponse, type ApiGasPoolDepositBody, type ApiGasPoolGrantBody, type ApiGasPoolResponse, type ApiGasPoolRevokeBody, type ApiGasPoolShareBody, type ApiGasPoolSponsorBody, type ApiGasPoolWithdrawBody, type ApiGasPoolWithdrawResponse, type ApiGetAccessTokenBody, type ApiGetAccessTokenResponse, type ApiHarvestFarmsRewardsBody, type ApiHarvestSuiFrenFeesBody, type ApiIndexerEventsBody, type ApiIndexerUserEventsBody, type ApiMixSuiFrensBody, type ApiNftAmmBuyBody, type ApiNftAmmDepositBody, type ApiNftAmmSellBody, type ApiNftAmmWithdrawBody, type ApiOwnedStakedSuiFrensBody, type ApiOwnedSuiFrenAccessoriesBody, type ApiOwnedSuiFrensBody, type ApiPerpetualsAccountCollateralHistoryBody, type ApiPerpetualsAccountCollateralHistoryResponse, type ApiPerpetualsAccountMarginHistoryBody, type ApiPerpetualsAccountMarginHistoryResponse, type ApiPerpetualsAccountOrderHistoryBody, type ApiPerpetualsAccountOrderHistoryResponse, type ApiPerpetualsAccountPositionsBody, type ApiPerpetualsAccountPositionsResponse, type ApiPerpetualsAdminAccountCapsBody, type ApiPerpetualsAdminAccountCapsResponse, type ApiPerpetualsAllMarketsBody, type ApiPerpetualsAllMarketsResponse, type ApiPerpetualsAllocateCollateralBody, type ApiPerpetualsBuilderCodesClaimIntegratorVaultFeesTxBody, type ApiPerpetualsBuilderCodesClaimIntegratorVaultFeesTxResponse, type ApiPerpetualsBuilderCodesCreateIntegratorConfigTxBody, type ApiPerpetualsBuilderCodesCreateIntegratorVaultTxBody, type ApiPerpetualsBuilderCodesIntegratorConfigBody, type ApiPerpetualsBuilderCodesIntegratorConfigResponse, type ApiPerpetualsBuilderCodesIntegratorVaultsBody, type ApiPerpetualsBuilderCodesIntegratorVaultsResponse, type ApiPerpetualsBuilderCodesRemoveIntegratorConfigTxBody, type ApiPerpetualsCancelAndPlaceOrdersBody, type ApiPerpetualsCancelOrdersBody, type ApiPerpetualsCancelStopOrdersBody, type ApiPerpetualsCreateAccountBody, type ApiPerpetualsCreateAccountResponse, type ApiPerpetualsCreateCsvRebatesBody, type ApiPerpetualsCreateCsvRebatesResponse, type ApiPerpetualsCreateReferralCsvRebatesBody, type ApiPerpetualsCreateReferralCsvRebatesResponse, type ApiPerpetualsCreateVaultBody, type ApiPerpetualsCreateVaultCapBody, type ApiPerpetualsCurrentRebateRewardsBody, type ApiPerpetualsCurrentRebateRewardsResponse, type ApiPerpetualsDeallocateCollateralBody, type ApiPerpetualsDepositCollateralBody, type ApiPerpetualsEditStopOrdersBody, type ApiPerpetualsExecutionPriceBody, type ApiPerpetualsExecutionPriceResponse, type ApiPerpetualsGrantAgentWalletTxBody, type ApiPerpetualsHistoricalDataWithCursorBody, type ApiPerpetualsHistoricalDataWithCursorResponse, type ApiPerpetualsLimitOrderBody, type ApiPerpetualsMarketCandleHistoryBody, type ApiPerpetualsMarketCandleHistoryResponse, type ApiPerpetualsMarketFundingHistoryBody, type ApiPerpetualsMarketFundingHistoryResponse, type ApiPerpetualsMarketOrderBody, type ApiPerpetualsMarketOrderHistoryBody, type ApiPerpetualsMarketOrderHistoryResponse, type ApiPerpetualsMarkets24hrStatsResponse, type ApiPerpetualsMarketsBody, type ApiPerpetualsMarketsPricesBody, type ApiPerpetualsMarketsPricesResponse, type ApiPerpetualsMarketsResponse, type ApiPerpetualsMaxOrderSizeBody, type ApiPerpetualsOrderToPlace, type ApiPerpetualsOrderbooksBody, type ApiPerpetualsOrderbooksResponse, type ApiPerpetualsOwnedAccountCapsBody, type ApiPerpetualsOwnedAccountCapsResponse, type ApiPerpetualsOwnedVaultAssistantCapsBody, type ApiPerpetualsOwnedVaultAssistantCapsResponse, type ApiPerpetualsOwnedVaultCapsBody, type ApiPerpetualsOwnedVaultCapsResponse, type ApiPerpetualsPlaceSlTpOrdersBody, type ApiPerpetualsPlaceStopOrdersBody, type ApiPerpetualsPreviewCancelOrdersBody, type ApiPerpetualsPreviewCancelOrdersResponse, type ApiPerpetualsPreviewEditCollateralBody, type ApiPerpetualsPreviewEditCollateralResponse, type ApiPerpetualsPreviewPlaceLimitOrderBody, type ApiPerpetualsPreviewPlaceMarketOrderBody, type ApiPerpetualsPreviewPlaceOrderResponse, type ApiPerpetualsPreviewPlaceScaleOrderBody, type ApiPerpetualsPreviewSetLeverageBody, type ApiPerpetualsPreviewSetLeverageResponse, type ApiPerpetualsRevokeAgentWalletTxBody, type ApiPerpetualsScaleOrderBody, type ApiPerpetualsSetLeverageTxBody, type ApiPerpetualsShareAccountBody, type ApiPerpetualsStopOrderDatasBody, type ApiPerpetualsStopOrderDatasResponse, type ApiPerpetualsTransferCapTxBody, type ApiPerpetualsTransferCollateralBody, type ApiPerpetualsVaultCancelWithdrawRequestTxBody, type ApiPerpetualsVaultCreateWithdrawRequestTxBody, type ApiPerpetualsVaultDepositTxBody, type ApiPerpetualsVaultLpCoinPricesBody, type ApiPerpetualsVaultLpCoinPricesResponse, type ApiPerpetualsVaultOwnedLpCoinsBody, type ApiPerpetualsVaultOwnedLpCoinsResponse, type ApiPerpetualsVaultOwnedWithdrawRequestsBody, type ApiPerpetualsVaultOwnedWithdrawRequestsResponse, type ApiPerpetualsVaultOwnerProcessWithdrawRequestsTxBody, type ApiPerpetualsVaultOwnerUpdateForceWithdrawDelayTxBody, type ApiPerpetualsVaultOwnerUpdateLockPeriodTxBody, type ApiPerpetualsVaultOwnerUpdatePerformanceFeeTxBody, type ApiPerpetualsVaultOwnerWithdrawCollateralTxBody, type ApiPerpetualsVaultOwnerWithdrawCollateralTxResponse, type ApiPerpetualsVaultOwnerWithdrawLockedLiquidityTxBody, type ApiPerpetualsVaultOwnerWithdrawLockedLiquidityTxResponse, type ApiPerpetualsVaultOwnerWithdrawPerformanceFeesTxBody, type ApiPerpetualsVaultOwnerWithdrawPerformanceFeesTxResponse, type ApiPerpetualsVaultPauseVaultForForceWithdrawRequestTxBody, type ApiPerpetualsVaultPreviewCreateWithdrawRequestBody, type ApiPerpetualsVaultPreviewCreateWithdrawRequestResponse, type ApiPerpetualsVaultPreviewDepositBody, type ApiPerpetualsVaultPreviewDepositResponse, type ApiPerpetualsVaultPreviewOwnerProcessWithdrawRequestsBody, type ApiPerpetualsVaultPreviewOwnerProcessWithdrawRequestsResponse, type ApiPerpetualsVaultPreviewOwnerWithdrawCollateralBody, type ApiPerpetualsVaultPreviewOwnerWithdrawCollateralResponse, type ApiPerpetualsVaultPreviewOwnerWithdrawLockedLiquidityBody, type ApiPerpetualsVaultPreviewOwnerWithdrawLockedLiquidityResponse, type ApiPerpetualsVaultPreviewOwnerWithdrawPerformanceFeesBody, type ApiPerpetualsVaultPreviewOwnerWithdrawPerformanceFeesResponse, type ApiPerpetualsVaultPreviewPauseVaultForForceWithdrawRequestBody, type ApiPerpetualsVaultPreviewPauseVaultForForceWithdrawRequestResponse, type ApiPerpetualsVaultPreviewProcessForceWithdrawRequestBody, type ApiPerpetualsVaultPreviewProcessForceWithdrawRequestResponse, type ApiPerpetualsVaultProcessForceWithdrawRequestTxBody, type ApiPerpetualsVaultProcessForceWithdrawRequestTxResponse, type ApiPerpetualsVaultUpdateWithdrawRequestSlippageTxBody, type ApiPerpetualsVaultsBody, type ApiPerpetualsVaultsResponse, type ApiPerpetualsVaultsWithdrawRequestsBody, type ApiPerpetualsVaultsWithdrawRequestsResponse, type ApiPerpetualsWithdrawCollateralBody, type ApiPerpetualsWithdrawCollateralResponse, type ApiPoolAllCoinWithdrawBody, type ApiPoolDepositBody, type ApiPoolObjectIdForLpCoinTypeBody, type ApiPoolSpotPriceBody, type ApiPoolTradeBody, type ApiPoolWithdrawBody, type ApiPoolsOwnedDaoFeePoolOwnerCapsBody, type ApiPoolsStatsBody, type ApiPublishLpCoinBody, type ApiReferralsCreateReferralLinkBody, type ApiReferralsCreateReferralLinkResponse, type ApiReferralsGetLinkedRefCodeBody, type ApiReferralsGetLinkedRefCodeResponse, type ApiReferralsGetRefCodeBody, type ApiReferralsGetRefCodeResponse, type ApiReferralsGetRefereesBody, type ApiReferralsGetRefereesResponse, type ApiReferralsIsRefCodeTakenBody, type ApiReferralsIsRefCodeTakenResponse, type ApiReferralsSetReferrerBody, type ApiReferralsSetReferrerResponse, type ApiRemoveSuiFrenAccessoryBody, type ApiRewardsClaimRequestTxBody, type ApiRewardsClaimRequestTxResponse, type ApiRewardsGetClaimableBody, type ApiRewardsGetClaimableResponse, type ApiRewardsGetHistoryBody, type ApiRewardsGetHistoryResponse, type ApiRewardsGetPointsBody, type ApiRewardsGetPointsResponse, type ApiRouterAddTransactionForCompleteTradeRouteBody, type ApiRouterAddTransactionForCompleteTradeRouteResponse, type ApiRouterCompleteTradeRouteBody, type ApiRouterDynamicGasBody, type ApiRouterPartialCompleteTradeRouteBody, type ApiRouterTradeEventsBody, type ApiRouterTransactionForCompleteTradeRouteBody, type ApiStakeBody, type ApiStakeStakedSuiBody, type ApiStakeSuiFrenBody, type ApiStakingEventsBody, type ApiStakingPositionsBody, type ApiTransactionResponse, type ApiTransactionsBody, type ApiUnstakeBody, type ApiUnstakeSuiFrenBody, type ApiUpdateValidatorFeeBody, type ApiValidatorOperationCapsBody, type Apr, type Apy, Auth, type Balance, type BigIntAsString, type Byte, type CallerConfig, type CanceledOrderEvent, type CapyLabsAppObject, Casting, Coin, type CoinDecimal, type CoinGeckoChain, type CoinGeckoCoinApiId, type CoinGeckoCoinData, type CoinGeckoCoinSymbolData, type CoinGeckoHistoricalTradeData, type CoinGeckoTickerData, type CoinMetadaWithInfo, type CoinPriceInfo, type CoinSymbol, type CoinSymbolToCoinTypes, type CoinSymbolsToPriceInfo, type CoinType, type CoinWithAmount, type CoinWithAmountOrUndefined, type CoinsToBalance, type CoinsToBalanceOrUndefined, type CoinsToDecimals, type CoinsToPrice, type CoinsToPriceInfo, type CollateralEvent, type Color, type ComposedTransferArgs, type ConfigAddresses, type CreatedAccountEvent, type CreatedDaoFeePoolEvent, type CreatedStopOrderTicketEvent, type DaoFeePoolObject, type DaoFeePoolOwnerCapObject, type DaoFeePoolsAddresses, type DcaAddresses, type DeallocatedCollateralEvent, type DecimalsScalar, type DeferredAccountArgs, type DeletedStopOrderTicketEvent, type DepositedCollateralEvent, type DynamicFieldObjectsWithCursor, type DynamicFieldsInputs, type DynamicFieldsWithCursor, type DynamicGasAddresses, type EditedStopOrderTicketDetailsEvent, type EditedStopOrderTicketExecutorEvent, type EpochWasChangedEvent, type Event$1 as Event, type EventsInputs, type EventsWithCursor, type ExecutedStopOrderTicketEvent, type ExternalFee, type FarmEvent, type FarmOwnerOrOneTimeAdminCap, type FarmUserEvent, Farms, type FarmsAddedRewardEvent, type FarmsAddresses, type FarmsCreatedVaultEvent, type FarmsDepositedPrincipalEvent, type FarmsDestroyedStakedPositionEvent, type FarmsHarvestedRewardsEvent, type FarmsIncreasedEmissionsEvent, type FarmsInitializedRewardEvent, type FarmsJoinedEvent, type FarmsLockEnforcement, type FarmsLockedEvent, type FarmsMultiplier, type FarmsSplitEvent, type FarmsStakedEvent, FarmsStakedPosition, type FarmsStakedPositionObject, type FarmsStakedPositionRewardCoin, type FarmsStakedRelaxedEvent, FarmsStakingPool, type FarmsStakingPoolObject, type FarmsStakingPoolRewardCoin, type FarmsUnlockedEvent, type FarmsVersion, type FarmsWithdrewPrincipalEvent, Faucet, type FaucetAddCoinEvent, type FaucetAddresses, type FaucetMintCoinEvent, type FilePath, type FilledMakerOrderEventFields, type FilledMakerOrdersEvent, type FilledTakerOrderEvent, type FunctionName, type GasBudget, GasPools, type HarvestSuiFrenFeesEvent, Helpers, type IFixed, type IFixedAsBytes, type IFixedAsString, type IFixedAsStringBytes, type IdAsStringBytes, type IndexerDataWithCursorQueryParams, type IndexerEventsWithCursor, type KeyType, type KioskObject, type KioskOwnerCapObject, type LimitAddresses, type LiquidatedEvent, type LocalUrl, type MixSuiFrensEvent, type ModuleName, type MoveErrorCode, type MoveErrors, type MoveErrorsInterface, type Nft, NftAmm, type NftAmmAddresses, type NftAmmInterfaceGenericTypes, type NftAmmMarketObject, type NftDisplay, type NftDisplayOther, type NftDisplaySuggested, type NftInfo, type NftsAddresses, type NormalizedBalance, type NumberAsString, type Object$1 as Object, type ObjectDigest, type ObjectId, type ObjectVersion, type OrderbookFillReceiptEvent, type PackageId, type ParsedMoveError, type PartialFarmsStakedPositionObject, type PartialSuiFrenObject, type Percentage, Perpetuals, PerpetualsAccount, type PerpetualsAccountCap, type PerpetualsAccountCollateralChange, type PerpetualsAccountData, type PerpetualsAccountId, type PerpetualsAccountMarginHistoryData, type PerpetualsAccountMarginHistoryTimeframeKey, type PerpetualsAccountObject, type PerpetualsAccountOrderHistoryData, type PerpetualsAddresses, type PerpetualsBuilderCodeParamaters, type PerpetualsCalculationVariables, type PerpetualsCapType, type PerpetualsExecutionInfo, type PerpetualsFilledOrderData, type PerpetualsIntegratorVaultData, type PerpetualsMakerData, PerpetualsMarket, type PerpetualsMarket24hrStats, type PerpetualsMarketCandleDataPoint, type PerpetualsMarketData, type PerpetualsMarketFundingHistoryPoint, type PerpetualsMarketId, type PerpetualsMarketOrderHistoryData, type PerpetualsMarketParams, type PerpetualsMarketState, type PerpetualsOrderData, type PerpetualsOrderEvent, type PerpetualsOrderId, type PerpetualsOrderIdAsString, type PerpetualsOrderInfo, type PerpetualsOrderPrice, PerpetualsOrderSide, type PerpetualsOrderState, PerpetualsOrderType, type PerpetualsOrderbook, type PerpetualsOrderbookDeltas, type PerpetualsOrderbookItem, type PerpetualsPartialVaultCap, type PerpetualsPosition, type PerpetualsRewardData, type PerpetualsSponsorConfig, type PerpetualsStopOrderData, PerpetualsStopOrderType, type PerpetualsTakerData, type PerpetualsTopOfOrderbook, type PerpetualsTopOfOrderbookDataPoint, type PerpetualsTwapEvent, PerpetualsVault, type PerpetualsVaultCap, type PerpetualsVaultLpCoin, type PerpetualsVaultMetatada, type PerpetualsVaultObject, type PerpetualsVaultWithdrawRequest, type PerpetualsVaultsAddresses, type PerpetualsWsCandleResponseMessage, type PerpetualsWsUpdatesMarketOrdersPayload, type PerpetualsWsUpdatesMarketOrdersSubscriptionType, type PerpetualsWsUpdatesMarketSubscriptionType, type PerpetualsWsUpdatesOraclePayload, type PerpetualsWsUpdatesOracleSubscriptionType, type PerpetualsWsUpdatesOrderbookPayload, type PerpetualsWsUpdatesOrderbookSubscriptionType, type PerpetualsWsUpdatesResponseMessage, type PerpetualsWsUpdatesSubscriptionAction, type PerpetualsWsUpdatesSubscriptionMessage, type PerpetualsWsUpdatesSubscriptionType, type PerpetualsWsUpdatesTopOfOrderbookPayload, type PerpetualsWsUpdatesTopOfOrderbookSubscriptionType, type PerpetualsWsUpdatesUserCollateralChangesPayload, type PerpetualsWsUpdatesUserCollateralChangesSubscriptionType, type PerpetualsWsUpdatesUserOrdersPayload, type PerpetualsWsUpdatesUserOrdersSubscriptionType, type PerpetualsWsUpdatesUserPayload, type PerpetualsWsUpdatesUserSubscriptionType, Pool, type PoolCoin, type PoolCoins, type PoolCreationCoinInfo, type PoolCreationLpCoinMetadata, type PoolDataPoint, type PoolDepositEvent, type PoolDepositFee, type PoolFlatness, type PoolGraphDataTimeUnit, type PoolGraphDataTimeframe, type PoolGraphDataTimeframeKey, type PoolLpInfo, type PoolName, type PoolObject, type PoolStats, type PoolTradeEvent, type PoolTradeFee, type PoolWeight, type PoolWithdrawEvent, type PoolWithdrawFee, Pools, type PoolsAddresses, type PostedOrderEvent, type RateLimit, type ReceivedCollateralEvent, type ReducedOrderEvent, ReferralVault, type ReferralVaultAddresses, type ReferralsRefereeInfo, type RewardsClaimableReward, type RewardsHistoryEntry, type RewardsHistoryEventType, type RewardsPaginationInfo, Router, type RouterAddresses, type RouterCompleteTradeRoute, type RouterCompleteTradeRouteWithFee, type RouterExternalFee, type RouterProtocolName, type RouterTradeCoin, type RouterTradeEvent, type RouterTradeInfo, type RouterTradePath, type RouterTradeRoute, type RpcEndpoint, type ScallopAddresses, type SdkPerpetualsCancelAndPlaceOrdersInputs, type SdkPerpetualsCancelOrdersPreviewInputs, type SdkPerpetualsPlaceLimitOrderInputs, type SdkPerpetualsPlaceLimitOrderPreviewInputs, type SdkPerpetualsPlaceMarketOrderInputs, type SdkPerpetualsPlaceMarketOrderPreviewInputs, type SdkPerpetualsPlaceScaleOrderInputs, type SdkPerpetualsPlaceScaleOrderPreviewInputs, type SdkPerpetualsPlaceSlTpOrdersInputs, type SdkPerpetualsPlaceStopOrdersInputs, type SdkTransactionResponse, type SerializedTransaction, type ServiceCoinData, type ServiceCoinDataV2, type SetPositionInitialMarginRatioEvent, type SettledFundingEvent, type SharedCustodyAddresses, type SignMessageCallback, type Slippage, type StakeBalanceDynamicField, type StakeEvent, type StakePosition, type StakeSuiFrenEvent, type StakedEvent, StakedSuiFren, type StakedSuiFrenInfo, type StakedSuiFrenMetadataV1Object, type StakedSuiFrenPositionObject, type StakedSuiVaultStateObject, Staking, type StakingAddresses, type StakingApyDataPoint, type StakingApyTimeframeKey, type StakingPoolOneTimeAdminCapObject, type StakingPoolOwnerCapObject, type StakingPosition, type StringByte, Sui, type SuiAddress, type SuiCheckpoint, type SuiDelegatedStake, type SuiDelegatedStakeState, SuiFren, type SuiFrenAccessoryName, type SuiFrenAccessoryObject, type SuiFrenAccessoryType, type SuiFrenAttributes, type SuiFrenObject, type SuiFrenStats, type SuiFrenVaultStateV1Object, SuiFrens, type SuiFrensAddresses, SuiFrensSortOption, type SuiNetwork, type Timestamp, type TransactionDigest, type TransactionsWithCursor, type TransferredDeallocatedCollateralEvent, type TranslatedMoveError, type TxBytes, type UniqueId, type UnstakeEvent, type UnstakePosition, type UnstakePositionState, type UnstakeRequestedEvent, type UnstakeSuiFrenEvent, type UnstakedEvent, type UpdatedFeeBpsEvent, type UpdatedFeeRecipientEvent, type UpdatedFundingEvent, type UpdatedMarketVersionEvent, type UpdatedPremiumTwapEvent, type UpdatedSpreadTwapEvent, type Url, type UserEventsInputs, type UserHistoryEventType, type ValidatorConfigObject, type ValidatorOperationCapObject, type WithdrewCollateralEvent, isAllocatedCollateralEvent, isCanceledOrderEvent, isDeallocatedCollateralEvent, isDepositedCollateralEvent, isFarmsDepositedPrincipalEvent, isFarmsHarvestedRewardsEvent, isFarmsLockedEvent, isFarmsStakedEvent, isFarmsUnlockedEvent, isFarmsWithdrewPrincipalEvent, isFilledMakerOrdersEvent, isFilledTakerOrderEvent, isLiquidatedEvent, isPostedOrderEvent, isReducedOrderEvent, isSettledFundingEvent, isStakeEvent, isStakePosition, isSuiDelegatedStake, isUnstakeEvent, isUnstakePosition, isUpdatedFundingEvent, isUpdatedMarketVersion, isUpdatedPremiumTwapEvent, isUpdatedSpreadTwapEvent, isWithdrewCollateralEvent };