@ferra-labs/damm 1.0.0

package/dist/index.d.mts

@@ -0,0 +1,4520 @@
+import { SuiTransactionBlockResponse, SuiMoveObject, SuiClient, SuiEventFilter, TransactionFilter, SuiObjectResponseQuery, SuiObjectDataOptions, SuiObjectResponse, DevInspectResults, CoinBalance, SuiObjectData, SuiObjectRef, OwnedObjectRef, ObjectOwner, DisplayFieldsResponse, SuiParsedData } from '@mysten/sui/client';
+import { TransactionArgument, Transaction, TransactionObjectArgument, TransactionResult } from '@mysten/sui/transactions';
+import BN from 'bn.js';
+import { Graph } from '@syntsugar/cc-graph';
+import Decimal, { Decimal as Decimal$1 } from 'decimal.js';
+import { Ed25519Keypair } from '@mysten/sui/keypairs/ed25519';
+import { Secp256k1Keypair } from '@mysten/sui/keypairs/secp256k1';
+
+/**
+ * Represents a SUI address, which is a string.
+ */
+type SuiAddressType = string;
+/**
+ * Represents a SUI object identifier, which is a string.
+ */
+type SuiObjectIdType = string;
+/**
+ * The address representing the clock in the system.
+ */
+declare const CLOCK_ADDRESS = "0x0000000000000000000000000000000000000000000000000000000000000006";
+/**
+ * Constants for different modules in the DAMM (Cryptocurrency Liquidity Mining Module).
+ */
+declare const DammPartnerModule = "partner";
+declare const DammIntegratePoolModule = "pool_script";
+declare const DammIntegrateRouterModule = "router";
+declare const DammIntegrateRouterWithPartnerModule = "router_with_partner";
+declare const DammFetcherModule = "fetcher_script";
+declare const DammExpectSwapModule = "expect_swap";
+declare const DammIntegrateUtilsModule = "utils";
+/**
+ * The address for CoinInfo module.
+ */
+declare const CoinInfoAddress = "0x1::coin::CoinInfo";
+/**
+ * The address for CoinStore module.
+ */
+declare const CoinStoreAddress = "0x1::coin::CoinStore";
+/**
+ * Represents a SUI resource, which can be of any type.
+ */
+type SuiResource = any;
+/**
+ * Represents a paginated data page with optional cursor and limit.
+ */
+type DataPage<T> = {
+    data: T[];
+    nextCursor?: any;
+    hasNextPage: boolean;
+};
+/**
+ * Represents query parameters for pagination.
+ */
+type PageQuery = {
+    cursor?: any;
+    limit?: number | null;
+};
+/**
+ * Represents arguments for pagination, with options for fetching all data or using PageQuery.
+ */
+type PaginationArgs = 'all' | PageQuery;
+/**
+ * Represents a Non-Fungible Token (NFT) with associated metadata.
+ */
+type NFT = {
+    /**
+     * The address or identifier of the creator of the NFT.
+     */
+    creator: string;
+    /**
+     * A description providing additional information about the NFT.
+     */
+    description: string;
+    /**
+     * The URL to the image representing the NFT visually.
+     */
+    image_url: string;
+    /**
+     * A link associated with the NFT, providing more details or interactions.
+     */
+    link: string;
+    /**
+     * The name or title of the NFT.
+     */
+    name: string;
+    /**
+     * The URL to the project or collection associated with the NFT.
+     */
+    project_url: string;
+};
+/**
+ * Represents a SUI struct tag.
+ */
+type SuiStructTag = {
+    /**
+     * The full address of the struct.
+     */
+    full_address: string;
+    /**
+     * The source address of the struct.
+     */
+    source_address: string;
+    /**
+     * The address of the struct.
+     */
+    address: SuiAddressType;
+    /**
+     * The module to which the struct belongs.
+     */
+    module: string;
+    /**
+     * The name of the struct.
+     */
+    name: string;
+    /**
+     * An array of type arguments (SUI addresses) for the struct.
+     */
+    type_arguments: SuiAddressType[];
+};
+/**
+ * Represents basic SUI data types.
+ */
+type SuiBasicTypes = 'address' | 'bool' | 'u8' | 'u16' | 'u32' | 'u64' | 'u128' | 'u256';
+/**
+ * Represents a SUI transaction argument, which can be of various types.
+ */
+type SuiTxArg = TransactionArgument | string | number | bigint | boolean;
+/**
+ * Represents input types for SUI data.
+ */
+type SuiInputTypes = 'object' | SuiBasicTypes;
+/**
+ * Gets the default SUI input type based on the provided value.
+ * @param value - The value to determine the default input type for.
+ * @returns The default SUI input type.
+ * @throws Error if the type of the value is unknown.
+ */
+declare const getDefaultSuiInputType: (value: any) => SuiInputTypes;
+
+/**
+ * Enumerates the possible status values of a position within a liquidity mining module.
+ */
+declare enum DammPositionStatus {
+    /**
+     * The position has been deleted or removed.
+     */
+    'Deleted' = "Deleted",
+    /**
+     * The position exists and is active.
+     */
+    'Exists' = "Exists",
+    /**
+     * The position does not exist or is not active.
+     */
+    'NotExists' = "NotExists"
+}
+/**
+ * Represents a package containing specific configuration or data.
+ * @template T - The type of configuration or data contained in the package.
+ */
+type Package<T = undefined> = {
+    /**
+     * The unique identifier of the package.
+     */
+    package_id: string;
+    /**
+     * the package was published.
+     */
+    published_at: string;
+    /**
+     * The version number of the package (optional).
+     */
+    version?: number;
+    /**
+     * The configuration or data contained in the package (optional).
+     */
+    config?: T;
+};
+/**
+ *  The Ferra dammpool's position NFT.
+ */
+type Position = {
+    /**
+     * The unique identifier of the position object.
+     */
+    pos_object_id: SuiObjectIdType;
+    /**
+     * The owner of the position.
+     */
+    owner: SuiObjectIdType;
+    /**
+     * The liquidity pool associated with the position.
+     */
+    pool: SuiObjectIdType;
+    /**
+     * The type of position represented by an address.
+     */
+    type: SuiAddressType;
+    /**
+     * The index of the position.
+     */
+    index: number;
+    /**
+     * The amount of liquidity held by the position.
+     */
+    liquidity: string;
+    /**
+     * The lower tick index of the position range.
+     */
+    tick_lower_index: number;
+    /**
+     * The upper tick index of the position range.
+     */
+    tick_upper_index: number;
+    /**
+     * The status of the position within the liquidity mining module.
+     */
+    position_status: DammPositionStatus;
+    lock_until: string;
+    /**
+     * The address type of the first coin in the position.
+     */
+    coin_type_a: SuiAddressType;
+    /**
+     * The address type of the second coin in the position.
+     */
+    coin_type_b: SuiAddressType;
+} & NFT & PositionReward;
+/**
+ * Represents reward information associated with a liquidity mining position.
+ */
+type PositionReward = {
+    /**
+     * The unique identifier of the position object.
+     */
+    pos_object_id: SuiObjectIdType;
+    /**
+     * The amount of liquidity held by the position.
+     */
+    liquidity: string;
+    /**
+     * The lower tick index of the position range.
+     */
+    tick_lower_index: number;
+    /**
+     * The upper tick index of the position range.
+     */
+    tick_upper_index: number;
+    /**
+     * The accumulated fee growth inside the first coin of the position.
+     */
+    fee_growth_inside_a: string;
+    /**
+     * The accumulated fee owed in the first coin of the position.
+     */
+    fee_owed_a: string;
+    /**
+     * The accumulated fee growth inside the second coin of the position.
+     */
+    fee_growth_inside_b: string;
+    /**
+     * The accumulated fee owed in the second coin of the position.
+     */
+    fee_owed_b: string;
+    /**
+     * The amount of reward owed in the first reward category.
+     */
+    reward_amount_owed_0: string;
+    /**
+     * The amount of reward owed in the second reward category.
+     */
+    reward_amount_owed_1: string;
+    /**
+     * The amount of reward owed in the third reward category.
+     */
+    reward_amount_owed_2: string;
+    /**
+     * The accumulated reward growth inside the first reward category.
+     */
+    reward_growth_inside_0: string;
+    /**
+     * The accumulated reward growth inside the second reward category.
+     */
+    reward_growth_inside_1: string;
+    /**
+     * The accumulated reward growth inside the third reward category.
+     */
+    reward_growth_inside_2: string;
+};
+/**
+ * Represents a pair of coins used in a financial context.
+ */
+type CoinPairType = {
+    /**
+     * The address type of the coin a in the pair.
+     */
+    coinTypeA: SuiAddressType;
+    /**
+     * The address type of the coin b in the pair.
+     */
+    coinTypeB: SuiAddressType;
+};
+/**
+ * Represents immutable properties of a liquidity pool.
+ */
+type PoolImmutables = {
+    /**
+     * The address of the liquidity pool.
+     */
+    poolAddress: string;
+    /**
+     * The tick spacing value used in the pool.
+     */
+    tickSpacing: string;
+} & CoinPairType;
+/**
+ * "Pool" is the core module of Damm protocol, which defines the trading pairs of "dammpool".
+ */
+type Pool = {
+    /**
+     * Represents the type or category of a liquidity pool.
+     */
+    poolType: string;
+    /**
+     * The amount of coin a.
+     */
+    coinAmountA: bigint;
+    /**
+     * The amount of coin b.
+     */
+    coinAmountB: bigint;
+    /**
+     * The current sqrt price
+     */
+    isQuoteY: boolean;
+    /**
+     * The current sqrt price
+     */
+    currentSqrtPrice: bigint;
+    collectFeeMode: number;
+    currentTickIndex: number;
+    parameters: {
+        currentSqrtPrice: bigint;
+        currentTickIndex: number;
+        tickLowerIndex: number;
+        tickUpperIndex: number;
+        activationTimestamp: bigint;
+        cliffFeeNumerator: bigint;
+        decayPeriod: bigint;
+        enabledDynamicFee: boolean;
+        isQuoteY: boolean;
+        enabledFeeScheduler: boolean;
+        feeRate: number;
+        feeSchedulerMode: bigint;
+        feeSchedulerReductionFactor: bigint;
+        filterPeriod: bigint;
+        idReference: number;
+        maxVolatilityAccumulator: number;
+        numberOfPeriod: number;
+        periodFrequency: number;
+        reductionFactor: number;
+        tickSpacing: number;
+        timeOfLastUpdate: number;
+        variableFeeControl: number;
+        volatilityAccumulator: number;
+        volatilityReference: number;
+    };
+    /**
+     * The global fee growth of coin a as Q64.64
+     */
+    feeGrowthGlobalB: number;
+    /**
+     * The global fee growth of coin b as Q64.64
+     */
+    feeGrowthGlobalA: number;
+    /**
+     * The amounts of coin a owend to protocol
+     */
+    feeProtocolCoinA: number;
+    /**
+     * The amounts of coin b owend to protocol
+     */
+    feeProtocolCoinB: number;
+    /**
+     * The numerator of fee rate, the denominator is 1_000_000.
+     */
+    feeRate: number;
+    /**
+     * is the pool pause
+     */
+    isPause: boolean;
+    /**
+     * The liquidity of current tick index
+     */
+    liquidity: number;
+    /**
+     * The pool index
+     */
+    index: number;
+    /**
+     * The positions manager
+     */
+    positionManager: {
+        positionsHandle: string;
+        size: number;
+    };
+    /**
+     * The rewarder manager
+     */
+    rewarderInfos: Array<Rewarder>;
+    rewarderLastUpdatedTime: string;
+    /**
+     * The tick manager handle
+     */
+    ticksHandle: string;
+    /**
+     * The url for pool and position
+     */
+    uri: string;
+    /**
+     * The name for pool
+     */
+    name: string;
+} & PoolImmutables;
+type Rewarder = {
+    /**
+     * The coin address where rewards will be distributed.
+     */
+    coinAddress: string;
+    /**
+     * The rate of emissions in coins per second.
+     */
+    emissions_per_second: number;
+    /**
+     * The global growth factor influencing reward emissions.
+     */
+    growth_global: number;
+    /**
+     * The total emissions in coins that occur every day.
+     */
+    emissionsEveryDay: number;
+};
+/**
+ * Configuration settings for the Cryptocurrency Liquidity Mining Module (DAMM).
+ */
+type DammConfig = {
+    /**
+     * Identifier of the pools for liquidity mining.
+     */
+    pools_id: SuiObjectIdType;
+    /**
+     * Identifier of the global configuration for the module.
+     */
+    global_config_id: SuiObjectIdType;
+    /**
+     * Identifier of the global vault for the module.
+     */
+    global_rewarder_vault_id: SuiObjectIdType;
+    /**
+     * Optional identifier of partners for the liquidity mining module.
+     */
+    partners_id?: SuiObjectIdType;
+};
+/**
+ * Represents an event to create a liquidity mining partner.
+ */
+type CreatePartnerEvent = {
+    /**
+     * The name of the liquidity mining partner.
+     */
+    name: string;
+    /**
+     * The recipient's address for the partner.
+     */
+    recipient: SuiAddressType;
+    /**
+     * Identifier of the partner.
+     */
+    partner_id: SuiObjectIdType;
+    /**
+     * Identifier of the partner's capacity.
+     */
+    partner_cap_id: SuiObjectIdType;
+    /**
+     * The fee rate associated with the partner.
+     */
+    fee_rate: string;
+    /**
+     * The starting epoch of the partnership.
+     */
+    start_epoch: string;
+    /**
+     * The ending epoch of the partnership.
+     */
+    end_epoch: string;
+};
+/**
+ * Represents a coin asset with address, object ID, and balance information.
+ */
+type CoinAsset = {
+    /**
+     * The address type of the coin asset.
+     */
+    coinAddress: SuiAddressType;
+    /**
+     * The object identifier of the coin asset.
+     */
+    coinObjectId: SuiObjectIdType;
+    /**
+     * The balance amount of the coin asset.
+     */
+    balance: bigint;
+};
+/**
+ * Represents a faucet coin configuration.
+ */
+type FaucetCoin = {
+    /**
+     * The name or identifier of the transaction module.
+     */
+    transactionModule: string;
+    /**
+     * The supply ID or object identifier of the faucet coin.
+     */
+    suplyID: SuiObjectIdType;
+    /**
+     * The number of decimal places used for the faucet coin.
+     */
+    decimals: number;
+};
+/**
+ * Represents parameters for creating a liquidity pool.
+ */
+type CreatePoolParams = {
+    /**
+     * The tick spacing value used for the pool.
+     */
+    tick_spacing: number;
+    /**
+     * The initial square root price value for the pool.
+     */
+    initialize_sqrt_price: string;
+    /**
+     * The Uniform Resource Identifier (URI) associated with the pool.
+     */
+    uri: string;
+} & CoinPairType;
+/**
+ * Represents parameters for adding liquidity to a created liquidity pool.
+ * Extends the CreatePoolParams type.
+ */
+type CreatePoolAddLiquidityParams = CreatePoolParams & {
+    /**
+     * The amount of the first coin to be added as liquidity.
+     * Can be a number or a string.
+     */
+    amount_a: number | string;
+    /**
+     * The amount of the second coin to be added as liquidity.
+     * Can be a number or a string.
+     */
+    amount_b: number | string;
+    /**
+     * Indicates whether the amount of the first coin is fixed.
+     */
+    fix_amount_a: boolean;
+    /**
+     * The lower tick index for liquidity provision.
+     */
+    tick_lower?: number;
+    /**
+     * The upper tick index for liquidity provision.
+     */
+    tick_upper?: number;
+    lock_until?: number;
+    collect_fee_mode: number;
+    is_quote_y: boolean;
+    fee_scheduler_mode: number;
+    enable_fee_scheduler: boolean;
+    enable_dynamic_fee: boolean;
+    activation_timestamp: number;
+    metadata_a?: SuiObjectIdType;
+    metadata_b?: SuiObjectIdType;
+    /**
+     * The allowed slippage percentage for the liquidity provision.
+     */
+    slippage: number;
+};
+type FetchParams = {
+    pool_id: SuiObjectIdType;
+} & CoinPairType;
+type CommonParams = {
+    /**
+     * The object id about which pool you want to operation.
+     */
+    pool_id: SuiObjectIdType;
+    /**
+     * The object id about position.
+     */
+    pos_id: SuiObjectIdType;
+};
+type AddLiquidityFixTokenParams = {
+    /**
+     * If fixed amount A, you must set amount_a, amount_b will be auto calculated by DammPoolUtil.estLiquidityAndcoinAmountFromOneAmounts().
+     */
+    amount_a: number | string;
+    /**
+     * If fixed amount B, you must set amount_b, amount_a will be auto calculated by DammPoolUtil.estLiquidityAndcoinAmountFromOneAmounts().
+     */
+    amount_b: number | string;
+    /**
+     * Price slippage point.
+     */
+    slippage: number;
+    /**
+     * true means fixed coinA amount, false means fixed coinB amount
+     */
+    fix_amount_a: boolean;
+    /**
+     * control whether or not to create a new position or add liquidity on existed position.
+     */
+    is_open: boolean;
+    lock_until?: number;
+} & AddLiquidityCommonParams;
+type AddLiquidityParams = {
+    /**
+     * The actual change in liquidity that has been added.
+     */
+    delta_liquidity: string;
+    /**
+     * The max limit about used coin a amount
+     */
+    max_amount_a: number | string;
+    /**
+     * The max limit about used coin b amount.
+     */
+    max_amount_b: number | string;
+    lock_until?: number;
+} & AddLiquidityCommonParams;
+type AddLiquidityCommonParams = {
+    /**
+     * Represents the index of the lower tick boundary.
+     */
+    tick_lower: string | number;
+    /**
+     * Represents the index of the upper tick boundary.
+     */
+    tick_upper: string | number;
+    /**
+     * If you already has one position, you can select collect fees while adding liquidity.
+     */
+    collect_fee: boolean;
+    /**
+     * If these not empty, it will collect rewarder in this position, if you already open the position.
+     */
+    rewarder_coin_types: SuiAddressType[];
+} & CoinPairType & CommonParams;
+/**
+ * Parameters for opening a position within a liquidity pool.
+ * Extends the CoinPairType type.
+ */
+type OpenPositionParams = CoinPairType & {
+    /**
+     * The lower tick index for the position.
+     */
+    tick_lower: string;
+    /**
+     * The upper tick index for the position.
+     */
+    tick_upper: string;
+    /**
+     * The object identifier of the liquidity pool.
+     */
+    pool_id: SuiObjectIdType;
+    lock_until?: number;
+};
+/**
+ * Parameters for removing liquidity from a pool.
+ * Extends the CoinPairType and CommonParams types.
+ */
+type RemoveLiquidityParams = CoinPairType & CommonParams & {
+    /**
+     * The change in liquidity amount to be removed.
+     */
+    delta_liquidity: string;
+    /**
+     * The minimum amount of the first coin to be received.
+     */
+    min_amount_a: string;
+    /**
+     * The minimum amount of the second coin to be received.
+     */
+    min_amount_b: string;
+    /**
+     * Indicates whether to collect fees during the removal.
+     */
+    collect_fee: boolean;
+    /**
+     * Coin types associated with rewarder contracts.
+     */
+    rewarder_coin_types: string[];
+};
+/**
+ * Parameters for closing a position within a liquidity pool.
+ * Extends the CoinPairType, CommonParams, and CommonParams types.
+ */
+type ClosePositionParams = CoinPairType & CommonParams & {
+    /**
+     * Coin types associated with rewarder contracts.
+     */
+    rewarder_coin_types: SuiAddressType[];
+    /**
+     * The minimum amount of the first coin to be received.
+     */
+    min_amount_a: string;
+    /**
+     * The minimum amount of the second coin to be received.
+     */
+    min_amount_b: string;
+    /**
+     * Indicates whether to collect fees during the closing.
+     */
+    collect_fee: boolean;
+} & CoinPairType & CommonParams;
+/**
+ * Represents parameters for collecting fees.
+ */
+type CollectFeeParams = CommonParams & CoinPairType;
+/**
+ * Represents parameters for creating a test transfer transaction payload.
+ */
+type createTestTransferTxPayloadParams = {
+    /**
+     * The recipient account address.
+     */
+    account: string;
+    /**
+     * The value to transfer.
+     */
+    value: number;
+};
+/**
+ * Represents parameters for calculating rates in a swap.
+ */
+type CalculateRatesParams = {
+    /**
+     * The number of decimal places for token A.
+     */
+    decimalsA: number;
+    /**
+     * The number of decimal places for token B.
+     */
+    decimalsB: number;
+    /**
+     * Specifies if the swap is from token A to token B.
+     */
+    a2b: boolean;
+    /**
+     * Specifies if the swap amount is specified in token A.
+     */
+    byAmountIn: boolean;
+    /**
+     * The amount to swap.
+     */
+    amount: BN;
+    /**
+     * An array of tick data for swap ticks.
+     */
+    swapTicks: Array<TickData>;
+    /**
+     * The current pool information.
+     */
+    currentPool: Pool;
+};
+/**
+ * Represents the result of calculating rates in a swap.
+ */
+type CalculateRatesResult = {
+    /**
+     * The estimated amount in token A.
+     */
+    estimatedAmountIn: BN;
+    /**
+     * The estimated amount in token B.
+     */
+    estimatedAmountOut: BN;
+    /**
+     * The estimated ending square root price.
+     */
+    estimatedEndSqrtPrice: BN;
+    /**
+     * The estimated fee amount.
+     */
+    estimatedFeeAmount: BN;
+    /**
+     * Indicates if the estimated amount exceeds the limit.
+     */
+    isExceed: boolean;
+    /**
+     * The extra compute limit.
+     */
+    extraComputeLimit: number;
+    /**
+     * Specifies if the swap is from token A to token B.
+     */
+    aToB: boolean;
+    /**
+     * Specifies if the swap amount is specified in token A.
+     */
+    byAmountIn: boolean;
+    /**
+     * The amount to swap.
+     */
+    amount: BN;
+    /**
+     * The price impact percentage.
+     */
+    priceImpactPct: number;
+};
+/**
+ * Represents parameters for a swap operation.
+ */
+type SwapParams = {
+    /**
+     * The identifier of the pool.
+     */
+    pool_id: SuiObjectIdType;
+    /**
+     * Specifies if the swap is from token A to token B.
+     */
+    a2b: boolean;
+    /**
+     * Specifies if the swap amount is specified in token A.
+     */
+    by_amount_in: boolean;
+    /**
+     * The swap amount.
+     */
+    amount: string;
+    /**
+     * The amount limit for the swap.
+     */
+    amount_limit: string;
+    /**
+     * The optional swap partner.
+     */
+    swap_partner?: string;
+} & CoinPairType;
+/**
+ * Represents parameters for a pre-swap operation.
+ */
+type PreSwapParams = {
+    /**
+     * The pool information for the pre-swap.
+     */
+    pool: Pool;
+    /**
+     * The current square root price.
+     */
+    currentSqrtPrice: number;
+    /**
+     * The number of decimal places for token A.
+     */
+    decimalsA: number;
+    /**
+     * The number of decimal places for token B.
+     */
+    decimalsB: number;
+    /**
+     * Specifies if the swap is from token A to token B.
+     */
+    a2b: boolean;
+    /**
+     * Specifies if the swap amount is specified in token A.
+     */
+    byAmountIn: boolean;
+    /**
+     * The swap amount.
+     */
+    amount: string;
+} & CoinPairType;
+/**
+ * Represents parameters for a pre-swap operation with multiple pools.
+ */
+type PreSwapWithMultiPoolParams = {
+    /**
+     * An array of pool addresses for the pre-swap.
+     */
+    poolAddresses: string[];
+    /**
+     * Specifies if the swap is from token A to token B.
+     */
+    a2b: boolean;
+    /**
+     * Specifies if the swap amount is specified in token A.
+     */
+    byAmountIn: boolean;
+    /**
+     * The swap amount.
+     */
+    amount: string;
+} & CoinPairType;
+/**
+ * If changes in liquidity are required before the swap, then this parameter should be passed.
+ */
+type PreSwapLpChangeParams = {
+    /**
+     * Unique identifier for the liquidity pool involved in the transaction.
+     */
+    pool_id: string;
+    /**
+     * Lower bound of the liquidity range. In AMM models, like Uniswap V3, liquidity is provided within specific price ranges. This represents the lower limit of that range.
+     */
+    tick_lower: number;
+    /**
+     * Upper bound of the liquidity range, corresponding to the lower bound. This defines the upper limit of the range where liquidity is provided.
+     */
+    tick_upper: number;
+    /**
+     * The change in liquidity, which can be a large number and is thus represented as a string. It can be positive or negative, indicating an increase or decrease in liquidity.
+     */
+    delta_liquidity: number;
+    /**
+     * A boolean value indicating whether the 'delta_liquidity' represents an increase (true) or decrease (false) in liquidity.
+     */
+    is_increase: boolean;
+};
+/**
+ * Represents parameters for a transitional pre-swap operation with multiple pools.
+ */
+type TransPreSwapWithMultiPoolParams = {
+    /**
+     * The address of the pool for the transitional pre-swap.
+     */
+    poolAddress: string;
+    /**
+     * Specifies if the swap is from token A to token B.
+     */
+    a2b: boolean;
+    /**
+     * Specifies if the swap amount is specified in token A.
+     */
+    byAmountIn: boolean;
+    /**
+     * The swap amount.
+     */
+    amount: string;
+} & CoinPairType;
+/**
+ * Represents parameters for collecting rewarder fees.
+ */
+type CollectRewarderParams = {
+    /**
+     * The identifier of the pool.
+     */
+    pool_id: SuiObjectIdType;
+    /**
+     * The identifier of the position.
+     */
+    pos_id: SuiObjectIdType;
+    /**
+     * Specifies if the fee should be collected.
+     */
+    collect_fee: boolean;
+    /**
+     * An array of rewarder coin types.
+     */
+    rewarder_coin_types: SuiAddressType[];
+} & CoinPairType;
+type RemoveLiquidityAndClaimRewardsParams = {
+    /**
+       * The identifier of the pool.
+       */
+    pool_id: SuiObjectIdType;
+    /**
+    * The minimum amount of the first coin to be received.
+    */
+    min_amount_a: bigint;
+    /**
+     * The minimum amount of the second coin to be received.
+     */
+    min_amount_b: bigint;
+    /**
+     * The actual change in liquidity that has been added.
+     */
+    delta_liquidity: string;
+    /**
+     * The identifier of the position.
+     */
+    pos_id: SuiObjectIdType;
+} & CoinPairType;
+/**
+ * Represents the amount owed by a rewarder.
+ */
+type RewarderAmountOwed = {
+    /**
+     * The amount owed.
+     */
+    amount_owed: BN;
+    /**
+     * The address of the coin.
+     */
+    coin_address: string;
+};
+/**
+ * Utility function to retrieve packager configurations from a package object.
+ * @param {Package<T>} packageObj - The package object containing configurations.
+ * @throws {Error} Throws an error if the package does not have a valid config.
+ * @returns {T} The retrieved configuration.
+ */
+declare function getPackagerConfigs<T>(packageObj: Package<T>): T;
+type PositionTransactionInfo = {
+    index: string;
+    txDigest: string;
+    packageId: string;
+    transactionModule: string;
+    sender: string;
+    type: string;
+    timestampMs: string;
+    parsedJson: any;
+};
+type PoolTransactionInfo = {
+    index: string;
+    tx: string;
+    sender: string;
+    type: string;
+    block_time: string;
+    parsedJson: any;
+};
+declare const poolFilterEvenTypes: string[];
+
+/**
+ * Represents tick data for a liquidity pool.
+ */
+type TickData = {
+    /**
+     * The object identifier of the tick data.
+     */
+    objectId: string;
+    /**
+     * The index of the tick.
+     */
+    index: number;
+    /**
+     * The square root price value for the tick.
+     */
+    sqrtPrice: BN;
+    /**
+     * The net liquidity value for the tick.
+     */
+    liquidityNet: BN;
+    /**
+     * The gross liquidity value for the tick.
+     */
+    liquidityGross: BN;
+    /**
+     * The fee growth outside coin A for the tick.
+     */
+    feeGrowthOutsideA: BN;
+    /**
+     * The fee growth outside coin B for the tick.
+     */
+    feeGrowthOutsideB: BN;
+    /**
+     * An array of rewarders' growth outside values for the tick.
+     */
+    rewardersGrowthOutside: BN[];
+};
+/**
+ * Represents a tick for a liquidity pool.
+ */
+type Tick = {
+    /**
+     * The index of the tick.
+     */
+    index: Bits;
+    /**
+     * The square root price value for the tick (string representation).
+     */
+    sqrt_price: string;
+    /**
+     * The net liquidity value for the tick (Bits format).
+     */
+    liquidity_net: Bits;
+    /**
+     * The gross liquidity value for the tick (string representation).
+     */
+    liquidity_gross: string;
+    /**
+     * The fee growth outside coin A for the tick (string representation).
+     */
+    fee_growth_outside_a: string;
+    /**
+     * The fee growth outside coin B for the tick (string representation).
+     */
+    fee_growth_outside_b: string;
+    /**
+     * An array of rewarders' growth outside values for the tick (array of string representations).
+     */
+    rewarders_growth_outside: string[3];
+};
+/**
+ * Represents bits information.
+ */
+type Bits = {
+    bits: string;
+};
+/**
+ * Represents data for a liquidity mining pool.
+ */
+type DammpoolData = {
+    coinA: string;
+    coinB: string;
+    currentSqrtPrice: BN;
+    currentTickIndex: number;
+    feeGrowthGlobalA: BN;
+    feeGrowthGlobalB: BN;
+    feeProtocolCoinA: BN;
+    feeProtocolCoinB: BN;
+    feeRate: BN;
+    liquidity: BN;
+    tickIndexes: number[];
+    tickSpacing: number;
+    ticks: Array<TickData>;
+    collection_name: string;
+};
+/**
+ * Transforms a Pool object into DammpoolData format.
+ * @param {Pool} pool - The liquidity pool object to transform.
+ * @returns {DammpoolData} The transformed DammpoolData object.
+ */
+declare function transDammpoolDataWithoutTicks(pool: Pool): DammpoolData;
+/**
+ * Creates a Bits object from an index.
+ * @param {number | string} index - The index value.
+ * @returns {Bits} The created Bits object.
+ */
+declare function newBits(index: number | string): Bits;
+
+/**
+ * The maximum tick index supported by the dammpool program.
+ * @category Constants
+ */
+declare const MAX_TICK_INDEX = 443636;
+/**
+ * The minimum tick index supported by the dammpool program.
+ * @category Constants
+ */
+declare const MIN_TICK_INDEX = -443636;
+/**
+ * The maximum sqrt-price supported by the dammpool program.
+ * @category Constants
+ */
+declare const MAX_SQRT_PRICE = "79226673515401279992447579055";
+/**
+ * The number of initialized ticks that a tick-array account can hold.
+ * @category Constants
+ */
+declare const TICK_ARRAY_SIZE = 64;
+/**
+ * The minimum sqrt-price supported by the dammpool program.
+ * @category Constants
+ */
+declare const MIN_SQRT_PRICE = "4295048016";
+/**
+ * The denominator which the fee rate is divided on.
+ * @category Constants
+ */
+declare const FEE_RATE_DENOMINATOR: BN;
+
+/**
+ * Represents configuration for tokens.
+ */
+type TokenConfig = {
+    /**
+     * The object identifier of the coin registry.
+     */
+    coin_registry_id: SuiObjectIdType;
+    /**
+     * The object identifier of the coin list owner.
+     */
+    coin_list_owner: SuiObjectIdType;
+    /**
+     * The object identifier of the pool registry.
+     */
+    pool_registry_id: SuiObjectIdType;
+    /**
+     * The object identifier of the pool list owner.
+     */
+    pool_list_owner: SuiObjectIdType;
+};
+/**
+ * Represents information about a token.
+ */
+type TokenInfo = {
+    /**
+     * The name of the token.
+     */
+    name: string;
+    /**
+     * The symbol of the token.
+     */
+    symbol: string;
+    /**
+     * The official symbol of the token.
+     */
+    official_symbol: string;
+    /**
+     * The Coingecko ID of the token.
+     */
+    coingecko_id: string;
+    /**
+     * The number of decimal places for the token.
+     */
+    decimals: number;
+    /**
+     * The project URL for the token.
+     */
+    project_url: string;
+    /**
+     * The URL to the logo image of the token.
+     */
+    logo_url: string;
+    /**
+     * The address of the token.
+     */
+    address: string;
+} & Record<string, any>;
+/**
+ * Represents information about a liquidity pool.
+ */
+type PoolInfo = {
+    /**
+     * The symbol of the pool.
+     */
+    symbol: string;
+    /**
+     * The name of the pool.
+     */
+    name: string;
+    /**
+     * The number of decimal places for the pool.
+     */
+    decimals: number;
+    /**
+     * The fee for the pool.
+     */
+    fee: string;
+    /**
+     * The tick spacing for the pool.
+     */
+    tick_spacing: number;
+    /**
+     * The type of the pool.
+     */
+    type: string;
+    /**
+     * The address of the pool.
+     */
+    address: string;
+    /**
+     * The address of coin A for the pool.
+     */
+    coin_a_address: string;
+    /**
+     * The address of coin B for the pool.
+     */
+    coin_b_address: string;
+    /**
+     * The project URL for the pool.
+     */
+    project_url: string;
+    /**
+     * The sort order for the pool.
+     */
+    sort: number;
+    /**
+     * Indicates if the rewarder is displayed for the pool.
+     */
+    is_display_rewarder: boolean;
+    /**
+     * Indicates if rewarder 1 is displayed for the pool.
+     */
+    rewarder_display1: boolean;
+    /**
+     * Indicates if rewarder 2 is displayed for the pool.
+     */
+    rewarder_display2: boolean;
+    /**
+     * Indicates if rewarder 3 is displayed for the pool.
+     */
+    rewarder_display3: boolean;
+    /**
+     * Indicates if the pool is stable.
+     */
+    is_stable: boolean;
+} & Record<string, any>;
+/**
+ * Represents an event related to token configuration.
+ */
+type TokenConfigEvent = {
+    /**
+     * The object identifier of the coin registry.
+     */
+    coin_registry_id: SuiObjectIdType;
+    /**
+     * The object identifier of the coin list owner.
+     */
+    coin_list_owner: SuiObjectIdType;
+    /**
+     * The object identifier of the pool registry.
+     */
+    pool_registry_id: SuiObjectIdType;
+    /**
+     * The object identifier of the pool list owner.
+     */
+    pool_list_owner: SuiObjectIdType;
+};
+
+/**
+ * Represents input data for adding liquidity to a pool.
+ */
+type LiquidityInput = {
+    /**
+     * The amount of coin A.
+     */
+    coinAmountA: BN;
+    /**
+     * The amount of coin B.
+     */
+    coinAmountB: BN;
+    /**
+     * The maximum amount of token A.
+     */
+    tokenMaxA: BN;
+    /**
+     * The maximum amount of token B.
+     */
+    tokenMaxB: BN;
+    /**
+     * The liquidity amount.
+     */
+    liquidityAmount: BN;
+    fix_amount_a: boolean;
+};
+/**
+ * Represents the direction of a swap.
+ */
+declare enum SwapDirection {
+    /**
+     * Swap from coin A to coin B.
+     */
+    A2B = "a2b",
+    /**
+     * Swap from coin B to coin A.
+     */
+    B2A = "b2a"
+}
+
+type BigNumber = Decimal.Value | number | string;
+
+interface IModule {
+    readonly sdk: FerraDammSDK;
+}
+
+type CreatePoolAndAddLiquidityRowResult = {
+    position: TransactionObjectArgument;
+    coinAObject: TransactionObjectArgument;
+    coinBObject: TransactionObjectArgument;
+    transaction: Transaction;
+    coinAType: string;
+    coinBType: string;
+};
+type FeeTier = {
+    tick_spacing: number;
+    dynamic_fee: {
+        decay_period: number;
+        filter_period: number;
+        max_volatility_accumulator: number;
+        reduction_factor: number;
+        variable_fee_control: number;
+    };
+    fee_rate: number;
+    fee_scheduler: {
+        exponential: {
+            cliff_fee_numerator: string;
+            number_of_period: number;
+            period_frequency: string;
+            reduction_factor: string;
+        };
+        linear: {
+            cliff_fee_numerator: string;
+            number_of_period: number;
+            period_frequency: string;
+            reduction_factor: string;
+        };
+    };
+};
+/**
+ * Pool module for comprehensive DAMM pool management
+ * Handles pool creation, data retrieval, liquidity operations, and tick management
+ * Includes caching mechanisms for optimal performance
+ *
+ * @example
+ * // Get pool information
+ * const pool = await sdk.Pool.getPool('0x_pool_address');
+ * console.log(`Liquidity: ${pool.liquidity}`);
+ * console.log(`Current tick: ${pool.currentTickIndex}`);
+ * console.log(`Fee rate: ${pool.feeRate / 10000000}%`);
+ *
+ * @example
+ * // Fetch all ticks for a pool
+ * const ticks = await sdk.Pool.fetchTicksByRpc('0x_pool_address');
+ * console.log(`Found ${ticks.length} initialized ticks`);
+ *
+ * @example
+ * // Create a new pool with initial liquidity
+ * const createPoolTx = await sdk.Pool.createPoolTransactionPayload({
+ *   coinTypeA: "0x2::sui::SUI",
+ *   coinTypeB: "0x5d4b...::coin::COIN",
+ *   tick_spacing: 60,
+ *   initialize_sqrt_price: "79228162514264337593543950336", // 1:1 price
+ *   uri: "https://example.com/pool-metadata.json",
+ *   amount_a: 1000000000, // 1 SUI
+ *   amount_b: 1000000,    // 1 COIN
+ *   fix_amount_a: true,
+ *   tick_lower: -120,
+ *   tick_upper: 120,
+ *   slippage: 0.05
+ * });
+ */
+declare class PoolModule implements IModule {
+    protected _sdk: FerraDammSDK;
+    private readonly _cache;
+    constructor(sdk: FerraDammSDK);
+    get sdk(): FerraDammSDK;
+    /**
+     * Retrieves available base fee tiers and their parameters
+     * Returns all supported fee configurations including dynamic fee settings
+     * @returns Array of fee tier configurations with tick spacing and fee parameters
+     * @throws {DammpoolsError} If config fetch fails
+     * @example
+     * const feeTiers = await sdk.Pool.getBaseFeesAvailable();
+     * feeTiers.forEach(tier => {
+     *   console.log(`Tick spacing: ${tier.tick_spacing}`);
+     *   console.log(`Fee rate: ${tier.fee_rate / 10000000}%`);
+     *   console.log(`Dynamic fee enabled: ${tier.dynamic_fee !== null}`);
+     * });
+     */
+    getBaseFeesAvailable(): Promise<FeeTier[]>;
+    /**
+     * Gets all positions for a specific pool
+     * Fetches position data from the pool's position manager
+     * @param positionHandle - Position manager handle ID from pool object
+     * @param paginationArgs - Pagination configuration or 'all' to fetch everything
+     * @returns Paginated list of positions
+     * @throws {DammpoolsError} If position handle is invalid
+     * @example
+     * const pool = await sdk.Pool.getPool(poolId);
+     * const positions = await sdk.Pool.getPositionList(
+     *   pool.positionManager.positionsHandle,
+     *   { cursor: null, limit: 50 }
+     * );
+     * console.log(`Found ${positions.data.length} positions`);
+     */
+    getPositionList(positionHandle: string, paginationArgs?: PaginationArgs): Promise<DataPage<Position>>;
+    /**
+     * Fetches pool immutable data (type, addresses, spacing) for multiple pools
+     * Immutables don't change after pool creation - safe to cache long-term
+     * @param assignPoolIDs - Specific pool IDs to fetch (empty = all pools)
+     * @param offset - Starting index for pagination
+     * @param limit - Maximum number of pools to return
+     * @param forceRefresh - Bypass cache and fetch fresh data
+     * @returns Array of pool immutable data
+     * @example
+     * // Get all pools
+     * const allPools = await sdk.Pool.getPoolImmutables();
+     *
+     * // Get specific pools
+     * const specificPools = await sdk.Pool.getPoolImmutables([
+     *   '0x_pool1',
+     *   '0x_pool2'
+     * ]);
+     *
+     * specificPools.forEach(pool => {
+     *   console.log(`${pool.name}: ${pool.coin_type_a} / ${pool.coin_type_b}`);
+     * });
+     */
+    getPoolImmutables(assignPoolIDs?: string[], offset?: number, limit?: number, forceRefresh?: boolean): Promise<PoolImmutables[]>;
+    /**
+     * Fetches complete pool state including current liquidity, price, and fees
+     * This is the main method for getting up-to-date pool data
+     * @param assignPools - Specific pool IDs to fetch (empty = all pools)
+     * @param offset - Starting index for pagination
+     * @param limit - Maximum number of pools to return
+     * @returns Array of complete pool objects
+     * @example
+     * const pools = await sdk.Pool.getPools(['0x_pool_id']);
+     * const pool = pools[0];
+     *
+     * console.log(`Current sqrt price: ${pool.currentSqrtPrice}`);
+     * console.log(`Current tick: ${pool.currentTickIndex}`);
+     * console.log(`Total liquidity: ${pool.liquidity}`);
+     * console.log(`Coin A amount: ${pool.coinAmountA}`);
+     * console.log(`Coin B amount: ${pool.coinAmountB}`);
+     * console.log(`Fee rate: ${pool.feeRate / 10000000}%`);
+     */
+    getPools(assignPools?: string[], offset?: number, limit?: number): Promise<Pool[]>;
+    /**
+     * Retrieves pool immutable data with advanced pagination support
+     * @param paginationArgs - Pagination parameters ('all' or specific cursor/limit)
+     * @param forceRefresh - Force cache refresh if true
+     * @returns Paginated pool immutable data with navigation metadata
+     */
+    getPoolImmutablesWithPage(paginationArgs?: PaginationArgs, forceRefresh?: boolean): Promise<DataPage<PoolImmutables>>;
+    /**
+     * Retrieves complete pool data with advanced pagination support
+     * @param assignPools - Specific pool IDs to retrieve (empty array for all pools)
+     * @param paginationArgs - Pagination parameters ('all' or specific cursor/limit)
+     * @param forceRefresh - Force cache refresh if true
+     * @returns Array of complete pool objects with current state
+     */
+    getPoolsWithPage(assignPools?: string[], paginationArgs?: PaginationArgs, forceRefresh?: boolean): Promise<Pool[]>;
+    /**
+     * Gets a single pool's complete state by ID
+     * Preferred method for fetching individual pool data - includes caching
+     * @param poolID - Pool object ID (0x-prefixed address)
+     * @param forceRefresh - Skip cache and fetch fresh data (default: true)
+     * @returns Complete pool object with current state
+     * @throws {DammpoolsError} If pool doesn't exist or fetch fails (PoolErrorCode.InvalidPoolObject)
+     * @example
+     * const pool = await sdk.Pool.getPool('0x_pool_address');
+     *
+     * // Check if pool is paused
+     * if (pool.isPause) {
+     *   console.log('Pool is currently paused');
+     * }
+     *
+     * // Calculate current price from sqrt price
+     * const sqrtPrice = new BN(pool.currentSqrtPrice);
+     * const price = TickMath.sqrtPriceX64ToPrice(sqrtPrice, 9, 6);
+     * console.log(`Current price: ${price.toString()} COIN per SUI`);
+     */
+    getPool(poolID: string, forceRefresh?: boolean): Promise<Pool>;
+    /**
+     * Creates a transaction to instantiate a new pool with initial liquidity
+     * Automatically sorts coins and validates parameters
+     * @param params - Pool creation parameters including coins, fee tier, and initial position
+     * @returns Transaction ready for signing and execution
+     * @throws {DammpoolsError} If coin types are invalid or amounts insufficient
+     * @example
+     * const tx = await sdk.Pool.createPoolTransactionPayload({
+     *   coinTypeA: "0x2::sui::SUI",
+     *   coinTypeB: "0x5d4b...::coin::COIN",
+     *   tick_spacing: 60,  // Standard 0.3% fee tier
+     *   initialize_sqrt_price: "79228162514264337593543950336", // 1:1 price
+     *   uri: "https://ferra.xyz/pool-metadata.json",
+     *   amount_a: 10_000_000_000, // 10 SUI
+     *   amount_b: 10_000_000,     // 10 COIN
+     *   fix_amount_a: true,
+     *   tick_lower: -600,  // Wide range
+     *   tick_upper: 600,
+     *   slippage: 0.05
+     * });
+     *
+     * const result = await sdk.fullClient.signAndExecuteTransaction({
+     *   transaction: tx,
+     *   signer: keypair
+     * });
+     *
+     * // Extract pool ID from events
+     * const poolCreatedEvent = result.events?.find(
+     *   e => e.type.includes('::PoolCreatedEvent')
+     * );
+     * const poolId = poolCreatedEvent?.parsedJson?.pool_id;
+     */
+    creatPoolTransactionPayload(params: CreatePoolAddLiquidityParams): Promise<Transaction>;
+    /**
+     * Creates a pool with initial liquidity position
+     * Automatically sorts coin types according to protocol requirements
+     * @param params - Pool creation and liquidity parameters
+     * @returns Transaction object for pool creation and liquidity addition
+     */
+    createPoolTransactionPayload(params: CreatePoolAddLiquidityParams): Promise<Transaction>;
+    /**
+     * Gets DAMM global configuration including registry IDs and settings
+     * Configuration is cached for performance
+     * @param forceRefresh - Bypass cache and fetch fresh config
+     * @returns Global DAMM configuration object
+     * @example
+     * const config = await sdk.Pool.getDammConfigs();
+     * console.log(`Global config ID: ${config.global_config_id}`);
+     * console.log(`Pools registry: ${config.pools_id}`);
+     * console.log(`Rewarder vault: ${config.global_rewarder_vault_id}`);
+     */
+    getDammConfigs(forceRefresh?: boolean): Promise<DammConfig>;
+    /**
+     * Retrieves full transaction details including events and effects
+     * Used for analyzing pool-related transactions
+     * @param digest - Transaction digest to query
+     * @param forceRefresh - Force cache refresh if true
+     * @returns Complete transaction block response or null
+     */
+    getSuiTransactionResponse(digest: string, forceRefresh?: boolean): Promise<SuiTransactionBlockResponse | null>;
+    /**
+     * Gets transaction history for a specific pool
+     * Returns swaps, adds/removes liquidity, fee collections
+     * @param pool_id - Pool object ID
+     * @param limit - Maximum transactions to return (default: 100)
+     * @param offset - Starting offset for pagination
+     * @returns Array of pool transaction info
+     * @example
+     * const txList = await sdk.Pool.getPoolTransactionList({
+     *   pool_id: poolId,
+     *   limit: 50,
+     *   offset: 0
+     * });
+     *
+     * txList.forEach(tx => {
+     *   const type = tx.type.split('::').pop();
+     *   console.log(`${type}: ${tx.tx}`);
+     * });
+     */
+    getPoolTransactionList({ poolId, paginationArgs, order, fullRpcUrl, }: {
+        poolId: string;
+        fullRpcUrl?: string;
+        paginationArgs: PageQuery;
+        order?: 'ascending' | 'descending' | null | undefined;
+    }): Promise<DataPage<PoolTransactionInfo>>;
+    /**
+     * Internal method for creating pool with initial liquidity
+     * Uses integrate contract to handle pool creation and liquidity in single transaction
+     * @param params - Pool creation and liquidity parameters
+     * @returns Transaction object
+     */
+    private createPoolAndAddLiquidity;
+    /**
+     * Fetches all initialized ticks for a pool from on-chain events
+     * More comprehensive but slower than fetchTicksByRpc
+     * Use this when you need complete tick history including deleted ticks
+     * @param params - Fetch parameters with pool ID
+     * @returns Array of all tick data from pool history
+     * @example
+     * const ticks = await sdk.Pool.fetchTicks({ pool_id: poolId });
+     * console.log(`Total ticks: ${ticks.length}`);
+     *
+     * // Find ticks in specific range
+     * const ticksInRange = ticks.filter(
+     *   t => t.index >= -120 && t.index <= 120
+     * );
+     */
+    fetchTicks(params: FetchParams): Promise<TickData[]>;
+    /**
+     * Internal method to fetch tick data using simulated transaction
+     * Uses devInspectTransactionBlock for gas-free tick data retrieval
+     * @param params - Tick fetch parameters including start indices and limit
+     * @returns Array of tick data
+     */
+    private getTicks;
+    /**
+     * Fetches position rewards from events for multiple positions
+     * Useful for displaying historical reward claims
+     * @param params - Fetch parameters with pool ID
+     * @returns Array of position reward data
+     * @example
+     * const rewards = await sdk.Pool.fetchPositionRewardList({
+     *   pool_id: poolId
+     * });
+     *
+     * rewards.forEach(reward => {
+     *   console.log(`Position: ${reward.pos_object_id}`);
+     *   console.log(`Reward 0: ${reward.reward_amount_owed_0}`);
+     *   console.log(`Reward 1: ${reward.reward_amount_owed_1}`);
+     *   console.log(`Reward 2: ${reward.reward_amount_owed_2}`);
+     * });
+     */
+    fetchPositionRewardList(params: FetchParams): Promise<PositionReward[]>;
+    /**
+     * Fetches current tick state directly from pool's tick manager (RPC)
+     * Faster than event-based fetch, returns only currently active ticks
+     * Recommended for most use cases
+     * @param tickHandle - Tick manager handle ID from pool object
+     * @returns Array of currently active tick data
+     * @example
+     * const pool = await sdk.Pool.getPool(poolId);
+     * const ticks = await sdk.Pool.fetchTicksByRpc(pool.ticksHandle);
+     *
+     * // Sort ticks by index for swap simulation
+     * ticks.sort((a, b) => a.index - b.index);
+     *
+     * // Find nearest tick below current
+     * const nearestBelow = ticks
+     *   .filter(t => t.index < pool.currentTickIndex)
+     *   .sort((a, b) => b.index - a.index)[0];
+     */
+    fetchTicksByRpc(tickHandle: string): Promise<TickData[]>;
+    /**
+     * Internal method to fetch tick objects by their IDs
+     * @param tickObjectId - Array of tick object IDs
+     * @returns Array of tick data
+     */
+    private getTicksByRpc;
+    /**
+     * Gets tick data for a specific tick index
+     * Returns null if tick is not initialized
+     * @param tickHandle - Tick manager handle ID
+     * @param tickIndex - Specific tick index to fetch
+     * @returns Tick data or throws if tick doesn't exist
+     * @throws {DammpoolsError} If tick is not initialized
+     * @example
+     * const pool = await sdk.Pool.getPool(poolId);
+     *
+     * try {
+     *   const tick = await sdk.Pool.getTickDataByIndex(
+     *     pool.ticksHandle,
+     *     -120
+     *   );
+     *   console.log(`Liquidity at tick -120: ${tick.liquidityGross.toString()}`);
+     * } catch (error) {
+     *   console.log('Tick -120 is not initialized');
+     * }
+     */
+    getTickDataByIndex(tickHandle: string, tickIndex: number): Promise<TickData>;
+    /**
+     * Retrieves tick data by its object ID
+     * Direct object fetch for known tick IDs
+     * @param tickId - Tick object ID
+     * @returns Tick data or null if not found
+     */
+    getTickDataByObjectId(tickId: string): Promise<TickData | null>;
+    /**
+     * Retrieves referral fee balances for a partner
+     * @param partner - Partner object ID
+     * @param showDisplay - Include display metadata
+     * @returns Array of coin assets with balances
+     */
+    getPartnerRefFeeAmount(partner: string, showDisplay?: boolean): Promise<CoinAsset[]>;
+    /**
+     * Claims partner referral fees accumulated for a partner
+     * Requires partner capability NFT
+     * @param partnerCap - Partner capability object ID
+     * @param partner - Partner address
+     * @param coinType - Type of coin to claim fees in
+     * @returns Transaction for claiming partner fees
+     * @throws {DammpoolsError} If partner not found or invalid (PartnerErrorCode.NotFoundPartnerObject)
+     * @example
+     * const tx = await sdk.Pool.claimPartnerRefFeePayload(
+     *   '0x_partner_cap_id',
+     *   '0x_partner_address',
+     *   '0x2::sui::SUI'
+     * );
+     *
+     * const result = await sdk.fullClient.signAndExecuteTransaction({
+     *   transaction: tx,
+     *   signer: partnerKeypair
+     * });
+     */
+    claimPartnerRefFeePayload(partnerCap: string, partner: string, coinType: string): Promise<Transaction>;
+    /**
+     * Updates cached data with expiration time
+     * @param key - Cache key
+     * @param data - Data to cache
+     * @param time - Cache duration in minutes (default: 5)
+     */
+    updateCache(key: string, data: SuiResource, time?: number): void;
+    /**
+     * Retrieves cached data if valid
+     * @param key - Cache key
+     * @param forceRefresh - Bypass cache if true
+     * @returns Cached data or undefined if expired/not found
+     */
+    getCache<T>(key: string, forceRefresh?: boolean): T | undefined;
+}
+
+declare function estPoolAPR(preBlockReward: BN, rewardPrice: BN, totalTradingFee: BN, totalLiquidityValue: BN): BN;
+type estPosAPRResult = {
+    feeAPR: Decimal;
+    posRewarder0APR: Decimal;
+    posRewarder1APR: Decimal;
+    posRewarder2APR: Decimal;
+};
+declare function estPositionAPRWithDeltaMethod(currentTickIndex: number, lowerTickIndex: number, upperTickIndex: number, currentSqrtPriceX64: BN, poolLiquidity: BN, decimalsA: number, decimalsB: number, decimalsRewarder0: number, decimalsRewarder1: number, decimalsRewarder2: number, feeRate: number, amountAStr: string, amountBStr: string, poolAmountA: BN, poolAmountB: BN, swapVolumeStr: string, poolRewarders0Str: string, poolRewarders1Str: string, poolRewarders2Str: string, coinAPriceStr: string, coinBPriceStr: string, rewarder0PriceStr: string, rewarder1PriceStr: string, rewarder2PriceStr: string): estPosAPRResult;
+declare function estPositionAPRWithMultiMethod(lowerUserPrice: number, upperUserPrice: number, lowerHistPrice: number, upperHistPrice: number): Decimal;
+
+type SwapStepResult = {
+    amountIn: BN;
+    amountOut: BN;
+    nextSqrtPrice: BN;
+    feeAmount: BN;
+};
+type SwapResult = {
+    amountIn: BN;
+    amountOut: BN;
+    feeAmount: BN;
+    startSqrtPrice: BN;
+    nextSqrtPrice: BN;
+    isExceed: boolean;
+    stepResults: Array<{
+        currentSqrtPrice: BN;
+        targetSqrtPrice: BN;
+        currentLiquidity: BN;
+        amountIn: BN;
+        amountOut: BN;
+        feeAmount: BN;
+        remainderAmount: BN;
+    }>;
+};
+type CoinAmounts = {
+    coinA: BN;
+    coinB: BN;
+};
+declare function toCoinAmount(a: number, b: number): CoinAmounts;
+/**
+ * Get the amount A delta about two prices, for give amount of liquidity.
+ * `delta_a = (liquidity * delta_sqrt_price) / sqrt_price_upper * sqrt_price_lower)`
+ *
+ * @param sqrtPrice0 - A sqrt price
+ * @param sqrtPrice1 - Another sqrt price
+ * @param liquidity - The amount of usable liquidity
+ * @param roundUp - Whether to round the amount up or down
+ * @returns
+ */
+declare function getDeltaA(sqrtPrice0: BN, sqrtPrice1: BN, liquidity: BN, roundUp: boolean): BN;
+/**
+ * Get the amount B delta about two prices, for give amount of liquidity.
+ * `delta_a = (liquidity * delta_sqrt_price) / sqrt_price_upper * sqrt_price_lower)`
+ *
+ * @param sqrtPrice0 - A sqrt price
+ * @param sqrtPrice1 - Another sqrt price
+ * @param liquidity - The amount of usable liquidity
+ * @param roundUp - Whether to round the amount up or down
+ * @returns
+ */
+declare function getDeltaB(sqrtPrice0: BN, sqrtPrice1: BN, liquidity: BN, roundUp: boolean): BN;
+/**
+ * Get the next sqrt price from give a delta of token_a.
+ * `new_sqrt_price = (sqrt_price * liquidity) / (liquidity +/- amount * sqrt_price)`
+ *
+ * @param sqrtPrice - The start sqrt price
+ * @param liquidity - The amount of usable liquidity
+ * @param amount - The amount of token_a
+ * @param byAmountIn - Weather to fixed input
+ */
+declare function getNextSqrtPriceAUp(sqrtPrice: BN, liquidity: BN, amount: BN, byAmountIn: boolean): BN;
+/**
+ * Get the next sqrt price from give a delta of token_b.
+ * `new_sqrt_price = (sqrt_price +(delta_b / liquidity)`
+ *
+ * @param sqrtPrice - The start sqrt price
+ * @param liquidity - The amount of usable liquidity
+ * @param amount - The amount of token_a
+ * @param byAmountIn - Weather to fixed input
+ */
+declare function getNextSqrtPriceBDown(sqrtPrice: BN, liquidity: BN, amount: BN, byAmountIn: boolean): BN;
+/**
+ * Get next sqrt price from input parameter.
+ *
+ * @param sqrtPrice
+ * @param liquidity
+ * @param amount
+ * @param aToB
+ * @returns
+ */
+declare function getNextSqrtPriceFromInput(sqrtPrice: BN, liquidity: BN, amount: BN, aToB: boolean): BN;
+/**
+ * Get the next sqrt price from output parameters.
+ *
+ * @param sqrtPrice
+ * @param liquidity
+ * @param amount
+ * @param a2b
+ * @returns
+ */
+declare function getNextSqrtPriceFromOutput(sqrtPrice: BN, liquidity: BN, amount: BN, a2b: boolean): BN;
+/**
+ * Get the amount of delta_a or delta_b from input parameters, and round up result.
+ *
+ * @param currentSqrtPrice
+ * @param targetSqrtPrice
+ * @param liquidity
+ * @param a2b
+ * @returns
+ */
+declare function getDeltaUpFromInput(currentSqrtPrice: BN, targetSqrtPrice: BN, liquidity: BN, a2b: boolean): BN;
+/**
+ * Get the amount of delta_a or delta_b from output parameters, and round down result.
+ *
+ * @param currentSqrtPrice
+ * @param targetSqrtPrice
+ * @param liquidity
+ * @param a2b
+ * @returns
+ */
+declare function getDeltaDownFromOutput(currentSqrtPrice: BN, targetSqrtPrice: BN, liquidity: BN, a2b: boolean): BN;
+/**
+ * Simulate per step of swap on every tick.
+ *
+ * @param currentSqrtPrice
+ * @param targetSqrtPrice
+ * @param liquidity
+ * @param amount
+ * @param feeRate
+ * @param byAmountIn
+ * @returns
+ */
+declare function computeSwapStep(currentSqrtPrice: BN, targetSqrtPrice: BN, liquidity: BN, amount: BN, feeRate: BN, byAmountIn: boolean): SwapStepResult;
+/**
+ * Simulate swap by imput lots of ticks.
+ * @param aToB
+ * @param byAmountIn
+ * @param amount
+ * @param poolData
+ * @param swapTicks
+ * @returns
+ */
+declare function computeSwap(poolData: DammpoolData, a2b: boolean, byAmountIn: boolean, amount: BN, swapTicks: Array<TickData>): SwapResult;
+/**
+ * Estimate liquidity for coin A
+ * @param sqrtPriceX - coin A sqrtprice
+ * @param sqrtPriceY - coin B sqrtprice
+ * @param coinAmount - token amount
+ * @return
+ */
+declare function estimateLiquidityForCoinA(sqrtPriceX: BN, sqrtPriceY: BN, coinAmount: BN): BN;
+/**
+ * Estimate liquidity for coin B
+ * @param sqrtPriceX - coin A sqrtprice
+ * @param sqrtPriceY - coin B sqrtprice
+ * @param coinAmount - token amount
+ * @return
+ */
+declare function estimateLiquidityForCoinB(sqrtPriceX: BN, sqrtPriceY: BN, coinAmount: BN): BN;
+declare class DammPoolUtil {
+    /**
+     * Update fee rate.
+     * @param damm - dammpool data
+     * @param feeAmount - fee Amount
+     * @param refRate - ref rate
+     * @param protocolFeeRate - protocol fee rate
+     * @param iscoinA - is token A
+     * @returns percentage
+     */
+    static updateFeeRate(damm: DammpoolData, feeAmount: BN, refRate: number, protocolFeeRate: number, iscoinA: boolean): {
+        refFee: BN;
+        damm: DammpoolData;
+    };
+    /**
+     * Get token amount fron liquidity.
+     * @param liquidity - liquidity
+     * @param curSqrtPrice - Pool current sqrt price
+     * @param lowerSqrtPrice - position lower sqrt price
+     * @param upperSqrtPrice - position upper sqrt price
+     * @param roundUp - is round up
+     * @returns
+     */
+    static getCoinAmountFromLiquidity(liquidity: BN, curSqrtPrice: BN, lowerSqrtPrice: BN, upperSqrtPrice: BN, roundUp: boolean): CoinAmounts;
+    /**
+     * Estimate liquidity and token amount from one amounts
+     * @param lowerTick - lower tick
+     * @param upperTick - upper tick
+     * @param coinAmount - token amount
+     * @param iscoinA - is token A
+     * @param roundUp - is round up
+     * @param isIncrease - is increase
+     * @param slippage - slippage percentage
+     * @param curSqrtPrice - current sqrt price.
+     * @return IncreaseLiquidityInput
+     */
+    static estLiquidityAndcoinAmountFromOneAmounts(lowerTick: number, upperTick: number, coinAmount: BN, iscoinA: boolean, roundUp: boolean, slippage: number, curSqrtPrice: BN): LiquidityInput;
+    /**
+     * Estimate liquidity from token amounts
+     * @param curSqrtPrice - current sqrt price.
+     * @param lowerTick - lower tick
+     * @param upperTick - upper tick
+     * @param tokenAmount - token amount
+     * @return
+     */
+    static estimateLiquidityFromcoinAmounts(curSqrtPrice: BN, lowerTick: number, upperTick: number, tokenAmount: CoinAmounts): BN;
+    /**
+     * Estimate coin amounts from total amount
+     * @param lowerTick
+     * @param upperTick
+     * @param decimalsA
+     * @param decimalsB
+     * @param curSqrtPrice
+     * @param totalAmount
+     * @param tokenPriceA
+     * @param tokenPriceB
+     * @returns
+     */
+    static estCoinAmountsFromTotalAmount(lowerTick: number, upperTick: number, curSqrtPrice: BN, totalAmount: string, tokenPriceA: string, tokenPriceB: string): {
+        amountA: Decimal;
+        amountB: Decimal;
+    };
+    static calculateDepositRatioFixTokenA(lowerTick: number, upperTick: number, curSqrtPrice: BN): {
+        ratioA: Decimal;
+        ratioB: Decimal;
+    };
+}
+
+declare const DEFAULT_GAS_BUDGET_FOR_SPLIT = 1000;
+declare const DEFAULT_GAS_BUDGET_FOR_MERGE = 500;
+declare const DEFAULT_GAS_BUDGET_FOR_TRANSFER = 100;
+declare const DEFAULT_GAS_BUDGET_FOR_TRANSFER_SUI = 100;
+declare const DEFAULT_GAS_BUDGET_FOR_STAKE = 1000;
+declare const GAS_TYPE_ARG = "0x2::sui::SUI";
+declare const GAS_TYPE_ARG_LONG = "0x0000000000000000000000000000000000000000000000000000000000000002::sui::SUI";
+declare const GAS_SYMBOL = "SUI";
+declare const DEFAULT_NFT_TRANSFER_GAS_FEE = 450;
+declare const SUI_SYSTEM_STATE_OBJECT_ID = "0x0000000000000000000000000000000000000005";
+/**
+ * This class provides helper methods for working with coins.
+ */
+declare class CoinAssist {
+    /**
+     * Get the coin type argument from a SuiMoveObject.
+     *
+     * @param obj The SuiMoveObject to get the coin type argument from.
+     * @returns The coin type argument, or null if it is not found.
+     */
+    static getCoinTypeArg(obj: SuiMoveObject): string;
+    /**
+     * Get whether a SuiMoveObject is a SUI coin.
+     *
+     * @param obj The SuiMoveObject to check.
+     * @returns Whether the SuiMoveObject is a SUI coin.
+     */
+    static isSUI(obj: SuiMoveObject): boolean;
+    /**
+     * Get the coin symbol from a coin type argument.
+     *
+     * @param coinTypeArg The coin type argument to get the symbol from.
+     * @returns The coin symbol.
+     */
+    static getCoinSymbol(coinTypeArg: string): string;
+    /**
+     * Get the balance of a SuiMoveObject.
+     *
+     * @param obj The SuiMoveObject to get the balance from.
+     * @returns The balance of the SuiMoveObject.
+     */
+    static getBalance(obj: SuiMoveObject): bigint;
+    /**
+     * Get the total balance of a list of CoinAsset objects for a given coin address.
+     *
+     * @param objs The list of CoinAsset objects to get the total balance for.
+     * @param coinAddress The coin address to get the total balance for.
+     * @returns The total balance of the CoinAsset objects for the given coin address.
+     */
+    static totalBalance(objs: CoinAsset[], coinAddress: SuiAddressType): bigint;
+    /**
+     * Get the ID of a SuiMoveObject.
+     *
+     * @param obj The SuiMoveObject to get the ID from.
+     * @returns The ID of the SuiMoveObject.
+     */
+    static getID(obj: SuiMoveObject): string;
+    /**
+     * Get the coin type from a coin type argument.
+     *
+     * @param coinTypeArg The coin type argument to get the coin type from.
+     * @returns The coin type.
+     */
+    static getCoinTypeFromArg(coinTypeArg: string): string;
+    /**
+     * Get the FaucetCoin objects from a SuiTransactionBlockResponse.
+     *
+     * @param suiTransactionResponse The SuiTransactionBlockResponse to get the FaucetCoin objects from.
+     * @returns The FaucetCoin objects.
+     */
+    static getFaucetCoins(suiTransactionResponse: SuiTransactionBlockResponse): FaucetCoin[];
+    /**
+     * Get the CoinAsset objects for a given coin type.
+     *
+     * @param coinType The coin type to get the CoinAsset objects for.
+     * @param allSuiObjects The list of all SuiMoveObjects.
+     * @returns The CoinAsset objects for the given coin type.
+     */
+    static getCoinAssets(coinType: string, allSuiObjects: CoinAsset[]): CoinAsset[];
+    /**
+     * Get whether a coin address is a SUI coin.
+     *
+     * @param coinAddress The coin address to check.
+     * @returns Whether the coin address is a SUI coin.
+     */
+    static isSuiCoin(coinAddress: SuiAddressType): boolean;
+    /**
+     * Select the CoinAsset objects from a list of CoinAsset objects that have a balance greater than or equal to a given amount.
+     *
+     * @param coins The list of CoinAsset objects to select from.
+     * @param amount The amount to select CoinAsset objects with a balance greater than or equal to.
+     * @param exclude A list of CoinAsset objects to exclude from the selection.
+     * @returns The CoinAsset objects that have a balance greater than or equal to the given amount.
+     */
+    static selectCoinObjectIdGreaterThanOrEqual(coins: CoinAsset[], amount: bigint, exclude?: string[]): {
+        objectArray: string[];
+        remainCoins: CoinAsset[];
+        amountArray: string[];
+    };
+    /**
+     * Select the CoinAsset objects from a list of CoinAsset objects that have a balance greater than or equal to a given amount.
+     *
+     * @param coins The list of CoinAsset objects to select from.
+     * @param amount The amount to select CoinAsset objects with a balance greater than or equal to.
+     * @param exclude A list of CoinAsset objects to exclude from the selection.
+     * @returns The CoinAsset objects that have a balance greater than or equal to the given amount.
+     */
+    static selectCoinAssetGreaterThanOrEqual(coins: CoinAsset[], amount: bigint, exclude?: string[]): {
+        selectedCoins: CoinAsset[];
+        remainingCoins: CoinAsset[];
+    };
+    /**
+     * Sort the CoinAsset objects by their balance.
+     *
+     * @param coins The CoinAsset objects to sort.
+     * @returns The sorted CoinAsset objects.
+     */
+    static sortByBalance(coins: CoinAsset[]): CoinAsset[];
+    static sortByBalanceDes(coins: CoinAsset[]): CoinAsset[];
+    /**
+     * Calculate the total balance of a list of CoinAsset objects.
+     *
+     * @param coins The list of CoinAsset objects to calculate the total balance for.
+     * @returns The total balance of the CoinAsset objects.
+     */
+    static calculateTotalBalance(coins: CoinAsset[]): bigint;
+}
+
+/**
+ * @category CollectFeesQuoteParam
+ */
+type CollectFeesQuoteParam = {
+    dammpool: Pool;
+    position: Position;
+    tickLower: TickData;
+    tickUpper: TickData;
+};
+/**
+ * @category CollectFeesQuote
+ */
+type CollectFeesQuote = {
+    position_id: string;
+    feeOwedA: BN;
+    feeOwedB: BN;
+};
+/**
+ * Get a fee quote on the outstanding fees owed to a position.
+ *
+ * @category CollectFeesQuoteParam
+ * @param param A collection of fetched Dammpool accounts to faciliate the quote.
+ * @returns A quote object containing the fees owed for each token in the pool.
+ */
+declare function collectFeesQuote(param: CollectFeesQuoteParam): CollectFeesQuote;
+
+/**
+ * Percentage - the util set for percentage struct.
+ */
+declare class Percentage {
+    readonly numerator: BN;
+    readonly denominator: BN;
+    constructor(numerator: BN, denominator: BN);
+    /**
+     * Get the percentage of a number.
+     *
+     * @param number
+     * @returns
+     */
+    static fromDecimal(number: Decimal$1): Percentage;
+    /**
+     * Get the percentage of a fraction.
+     *
+     * @param numerator
+     * @param denominator
+     * @returns
+     */
+    static fromFraction(numerator: BN | number, denominator: BN | number): Percentage;
+}
+
+declare enum AmountSpecified {
+    Input = "Specified input amount",
+    Output = "Specified output amount"
+}
+declare enum PositionStatus {
+    BelowRange = 0,
+    InRange = 1,
+    AboveRange = 2
+}
+/**
+ * This class provides utility methods for working with positions.
+ */
+declare class PositionUtil {
+    /**
+     * Get the position status for the given tick indices.
+     *
+     * @param currentTickIndex The current tick index.
+     * @param lowerTickIndex The lower tick index.
+     * @param upperTickIndex The upper tick index.
+     * @returns The position status.
+     */
+    static getPositionStatus(currentTickIndex: number, lowerTickIndex: number, upperTickIndex: number): PositionStatus;
+}
+/**
+ * Get token A from liquidity.
+ * @param liquidity - liquidity.
+ * @param sqrtPrice0X64 - Current sqrt price of coin 0.
+ * @param sqrtPrice1X64 - Current sqrt price of coin 1.
+ * @param roundUp - If round up.
+ *
+ * @returns
+ */
+declare function getCoinAFromLiquidity(liquidity: BN, sqrtPrice0X64: BN, sqrtPrice1X64: BN, roundUp: boolean): BN;
+/**
+ * Get token B from liquidity.
+ * @param liquidity - liqudity.
+ * @param sqrtPrice0X64 - Current sqrt price of token 0.
+ * @param sqrtPrice1X64 - Current sqrt price of token 1.
+ * @param roundUp - If round up.
+ *
+ * @returns
+ */
+declare function getCoinBFromLiquidity(liquidity: BN, sqrtPrice0X64: BN, sqrtPrice1X64: BN, roundUp: boolean): BN;
+/**
+ * Get liquidity from token A.
+ *
+ * @param amount - The amount of token A.
+ * @param sqrtPriceLowerX64 - The lower sqrt price.
+ * @param sqrtPriceUpperX64 - The upper sqrt price.
+ * @param roundUp - If round up.
+ * @returns liquidity.
+ */
+declare function getLiquidityFromCoinA(amount: BN, sqrtPriceLowerX64: BN, sqrtPriceUpperX64: BN, roundUp: boolean): BN;
+/**
+ * Get liquidity from token B.
+ * @param amount - The amount of token B.
+ * @param sqrtPriceLowerX64 - The lower sqrt price.
+ * @param sqrtPriceUpperX64 - The upper sqrt price.
+ * @param roundUp - If round up.
+ *
+ * @returns liquidity.
+ */
+declare function getLiquidityFromCoinB(amount: BN, sqrtPriceLowerX64: BN, sqrtPriceUpperX64: BN, roundUp: boolean): BN;
+/**
+ * Get amount of fixed delta.
+ * @param currentSqrtPriceX64 - Current sqrt price.
+ * @param targetSqrtPriceX64 - Target sqrt price.
+ * @param liquidity - liqudity.
+ * @param amountSpecified - The amount specified in the swap.
+ * @param swapDirection - The swap direction.
+ *
+ * @returns
+ */
+declare function getAmountFixedDelta(currentSqrtPriceX64: BN, targetSqrtPriceX64: BN, liquidity: BN, amountSpecified: AmountSpecified, swapDirection: SwapDirection): BN;
+/**
+ * Get amount of unfixed delta.
+ * @param currentSqrtPriceX64 - Current sqrt price.
+ * @param targetSqrtPriceX64 - Target sqrt price.
+ * @param liquidity - liqudity.
+ * @param amountSpecified - The amount specified in the swap.
+ * @param swapDirection - The swap direction.
+ *
+ * @returns
+ */
+declare function getAmountUnfixedDelta(currentSqrtPriceX64: BN, targetSqrtPriceX64: BN, liquidity: BN, amountSpecified: AmountSpecified, swapDirection: SwapDirection): BN;
+declare function adjustForSlippage(n: BN, { numerator, denominator }: Percentage, adjustUp: boolean): BN;
+declare function adjustForCoinSlippage(tokenAmount: CoinAmounts, slippage: Percentage, adjustUp: boolean): {
+    tokenMaxA: BN;
+    tokenMaxB: BN;
+};
+
+declare class SwapUtils {
+    /**
+     * Get the default sqrt price limit for a swap.
+     *
+     * @param a2b - true if the swap is A to B, false if the swap is B to A.
+     * @returns The default sqrt price limit for the swap.
+     */
+    static getDefaultSqrtPriceLimit(a2b: boolean): BN;
+    /**
+     * Get the default values for the otherAmountThreshold in a swap.
+     *
+     * @param amountSpecifiedIsInput - The direction of a swap
+     * @returns The default values for the otherAmountThreshold parameter in a swap.
+     */
+    static getDefaultOtherAmountThreshold(amountSpecifiedIsInput: boolean): BN;
+}
+/**
+ * Get lower sqrt price from token A.
+ *
+ * @param amount - The amount of tokens the user wanted to swap from.
+ * @param liquidity - The liquidity of the pool.
+ * @param sqrtPriceX64 - The sqrt price of the pool.
+ * @returns LowesqrtPriceX64
+ */
+declare function getLowerSqrtPriceFromCoinA(amount: BN, liquidity: BN, sqrtPriceX64: BN): BN;
+/**
+ * Get upper sqrt price from token A.
+ *
+ * @param amount - The amount of tokens the user wanted to swap from.
+ * @param liquidity - The liquidity of the pool.
+ * @param sqrtPriceX64 - The sqrt price of the pool.
+ * @returns LowesqrtPriceX64
+ */
+declare function getUpperSqrtPriceFromCoinA(amount: BN, liquidity: BN, sqrtPriceX64: BN): BN;
+/**
+ * Get lower sqrt price from coin B.
+ *
+ * @param amount - The amount of coins the user wanted to swap from.
+ * @param liquidity - The liquidity of the pool.
+ * @param sqrtPriceX64 - The sqrt price of the pool.
+ * @returns LowesqrtPriceX64
+ */
+declare function getLowerSqrtPriceFromCoinB(amount: BN, liquidity: BN, sqrtPriceX64: BN): BN;
+/**
+ * Get upper sqrt price from coin B.
+ *
+ * @param amount - The amount of coins the user wanted to swap from.
+ * @param liquidity - The liquidity of the pool.
+ * @param sqrtPriceX64 - The sqrt price of the pool.
+ * @returns LowesqrtPriceX64
+ */
+declare function getUpperSqrtPriceFromCoinB(amount: BN, liquidity: BN, sqrtPriceX64: BN): BN;
+
+declare class TickMath {
+    static priceToSqrtPriceX64(price: Decimal, decimalsA: number, decimalsB: number): BN;
+    static sqrtPriceX64ToPrice(sqrtPriceX64: BN, decimalsA: number, decimalsB: number): Decimal;
+    static tickIndexToSqrtPriceX64(tickIndex: number): BN;
+    static sqrtPriceX64ToTickIndex(sqrtPriceX64: BN): number;
+    static tickIndexToPrice(tickIndex: number, decimalsA: number, decimalsB: number): Decimal;
+    static priceToTickIndex(price: Decimal, decimalsA: number, decimalsB: number): number;
+    static priceToInitializableTickIndex(price: Decimal, decimalsA: number, decimalsB: number, tickSpacing: number): number;
+    static getInitializableTickIndex(tickIndex: number, tickSpacing: number): number;
+    /**
+     *
+     * @param tickIndex
+     * @param tickSpacing
+     * @returns
+     */
+    static getNextInitializableTickIndex(tickIndex: number, tickSpacing: number): number;
+    static getPrevInitializableTickIndex(tickIndex: number, tickSpacing: number): number;
+}
+declare function getTickDataFromUrlData(ticks: any): any[];
+declare function tickScore(tickIndex: number): Decimal;
+
+declare const ZERO: BN;
+declare const ONE: BN;
+declare const TWO: BN;
+declare const U128: BN;
+declare const U64_MAX: BN;
+declare const U128_MAX: BN;
+/**
+ * @category MathUtil
+ */
+declare class MathUtil {
+    static toX64_BN(num: BN): BN;
+    static toX64_Decimal(num: Decimal): Decimal;
+    static toX64(num: Decimal): BN;
+    static fromX64(num: BN): Decimal;
+    static fromX64_Decimal(num: Decimal): Decimal;
+    static fromX64_BN(num: BN): BN;
+    static shiftRightRoundUp(n: BN): BN;
+    static divRoundUp(n0: BN, n1: BN): BN;
+    static subUnderflowU128(n0: BN, n1: BN): BN;
+    static checkUnsignedSub(n0: BN, n1: BN): BN;
+    static checkMul(n0: BN, n1: BN, limit: number): BN;
+    static checkMulDivFloor(n0: BN, n1: BN, denom: BN, limit: number): BN;
+    static checkMulDivCeil(n0: BN, n1: BN, denom: BN, limit: number): BN;
+    static checkMulDivRound(n0: BN, n1: BN, denom: BN, limit: number): BN;
+    static checkMulShiftRight(n0: BN, n1: BN, shift: number, limit: number): BN;
+    static checkMulShiftRight64RoundUpIf(n0: BN, n1: BN, limit: number, roundUp: boolean): BN;
+    static checkMulShiftLeft(n0: BN, n1: BN, shift: number, limit: number): BN;
+    static checkDivRoundUpIf(n0: BN, n1: BN, roundUp: boolean): BN;
+    static isOverflow(n: BN, bit: number): boolean;
+    static sign(v: BN): number;
+    static is_neg(v: BN): boolean;
+    static abs_u128(v: BN): BN;
+    static u128_neg(v: BN): BN;
+    static neg(v: BN): BN;
+    static abs(v: BN): BN;
+    static neg_from(v: BN): BN;
+}
+
+declare enum SplitUnit {
+    FIVE = 5,
+    TEN = 10,
+    TWENTY = 20,
+    TWENTY_FIVE = 25,
+    FIVETY = 50,
+    HUNDRED = 100
+}
+declare function createSplitArray(minSplitUnit: SplitUnit): number[];
+declare function createSplitAmountArray(amount: BN, minSplitUnit: SplitUnit): BN[];
+type SplitSwapResult = {
+    amountInArray: BN[];
+    amountOutArray: BN[];
+    feeAmountArray: BN[];
+    nextSqrtPriceArray: BN[];
+    isExceed: boolean[];
+};
+declare class SplitSwap {
+    readonly minSplitUnit: number;
+    amountArray: BN[];
+    private byAmountIn;
+    private a2b;
+    private dammpool;
+    private ticks;
+    private splitSwapResult;
+    constructor(amount: BN, unit: SplitUnit, dammpool: Pool, a2b: boolean, byAmountIn: boolean, tickData: TickData[]);
+    createSplitSwapParams(amount: BN, unit: SplitUnit): void;
+    computeSwap(): SplitSwapResult;
+}
+
+type FetchPosRewardParams = {
+    poolAddress: string;
+    positionId: string;
+    coinTypeA: string;
+    coinTypeB: string;
+    rewarderInfo: Rewarder[];
+};
+type FetchPosFeeParams = {
+    poolAddress: string;
+    positionId: string;
+    coinTypeA: string;
+    coinTypeB: string;
+};
+type PosRewarderResult = {
+    poolAddress: string;
+    positionId: string;
+    rewarderAmountOwed: RewarderAmountOwed[];
+};
+/**
+ * Rewarder module for managing pool incentive rewards
+ * Handles reward calculations, claiming, and emissions tracking
+ * Supports up to 3 simultaneous reward tokens per pool
+ *
+ * @example
+ * // Check daily emissions for a pool
+ * const emissions = await sdk.Rewarder.emissionsEveryDay(poolId);
+ * console.log(`Rewarder 0: ${emissions[0]} tokens/day`);
+ * console.log(`Rewarder 1: ${emissions[1]} tokens/day`);
+ * console.log(`Rewarder 2: ${emissions[2]} tokens/day`);
+ *
+ * @example
+ * // Fetch pending rewards for a position
+ * const pool = await sdk.Pool.getPool(poolId);
+ * const rewards = await sdk.Rewarder.fetchPositionRewarders(pool, positionId);
+ *
+ * rewards.forEach((reward, index) => {
+ *   const rewarderInfo = pool.rewarderInfos[index];
+ *   console.log(`Reward ${index} (${rewarderInfo.coinAddress}):`);
+ *   console.log(`  Owed: ${reward.amount_owed}`);
+ * });
+ *
+ * @example
+ * // Claim all rewards from a position
+ * const claimTx = await sdk.Rewarder.collectRewarderTransactionPayload({
+ *   pool_id: poolId,
+ *   pos_id: positionId,
+ *   rewarder_coin_types: [
+ *     pool.rewarderInfos[0].coinAddress,
+ *     pool.rewarderInfos[1].coinAddress,
+ *     pool.rewarderInfos[2].coinAddress
+ *   ],
+ *   coinTypeA: pool.coinTypeA,
+ *   coinTypeB: pool.coinTypeB
+ * });
+ */
+declare class RewarderModule implements IModule {
+    protected _sdk: FerraDammSDK;
+    private growthGlobal;
+    constructor(sdk: FerraDammSDK);
+    get sdk(): FerraDammSDK;
+    /**
+     * Calculates daily emission rates for all rewarders in a pool
+     * Emissions are continuous, this converts to daily amounts
+     * @param poolID - Pool object ID
+     * @returns Array of daily emission amounts [rewarder0, rewarder1, rewarder2]
+     * @example
+     * const emissions = await sdk.Rewarder.emissionsEveryDay(poolId);
+     * const pool = await sdk.Pool.getPool(poolId);
+     *
+     * pool.rewarderInfos.forEach((info, i) => {
+     *   const dailyEmission = emissions[i];
+     *   console.log(`${info.coinAddress}: ${dailyEmission} per day`);
+     * });
+     */
+    emissionsEveryDay(poolID: string): Promise<any[]>;
+    /**
+     * Updates pool rewarder growth globals based on time elapsed
+     * Internal method used for reward calculations
+     * @param poolID - The pool object ID
+     * @param currentTime - Current timestamp in milliseconds
+     * @returns Updated pool object with new rewarder state
+     */
+    private updatePoolRewarder;
+    /**
+     * Batch fetches pending rewards for multiple positions
+     * More efficient than calling fetchPositionRewarders multiple times
+     * @param positionIDs - Array of position NFT IDs
+     * @returns Map of position ID to array of reward amounts
+     * @example
+     * const rewardMap = await sdk.Rewarder.batchFetchPositionRewarders([
+     *   '0x_pos1',
+     *   '0x_pos2',
+     *   '0x_pos3'
+     * ]);
+     *
+     * for (const [posId, rewards] of Object.entries(rewardMap)) {
+     *   console.log(`Position ${posId}:`);
+     *   rewards.forEach((reward, i) => {
+     *     console.log(`  Reward ${i}: ${reward.amount_owed}`);
+     *   });
+     * }
+     */
+    batchFetchPositionRewarders(positionIDs: string[]): Promise<Record<string, RewarderAmountOwed[]>>;
+    /**
+     * Fetches pending reward amounts for a specific position
+     * Uses on-chain data for accurate calculations
+     * @param pool - Pool object containing rewarder info
+     * @param positionId - Position NFT ID
+     * @returns Array of reward amounts owed
+     * @example
+     * const pool = await sdk.Pool.getPool(poolId);
+     * const rewards = await sdk.Rewarder.fetchPositionRewarders(pool, positionId);
+     *
+     * // Display rewards with token info
+     * for (let i = 0; i < rewards.length; i++) {
+     *   const rewarder = pool.rewarderInfos[i];
+     *   const reward = rewards[i];
+     *   console.log(`Rewarder ${i}:`);
+     *   console.log(`  Token: ${rewarder.coinAddress}`);
+     *   console.log(`  Owed: ${reward.amount_owed}`);
+     *   console.log(`  Growth inside: ${reward.growth_inside}`);
+     * }
+     */
+    fetchPositionRewarders(pool: Pool, positionId: string): Promise<RewarderAmountOwed[]>;
+    /**
+     * Fetches both fees and rewards for multiple positions
+     * Convenience method that combines fee and reward queries
+     * @param positionIDs - Array of position NFT IDs
+     * @returns Map of position ID to fee quote
+     * @example
+     * const feeMap = await sdk.Rewarder.batchFetchPositionFees([
+     *   '0x_pos1',
+     *   '0x_pos2'
+     * ]);
+     *
+     * for (const [posId, fees] of Object.entries(feeMap)) {
+     *   console.log(`Position ${posId}:`);
+     *   console.log(`  Fee A: ${fees.feeOwedA.toString()}`);
+     *   console.log(`  Fee B: ${fees.feeOwedB.toString()}`);
+     * }
+     */
+    batchFetchPositionFees(positionIDs: string[]): Promise<Record<string, CollectFeesQuote>>;
+    /**
+     * Fetches pending fee amounts for multiple positions
+     * Uses on-chain simulation for accurate results
+     * @param params - Array of position and pool parameters
+     * @returns Array of fee quotes
+     * @example
+     * const fees = await sdk.Rewarder.fetchPosFeeAmount([
+     *   {
+     *     pool_id: poolId1,
+     *     pos_id: posId1,
+     *     coinTypeA: "0x2::sui::SUI",
+     *     coinTypeB: "0x5d4b...::coin::COIN"
+     *   }
+     * ]);
+     *
+     * fees.forEach(fee => {
+     *   console.log(`Fees for ${fee.position_id}:`);
+     *   console.log(`  A: ${fee.feeOwedA.toString()}`);
+     *   console.log(`  B: ${fee.feeOwedB.toString()}`);
+     * });
+     */
+    fetchPosFeeAmount(params: FetchPosFeeParams[]): Promise<CollectFeesQuote[]>;
+    /**
+     * Fetches pending reward amounts for multiple positions
+     * Uses on-chain simulation for accurate calculations
+     * @param params - Array of position and pool parameters
+     * @returns Array of reward amount quotes
+     * @example
+     * const pool = await sdk.Pool.getPool(poolId);
+     *
+     * const rewards = await sdk.Rewarder.fetchPosRewardersAmount([
+     *   {
+     *     pool_id: poolId,
+     *     pos_id: posId1,
+     *     coinTypeA: pool.coinTypeA,
+     *     coinTypeB: pool.coinTypeB,
+     *     rewarder_coin_types: pool.rewarderInfos.map(r => r.coinAddress)
+     *   }
+     * ]);
+     *
+     * rewards.forEach(reward => {
+     *   console.log(`Position: ${reward.pos_object_id}`);
+     *   console.log(`Rewards: ${reward.rewarder_amounts}`);
+     * });
+     */
+    fetchPosRewardersAmount(params: FetchPosRewardParams[]): Promise<PosRewarderResult[]>;
+    /**
+     * Fetches total accumulated rewards for an account in a specific pool
+     * Aggregates rewards across all positions in the pool
+     * @param account - Wallet address
+     * @param poolObjectId - Pool object ID
+     * @returns Total reward amounts by token
+     * @example
+     * const poolRewards = await sdk.Rewarder.fetchPoolRewardersAmount(
+     *   walletAddress,
+     *   poolId
+     * );
+     *
+     * console.log('Total pool rewards for account:');
+     * poolRewards.forEach((amount, index) => {
+     *   console.log(`  Rewarder ${index}: ${amount}`);
+     * });
+     */
+    fetchPoolRewardersAmount(account: string, poolObjectId: string): Promise<BN[]>;
+    /**
+     * Fetches tick data for all positions' upper and lower bounds
+     * @param ticksHandle - Pool's tick collection handle
+     * @param positions - Array of positions
+     * @returns Array containing lower and upper tick data arrays
+     */
+    private getPoolLowerAndUpperTicks;
+    /**
+     * Creates a transaction to collect rewards from a position
+     * Can optionally collect fees at the same time
+     * @param params - Parameters including reward coin types
+     * @param tx - Optional transaction to extend
+     * @returns Transaction for collecting rewards
+     * @example
+     * const pool = await sdk.Pool.getPool(poolId);
+     *
+     * const claimTx = await sdk.Rewarder.collectRewarderTransactionPayload({
+     *   pool_id: poolId,
+     *   pos_id: positionId,
+     *   rewarder_coin_types: pool.rewarderInfos.map(r => r.coinAddress),
+     *   coinTypeA: pool.coinTypeA,
+     *   coinTypeB: pool.coinTypeB,
+     *   collect_fee: true  // Also collect trading fees
+     * });
+     *
+     * const result = await sdk.fullClient.signAndExecuteTransaction({
+     *   transaction: claimTx,
+     *   signer: keypair
+     * });
+     */
+    collectRewarderTransactionPayload(params: CollectRewarderParams, tx?: Transaction): Promise<Transaction>;
+    /**
+     * Creates a transaction to batch collect rewards from multiple positions
+     * More gas efficient than individual collection transactions
+     * @param paramsList - Array of reward collection parameters
+     * @param allCoinAsset - Available coin assets for the wallet
+     * @returns Transaction for batch reward collection
+     * @example
+     * const pool = await sdk.Pool.getPool(poolId);
+     * const coinAssets = await sdk.getOwnerCoinAssets(walletAddress);
+     *
+     * const batchTx = await sdk.Rewarder.batchCollectRewardePayload(
+     *   [
+     *     {
+     *       pool_id: poolId,
+     *       pos_id: posId1,
+     *       rewarder_coin_types: pool.rewarderInfos.map(r => r.coinAddress),
+     *       coinTypeA: pool.coinTypeA,
+     *       coinTypeB: pool.coinTypeB,
+     *       collect_fee: true
+     *     },
+     *     {
+     *       pool_id: poolId,
+     *       pos_id: posId2,
+     *       rewarder_coin_types: pool.rewarderInfos.map(r => r.coinAddress),
+     *       coinTypeA: pool.coinTypeA,
+     *       coinTypeB: pool.coinTypeB,
+     *       collect_fee: true
+     *     }
+     *   ],
+     *   coinAssets
+     * );
+     */
+    batchCollectRewardePayload(params: CollectRewarderParams[], tx?: Transaction, inputCoinA?: TransactionObjectArgument, inputCoinB?: TransactionObjectArgument): Promise<Transaction>;
+    /**
+     * Creates collect reward move calls (internal method)
+     * @param params - Collection parameters
+     * @param tx - Transaction object
+     * @param primaryCoinInputs - Array of coin objects for each rewarder
+     * @returns Transaction object with collect reward calls
+     */
+    createCollectRewarderPaylod(params: CollectRewarderParams, tx: Transaction, primaryCoinInputs: TransactionArgument[]): Transaction;
+    /**
+     * Creates collect reward calls without sending coins to sender
+     * Used when coins need to be used in subsequent operations
+     * @param params - Collection parameters
+     * @param tx - Transaction object
+     * @param primaryCoinInputs - Array of coin objects for each rewarder
+     * @returns Transaction object with collect reward calls
+     */
+    createCollectRewarderNoSendPaylod(params: CollectRewarderParams, tx: Transaction, primaryCoinInputs: TransactionArgument[]): Transaction;
+}
+
+/**
+ * Position module for managing liquidity positions in DAMM pools
+ * Handles position creation, liquidity adjustments, fee collection, and rewards
+ * Positions are represented as NFTs that can be transferred or locked
+ *
+ * @example
+ * // Get all positions for a wallet
+ * const positions = await sdk.Position.getPositionList(
+ *   '0x_wallet_address',
+ *   [] // All pools
+ * );
+ *
+ * positions.forEach(pos => {
+ *   console.log(`Position ${pos.pos_object_id}`);
+ *   console.log(`Pool: ${pos.pool}`);
+ *   console.log(`Liquidity: ${pos.liquidity}`);
+ *   console.log(`Range: [${pos.tick_lower_index}, ${pos.tick_upper_index}]`);
+ * });
+ *
+ * @example
+ * // Add liquidity to existing position
+ * const addLiqTx = await sdk.Position.createAddLiquidityPayload({
+ *   pool_id: poolId,
+ *   pos_id: positionId,
+ *   coinTypeA: "0x2::sui::SUI",
+ *   coinTypeB: "0x5d4b...::coin::COIN",
+ *   delta_liquidity: "1000000000",
+ *   max_amount_a: "1100000000",  // 10% slippage
+ *   max_amount_b: "1100000"
+ * });
+ *
+ * @example
+ * // Collect fees from position
+ * const pool = await sdk.Pool.getPool(poolId);
+ * const collectTx = await sdk.Position.collectFeeTransactionPayload({
+ *   pool,
+ *   pos_id: positionId,
+ *   coinTypeA: pool.coinTypeA,
+ *   coinTypeB: pool.coinTypeB
+ * });
+ */
+declare class PositionModule implements IModule {
+    protected _sdk: FerraDammSDK;
+    private readonly _cache;
+    constructor(sdk: FerraDammSDK);
+    get sdk(): FerraDammSDK;
+    /**
+     * Constructs the full type address for Position objects
+     * @returns Full type string in format: packageId::module::type
+     */
+    buildPositionType(): string;
+    /**
+    * Gets transaction history for specific positions
+    * Returns liquidity changes, fee collections, reward claims
+    * @param account - Wallet address that owns positions
+    * @param positionIds - Array of position NFT IDs
+    * @param limit - Max transactions to return (default: 100)
+    * @param offset - Starting offset for pagination
+    * @returns Array of position transaction info
+    * @example
+    * const txList = await sdk.Position.getPositionTransactionList({
+    *   account: walletAddress,
+    *   positionIds: [posId1, posId2],
+    *   limit: 50
+    * });
+    *
+    * txList.forEach(tx => {
+    *   console.log(`${tx.type}: ${tx.txDigest}`);
+    *   console.log(`  Timestamp: ${new Date(Number(tx.timestampMs))}`);
+    * });
+    */
+    getPositionTransactionList({ posId, paginationArgs, order, fullRpcUrl, originPosId, }: {
+        posId: string;
+        originPosId?: string;
+        fullRpcUrl?: string;
+        paginationArgs?: PaginationArgs;
+        order?: 'ascending' | 'descending' | null | undefined;
+    }): Promise<DataPage<PositionTransactionInfo>>;
+    /**
+     * Gets all positions owned by a specific wallet address
+     * Optionally filters by pool IDs
+     * @param accountAddress - Wallet address to query positions for
+     * @param assignPoolIds - Filter by specific pool IDs (empty = all pools)
+     * @param showDisplay - Include NFT display metadata (default: true)
+     * @returns Array of position objects owned by the account
+     * @example
+     * // Get all positions
+     * const allPositions = await sdk.Position.getPositionList(
+     *   '0x_wallet_address'
+     * );
+     *
+     * // Get positions for specific pools only
+     * const filteredPositions = await sdk.Position.getPositionList(
+     *   '0x_wallet_address',
+     *   ['0x_pool1', '0x_pool2']
+     * );
+     *
+     * // Check position status
+     * filteredPositions.forEach(pos => {
+     *   const pool = await sdk.Pool.getPool(pos.pool);
+     *   const status = PositionUtil.getPositionStatus(
+     *     pool.currentTickIndex,
+     *     pos.tick_lower_index,
+     *     pos.tick_upper_index
+     *   );
+     *   console.log(`Position ${pos.pos_object_id}: ${status}`);
+     * });
+     */
+    getPositionList(accountAddress: string, assignPoolIds?: string[], showDisplay?: boolean): Promise<Position[]>;
+    /**
+     * Retrieves position data using position handle (requires pool info)
+     * Note: getPositionById is recommended for direct position retrieval
+     * @param positionHandle - Position collection handle from pool
+     * @param positionID - Position object ID
+     * @param calculateRewarder - Calculate reward amounts (default: true)
+     * @param showDisplay - Include display metadata (default: true)
+     * @returns Complete position object with optional rewards
+     */
+    getPosition(positionHandle: string, positionID: string, calculateRewarder?: boolean, showDisplay?: boolean): Promise<Position>;
+    /**
+     * Gets complete position data by position ID
+     * This is the recommended method - simpler than getPosition()
+     * @param positionID - Position NFT object ID
+     * @param calculateRewarder - Calculate pending rewards (default: true)
+     * @param showDisplay - Include NFT metadata (default: true)
+     * @returns Complete position object
+     * @throws {DammpoolsError} If position doesn't exist
+     * @example
+     * const position = await sdk.Position.getPositionById(
+     *   '0x_position_id',
+     *   true  // Calculate rewards
+     * );
+     *
+     * console.log(`Liquidity: ${position.liquidity}`);
+     * console.log(`Fee owed A: ${position.fee_owed_a}`);
+     * console.log(`Fee owed B: ${position.fee_owed_b}`);
+     * console.log(`Reward 0: ${position.reward_amount_owed_0}`);
+     */
+    getPositionById(positionID: string, calculateRewarder?: boolean, showDisplay?: boolean): Promise<Position>;
+    /**
+     * Gets basic position data without reward calculations
+     * Faster than getPositionById when rewards not needed
+     * @param positionID - Position NFT object ID
+     * @param showDisplay - Include NFT metadata (default: true)
+     * @returns Position object without reward amounts
+     * @example
+     * // Quick position check
+     * const position = await sdk.Position.getSimplePosition(positionId);
+     * console.log(`Range: [${position.tick_lower_index}, ${position.tick_upper_index}]`);
+     * console.log(`In pool: ${position.pool}`);
+     */
+    getSimplePosition(positionID: string, showDisplay?: boolean): Promise<Position>;
+    /**
+     * Internal method to retrieve cached position data
+     * @param positionID - Position object ID
+     * @returns Cached position or undefined if not found/expired
+     */
+    private getSimplePositionByCache;
+    /**
+     * Batch fetches simple position data for multiple positions
+     * More efficient than calling getSimplePosition multiple times
+     * @param positionIDs - Array of position NFT IDs
+     * @param showDisplay - Include NFT metadata (default: true)
+     * @returns Array of position objects
+     * @example
+     * const positions = await sdk.Position.getSipmlePositionList([
+     *   '0x_pos1',
+     *   '0x_pos2',
+     *   '0x_pos3'
+     * ]);
+     *
+     * // Quick overview
+     * positions.forEach(pos => {
+     *   console.log(`${pos.pos_object_id}: ${pos.liquidity} liquidity`);
+     * });
+     */
+    getSipmlePositionList(positionIDs: SuiObjectIdType[], showDisplay?: boolean): Promise<Position[]>;
+    /**
+     * Internal method to update position with reward information
+     * @param positionHandle - Position collection handle
+     * @param position - Position object to update
+     * @returns Position object with reward data
+     */
+    private updatePositionRewarders;
+    /**
+     * Retrieves reward information for a specific position
+     * @param positionHandle - Position collection handle
+     * @param positionID - Position object ID
+     * @returns Position reward data or undefined if not found
+     */
+    getPositionRewarders(positionHandle: string, positionID: string): Promise<PositionReward | undefined>;
+    /**
+     * Calculates pending fees for multiple positions
+     * Uses on-chain simulation for accurate calculations
+     * @param params - Array of position and pool parameters
+     * @returns Array of fee quotes (amounts owed)
+     * @example
+     * const fees = await sdk.Position.fetchPosFeeAmount([
+     *   {
+     *     pool_id: poolId1,
+     *     pos_id: posId1,
+     *     coinTypeA: "0x2::sui::SUI",
+     *     coinTypeB: "0x5d4b...::coin::COIN"
+     *   },
+     *   {
+     *     pool_id: poolId2,
+     *     pos_id: posId2,
+     *     coinTypeA: "0x2::sui::SUI",
+     *     coinTypeB: "0x456::usdc::USDC"
+     *   }
+     * ]);
+     *
+     * fees.forEach(fee => {
+     *   console.log(`Position: ${fee.position_id}`);
+     *   console.log(`Fee A: ${fee.feeOwedA.toString()}`);
+     *   console.log(`Fee B: ${fee.feeOwedB.toString()}`);
+     * });
+     */
+    fetchPosFeeAmount(params: FetchPosFeeParams[]): Promise<CollectFeesQuote[]>;
+    /**
+     * Batch fetches pending fees for multiple positions by ID
+     * Convenient wrapper around fetchPosFeeAmount
+     * @param positionIDs - Array of position NFT IDs
+     * @returns Map of position ID to fee quote
+     * @example
+     * const feeMap = await sdk.Position.batchFetchPositionFees([
+     *   '0x_pos1',
+     *   '0x_pos2'
+     * ]);
+     *
+     * for (const [posId, fees] of Object.entries(feeMap)) {
+     *   console.log(`Position ${posId}:`);
+     *   console.log(`  Fee A: ${fees.feeOwedA.toString()}`);
+     *   console.log(`  Fee B: ${fees.feeOwedB.toString()}`);
+     * }
+     */
+    batchFetchPositionFees(positionIDs: string[]): Promise<Record<string, CollectFeesQuote>>;
+    /**
+     * Creates a transaction to add liquidity with fixed token amounts
+     * Useful when you want to specify exact amounts rather than liquidity delta
+     * @param params - Parameters including amounts and slippage tolerance
+     * @returns Transaction for adding liquidity
+     * @example
+     * const tx = await sdk.Position.createAddLiquidityFixTokenPayload({
+     *   coinTypeA: "0x2::sui::SUI",
+     *   coinTypeB: "0x5d4b...::coin::COIN",
+     *   pool_id: poolId,
+     *   pos_id: positionId,
+     *   amount_a: 1000000000,  // 1 SUI
+     *   amount_b: 5000000,     // 5 COIN
+     *   fix_amount_a: true,    // Fix SUI, adjust COIN
+     *   slippage: 0.05,        // 5% slippage
+     *   tick_lower: -120,
+     *   tick_upper: 120,
+     *   collect_fee: true      // Auto-collect fees before adding
+     * });
+     */
+    createAddLiquidityFixTokenPayload(params: AddLiquidityFixTokenParams, gasEstimateArg?: {
+        slippage: number;
+        curSqrtPrice: BN;
+    }, tx?: Transaction, inputCoinA?: TransactionObjectArgument, inputCoinB?: TransactionObjectArgument): Promise<Transaction>;
+    /**
+     * Retrieves the balance of multiple coin types from a RewarderGlobalVault on the SUI network.
+     *
+     * This function queries the RewarderGlobalVault's dynamic fields (stored in a Bag)
+     * to find the balance for each provided coin type. If a coin type is not found in the vault,
+     * it returns 0n for that coin type.
+     *
+     * @param {SuiClient} client - The SUI client instance used to make RPC calls
+     * @param {string} rewarderVaultId - The object ID of the RewarderGlobalVault on SUI blockchain
+     * @param {string[]} coinTypes - Array of coin type identifiers to query balances for
+     *
+     * @returns {Promise<bigint[]>} Array of balances corresponding to each coin type.
+     *                               Returns 0n if a coin type doesn't exist in the vault.
+     *                               The order matches the input coinTypes array.
+     *
+     * @example
+     * ```typescript
+     * const client = new SuiClient({ url: "https://fullnode.mainnet.sui.io" });
+     *
+     * const balances = await getRewarderBalances(
+     *   client,
+     *   "0xd68c56a1610953b0a81c48ad26e463c6c51e50ddcc13e5e4121fe70ee75c1bf7",
+     *   [
+     *     "0xdba34672e30cb065b1f93e3ab55318768fd6fef66c15942c9f7cb846e2f900e7::usdc::USDC",
+     *     "0x2::sui::SUI",
+     *   ]
+     * );
+     *
+     * console.log(balances); // [47463762n, 0n]
+     * ```
+     *
+     * @throws {Error} Throws if the vault object is invalid or not a moveObject
+     */
+    getRewarderBalances<T extends Array<string>>(coinTypes: T): Promise<SizedArray<bigint, T['length']>>;
+    /**
+     * Creates a transaction to add liquidity with exact liquidity delta
+     * Preferred method when you know the exact liquidity amount to add
+     * @param params - Parameters including liquidity delta and amount limits
+     * @returns Transaction for adding liquidity
+     * @example
+     * const tx = await sdk.Position.createAddLiquidityPayload({
+     *   pool_id: poolId,
+     *   pos_id: positionId,
+     *   coinTypeA: "0x2::sui::SUI",
+     *   coinTypeB: "0x5d4b...::coin::COIN",
+     *   delta_liquidity: "1000000000",
+     *   max_amount_a: "1100000000",  // Max SUI to spend
+     *   max_amount_b: "1100000"      // Max COIN to spend
+     * });
+     */
+    createAddLiquidityPayload(params: AddLiquidityParams, tx?: Transaction, inputCoinA?: TransactionObjectArgument, inputCoinB?: TransactionObjectArgument): Promise<Transaction>;
+    /**
+     * Creates a transaction to remove liquidity from a position
+     * @param params - Parameters including liquidity amount to remove and minimum outputs
+     * @param tx - Optional existing transaction to extend
+     * @returns Transaction for removing liquidity
+     * @example
+     * // Remove 50% of liquidity
+     * const position = await sdk.Position.getPositionById(positionId);
+     * const halfLiquidity = new BN(position.liquidity).divn(2);
+     *
+     * const tx = await sdk.Position.removeLiquidityTransactionPayload({
+     *   pool_id: poolId,
+     *   pos_id: positionId,
+     *   coinTypeA: "0x2::sui::SUI",
+     *   coinTypeB: "0x5d4b...::coin::COIN",
+     *   delta_liquidity: halfLiquidity.toString(),
+     *   min_amount_a: "900000000",  // Minimum SUI to receive
+     *   min_amount_b: "4500000",    // Minimum COIN to receive
+     *   collect_fee: true           // Also collect pending fees
+     * });
+     */
+    removeLiquidityTransactionPayload(params: RemoveLiquidityParams, tx?: Transaction): Promise<Transaction>;
+    /**
+     * Creates a transaction to close a position (remove all liquidity)
+     * Position NFT is burned after closing
+     * @param params - Parameters including slippage tolerance
+     * @param tx - Optional existing transaction to extend
+     * @returns Transaction for closing position
+     * @example
+     * const tx = await sdk.Position.closePositionTransactionPayload({
+     *   pool_id: poolId,
+     *   pos_id: positionId,
+     *   coinTypeA: "0x2::sui::SUI",
+     *   coinTypeB: "0x5d4b...::coin::COIN",
+     *   min_amount_a: "950000000",  // Accept 5% slippage
+     *   min_amount_b: "4750000",
+     *   collect_fee: true,
+     *   rewarder_coin_types: [
+     *     "0x_reward_coin_1",
+     *     "0x_reward_coin_2",
+     *     "0x_reward_coin_3"
+     *   ]
+     * });
+     */
+    closePositionTransactionPayload(params: ClosePositionParams, tx?: Transaction): Promise<Transaction>;
+    /**
+     * Creates transaction to open a new empty position
+     * Position will have no liquidity until added separately
+     * @param params - Position opening parameters
+     * @param tx - Optional existing transaction to append to
+     * @returns Transaction object for opening position
+     */
+    openPositionTransactionPayload(params: OpenPositionParams, tx?: Transaction): Transaction;
+    /**
+     * Locks a position until a specific timestamp
+     * Locked positions cannot be closed or have liquidity removed
+     * Useful for governance or vesting mechanisms
+     * @param pool - Pool object
+     * @param positionId - Position NFT ID
+     * @param untilTimestamp - Unix timestamp (seconds) when lock expires
+     * @param tx - Optional transaction to extend
+     * @returns Transaction for locking position
+     * @example
+     * const pool = await sdk.Pool.getPool(poolId);
+     * const oneWeekFromNow = Math.floor(Date.now() / 1000) + (7 * 24 * 60 * 60);
+     *
+     * const tx = await sdk.Position.lockPosition(
+     *   pool,
+     *   positionId,
+     *   oneWeekFromNow
+     * );
+     *
+     * console.log(`Position locked until: ${new Date(oneWeekFromNow * 1000)}`);
+     */
+    lockPosition(pool: Pool, positionId: string, untilTimestamp: number, tx?: Transaction): Promise<Transaction>;
+    /**
+     * Gets lock status for a position by ID
+     * @param positionId - Position NFT ID
+     * @returns Tuple of [lockTimestamp, currentTimestamp, isLocked]
+     * @example
+     * const [lockTime, currentTime, isLocked] =
+     *   await sdk.Position.getLockPositionStatusById(positionId);
+     *
+     * if (isLocked) {
+     *   const unlockDate = new Date(lockTime * 1000);
+     *   console.log(`Locked until: ${unlockDate}`);
+     *   console.log(`Time remaining: ${lockTime - currentTime}s`);
+     * } else {
+     *   console.log('Position is unlocked');
+     * }
+     */
+    getLockPositionStatusById(positionId: string): Promise<[current_lock: number, current_timestamp: number, is_locked: boolean]>;
+    getLockPositionStatus(position: Position): Promise<[current_lock: number, current_timestamp: number, is_locked: boolean]>;
+    /**
+     * Creates a transaction to collect accumulated fees from a position
+     * Fees can be collected without affecting liquidity
+     * @param params - Parameters including pool and position info
+     * @param tx - Optional transaction to extend
+     * @returns Transaction for collecting fees
+     * @example
+     * const pool = await sdk.Pool.getPool(poolId);
+     *
+     * const collectTx = await sdk.Position.collectFeeTransactionPayload({
+     *   pool,
+     *   pos_id: positionId,
+     *   coinTypeA: pool.coinTypeA,
+     *   coinTypeB: pool.coinTypeB,
+     *   collect_fee: true
+     * });
+     *
+     * const result = await sdk.fullClient.signAndExecuteTransaction({
+     *   transaction: collectTx,
+     *   signer: keypair
+     * });
+     *
+     * // Check collected amounts from events
+     * const collectEvent = result.events?.find(
+     *   e => e.type.includes('CollectFeeEvent')
+     * );
+     * console.log(`Collected A: ${collectEvent?.parsedJson?.amount_a}`);
+     * console.log(`Collected B: ${collectEvent?.parsedJson?.amount_b}`);
+     */
+    collectFeeTransactionPayload(params: CollectFeeParams, tx?: Transaction, inputCoinA?: TransactionObjectArgument, inputCoinB?: TransactionObjectArgument): Promise<Transaction>;
+    /**
+     * Internal method to create collect fee move call
+     * @param params - Fee collection parameters
+     * @param tx - Transaction object
+     * @param primaryCoinAInput - Coin A object
+     * @param primaryCoinBInput - Coin B object
+     * @returns Transaction object with collect fee call
+     */
+    createCollectFeePaylod(params: CollectFeeParams, tx: Transaction, primaryCoinAInput: TransactionObjectArgument, primaryCoinBInput: TransactionObjectArgument): Transaction;
+    /**
+     * Creates collect fee call without sending coins to sender
+     * Used when coins need to be used in subsequent operations
+     * @param params - Fee collection parameters
+     * @param tx - Transaction object
+     * @param primaryCoinAInput - Coin A object
+     * @param primaryCoinBInput - Coin B object
+     * @returns Transaction object with collect fee call
+     */
+    createCollectFeeNoSendPaylod(params: CollectFeeParams, tx: Transaction, primaryCoinAInput: TransactionObjectArgument, primaryCoinBInput: TransactionObjectArgument): Transaction;
+    /**
+   * Calculates pending fees for a position using local computation
+   * Faster than on-chain simulation but less accurate
+   * @param params - Pool and position parameters
+   * @returns Fee quote with amounts owed
+   * @example
+   * const pool = await sdk.Pool.getPool(poolId);
+   * const position = await sdk.Position.getPositionById(positionId);
+   * const ticks = await sdk.Pool.fetchTicksByRpc(pool.ticksHandle);
+   *
+   * const tickLower = ticks.find(t => t.index === position.tick_lower_index);
+   * const tickUpper = ticks.find(t => t.index === position.tick_upper_index);
+   *
+   * const fees = await sdk.Position.calculateFee({
+   *   pool,
+   *   position,
+   *   tickLower,
+   *   tickUpper
+   * });
+   *
+   * console.log(`Pending fee A: ${fees.feeOwedA.toString()}`);
+   * console.log(`Pending fee B: ${fees.feeOwedB.toString()}`);
+   */
+    calculateFee(params: CollectFeeParams): Promise<{
+        feeOwedA: any;
+        feeOwedB: any;
+    }>;
+    /**
+     * Updates cached data with expiration time
+     * @param key - Cache key
+     * @param data - Data to cache
+     * @param time - Cache duration in minutes (default: 5)
+     */
+    private updateCache;
+    /**
+     * Retrieves cached data if valid
+     * @param key - Cache key
+     * @param forceRefresh - Bypass cache if true
+     * @returns Cached data or undefined if expired/not found
+     */
+    private getCache;
+}
+type SizedArray<T, S extends number, Arr extends T[] = []> = Arr['length'] extends S ? Arr : SizedArray<T, S, [...Arr, T]>;
+
+interface CoinNode {
+    address: string;
+    decimals: number;
+}
+interface CoinProvider {
+    coins: CoinNode[];
+}
+interface PathLink {
+    base: string;
+    quote: string;
+    addressMap: Map<number, string>;
+}
+interface PathProvider {
+    paths: PathLink[];
+}
+type OnePath = {
+    amountIn: BN;
+    amountOut: BN;
+    poolAddress: string[];
+    a2b: boolean[];
+    rawAmountLimit: BN[];
+    isExceed: boolean;
+    coinType: string[];
+};
+type BasePath = {
+    direction: boolean;
+    label: string;
+    poolAddress: string;
+    fromCoin: string;
+    toCoin: string;
+    feeRate: number;
+    outputAmount: number;
+    inputAmount: number;
+    currentSqrtPrice: BN;
+    fromDecimal: number;
+    toDecimal: number;
+    currentPrice: Decimal;
+};
+type SplitPath = {
+    percent: number;
+    inputAmount: number;
+    outputAmount: number;
+    pathIndex: number;
+    lastQuoteOutput: number;
+    basePaths: BasePath[];
+};
+type AddressAndDirection = {
+    addressMap: Map<number, string>;
+    direction: boolean;
+};
+type SwapWithRouterParams = {
+    paths: OnePath[];
+    partner: string;
+    priceSlippagePoint: number;
+};
+type PreRouterSwapParams = {
+    stepNums: number;
+    poolAB: string;
+    poolBC: string | undefined;
+    a2b: boolean;
+    b2c: boolean | undefined;
+    byAmountIn: boolean;
+    amount: BN;
+    coinTypeA: SuiAddressType;
+    coinTypeB: SuiAddressType;
+    coinTypeC: SuiAddressType | undefined;
+};
+type PreSwapResult = {
+    index: number;
+    amountIn: BN;
+    amountMedium: BN;
+    amountOut: BN;
+    targetSqrtPrice: BN[];
+    currentSqrtPrice: BN[];
+    isExceed: boolean;
+    stepNum: number;
+};
+type BestInternalRouterResult = {
+    amountIn: BN;
+    amountOut: BN;
+    paths: OnePath[];
+    a2b: boolean;
+    b2c: boolean | undefined;
+    byAmountIn: boolean;
+    isExceed: boolean;
+    targetSqrtPrice: BN[];
+    currentSqrtPrice: BN[];
+    coinTypeA: SuiAddressType;
+    coinTypeB: SuiAddressType;
+    coinTypeC: SuiAddressType | undefined;
+    createTxParams: SwapWithRouterParams | undefined;
+};
+type PoolWithTvl = {
+    poolAddress: string;
+    tvl: number;
+};
+/**
+ * Router module for finding optimal multi-hop swap paths
+ * Analyzes liquidity across pools to find best execution routes
+ * Supports complex routing with intermediate tokens
+ *
+ * @example
+ * // Find best route for SUI -> USDC swap
+ * await sdk.Router.loadGraphData(); // Load pool graph first
+ *
+ * const route = await sdk.Router.getBestInternalRouter({
+ *   from: "0x2::sui::SUI",
+ *   target: "0x5d4b...::usdc::USDC",
+ *   amount: "1000000000", // 1 SUI
+ *   byAmountIn: true,
+ *   depth: 3  // Allow up to 3 hops
+ * });
+ *
+ * if (route) {
+ *   console.log(`Best route: ${route.paths.map(p => p.coinType).join(' -> ')}`);
+ *   console.log(`Expected output: ${route.amountOut}`);
+ *   console.log(`Price impact: ${route.priceImpact}%`);
+ * }
+ *
+ * @example
+ * // Execute multi-hop swap
+ * const swapTx = await sdk.Router.createSwapTransactionPayload({
+ *   paths: route.paths,
+ *   partner: null,
+ *   byAmountIn: true
+ * });
+ */
+declare class RouterModule implements IModule {
+    readonly graph: Graph;
+    readonly pathProviders: PathProvider[];
+    private coinProviders;
+    private _coinAddressMap;
+    private poolAddressMap;
+    private _isGraphLoaded;
+    protected _sdk: FerraDammSDK;
+    constructor(sdk: FerraDammSDK);
+    get sdk(): FerraDammSDK;
+    get isGraphLoaded(): boolean;
+    /**
+     * Retrieves pool address mapping with trading direction
+     * @param baseCoin - Base coin identifier
+     * @param quoteCoin - Quote coin identifier
+     * @returns Address mapping with direction information, or undefined if not found
+     */
+    getPoolAddressMapAndDirection(baseCoin: string, quoteCoin: string): AddressAndDirection | undefined;
+    /**
+     * Populates the coin address mapping with available coins
+     */
+    private setCoinList;
+    /**
+     * Loads pool and coin graph data for routing
+     * Must be called before using routing functions
+     * Caches data for performance
+     * @example
+     * // Load graph once at app startup
+     * await sdk.Router.loadGraphData();
+     *
+     * // Now you can use routing
+     * const route = await sdk.Router.getBestInternalRouter({
+     *   from: "0x2::sui::SUI",
+     *   target: "0x5d4b...::usdc::USDC",
+     *   amount: "1000000000",
+     *   byAmountIn: true
+     * });
+     */
+    loadGraph(coinData: CoinProvider, pathData: PathProvider): void;
+    /**
+     * Adds a new path provider to the routing graph
+     * @param provider - Path provider containing trading paths
+     * @returns Current RouterModule instance for chaining
+     */
+    private addPathProvider;
+    /**
+     * Registers a coin provider with the router
+     * @param provider - Coin provider containing coin information
+     * @returns Current RouterModule instance for chaining
+     */
+    private addCoinProvider;
+    /**
+     * Retrieves token information from the coin address mapping
+     * @param coinType - Coin type identifier
+     * @returns Coin node information or undefined if not found
+     */
+    tokenInfo(coinType: string): CoinNode | undefined;
+    /**
+     * Calculates the fee rate for a specific pool
+     * @param fromCoin - Source coin type
+     * @param toCoin - Target coin type
+     * @param poolAddress - Pool address
+     * @returns Fee rate percentage for the pool
+     */
+    getFeeRate(fromCoin: string, toCoin: string, poolAddress: string): number;
+    /**
+     * Finds the optimal swap route between two tokens
+     * Analyzes all possible paths considering liquidity and fees
+     * @param params - Routing parameters including tokens and amount
+     * @returns Best route with expected output and path details, or null if no path found
+     * @example
+     * await sdk.Router.loadGraphData();
+     *
+     * const route = await sdk.Router.getBestInternalRouter({
+     *   from: "0x2::sui::SUI",
+     *   target: "0x5d4b...::usdc::USDC",
+     *   amount: "1000000000",  // 1 SUI
+     *   byAmountIn: true,
+     *   depth: 3,              // Max 3 hops
+     *   splitCount: 1          // Single path (no split routing)
+     * });
+     *
+     * if (!route) {
+     *   console.log('No route found');
+     *   return;
+     * }
+     *
+     * console.log('Route found:');
+     * route.paths.forEach((path, i) => {
+     *   console.log(`  Hop ${i + 1}: ${path.coinType}`);
+     *   console.log(`    Pool: ${path.poolAddress}`);
+     *   console.log(`    Direction: ${path.a2b ? 'A->B' : 'B->A'}`);
+     * });
+     * console.log(`Total output: ${route.amountOut}`);
+     * console.log(`Price impact: ${route.priceImpact}%`);
+     */
+    getBestInternalRouter(fromCoin: string, toCoin: string, swapAmount: BN, isFixedInput: boolean, slippagePoint: number, partnerObjectId: string, multiPoolParams?: PreSwapWithMultiPoolParams): Promise<BestInternalRouterResult | undefined>;
+    /**
+     * Loads graph data from the remote API endpoint
+     */
+    loadGraphData(): Promise<void>;
+    /**
+     * Simulates multi-hop swaps across different parameter sets
+     * Useful for comparing different amounts or paths
+     * @param parameterSets - Array of routing parameters to test
+     * @returns Array of best routes for each parameter set
+     * @example
+     * await sdk.Router.loadGraphData();
+     *
+     * const routes = await sdk.Router.preRouterSwapA2B2C([
+     *   {
+     *     from: "0x2::sui::SUI",
+     *     target: "0x5d4b...::usdc::USDC",
+     *     amount: "1000000000",  // 1 SUI
+     *     byAmountIn: true
+     *   },
+     *   {
+     *     from: "0x2::sui::SUI",
+     *     target: "0x5d4b...::usdc::USDC",
+     *     amount: "10000000000", // 10 SUI
+     *     byAmountIn: true
+     *   }
+     * ]);
+     *
+     * routes.forEach((route, i) => {
+     *   console.log(`Route ${i + 1}:`);
+     *   console.log(`  Output: ${route?.amountOut ?? 'No route'}`);
+     * });
+     */
+    preRouterSwapA2B2C(parameterSets: PreRouterSwapParams[]): Promise<PreSwapResult>;
+    /**
+     * Gets all pools with their Total Value Locked (TVL)
+     * Useful for analytics and pool selection
+     * @returns Array of pools with TVL data
+     * @example
+     * const poolsWithTvl = await sdk.Router.getPoolWithTVL();
+     *
+     * // Sort by TVL
+     * poolsWithTvl.sort((a, b) => b.tvl - a.tvl);
+     *
+     * console.log('Top 10 pools by TVL:');
+     * poolsWithTvl.slice(0, 10).forEach(pool => {
+     *   console.log(`${pool.name}: $${pool.tvl.toLocaleString()}`);
+     * });
+     */
+    getPoolWithTVL(): Promise<PoolWithTvl[]>;
+}
+
+/**
+ * Swap module for executing token swaps in DAMM pools
+ * Handles swap calculations, fee estimation, price impact analysis, and transaction creation
+ * Supports both single-pool and multi-pool swap operations with gas optimization
+ */
+declare class SwapModule implements IModule {
+    protected _sdk: FerraDammSDK;
+    constructor(sdk: FerraDammSDK);
+    get sdk(): FerraDammSDK;
+    /**
+     * Performs pre-swap simulation across multiple pools to find optimal execution
+     * @param swapParams - Parameters for multi-pool swap simulation
+     * @returns Promise resolving to optimal swap data or null if no valid swap found
+     */
+    preSwapWithMultiPool(swapParams: PreSwapWithMultiPoolParams): Promise<{
+        poolAddress: string;
+        estimatedAmountIn: string;
+        estimatedAmountOut: any;
+        estimatedEndSqrtPrice: any;
+        estimatedStartSqrtPrice: any;
+        estimatedFeeAmount: any;
+        isExceed: any;
+        amount: string;
+        aToB: boolean;
+        byAmountIn: boolean;
+    }>;
+    /**
+     * Performs pre-swap simulation for a single pool
+     * @param swapParams - Parameters for single pool swap simulation
+     * @returns Promise resolving to swap simulation data or null if simulation fails
+     */
+    preswap(swapParams: PreSwapParams): Promise<{
+        poolAddress: string;
+        currentSqrtPrice: number;
+        estimatedAmountIn: any;
+        estimatedAmountOut: any;
+        estimatedEndSqrtPrice: any;
+        estimatedFeeAmount: any;
+        isExceed: any;
+        amount: string;
+        aToB: boolean;
+        byAmountIn: boolean;
+    }>;
+    /**
+     * Transforms raw swap simulation data into structured swap result
+     * @param swapParams - Original swap parameters
+     * @param simulationData - Raw simulation result data
+     * @returns Structured swap data object
+     */
+    private transformSwapData;
+    /**
+     * Transforms multi-pool swap simulation data into structured result
+     * @param swapParams - Original multi-pool swap parameters
+     * @param responseData - Raw JSON response from simulation
+     * @returns Structured multi-pool swap data object
+     */
+    private transformSwapWithMultiPoolData;
+    /**
+     * Calculates swap rates and impact metrics using local computation
+     * @param calculationParams - Parameters for rate calculation including pool data and ticks
+     * @returns Detailed calculation results including amounts, fees, and price impact
+     */
+    calculateRates(calculationParams: CalculateRatesParams): CalculateRatesResult;
+    /**
+     * Creates a transaction for multi-hop swap execution
+     * Builds the complete swap path through multiple pools
+     * @param params - Swap parameters including path and partner info
+     * @returns Transaction ready for execution
+     * @example
+     * // First find the best route
+     * const route = await sdk.Router.getBestInternalRouter({
+     *   from: "0x2::sui::SUI",
+     *   target: "0x5d4b...::usdc::USDC",
+     *   amount: "1000000000",
+     *   byAmountIn: true
+     * });
+     *
+     * // Then create transaction
+     * const tx = await sdk.Router.createSwapTransactionPayload({
+     *   paths: route.paths,
+     *   partner: null,        // Or partner ID for fee sharing
+     *   byAmountIn: true
+     * });
+     *
+     * const result = await sdk.fullClient.signAndExecuteTransaction({
+     *   transaction: tx,
+     *   signer: keypair
+     * });
+     */
+    createSwapTransactionPayload(swapParams: SwapParams, gasEstimationConfig?: {
+        byAmountIn: boolean;
+        slippage: Percentage;
+        decimalsA: number;
+        decimalsB: number;
+        swapTicks: Array<TickData>;
+        currentPool: Pool;
+    }): Promise<Transaction>;
+    /**
+     * Creates a swap transaction without automatic coin transfers (for advanced usage)
+     * @param swapParams - Parameters for swap execution
+     * @param gasEstimationConfig - Optional gas estimation configuration for SUI swaps
+     * @returns Promise resolving to transaction and coin arguments for manual handling
+     */
+    createSwapTransactionWithoutTransferCoinsPayload(swapParams: SwapParams, gasEstimationConfig?: {
+        byAmountIn: boolean;
+        slippage: Percentage;
+        decimalsA: number;
+        decimalsB: number;
+        swapTicks: Array<TickData>;
+        currentPool: Pool;
+    }): Promise<{
+        tx: Transaction;
+        coinABs: TransactionObjectArgument[];
+    }>;
+}
+
+/**
+ * Represents a module for making RPC (Remote Procedure Call) requests.
+ */
+declare class RpcModule extends SuiClient {
+    /**
+     * Get events for a given query criteria
+     * @param query
+     * @param paginationArgs
+     * @returns
+     */
+    queryEventsByPage(query: SuiEventFilter, paginationArgs?: PaginationArgs): Promise<DataPage<any>>;
+    queryTransactionBlocksByPage(filter?: TransactionFilter, paginationArgs?: PaginationArgs, order?: 'ascending' | 'descending' | null | undefined): Promise<DataPage<SuiTransactionBlockResponse>>;
+    /**
+     * Get all objects owned by an address
+     * @param owner
+     * @param query
+     * @param paginationArgs
+     * @returns
+     */
+    getOwnedObjectsByPage(owner: string, query: SuiObjectResponseQuery, paginationArgs?: PaginationArgs): Promise<DataPage<any>>;
+    /**
+     * Return the list of dynamic field objects owned by an object
+     * @param parentId
+     * @param paginationArgs
+     * @returns
+     */
+    getDynamicFieldsByPage(parentId: SuiObjectIdType, paginationArgs?: PaginationArgs): Promise<DataPage<any>>;
+    /**
+     * Batch get details about a list of objects. If any of the object ids are duplicates the call will fail
+     * @param ids
+     * @param options
+     * @param limit
+     * @returns
+     */
+    batchGetObjects(ids: SuiObjectIdType[], options?: SuiObjectDataOptions, limit?: number): Promise<SuiObjectResponse[]>;
+    /**
+   * Calculates the gas cost of a transaction block.
+   * @param {Transaction} tx - The transaction block to calculate gas for.
+   * @returns {Promise<number>} - The estimated gas cost of the transaction block.
+   * @throws {Error} - Throws an error if the sender is empty or devInspect fails.
+   */
+    calculationTxGas(tx: Transaction): Promise<number>;
+    /**
+     * Sends a transaction block after signing it with the provided keypair.
+     *
+     * @param {Ed25519Keypair | Secp256k1Keypair} keypair - The keypair used for signing the transaction.
+     * @param {Transaction} tx - The transaction block to send.
+     * @returns {Promise<SuiTransactionBlockResponse | undefined>} - The response of the sent transaction block.
+     */
+    sendTransaction(keypair: Ed25519Keypair | Secp256k1Keypair, tx: Transaction): Promise<SuiTransactionBlockResponse | undefined>;
+    /**
+     * Send a simulation transaction.
+     * @param tx - The transaction block.
+     * @param simulationAccount - The simulation account.
+     * @param useDevInspect - A flag indicating whether to use DevInspect. Defaults to true.
+     * @returns A promise that resolves to DevInspectResults or undefined.
+     */
+    sendSimulationTransaction(tx: Transaction, simulationAccount: string, useDevInspect?: boolean): Promise<DevInspectResults | undefined>;
+}
+
+/**
+ * Represents options and configurations for an SDK.
+ */
+type SdkOptions = {
+    /**
+     * The full URL for interacting with the RPC (Remote Procedure Call) service.
+     */
+    fullRpcUrl: string;
+    /**
+     * Optional URL for the faucet service.
+     */
+    faucetURL?: string;
+    /**
+     * Configuration for the simulation account.
+     */
+    simulationAccount: {
+        /**
+         * The address of the simulation account.
+         */
+        address: string;
+    };
+    /**
+     * Package containing faucet-related configurations.
+     */
+    faucet?: Package;
+    /**
+     * Package containing token-related configurations.
+     */
+    token?: Package<TokenConfig>;
+    /**
+     * Package containing Cryptocurrency Liquidity Mining Module (DAMM) pool configurations.
+     */
+    damm_pool: Package<DammConfig>;
+    /**
+     * Package containing integration-related configurations.
+     */
+    integrate: Package;
+    /**
+     * The URL for the swap count
+     */
+    swapCountUrl?: string;
+};
+/**
+ * The entry class of FerraDammSDK, which is almost responsible for all interactions with DAMM.
+ */
+declare class FerraDammSDK {
+    private readonly _cache;
+    /**
+     * RPC provider on the SUI chain
+     */
+    protected _rpcModule: RpcModule;
+    /**
+     * Provide interact with damm pools with a pool router interface.
+     */
+    protected _pool: PoolModule;
+    /**
+     * Provide interact with damm position with a position router interface.
+     */
+    protected _position: PositionModule;
+    /**
+     * Provide interact with a pool swap router interface.
+     */
+    protected _swap: SwapModule;
+    /**
+     * Provide interact  with a position rewarder interface.
+     */
+    protected _rewarder: RewarderModule;
+    /**
+     * Provide interact with a pool router interface.
+     */
+    protected _router: RouterModule;
+    /**
+     *  Provide sdk options
+     */
+    protected _sdkOptions: SdkOptions;
+    /**
+     * After connecting the wallet, set the current wallet address to senderAddress.
+     */
+    protected _senderAddress: string;
+    constructor(options: SdkOptions);
+    /**
+     * Getter for the sender address property.
+     * @returns {SuiAddressType} The sender address.
+     */
+    get senderAddress(): SuiAddressType;
+    /**
+     * Setter for the sender address property.
+     * @param {string} value - The new sender address value.
+     */
+    set senderAddress(value: string);
+    /**
+     * Getter for the Swap property.
+     * @returns {SwapModule} The Swap property value.
+     */
+    get Swap(): SwapModule;
+    /**
+     * Getter for the fullClient property.
+     * @returns {RpcModule} The fullClient property value.
+     */
+    get fullClient(): RpcModule;
+    /**
+     * Getter for the sdkOptions property.
+     * @returns {SdkOptions} The sdkOptions property value.
+     */
+    get sdkOptions(): SdkOptions;
+    /**
+     * Getter for the Pool property.
+     * @returns {PoolModule} The Pool property value.
+     */
+    get Pool(): PoolModule;
+    /**
+     * Getter for the Position property.
+     * @returns {PositionModule} The Position property value.
+     */
+    get Position(): PositionModule;
+    /**
+     * Getter for the Rewarder property.
+     * @returns {RewarderModule} The Rewarder property value.
+     */
+    get Rewarder(): RewarderModule;
+    /**
+     * Getter for the Router property.
+     * @returns {RouterModule} The Router property value.
+     */
+    get Router(): RouterModule;
+    /**
+     * Gets all coin assets for the given owner and coin type.
+     *
+     * @param suiAddress The address of the owner.
+     * @param coinType The type of the coin.
+     * @returns an array of coin assets.
+     */
+    getOwnerCoinAssets(suiAddress: string, coinType?: string | null, forceRefresh?: boolean): Promise<CoinAsset[]>;
+    /**
+     * Gets all coin balances for the given owner and coin type.
+     *
+     * @param suiAddress The address of the owner.
+     * @param coinType The type of the coin.
+     * @returns an array of coin balances.
+     */
+    getOwnerCoinBalances(suiAddress: string, coinType?: string | null): Promise<CoinBalance[]>;
+    /**
+     * Updates the cache for the given key.
+     *
+     * @param key The key of the cache entry to update.
+     * @param data The data to store in the cache.
+     * @param time The time in minutes after which the cache entry should expire.
+     */
+    updateCache(key: string, data: SuiResource, time?: number): void;
+    /**
+     * Gets the cache entry for the given key.
+     *
+     * @param key The key of the cache entry to get.
+     * @param forceRefresh Whether to force a refresh of the cache entry.
+     * @returns The cache entry for the given key, or undefined if the cache entry does not exist or is expired.
+     */
+    getCache<T>(key: string, forceRefresh?: boolean): T | undefined;
+}
+
+declare const cacheTime5min: number;
+declare const cacheTime24h: number;
+declare function getFutureTime(interval: number): number;
+/**
+ * Defines the structure of a CachedContent object, used for caching resources in memory.
+ */
+declare class CachedContent {
+    overdueTime: number;
+    value: SuiResource | null;
+    constructor(value: SuiResource | null, overdueTime?: number);
+    isValid(): boolean;
+}
+
+/**
+ * Converts an amount to a decimal value, based on the number of decimals specified.
+ * @param  {number | string} amount - The amount to convert to decimal.
+ * @param  {number | string} decimals - The number of decimals to use in the conversion.
+ * @returns {number} - Returns the converted amount as a number.
+ */
+declare function toDecimalsAmount(amount: number | string, decimals: number | string): number;
+/**
+ * Converts a bigint to an unsigned integer of the specified number of bits.
+ * @param {bigint} int - The bigint to convert.
+ * @param {number} bits - The number of bits to use in the conversion. Defaults to 32 bits.
+ * @returns {string} - Returns the converted unsigned integer as a string.
+ */
+declare function asUintN(int: bigint, bits?: number): string;
+/**
+ * Converts a bigint to a signed integer of the specified number of bits.
+ * @param {bigint} int - The bigint to convert.
+ * @param {number} bits - The number of bits to use in the conversion. Defaults to 32 bits.
+ * @returns {number} - Returns the converted signed integer as a number.
+ */
+declare function asIntN(int: bigint, bits?: number): bigint;
+/**
+ * Converts an amount in decimals to its corresponding numerical value.
+ * @param {number|string} amount - The amount to convert.
+ * @param {number|string} decimals - The number of decimal places used in the amount.
+ * @returns {number} - Returns the converted numerical value.
+ */
+declare function fromDecimalsAmount(amount: number | string, decimals: number | string): number;
+/**
+ * Converts a secret key in string or Uint8Array format to an Ed25519 key pair.
+ * @param {string|Uint8Array} secretKey - The secret key to convert.
+ * @param {string} ecode - The encoding of the secret key ('hex' or 'base64'). Defaults to 'hex'.
+ * @returns {Ed25519Keypair} - Returns the Ed25519 key pair.
+ */
+declare function secretKeyToEd25519Keypair(secretKey: string | Uint8Array, ecode?: 'hex' | 'base64'): Ed25519Keypair;
+/**
+ * Converts a secret key in string or Uint8Array format to a Secp256k1 key pair.
+ * @param {string|Uint8Array} secretKey - The secret key to convert.
+ * @param {string} ecode - The encoding of the secret key ('hex' or 'base64'). Defaults to 'hex'.
+ * @returns {Ed25519Keypair} - Returns the Secp256k1 key pair.
+ */
+declare function secretKeyToSecp256k1Keypair(secretKey: string | Uint8Array, ecode?: 'hex' | 'base64'): Secp256k1Keypair;
+/**
+ * Builds a Pool object based on a SuiObjectResponse.
+ * @param {SuiObjectResponse} objects - The SuiObjectResponse containing information about the pool.
+ * @returns {Pool} - The built Pool object.
+ */
+declare function buildPool(objects: SuiObjectResponse): Pool;
+/**
+ * Builds an NFT object based on a response containing information about the NFT.
+ * @param {any} objects - The response containing information about the NFT.
+ * @returns {NFT} - The built NFT object.
+ */
+declare function buildNFT(objects: any): NFT;
+/** Builds a Position object based on a SuiObjectResponse.
+ * @param {SuiObjectResponse} object - The SuiObjectResponse containing information about the position.
+ * @returns {Position} - The built Position object.
+ */
+declare function buildPosition(object: SuiObjectResponse): Position;
+/**
+ * Builds a PositionReward object based on a response containing information about the reward.
+ * @param {any} fields - The response containing information about the reward.
+ * @returns {PositionReward} - The built PositionReward object.
+ */
+declare function buildPositionReward(fields: any): PositionReward;
+/**
+ * Builds a TickData object based on a response containing information about tick data.
+ * It must check if the response contains the required fields.
+ * @param {SuiObjectResponse} objects - The response containing information about tick data.
+ * @returns {TickData} - The built TickData object.
+ */
+declare function buildTickData(objects: SuiObjectResponse): TickData;
+/**
+ * Builds a TickData object based on a given event's fields.
+ * @param {any} fields - The fields of an event.
+ * @returns {TickData} - The built TickData object.
+ * @throws {Error} If any required field is missing.
+ */
+declare function buildTickDataByEvent(fields: any): TickData;
+declare function buildDammPositionName(pool_index: number, position_index: number): string;
+declare function buildPositionTransactionInfo(data: SuiTransactionBlockResponse, txIndex: number, filterIds: string[]): PositionTransactionInfo[];
+declare function buildPoolTransactionInfo(data: SuiTransactionBlockResponse, txIndex: number, package_id: string, poolId: string): PoolTransactionInfo[];
+
+declare function isSortedSymbols(symbolX: string, symbolY: string): boolean;
+declare function composeType(address: string, generics: SuiAddressType[]): SuiAddressType;
+declare function composeType(address: string, struct: string, generics?: SuiAddressType[]): SuiAddressType;
+declare function composeType(address: string, module: string, struct: string, generics?: SuiAddressType[]): SuiAddressType;
+declare function extractAddressFromType(type: string): string;
+declare function extractStructTagFromType(type: string): SuiStructTag;
+declare function normalizeCoinType(coinType: string): string;
+declare function fixSuiObjectId(value: string): string;
+/**
+ * Fixes and normalizes a coin type by removing or keeping the prefix.
+ *
+ * @param {string} coinType - The coin type to be fixed.
+ * @param {boolean} removePrefix - Whether to remove the prefix or not (default: true).
+ * @returns {string} - The fixed and normalized coin type.
+ */
+declare const fixCoinType: (coinType: string, removePrefix?: boolean) => string;
+/**
+ * Recursively traverses the given data object and patches any string values that represent Sui object IDs.
+ *
+ * @param {any} data - The data object to be patched.
+ */
+declare function patchFixSuiObjectId(data: any): void;
+
+declare function addHexPrefix(hex: string): string;
+declare function removeHexPrefix(hex: string): string;
+declare function shortString(str: string, start?: number, end?: number): string;
+declare function shortAddress(address: string, start?: number, end?: number): string;
+declare function checkAddress(address: any, options?: {
+    leadingZero: boolean;
+}): boolean;
+/**
+ * Attempts to turn a value into a `Buffer`. As input it supports `Buffer`, `String`, `Number`, null/undefined, `BN` and other objects with a `toArray()` method.
+ * @param v the value
+ */
+declare function toBuffer(v: any): Buffer;
+declare function bufferToHex(buffer: Buffer): string;
+/**
+ * '\x02\x00\x00\x00' to 2
+ * @param binaryData
+ */
+declare function hexToNumber(binaryData: string): number;
+declare function utf8to16(str: string): any;
+declare function hexToString(str: string): any;
+
+declare function d(value?: Decimal.Value): Decimal.Instance;
+declare function decimalsMultiplier(decimals?: Decimal.Value): Decimal.Instance;
+
+declare class TickUtil {
+    /**
+     * Get min tick index.
+     * @param tick_spacing tick spacing
+     * @retruns min tick index
+     */
+    static getMinIndex(tickSpacing: number): number;
+    /**
+     * Get max tick index.
+     * @param tick_spacing - tick spacing
+     * @retruns max tick index
+     */
+    static getMaxIndex(tickSpacing: number): number;
+}
+/**
+ * Get nearest tick by current tick.
+ *
+ * @param tickIndex
+ * @param tickSpacing
+ * @returns
+ */
+declare function getNearestTickByTick(tickIndex: number, tickSpacing: number): number;
+/**
+ * Calculate reward amount in tick range.
+ * @param {Pool}pool Pool object.
+ * @param {TickData}tickLower Tick lower data.
+ * @param {TickData}tickUpper Tick upper data.
+ * @param {number}tickLowerIndex Tick lower index.
+ * @param {number}tickUpperIndex Tick upper index.
+ * @param {BN[]}growthGlobal
+ * @returns
+ */
+declare function getRewardInTickRange(pool: Pool, tickLower: TickData, tickUpper: TickData, tickLowerIndex: number, tickUpperIndex: number, growthGlobal: BN[]): BN[];
+
+type AdjustResult = {
+    isAdjustCoinA: boolean;
+    isAdjustCoinB: boolean;
+};
+/**
+ * Determines which coins in a pair are SUI tokens that need adjustment
+ * @param coinPair - Pair of coin types to check
+ * @returns Object indicating which coins are SUI and need adjustment
+ */
+declare function findAdjustCoin(coinPair: CoinPairType): AdjustResult;
+type BuildCoinResult = {
+    targetCoin: TransactionObjectArgument;
+    remainCoins: CoinAsset[];
+    isMintZeroCoin: boolean;
+    tragetCoinAmount: string;
+    originalSplitedCoin?: TransactionObjectArgument;
+};
+type CoinInputInterval = {
+    amountSecond: bigint;
+    amountFirst: bigint;
+};
+type TxCoin = {
+    $kind: 'NestedResult';
+    NestedResult: [number, number];
+} | ((tx: Transaction) => {
+    $kind: 'NestedResult';
+    NestedResult: [number, number];
+}) | ((tx: Transaction) => TransactionResult);
+/**
+ * Utility function for debugging transaction structure
+ * @param transaction - Transaction to inspect
+ * @param enablePrint - Whether to print command details
+ */
+declare function printTransaction(transaction: Transaction, enablePrint?: boolean): Promise<void>;
+/**
+ * Transaction utility class for building DAMM-related transactions
+ * Provides methods for liquidity operations, swaps, and coin management
+ */
+declare class TransactionUtil {
+    /**
+     * Creates transaction parameters for collecting rewards and fees
+     * @param sdk - SDK instance
+     * @param transaction - Transaction to modify
+     * @param rewarderParams - Parameters for reward collection
+     * @param allCoinAssets - All available coin assets
+     * @param coinAssetsA - Optional coin assets for token A
+     * @param coinAssetsB - Optional coin assets for token B
+     * @returns Modified transaction with reward collection logic
+     */
+    static createCollectRewarderAndFeeParams(sdk: FerraDammSDK, transaction: Transaction, rewarderParams: CollectRewarderParams, allCoinAssets: CoinAsset[], coinAssetsA?: CoinAsset[], coinAssetsB?: CoinAsset[]): Transaction;
+    static createRemoveLiquidityPayload(params: RemoveLiquidityAndClaimRewardsParams, sdkOptions: SdkOptions, tx: Transaction): [coinA: TxCoin, coinB: TxCoin];
+    static joinBalanceTx(currentBalance: TxCoin, targetBalance: TxCoin, coinType: string, transaction: Transaction): void;
+    static joinCoinTx(currentCoin: TxCoin, targetCoin: TxCoin, coinType: string, transaction: Transaction): void;
+    static balanceToCoinTx(balance: TxCoin, coinType: string, tx: Transaction): TransactionResult;
+    /**
+     * Adjusts transaction parameters to account for gas costs
+     * @param sdk - SDK instance
+     * @param availableCoins - Available coin assets
+     * @param requiredAmount - Required amount for operation
+     * @param transaction - Transaction to analyze
+     * @returns Adjusted amount and optionally a new transaction
+     */
+    static adjustTransactionForGas(sdk: FerraDammSDK, availableCoins: CoinAsset[], requiredAmount: bigint, transaction: Transaction): Promise<{
+        fixAmount: bigint;
+        newTx?: Transaction;
+    }>;
+    /**
+     * Builds add liquidity transaction with gas optimization for SUI tokens
+     * @param sdk - SDK instance
+     * @param allCoins - All available coin assets
+     * @param liquidityParams - Parameters for adding liquidity
+     * @param gasEstimationConfig - Gas estimation configuration
+     * @param transaction - Optional existing transaction
+     * @param inputCoinA - Optional pre-built coin A input
+     * @param inputCoinB - Optional pre-built coin B input
+     * @returns Transaction with gas-optimized liquidity addition
+     */
+    static buildAddLiquidityFixTokenForGas(sdk: FerraDammSDK, allCoins: CoinAsset[], liquidityParams: AddLiquidityFixTokenParams, gasEstimationConfig: {
+        slippage: number;
+        curSqrtPrice: BN;
+    }, transaction?: Transaction, inputCoinA?: TransactionObjectArgument, inputCoinB?: TransactionObjectArgument): Promise<Transaction>;
+    /**
+     * Builds basic add liquidity transaction
+     * @param sdk - SDK instance
+     * @param allCoinAssets - All available coin assets
+     * @param liquidityParams - Parameters for adding liquidity
+     * @param transaction - Optional existing transaction
+     * @param inputCoinA - Optional pre-built coin A input
+     * @param inputCoinB - Optional pre-built coin B input
+     * @returns Transaction for adding liquidity
+     */
+    static buildAddLiquidityFixToken(sdk: FerraDammSDK, allCoinAssets: CoinAsset[], liquidityParams: AddLiquidityFixTokenParams, transaction?: Transaction, inputCoinA?: TransactionObjectArgument, inputCoinB?: TransactionObjectArgument): Promise<Transaction>;
+    /**
+     * Builds coin input for add liquidity operations with slippage handling
+     * @param transaction - Transaction to modify
+     * @param needIntervalAmount - Whether amount needs interval calculation
+     * @param amount - Amount to use
+     * @param slippageRate - Slippage rate
+     * @param coinType - Type of coin
+     * @param allCoinAssets - Available coin assets
+     * @param buildVector - Whether to build as vector
+     * @param fixAmount - Whether to fix amount exactly
+     * @returns Built coin result
+     */
+    static buildAddLiquidityFixTokenCoinInput(transaction: Transaction, needIntervalAmount: boolean, amount: number | string, slippageRate: number, coinType: string, allCoinAssets: CoinAsset[], buildVector?: boolean, fixAmount?: boolean): BuildCoinResult;
+    /**
+     * Adjusts liquidity parameters based on current pool state
+     * @param liquidityParams - Original liquidity parameters
+     * @param slippageRate - Slippage tolerance
+     * @param currentSqrtPrice - Current pool sqrt price
+     * @returns Adjusted liquidity parameters
+     */
+    static fixAddLiquidityFixTokenParams(liquidityParams: AddLiquidityFixTokenParams, slippageRate: number, currentSqrtPrice: BN): AddLiquidityFixTokenParams;
+    /**
+     * Builds the core arguments for add liquidity transaction
+     * @param transaction - Transaction to modify
+     * @param sdk - SDK instance
+     * @param allCoinAssets - All available coin assets
+     * @param liquidityParams - Liquidity parameters
+     * @param coinAInputs - Coin A input result
+     * @param coinBInputs - Coin B input result
+     * @returns Transaction with liquidity arguments
+     */
+    private static buildAddLiquidityFixTokenArgs;
+    /**
+     * Builds swap transaction with gas optimization for SUI tokens
+     * @param sdk - SDK instance
+     * @param swapParams - Parameters for swap
+     * @param allCoinAssets - All available coin assets
+     * @param gasEstimationConfig - Gas estimation configuration
+     * @returns Gas-optimized swap transaction
+     */
+    static buildSwapTransactionForGas(sdk: FerraDammSDK, swapParams: SwapParams, allCoinAssets: CoinAsset[], gasEstimationConfig: {
+        byAmountIn: boolean;
+        slippage: Percentage;
+        decimalsA: number;
+        decimalsB: number;
+        swapTicks: Array<TickData>;
+        currentPool: Pool;
+    }): Promise<Transaction>;
+    /**
+     * Builds basic swap transaction
+     * @param sdk - SDK instance
+     * @param swapParams - Parameters for swap
+     * @param allCoinAssets - All available coin assets
+     * @returns Swap transaction
+     */
+    static buildSwapTransaction(sdk: FerraDammSDK, swapParams: SwapParams, allCoinAssets: CoinAsset[]): Transaction;
+    /**
+     * Builds the core arguments for swap transaction
+     * @param transaction - Transaction to modify
+     * @param swapParams - Swap parameters
+     * @param sdkOptions - SDK configuration options
+     * @param coinAInput - Coin A input result
+     * @param coinBInput - Coin B input result
+     * @returns Transaction with swap arguments
+     */
+    static buildSwapTransactionArgs(transaction: Transaction, swapParams: SwapParams, sdkOptions: SdkOptions, coinAInput: BuildCoinResult, coinBInput: BuildCoinResult): Transaction;
+    /**
+     * Builds swap transaction without automatic coin transfers, with gas optimization
+     * @param sdk - SDK instance
+     * @param swapParams - Parameters for swap
+     * @param allCoinAssets - All available coin assets
+     * @param gasEstimationConfig - Gas estimation configuration
+     * @returns Object containing transaction and coin arguments for manual handling
+     */
+    static buildSwapTransactionWithoutTransferCoinsForGas(sdk: FerraDammSDK, swapParams: SwapParams, allCoinAssets: CoinAsset[], gasEstimationConfig: {
+        byAmountIn: boolean;
+        slippage: Percentage;
+        decimalsA: number;
+        decimalsB: number;
+        swapTicks: Array<TickData>;
+        currentPool: Pool;
+    }): Promise<{
+        tx: Transaction;
+        coinABs: TransactionObjectArgument[];
+    }>;
+    /**
+     * Builds swap transaction without automatic coin transfers
+     * @param sdk - SDK instance
+     * @param swapParams - Parameters for swap
+     * @param allCoinAssets - All available coin assets
+     * @returns Object containing transaction and coin arguments for manual handling
+     */
+    static buildSwapTransactionWithoutTransferCoins(sdk: FerraDammSDK, swapParams: SwapParams, allCoinAssets: CoinAsset[]): {
+        tx: Transaction;
+        coinABs: TransactionObjectArgument[];
+    };
+    /**
+     * Builds swap transaction arguments without automatic transfers
+     * @param sdk - SDK instance
+     * @param transaction - Transaction to modify
+     * @param swapParams - Swap parameters
+     * @param sdkOptions - SDK configuration options
+     * @param coinAInput - Coin A input result
+     * @param coinBInput - Coin B input result
+     * @returns Object containing transaction and resulting coin arguments
+     */
+    static buildSwapTransactionWithoutTransferCoinArgs(sdk: FerraDammSDK, transaction: Transaction, swapParams: SwapParams, sdkOptions: SdkOptions, coinAInput: BuildCoinResult, coinBInput: BuildCoinResult): {
+        tx: Transaction;
+        txRes: TransactionObjectArgument[];
+    };
+    /**
+     * Fixes swap parameters by recalculating limits based on current pool state
+     * @param sdk - SDK instance
+     * @param swapParams - Original swap parameters
+     * @param gasEstimationConfig - Gas estimation configuration
+     * @returns Updated swap parameters with correct limits
+     */
+    static fixSwapParams(sdk: FerraDammSDK, swapParams: SwapParams, gasEstimationConfig: {
+        byAmountIn: boolean;
+        slippage: Percentage;
+        decimalsA: number;
+        decimalsB: number;
+        swapTicks: Array<TickData>;
+        currentPool: Pool;
+    }): Promise<SwapParams>;
+    /**
+     * Asynchronously builds coin input for a specific amount
+     * @param sdk - SDK instance
+     * @param transaction - Transaction to modify
+     * @param amount - Amount to build coin for
+     * @param coinType - Type of coin
+     * @param buildVector - Whether to build as vector
+     * @param fixAmount - Whether to fix amount exactly
+     * @returns Transaction object argument or undefined
+     */
+    static syncBuildCoinInputForAmount(sdk: FerraDammSDK, transaction: Transaction, amount: bigint, coinType: string, buildVector?: boolean, fixAmount?: boolean): Promise<TransactionObjectArgument | undefined>;
+    /**
+     * Builds coin input for a specific amount from available assets
+     * @param transaction - Transaction to modify
+     * @param availableCoins - Available coin assets
+     * @param amount - Amount to build coin for
+     * @param coinType - Type of coin
+     * @param buildVector - Whether to build as vector
+     * @param fixAmount - Whether to fix amount exactly
+     * @returns Built coin result
+     */
+    static buildCoinForAmount(transaction: Transaction, availableCoins: CoinAsset[], amount: bigint, coinType: string, buildVector?: boolean, fixAmount?: boolean): BuildCoinResult;
+    /**
+     * Builds coin with specific balance using coinWithBalance utility
+     * @param amount - Amount for the coin
+     * @param coinType - Type of coin
+     * @returns Transaction object argument for the coin
+     */
+    static buildCoinWithBalance(amount: bigint, coinType: string): TransactionObjectArgument;
+    /**
+     * Builds vector of coins for transaction use
+     * @param transaction - Transaction to modify
+     * @param availableCoins - All available coin assets
+     * @param targetCoinAssets - Target coin assets to use
+     * @param amount - Amount needed
+     * @param coinType - Type of coin
+     * @param fixAmount - Whether to fix amount exactly
+     * @returns Built coin result as vector
+     */
+    private static buildVectorCoin;
+    /**
+     * Builds single coin for transaction use
+     * @param transaction - Transaction to modify
+     * @param targetCoinAssets - Target coin assets to use
+     * @param amount - Amount needed
+     * @param coinType - Type of coin
+     * @param fixAmount - Whether to fix amount exactly
+     * @returns Built coin result as single coin
+     */
+    private static buildOneCoin;
+    /**
+     * Builds split target coin by merging and splitting as needed
+     * @param transaction - Transaction to modify
+     * @param amount - Amount needed
+     * @param targetCoinAssets - Coin assets to use
+     * @param fixAmount - Whether to fix amount exactly
+     * @returns Split coin result with metadata
+     */
+    private static buildSplitTargetCoin;
+    /**
+     * Generic coin building method that delegates to vector or single coin building
+     * @param transaction - Transaction to modify
+     * @param availableCoins - All available coin assets
+     * @param targetCoinAssets - Target coin assets to use
+     * @param amount - Amount needed
+     * @param coinType - Type of coin
+     * @param buildVector - Whether to build as vector
+     * @param fixAmount - Whether to fix amount exactly
+     * @returns Built coin result
+     */
+    private static buildCoin;
+    /**
+     * Builds zero-value coin for cases where no amount is needed
+     * @param availableCoins - All available coin assets
+     * @param transaction - Transaction to modify
+     * @param coinType - Type of coin to mint
+     * @param buildVector - Whether to build as vector
+     * @returns Built zero coin result
+     */
+    private static buildZeroValueCoin;
+    /**
+     * Builds coin for amount with interval support (for slippage handling)
+     * @param transaction - Transaction to modify
+     * @param availableCoins - All available coin assets
+     * @param amounts - Amount interval with first and second options
+     * @param coinType - Type of coin
+     * @param buildVector - Whether to build as vector
+     * @param fixAmount - Whether to fix amount exactly
+     * @returns Built coin result using interval logic
+     */
+    static buildCoinForAmountInterval(transaction: Transaction, availableCoins: CoinAsset[], amounts: CoinInputInterval, coinType: string, buildVector?: boolean, fixAmount?: boolean): BuildCoinResult;
+    /**
+     * Calls the Move function to mint a zero-value coin
+     * @param transaction - Transaction to modify
+     * @param coinType - Type of coin to mint
+     * @returns Transaction object argument for zero coin
+     */
+    static callMintZeroValueCoin: (transaction: Transaction, coinType: string) => TransactionResult;
+    /**
+     * Builds router swap transaction for multi-path swapping
+     * @param sdk - SDK instance
+     * @param routerParams - Router swap parameters
+     * @param isAmountIn - Whether amount is input (true) or output (false)
+     * @param allCoinAssets - All available coin assets
+     * @param recipient - Optional recipient address for transfers
+     * @returns Router swap transaction
+     */
+    static buildRouterSwapTransaction(sdk: FerraDammSDK, routerParams: SwapWithRouterParams, isAmountIn: boolean, allCoinAssets: CoinAsset[], recipient?: string): Promise<Transaction>;
+    /**
+     * Builds the base path transaction for router swaps
+     * @param sdk - SDK instance
+     * @param routerParams - Router swap parameters
+     * @param isAmountIn - Whether amount is input
+     * @param allCoinAssets - All available coin assets
+     * @param transaction - Transaction to modify
+     * @param recipient - Optional recipient address
+     * @returns Modified transaction with router swap logic
+     */
+    static buildRouterBasePathTx(sdk: FerraDammSDK, routerParams: SwapWithRouterParams, isAmountIn: boolean, allCoinAssets: CoinAsset[], transaction: Transaction, recipient?: string): Promise<Transaction>;
+    /**
+     * Builds router swap operations and returns resulting coins
+     * @param sdk - SDK instance
+     * @param routerParams - Router swap parameters
+     * @param isAmountIn - Whether amount is input
+     * @param sourceCoinResult - Source coin build result
+     * @param targetCoinResult - Target coin build result
+     * @param transaction - Transaction to modify
+     * @returns Object with resulting coins and modified transaction
+     */
+    static buildRouterBasePathReturnCoins(sdk: FerraDammSDK, routerParams: SwapWithRouterParams, isAmountIn: boolean, sourceCoinResult: BuildCoinResult, targetCoinResult: BuildCoinResult, transaction: Transaction): Promise<{
+        fromCoin: TransactionObjectArgument;
+        toCoin: any;
+        tx: Transaction;
+    }>;
+    /**
+     * Validates that output coin meets minimum threshold requirements
+     * @param sdk - SDK instance
+     * @param isAmountIn - Whether amount is input
+     * @param transaction - Transaction to modify
+     * @param outputCoin - Coin to check
+     * @param minimumAmount - Minimum required amount
+     * @param coinType - Type of coin being checked
+     */
+    static checkCoinThreshold(sdk: FerraDammSDK, isAmountIn: boolean, transaction: Transaction, outputCoin: TransactionObjectArgument, minimumAmount: number, coinType: string): void;
+    /**
+     * Validates that output coin meets minimum threshold requirements
+     * @param sdk - SDK instance
+     * @param isAmountIn - Whether amount is input
+     * @param transaction - Transaction to modify
+     * @param outputCoin - Coin to check
+     * @param minimumAmount - Minimum required amount
+     * @param coinType - Type of coin being checked
+     */
+    static checkCoinThresholdInternal(coin: TransactionObjectArgument, minimumAmount: bigint, coinType: string, sdkOptions: SdkOptions, transaction: Transaction): void;
+    /**
+     * Builds DAMM base path transaction for individual swap steps
+     * @param sdk - SDK instance
+     * @param basePath - Base path configuration
+     * @param transaction - Transaction to modify
+     * @param isAmountIn - Whether amount is input
+     * @param sourceCoin - Source coin argument
+     * @param targetCoin - Target coin argument
+     * @param isMiddleStep - Whether this is a middle step in multi-hop
+     * @param partnerAddress - Partner address for fees
+     * @returns Object with resulting coins and transaction
+     */
+    private static buildDammBasePathTx;
+    /**
+     * Builds coin type pairs for multi-hop routing
+     * @param coinTypes - Array of coin types in the path
+     * @param partitionQuantities - Quantities for each partition
+     * @returns Array of coin type pairs for routing
+     */
+    static buildCoinTypePair(coinTypes: string[], partitionQuantities: number[]): string[][];
+    /**
+     * Transfers coin to sender using Move call
+     * @param sdk - SDK instance
+     * @param transaction - Transaction to modify
+     * @param coinToTransfer - Coin to transfer
+     * @param coinType - Type of coin
+     */
+    static buildTransferCoinToSender(sdk: FerraDammSDK, transaction: Transaction, coinToTransfer: TransactionObjectArgument, coinType: string): void;
+    /**
+     * Transfers coin to specified recipient or sender if no recipient provided
+     * @param sdk - SDK instance
+     * @param transaction - Transaction to modify
+     * @param coinToTransfer - Coin to transfer
+     * @param coinType - Type of coin
+     * @param recipient - Optional recipient address
+     */
+    static buildTransferCoin(sdk: FerraDammSDK, transaction: Transaction, coinToTransfer: TransactionObjectArgument, coinType: string, recipient?: string): void;
+    static buildLockPosition(args: {
+        positionId: string;
+        untilTimestamp: number;
+        poolId: string;
+        typeA: string;
+        typeB: string;
+    }, sdkOptions: SdkOptions, tx?: Transaction): readonly [Transaction];
+}
+
+/**
+ * Check if the address is a valid sui address.
+ * @param {string}address
+ * @returns
+ */
+declare function checkValidSuiAddress(address: string): boolean;
+declare class TxBlock {
+    txBlock: Transaction;
+    constructor();
+    /**
+     * Transfer sui to many recipoents.
+     * @param {string[]}recipients The recipient addresses.
+     * @param {number[]}amounts The amounts of sui coins to be transferred.
+     * @returns this
+     */
+    transferSuiToMany(recipients: string[], amounts: number[]): this;
+    /**
+     * Transfer sui to one recipient.
+     * @param {string}recipient recipient cannot be empty or invalid sui address.
+     * @param {number}amount
+     * @returns this
+     */
+    transferSui(recipient: string, amount: number): this;
+    /**
+     * Transfer coin to many recipients.
+     * @param {string}recipient recipient cannot be empty or invalid sui address.
+     * @param {number}amount amount cannot be empty or invalid sui address.
+     * @param {string[]}coinObjectIds object ids of coins to be transferred.
+     * @returns this
+     * @deprecated use transferAndDestoryZeroCoin instead
+     */
+    transferCoin(recipient: string, amount: number, coinObjectIds: string[]): this;
+}
+
+declare function getSuiObjectData(resp: SuiObjectResponse): SuiObjectData | null | undefined;
+declare function getObjectDeletedResponse(resp: SuiObjectResponse): SuiObjectRef | undefined;
+declare function getObjectNotExistsResponse(resp: SuiObjectResponse): string | undefined;
+declare function getObjectReference(resp: SuiObjectResponse | OwnedObjectRef): SuiObjectRef | undefined;
+declare function getObjectId(data: SuiObjectResponse | SuiObjectRef | OwnedObjectRef): string;
+declare function getObjectVersion(data: SuiObjectResponse | SuiObjectRef | SuiObjectData): string | number | undefined;
+declare function isSuiObjectResponse(resp: SuiObjectResponse | SuiObjectData): resp is SuiObjectResponse;
+declare function getMovePackageContent(data: SuiObjectResponse): any | undefined;
+declare function getMoveObject(data: SuiObjectResponse | SuiObjectData): SuiMoveObject | undefined;
+declare function getMoveObjectType(resp: SuiObjectResponse): string | undefined;
+/**
+ * Deriving the object type from the object response
+ * @returns 'package' if the object is a package, move object type(e.g., 0x2::coin::Coin<0x2::sui::SUI>)
+ * if the object is a move object
+ */
+declare function getObjectType(resp: SuiObjectResponse | SuiObjectData): string | null | undefined;
+declare function getObjectPreviousTransactionDigest(resp: SuiObjectResponse): string | null | undefined;
+declare function getObjectOwner(resp: SuiObjectResponse): ObjectOwner | null | undefined;
+declare function getObjectDisplay(resp: SuiObjectResponse): DisplayFieldsResponse;
+/**
+ * Get the fields of a sui object response or data. The dataType of the object must be moveObject.
+ * @param {SuiObjectResponse | SuiObjectData}object The object to get the fields from.
+ * @returns {any} The fields of the object.
+ */
+declare function getObjectFields(object: SuiObjectResponse | SuiObjectData): any;
+interface SuiObjectDataWithContent extends SuiObjectData {
+    content: SuiParsedData;
+}
+/**
+ * Return hasPublicTransfer of a move object.
+ * @param {SuiObjectResponse | SuiObjectData}data
+ * @returns
+ */
+declare function hasPublicTransfer(data: SuiObjectResponse | SuiObjectData): boolean;
+
+declare const dammMainnet: SdkOptions;
+/**
+ * Initialize the mainnet SDK
+ * @param fullNodeUrl. If provided, it will be used as the full node URL.
+ * @param simulationAccount. If provided, it will be used as the simulation account address.
+ *                           when you use the `preswap` method or other methods that require payment assistance,
+ *                           you must configure a simulation account with sufficient balance of input tokens.
+ *                           If you connect the wallet, you can set the current wallet address to simulationAccount.
+ * @returns
+ */
+declare function initMainnetSDK(fullNodeUrl?: string, wallet?: string): FerraDammSDK;
+
+declare const dammTestnet: SdkOptions;
+/**
+ * Initialize the testnet SDK
+ * @param fullNodeUrl. If provided, it will be used as the full node URL.
+ * @param simulationAccount. If provided, it will be used as the simulation account address.
+ * @returns
+ */
+declare function initTestnetSDK(fullNodeUrl?: string, wallet?: string): FerraDammSDK;
+
+declare const dammBeta: SdkOptions;
+/**
+ * Initialize the beta SDK
+ * @param fullNodeUrl. If provided, it will be used as the full node URL.
+ * @param simulationAccount. If provided, it will be used as the simulation account address.
+ * @returns
+ */
+declare function initBetaSDK(fullNodeUrl?: string, wallet?: string): FerraDammSDK;
+
+interface InitFerraSDKOptions {
+    network: 'mainnet' | 'testnet' | 'beta';
+    fullNodeUrl?: string;
+    wallet?: string;
+}
+/**
+ * Helper function to initialize the Ferra SDK
+ * @param env - The environment to initialize the SDK in. One of 'mainnet' or 'testnet'.
+ * @param fullNodeUrl - The full node URL to use.
+ * @param wallet - The wallet address to use. If not provided,
+ *                 If you use the `preswap` method or other methods that require payment assistance,
+ *                  you must configure a wallet with sufficient balance of input tokens.
+ *                  If you do not set a wallet, the SDK will throw an error.
+ * @returns The initialized Ferra SDK.
+ */
+declare function initFerraSDK(options: InitFerraSDKOptions): FerraDammSDK;
+declare function initFerraDammSDK(options: InitFerraSDKOptions): FerraDammSDK;
+
+export { type AddLiquidityCommonParams, type AddLiquidityFixTokenParams, type AddLiquidityParams, type AddressAndDirection, type AdjustResult, AmountSpecified, type BasePath, type BestInternalRouterResult, type BigNumber, type Bits, type BuildCoinResult, CLOCK_ADDRESS, CachedContent, type CalculateRatesParams, type CalculateRatesResult, type ClosePositionParams, type CoinAmounts, type CoinAsset, CoinAssist, CoinInfoAddress, type CoinNode, type CoinPairType, type CoinProvider, CoinStoreAddress, type CollectFeeParams, type CollectFeesQuote, type CollectFeesQuoteParam, type CollectRewarderParams, type CreatePartnerEvent, type CreatePoolAddLiquidityParams, type CreatePoolAndAddLiquidityRowResult, type CreatePoolParams, DEFAULT_GAS_BUDGET_FOR_MERGE, DEFAULT_GAS_BUDGET_FOR_SPLIT, DEFAULT_GAS_BUDGET_FOR_STAKE, DEFAULT_GAS_BUDGET_FOR_TRANSFER, DEFAULT_GAS_BUDGET_FOR_TRANSFER_SUI, DEFAULT_NFT_TRANSFER_GAS_FEE, type DammConfig, DammExpectSwapModule, DammFetcherModule, DammIntegratePoolModule, DammIntegrateRouterModule, DammIntegrateRouterWithPartnerModule, DammIntegrateUtilsModule, DammPartnerModule, DammPoolUtil, DammPositionStatus, type DammpoolData, type DataPage, FEE_RATE_DENOMINATOR, type FaucetCoin, type FeeTier, FerraDammSDK, type FetchParams, GAS_SYMBOL, GAS_TYPE_ARG, GAS_TYPE_ARG_LONG, type LiquidityInput, MAX_SQRT_PRICE, MAX_TICK_INDEX, MIN_SQRT_PRICE, MIN_TICK_INDEX, MathUtil, type NFT, ONE, type OnePath, type OpenPositionParams, type Package, type PageQuery, type PaginationArgs, type PathLink, type PathProvider, Percentage, type Pool, type PoolImmutables, type PoolInfo, PoolModule, type PoolTransactionInfo, type Position, PositionModule, type PositionReward, PositionStatus, type PositionTransactionInfo, PositionUtil, type PreRouterSwapParams, type PreSwapLpChangeParams, type PreSwapParams, type PreSwapResult, type PreSwapWithMultiPoolParams, type RemoveLiquidityAndClaimRewardsParams, type RemoveLiquidityParams, type Rewarder, type RewarderAmountOwed, RouterModule, RpcModule, SUI_SYSTEM_STATE_OBJECT_ID, type SdkOptions, type SplitPath, SplitSwap, type SplitSwapResult, SplitUnit, type SuiAddressType, type SuiBasicTypes, type SuiInputTypes, type SuiObjectDataWithContent, type SuiObjectIdType, type SuiResource, type SuiStructTag, type SuiTxArg, SwapDirection, SwapModule, type SwapParams, type SwapResult, type SwapStepResult, SwapUtils, type SwapWithRouterParams, TICK_ARRAY_SIZE, TWO, type Tick, type TickData, TickMath, TickUtil, type TokenConfig, type TokenConfigEvent, type TokenInfo, type TransPreSwapWithMultiPoolParams, TransactionUtil, TxBlock, U128, U128_MAX, U64_MAX, ZERO, addHexPrefix, adjustForCoinSlippage, adjustForSlippage, asIntN, asUintN, bufferToHex, buildDammPositionName, buildNFT, buildPool, buildPoolTransactionInfo, buildPosition, buildPositionReward, buildPositionTransactionInfo, buildTickData, buildTickDataByEvent, cacheTime24h, cacheTime5min, checkAddress, checkValidSuiAddress, collectFeesQuote, composeType, computeSwap, computeSwapStep, createSplitAmountArray, createSplitArray, type createTestTransferTxPayloadParams, d, dammBeta, dammMainnet, dammTestnet, decimalsMultiplier, FerraDammSDK as default, estPoolAPR, type estPosAPRResult, estPositionAPRWithDeltaMethod, estPositionAPRWithMultiMethod, estimateLiquidityForCoinA, estimateLiquidityForCoinB, extractAddressFromType, extractStructTagFromType, findAdjustCoin, fixCoinType, fixSuiObjectId, fromDecimalsAmount, getAmountFixedDelta, getAmountUnfixedDelta, getCoinAFromLiquidity, getCoinBFromLiquidity, getDefaultSuiInputType, getDeltaA, getDeltaB, getDeltaDownFromOutput, getDeltaUpFromInput, getFutureTime, getLiquidityFromCoinA, getLiquidityFromCoinB, getLowerSqrtPriceFromCoinA, getLowerSqrtPriceFromCoinB, getMoveObject, getMoveObjectType, getMovePackageContent, getNearestTickByTick, getNextSqrtPriceAUp, getNextSqrtPriceBDown, getNextSqrtPriceFromInput, getNextSqrtPriceFromOutput, getObjectDeletedResponse, getObjectDisplay, getObjectFields, getObjectId, getObjectNotExistsResponse, getObjectOwner, getObjectPreviousTransactionDigest, getObjectReference, getObjectType, getObjectVersion, getPackagerConfigs, getRewardInTickRange, getSuiObjectData, getTickDataFromUrlData, getUpperSqrtPriceFromCoinA, getUpperSqrtPriceFromCoinB, hasPublicTransfer, hexToNumber, hexToString, initBetaSDK, initFerraDammSDK, initFerraSDK, initMainnetSDK, initTestnetSDK, isSortedSymbols, isSuiObjectResponse, newBits, normalizeCoinType, patchFixSuiObjectId, poolFilterEvenTypes, printTransaction, removeHexPrefix, secretKeyToEd25519Keypair, secretKeyToSecp256k1Keypair, shortAddress, shortString, tickScore, toBuffer, toCoinAmount, toDecimalsAmount, transDammpoolDataWithoutTicks, utf8to16 };