@cetusprotocol/deepbook-utils 0.0.0-experimental-20251225165838

package/dist/index.d.ts

@@ -0,0 +1,1353 @@
+import { SuiTransactionBlockResponse, SuiClient, SuiEventFilter, SuiObjectResponseQuery, SuiObjectDataOptions, CoinBalance, SuiObjectResponse, SuiObjectData, SuiObjectRef, OwnedObjectRef, SuiMoveObject, ObjectOwner, DisplayFieldsResponse, SuiParsedData } from '@mysten/sui/client';
+import { SuiGraphQLClient } from '@mysten/sui/graphql';
+import * as _mysten_sui_transactions from '@mysten/sui/transactions';
+import { TransactionArgument, Transaction } from '@mysten/sui/transactions';
+import { SuiPriceServiceConnection, SuiPythClient } from '@pythnetwork/pyth-sui-js';
+import { Ed25519Keypair } from '@mysten/sui/keypairs/ed25519';
+import { Secp256k1Keypair } from '@mysten/sui/keypairs/secp256k1';
+import Decimal from 'decimal.js';
+
+interface IModule {
+    readonly sdk: DeepbookUtilsSDK;
+}
+
+/**
+ * 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 CLMM (Cryptocurrency Liquidity Mining Module).
+ */
+declare const ClmmIntegratePoolModule = "pool_script";
+declare const ClmmIntegratePoolV2Module = "pool_script_v2";
+declare const ClmmIntegrateRouterModule = "router";
+declare const ClmmIntegrateRouterWithPartnerModule = "router_with_partner";
+declare const ClmmFetcherModule = "fetcher_script";
+declare const ClmmExpectSwapModule = "expect_swap";
+declare const ClmmIntegrateUtilsModule = "utils";
+/**
+ * The address for CoinInfo module.
+ */
+declare const CoinInfoAddress = "0x1::coin::CoinInfo";
+/**
+ * The address for CoinStore module.
+ */
+declare const CoinStoreAddress = "0x1::coin::CoinStore";
+/**
+ * Constants for different modules in the Deepbook system.
+ */
+declare const DeepbookCustodianV2Moudle = "custodian_v2";
+declare const DeepbookClobV2Moudle = "clob_v2";
+declare const DeepbookEndpointsV2Moudle = "endpoints_v2";
+/**
+ * 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;
+/**
+ * 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 configuration data for a cryptocurrency coin.
+ */
+type CoinConfig = {
+    /**
+     * The unique identifier of the coin.
+     */
+    id: string;
+    /**
+     * The name of the coin.
+     */
+    name: string;
+    /**
+     * The symbol of the coin.
+     */
+    symbol: string;
+    /**
+     * The address associated with the coin.
+     */
+    address: string;
+    /**
+     * The Pyth identifier of the coin.
+     */
+    pyth_id: string;
+    /**
+     * The project URL related to the coin.
+     */
+    project_url: string;
+    /**
+     * The URL to the logo image of the coin.
+     */
+    logo_url: string;
+    /**
+     * The number of decimal places used for the coin.
+     */
+    decimals: number;
+} & Record<string, any>;
+/**
+ * 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;
+};
+
+type OrderFee = {
+    takerFee: string;
+    makerFee: string;
+    feeType: string;
+    takerFeeDisplay: string;
+    makerFeeDisplay: string;
+};
+type OrderDeepPrice = {
+    asset_is_base: boolean;
+    deep_per_asset: number;
+};
+declare enum OrderType {
+    NO_RESTRICTION = 0,
+    IMMEDIATE_OR_CANCEL = 1,
+    FILL_OR_KILL = 2,
+    POST_ONLY = 3
+}
+type Token = {
+    coinType: string;
+    decimals: number;
+};
+type PoolInfo = {
+    address: string;
+    baseCoin: Token;
+    quoteCoin: Token;
+    [key: string]: any;
+};
+
+type MarginCoinInfo = {
+    coinType: string;
+    feed?: string;
+    decimals?: number;
+    scalar?: number;
+    priceInfoObjectId?: string;
+};
+type MarginPoolInfo = {
+    id: string;
+    baseCoin: MarginCoinInfo;
+    quoteCoin: MarginCoinInfo;
+};
+
+type BigNumber = Decimal.Value | number | string;
+
+type CoinItem = {
+    coinType: string;
+    decimals: number;
+};
+type DeepCoin = {
+    coinType: string;
+    decimals: number;
+};
+type StateAccount = {
+    balance_manager_id: string;
+    open_orders: string[];
+    owed_balances: Balances;
+    settled_balances: Balances;
+    unclaimed_rebates: Balances;
+    taker_volume: string;
+    poolInfo: any;
+};
+type Balances = {
+    base: string;
+    quote: string;
+    deep: string;
+};
+/**
+ * Provides a high-level interface around deepbook utilities, handling
+ * transaction preparation, caching, and common workflows for interacting with
+ * DeepBook pools.
+ */
+declare class DeepbookUtilsModule implements IModule {
+    protected _sdk: DeepbookUtilsSDK;
+    protected _deep: DeepCoin;
+    private readonly _cache;
+    constructor(sdk: DeepbookUtilsSDK);
+    get sdk(): DeepbookUtilsSDK;
+    get deepCoin(): DeepCoin;
+    /**
+     * Creates a balance manager and shares it with the caller account.
+     */
+    createAndShareBalanceManager(): Transaction;
+    /**
+     * Creates a new balance manager and deposits the specified coin amount into it.
+     */
+    createAndDepsit({ account, coin, amountToDeposit }: {
+        account: string;
+        coin: CoinItem;
+        amountToDeposit: string;
+    }): Transaction;
+    /**
+     * Deposits assets into an existing balance manager, creating a transaction if
+     * one is not provided.
+     */
+    depositIntoManager({ account, balanceManager, coin, amountToDeposit, tx, }: {
+        account: string;
+        balanceManager: string;
+        coin: CoinItem;
+        amountToDeposit: string;
+        tx?: Transaction;
+    }): Transaction | null;
+    /**
+     * Withdraws assets from a balance manager. Optionally returns the withdrawn
+     * asset objects instead of transferring them immediately.
+     */
+    withdrawFromManager({ account, balanceManager, coin, amountToWithdraw, returnAssets, txb, }: {
+        account: string;
+        balanceManager: string;
+        coin: CoinItem;
+        amountToWithdraw: string;
+        returnAssets?: boolean;
+        txb?: Transaction;
+    }): Transaction | _mysten_sui_transactions.TransactionResult;
+    /**
+     * Withdraws free balances from multiple managers into the owner account.
+     */
+    withdrawManagersFreeBalance({ account, balanceManagers, tx, }: {
+        account: string;
+        balanceManagers: Record<string, {
+            coinType: string;
+            amount: string;
+        }[]>;
+        tx?: Transaction;
+    }): Transaction;
+    /**
+     * Retrieves balance managers for an account, optionally using the cached
+     * result when it is still valid.
+     */
+    getBalanceManager(account: string, forceRefresh?: boolean): Promise<any>;
+    withdrawSettledAmounts({ poolInfo, balanceManager }: {
+        poolInfo: any;
+        balanceManager: string;
+    }): Transaction;
+    /**
+     * Retrieves balances for the provided coins tracked by a specific balance
+     * manager.
+     */
+    getManagerBalance({ account, balanceManager, coins }: {
+        account: string;
+        balanceManager: string;
+        coins: CoinItem[];
+    }): Promise<any>;
+    /**
+     * Retrieves balances for all balance managers owned by the account.
+     */
+    getAccountAllManagerBalance({ account, coins }: {
+        account: string;
+        coins: CoinItem[];
+    }): Promise<any>;
+    /**
+     * Retrieves the mid-market price for a pool via dev-inspect.
+     */
+    getMarketPrice(poolInfo: any): Promise<string>;
+    /**
+     * Queries on-chain events to retrieve known pools.
+     */
+    getPools(): Promise<any>;
+    /**
+     * Estimates quote quantity output for a given base amount.
+     */
+    getQuoteQuantityOut(poolInfo: any, baseQuantity: string, account: string): Promise<{
+        baseQuantityDisplay: string;
+        baseOutDisplay: string;
+        quoteOutDisplay: string;
+        deepRequiredDisplay: string;
+        baseQuantity: string;
+        baseOut: string;
+        quoteOut: string;
+        deepRequired: string;
+    }>;
+    /**
+     * Estimates base quantity output for a provided quote amount.
+     */
+    getBaseQuantityOut(poolInfo: any, quoteQuantity: string, account: string): Promise<{
+        quoteQuantityDisplay: string;
+        baseOutDisplay: string;
+        quoteOutDisplay: string;
+        deepRequiredDisplay: string;
+        quoteQuantity: string;
+        baseOut: string;
+        quoteOut: string;
+        deepRequired: string;
+    }>;
+    /**
+     * Estimates both base and quote outputs given respective input amounts.
+     */
+    getQuantityOut(poolInfo: any, baseQuantity: string, quoteQuantity: string, account: string): Promise<{
+        baseQuantityDisplay: string;
+        quoteQuantityDisplay: string;
+        baseOutDisplay: string;
+        quoteOutDisplay: string;
+        deepRequiredDisplay: string;
+        baseQuantity: string;
+        quoteQuantity: string;
+        baseOut: number;
+        quoteOut: number;
+        deepRequired: number;
+    }>;
+    /**
+     * Estimates taker and maker fees for a prospective trade.
+     */
+    estimatedMaxFee(poolInfo: any, quantity: string, priceInput: string, payWithDeep: boolean, isBid: boolean, isLimit: boolean, priceOrigin?: string): Promise<OrderFee>;
+    /**
+     * Retrieves the deep price information required for fee calculation.
+     */
+    getOrderDeepPrice(poolInfo: any): Promise<OrderDeepPrice | null>;
+    /**
+     * Parses a serialized `OrderDeepPrice` struct from Move into a JS object.
+     */
+    parseOrderDeepPrice(bytes: Uint8Array): OrderDeepPrice;
+    /**
+     * Builds coin assets for the requested amount, sourcing from the owner's coins.
+     */
+    getCoinAssets(coin: string, amount: string, allCoinAsset: any, txb: any): TransactionArgument;
+    /**
+     * Retrieves balances related to an upcoming transaction to determine deposit needs.
+     */
+    getTransactionRelatedBalance(poolInfo: any, baseAmount: string, quoteAmount: string, noDeep: boolean, account: string, payWithDeep: boolean, balanceManager: string): Promise<{
+        baseManagerBlance: any;
+        quoteManagerBlance: any;
+        feeManaerBalance: any;
+    }>;
+    /**
+     * Determines the fee asset to use and whether additional deposits are required.
+     */
+    getFeeAsset(maxFee: string, feeCoin: string, baseAmount: string, quoteAmount: string, feeManaerBalance: string, quoteIsDeep: boolean, baseIsDeep: boolean, allCoinAsset: any, payWithDeep: boolean, txb: Transaction): {
+        feeAsset: any;
+        haveDepositFee: string;
+    };
+    /**
+     * Prepares the assets necessary to execute a limit order transaction.
+     */
+    getTransactionRelatedAssets(poolInfo: any, baseAmount: string, quoteAmount: string, maxFee: string, isBid: boolean, account: string, payWithDeep: boolean, balanceManager: string, txb: Transaction): Promise<{
+        baseAsset: any;
+        quoteAsset: any;
+        feeAsset: {
+            feeAsset: any;
+            haveDepositFee: string;
+        };
+        haveDeposit: boolean;
+    }>;
+    /**
+     * Prepares assets necessary to execute a market order transaction.
+     */
+    getMarketTransactionRelatedAssets(poolInfo: any, baseAmount: string, quoteAmount: string, maxFee: string, isBid: boolean, account: string, payWithDeep: boolean, balanceManager: string, txb: Transaction): Promise<{
+        baseAsset: any;
+        quoteAsset: any;
+        feeAsset: any;
+    }>;
+    /**
+     * Creates a transaction that deposits required assets and then places a limit order.
+     */
+    createDepositThenPlaceLimitOrder({ poolInfo, priceInput, quantity, orderType, isBid, maxFee, account, payWithDeep, expirationTimestamp, }: {
+        poolInfo: PoolInfo;
+        priceInput: string;
+        quantity: string;
+        orderType: OrderType;
+        isBid: boolean;
+        maxFee: string;
+        account: string;
+        payWithDeep: boolean;
+        expirationTimestamp?: number;
+    }): Promise<any>;
+    getEmptyCoin(txb: any, coin: string): any;
+    /**
+     * Creates a transaction that deposits necessary assets and places a market order.
+     */
+    createDepositThenPlaceMarketOrder({ poolInfo, quantity, isBid, maxFee, account, payWithDeep, slippage, }: {
+        poolInfo: any;
+        quantity: string;
+        isBid: boolean;
+        maxFee: string;
+        account: string;
+        payWithDeep: boolean;
+        slippage?: number;
+    }): Promise<any>;
+    /**
+     * Builds a transaction to place a limit order and handles required deposits.
+     */
+    placeLimitOrder({ balanceManager, poolInfo, priceInput, quantity, isBid, orderType, maxFee, account, payWithDeep, expirationTimestamp, }: {
+        balanceManager: string;
+        poolInfo: any;
+        priceInput: string;
+        quantity: string;
+        isBid: boolean;
+        orderType: OrderType;
+        maxFee: string;
+        account: string;
+        payWithDeep: boolean;
+        expirationTimestamp?: number;
+    }): Promise<Transaction>;
+    /**
+     * Builds a transaction to modify an existing order quantity.
+     */
+    modifyOrder({ balanceManager, poolInfo, orderId, newOrderQuantity, }: {
+        balanceManager: string;
+        poolInfo: PoolInfo;
+        orderId: string;
+        newOrderQuantity: string;
+    }): Transaction;
+    getBestAskprice(poolInfo: any): Promise<any>;
+    getBestBidprice(poolInfo: any): Promise<any>;
+    getBestAskOrBidPrice(poolInfo: any, isBid: boolean): Promise<any>;
+    /**
+     * Builds a transaction to place a market order, handling deposits as needed.
+     */
+    placeMarketOrder({ balanceManager, poolInfo, baseQuantity, quoteQuantity, isBid, maxFee, account, payWithDeep, slippage, }: {
+        balanceManager: string;
+        poolInfo: PoolInfo;
+        baseQuantity: string;
+        quoteQuantity: string;
+        isBid: boolean;
+        maxFee: string;
+        account: string;
+        payWithDeep: boolean;
+        slippage?: number;
+    }): Promise<any>;
+    getOrderInfoList(poolInfo: any, orderIds: string[], account: string): Promise<any>;
+    decodeOrderId(encodedOrderId: bigint): {
+        isBid: boolean;
+        price: bigint;
+        orderId: bigint;
+    };
+    getOpenOrder(poolInfo: any, account: string, balanceManager: string, orders?: string[]): Promise<any>;
+    cancelOrders(orderList: any, balanceManager: string): Transaction;
+    getDeepbookOrderBook(poolKey: string, priceLow: number, priceHigh: number, isBid: boolean, account: string, balanceManager: string): Promise<void>;
+    /**
+     * Processes raw level 2 order book data returned from dev-inspect into
+     * aggregated price levels.
+     */
+    processOrderBookData(data: any, baseCoin: any, quoteCoin: any, unit: number): unknown[];
+    getLevel2RangeTx(poolInfo: any, isBid: boolean, priceLow: string | number, priceHigh: string | number, tx?: Transaction): Transaction;
+    /**
+     * Fetches order book data for the specified price range and order side.
+     */
+    fetchOrderBook(poolInfo: any, orderType: 'bid' | 'ask' | 'all', midPrice: string, low: number, high: number, unit: number): Promise<{
+        bid: any;
+        ask: any;
+    }>;
+    /**
+     * Retrieves the order book for the pool, performing additional requests if needed.
+     */
+    getOrderBook(poolInfo: any, orderType: 'bid' | 'ask' | 'all', unit: number): Promise<any>;
+    /**
+     * Retrieves the raw order book without post-processing, primarily for debugging.
+     */
+    getOrderBookOrigin(poolInfo: any, orderType: 'bid' | 'ask' | 'all'): Promise<{
+        bid: any;
+        ask: any;
+        bids?: undefined;
+        asks?: undefined;
+    } | {
+        bids: never[];
+        asks: never[];
+        bid?: undefined;
+        ask?: undefined;
+    }>;
+    getWalletBalance(account: string): Promise<{
+        [k: string]: any;
+    }>;
+    getAccount(balanceManager: string, poolList: any): Promise<StateAccount[] | null>;
+    /**
+     * Gets the SUI transaction response for a given transaction digest.
+     * @param digest - The digest of the transaction for which the SUI transaction response is requested.
+     * @param forceRefresh - A boolean flag indicating whether to force a refresh of the response.
+     * @returns A Promise that resolves with the SUI transaction block response or null if the response is not available.
+     */
+    getSuiTransactionResponse(digest: string, forceRefresh?: boolean): Promise<SuiTransactionBlockResponse | null>;
+    private transformExtensions;
+    /**
+     * Get coin config list.
+     * @param {boolean} forceRefresh Whether to force a refresh of the cache entry.
+     * @param {boolean} transformExtensions Whether to transform extensions.
+     * @returns {Promise<CoinConfig[]>} Coin config list.
+     */
+    getCoinConfigs(forceRefresh?: boolean, transformExtensions?: boolean): Promise<CoinConfig[]>;
+    /**
+     * Build coin config.
+     * @param {SuiObjectResponse} object Coin object.
+     * @param {boolean} transformExtensions Whether to transform extensions.
+     * @returns {CoinConfig} Coin config.
+     */
+    private buildCoinConfig;
+    /**
+     * 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;
+}
+
+type Price = {
+    coin_type: string;
+    price: string;
+    oracle_price: bigint;
+    last_update_time: number;
+};
+declare class PythPriceModule implements IModule {
+    protected _sdk: DeepbookUtilsSDK;
+    protected connection: SuiPriceServiceConnection;
+    protected suiPythClient: SuiPythClient;
+    protected hasChangeConnection: boolean;
+    private readonly _cache;
+    constructor(sdk: DeepbookUtilsSDK);
+    get sdk(): DeepbookUtilsSDK;
+    updatePythPriceIDs(priceIDs: string[], txb: Transaction): Promise<Map<string, string>>;
+    /**
+     * Checks if the price has been updated within the last 60 seconds.
+     *
+     * @param price - The price object to check.
+     * @returns The price object if it has been updated within the last 60 seconds, otherwise undefined.
+     */
+    priceCheck(price: Price, age?: number): Price | undefined;
+    /**
+     * Fetches the latest prices for a list of coin types.
+     * Optionally uses cached prices if available.
+     *
+     * @param coinTypeList - The list of coin types for which prices are required.
+     * @param useCache - A flag to indicate whether to use cached prices (default: false).
+     * @returns A promise that resolves to a record mapping coin types to their respective price information.
+     */
+    getLatestPrice(coinList: {
+        feed: string;
+        coinType: string;
+    }[], useCache?: boolean): Promise<Record<string, Price>>;
+}
+
+declare class MarginUtilsModule implements IModule {
+    #private;
+    protected _sdk: DeepbookUtilsSDK;
+    protected pythPrice: PythPriceModule;
+    private readonly _cache;
+    constructor(sdk: DeepbookUtilsSDK);
+    get sdk(): DeepbookUtilsSDK;
+    /**
+     * Creates a margin manager and shares it with the caller account.
+     */
+    createAndShareMarginManager(poolInfo: MarginPoolInfo, tx?: Transaction): Transaction;
+    getBalanceManagerByMarginManager(account: string): Promise<any>;
+    /**
+     * get margin manager by account
+     * @param account
+     * @returns
+     */
+    getMarginManagerByAccount(account: string): Promise<any[]>;
+    getBaseBalance({ account, marginManager, baseCoinType, quoteCoinType, }: {
+        account: string;
+        marginManager: string;
+        baseCoinType: string;
+        quoteCoinType: string;
+    }): Promise<string>;
+    getQuoteBalance({ account, marginManager, baseCoinType, quoteCoinType, }: {
+        account: string;
+        marginManager: string;
+        baseCoinType: string;
+        quoteCoinType: string;
+    }): Promise<string>;
+    getBorrowedShares({ account, marginManager, baseCoinType, quoteCoinType, }: {
+        account: string;
+        marginManager: string;
+        baseCoinType: string;
+        quoteCoinType: string;
+    }): Promise<{
+        baseBorrowedShare: string;
+        quoteBorrowedShare: string;
+    }>;
+    managerState: ({ account, marginManager, baseCoin, quoteCoin, pool, baseMarginPool, quoteMarginPool, decimals, basePriceFeedObjectId, quotePriceFeedObjectId, }: {
+        account: string;
+        marginManager: string;
+        baseCoin: MarginCoinInfo;
+        quoteCoin: MarginCoinInfo;
+        pool: string;
+        baseMarginPool: string;
+        quoteMarginPool: string;
+        decimals?: number;
+        basePriceFeedObjectId: string;
+        quotePriceFeedObjectId: string;
+    }) => (tx: Transaction) => void;
+    getManagerState(params: {
+        account: string;
+        marginManager: string;
+        baseCoin: MarginCoinInfo;
+        quoteCoin: MarginCoinInfo;
+        pool: string;
+        baseMarginPool: string;
+        quoteMarginPool: string;
+        decimals?: number;
+    }, tx?: Transaction): Promise<{
+        managerId: string;
+        deepbookPoolId: string;
+        riskRatio: number;
+        baseAsset: string;
+        quoteAsset: string;
+        baseDebt: string;
+        quoteDebt: string;
+        basePythPrice: string;
+        basePythDecimals: number;
+        quotePythPrice: string;
+        quotePythDecimals: number;
+        currentPrice: bigint;
+        lowestTriggerAbovePrice: bigint;
+        highestTriggerBelowPrice: bigint;
+    }>;
+    calculateAssets({ account, marginManager, pool, baseCoin, quoteCoin, decimals, }: {
+        account: string;
+        marginManager: string;
+        pool: string;
+        baseCoin: MarginCoinInfo;
+        quoteCoin: MarginCoinInfo;
+        decimals?: number;
+    }): Promise<{
+        baseAsset: string;
+        quoteAsset: string;
+    }>;
+    getBorrowedAmount({ account, marginManager, baseCoinType, quoteCoinType, baseMarginPool, quoteMarginPool, }: {
+        account: string;
+        marginManager: string;
+        baseCoinType: string;
+        quoteCoinType: string;
+        baseMarginPool: string;
+        quoteMarginPool: string;
+    }): Promise<{
+        baseBorrowedAmount: string;
+        quoteBorrowedAmount: string;
+    }>;
+    /**
+     * deposit into margin manager
+     * @param marginManager
+     * @param baseCoinType
+     * @param quoteCoinType
+     * @param isBase
+     * @param quantity
+     * @returns
+     */
+    deposit({ marginManager, baseCoin, quoteCoin, isBase, amount, }: {
+        marginManager: string;
+        baseCoin: MarginCoinInfo;
+        quoteCoin: MarginCoinInfo;
+        isBase: boolean;
+        amount: string;
+    }, tx?: Transaction): Promise<Transaction>;
+    /**
+     * withdraw from margin manager
+     * @param marginManager
+     * @param baseMarginPool
+     * @param quoteMarginPool
+     * @param baseCoin
+     * @param quoteCoin
+     * @param pool
+     * @param isBase
+     * @param amount
+     * @returns
+     */
+    withdraw({ account, marginManager, baseMarginPool, quoteMarginPool, baseCoin, quoteCoin, pool, isBase, amount, }: {
+        account: string;
+        marginManager: string;
+        baseMarginPool: string;
+        quoteMarginPool: string;
+        baseCoin: MarginCoinInfo;
+        quoteCoin: MarginCoinInfo;
+        pool: string;
+        isBase: boolean;
+        amount: string;
+    }, tx?: Transaction): Promise<Transaction>;
+    borrowBase({ marginManager, baseMarginPool, baseCoin, quoteCoin, pool, amount, }: {
+        marginManager: string;
+        baseMarginPool: string;
+        baseCoin: MarginCoinInfo;
+        quoteCoin: MarginCoinInfo;
+        pool: string;
+        amount: string;
+    }, tx?: Transaction): Promise<Transaction>;
+    borrowQuote({ marginManager, quoteMarginPool, baseCoin, quoteCoin, pool, amount, }: {
+        marginManager: string;
+        quoteMarginPool: string;
+        baseCoin: MarginCoinInfo;
+        quoteCoin: MarginCoinInfo;
+        pool: string;
+        amount: string;
+    }, tx?: Transaction): Promise<Transaction>;
+    repayBase({ marginManager, baseMarginPool, baseCoinType, quoteCoinType, amount, }: {
+        marginManager: string;
+        baseMarginPool: string;
+        baseCoinType: string;
+        quoteCoinType: string;
+        amount?: string;
+    }, tx?: Transaction): Promise<Transaction>;
+    repayQuote({ marginManager, quoteMarginPool, baseCoinType, quoteCoinType, amount, }: {
+        marginManager: string;
+        quoteMarginPool: string;
+        baseCoinType: string;
+        quoteCoinType: string;
+        amount?: string;
+    }, tx?: Transaction): Promise<Transaction>;
+    placeMarginMarketOrder({ marginManager, poolInfo, selfMatchingOption, quantity, isBid, payWithDeep, }: {
+        marginManager: string;
+        poolInfo: MarginPoolInfo;
+        selfMatchingOption: number;
+        quantity: string;
+        isBid: boolean;
+        payWithDeep: boolean;
+    }, tx?: Transaction): Promise<Transaction>;
+    /**
+     * 提交限价单
+     * @param - orderType: 订单类型 (0=NO_RESTRICTION, 1=IMMEDIATE_OR_CANCEL, 2=FILL_OR_KILL, 3=POST_ONLY)
+     * @param - selfMatchingOption: 自成交选项 (0=SELF_MATCHING_ALLOWED, 1=CANCEL_TAKER, 2=CANCEL_MAKER)
+     * @param tx
+     * @returns
+     */
+    placeMarginLimitOrder({ marginManager, poolInfo, orderType, selfMatchingOption, priceInput, quantity, isBid, payWithDeep, expirationTimestamp, }: {
+        marginManager: string;
+        poolInfo: MarginPoolInfo;
+        orderType: number;
+        selfMatchingOption: number;
+        priceInput: string;
+        quantity: string;
+        isBid: boolean;
+        payWithDeep: boolean;
+        expirationTimestamp?: number;
+    }, tx?: Transaction): Promise<Transaction>;
+    modifyMarginOrder({ marginManager, poolInfo, orderId, newQuantity, }: {
+        marginManager: string;
+        poolInfo: MarginPoolInfo;
+        orderId: string;
+        newQuantity: string;
+    }, tx?: Transaction): Transaction;
+    cancelMarginOrder({ marginManager, poolInfo, orderId, }: {
+        marginManager: string;
+        poolInfo: MarginPoolInfo;
+        orderId: string;
+    }, tx?: Transaction): Transaction;
+    cancelAllMarginOrders({ marginManager, poolInfo, }: {
+        marginManager: string;
+        poolInfo: MarginPoolInfo;
+    }, tx?: Transaction): Transaction;
+}
+
+/**
+ * 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>>;
+    /**
+     * 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<any[]>;
+    /**
+     * 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.
+     */
+    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>;
+}
+
+/**
+ * Represents options and configurations for an SDK.
+ */
+type SdkOptions = {
+    network: string;
+    /**
+     * The full URL for interacting with the RPC (Remote Procedure Call) service.
+     */
+    fullRpcUrl: string;
+    graphqlUrl: string;
+    /**
+     * Configuration for the simulation account.
+     */
+    simulationAccount: {
+        /**
+         * The address of the simulation account.
+         */
+        address: string;
+    };
+    deepbook: {
+        package_id: string;
+        published_at: string;
+        margin_package_id: string;
+        margin_published_at: string;
+    };
+    deepbook_utils: {
+        package_id: string;
+        published_at: string;
+        global_config_id: string;
+        cetus_balance_manager_indexer_id: string;
+        vault_global_config_id?: string;
+    };
+    margin_utils: {
+        package_id: string;
+        published_at: string;
+        registry_id: string;
+        margin_registry_id: string;
+        wormhole_state_id: string;
+        pyth_state_id: string;
+    };
+    DEEP_COIN: {
+        coinType: string;
+        decimals: number;
+    };
+    coinlist: {
+        id: string;
+        handle: string;
+    };
+};
+/**
+ * The entry class of CetusClmmSDK, which is almost responsible for all interactions with CLMM.
+ */
+declare class DeepbookUtilsSDK {
+    private readonly _cache;
+    /**
+     * RPC provider on the SUI chain
+     */
+    protected _rpcModule: RpcModule;
+    protected _deepbookUtils: any;
+    protected _marginUtils: any;
+    protected _pythPrice: PythPriceModule;
+    protected _graphqlClient: SuiGraphQLClient;
+    /**
+     *  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);
+    get DeepbookUtils(): DeepbookUtilsModule;
+    get MarginUtils(): MarginUtilsModule;
+    get PythPrice(): PythPriceModule;
+    /**
+     * Getter for the fullClient property.
+     * @returns {RpcModule} The fullClient property value.
+     */
+    get fullClient(): RpcModule;
+    get graphqlClient(): SuiGraphQLClient;
+    /**
+     * Getter for the sdkOptions property.
+     * @returns {SdkOptions} The sdkOptions property value.
+     */
+    get sdkOptions(): SdkOptions;
+    /**
+     * 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;
+}
+
+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 const NORMALIZED_SUI_COIN_TYPE: string;
+
+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): string;
+declare function hexToString(str: string): string;
+
+declare function d(value?: Decimal.Value): Decimal.Instance;
+declare function decimalsMultiplier(decimals?: Decimal.Value): Decimal.Instance;
+declare const fixDown: (value: string | number, decimal: number) => string | number;
+declare const maxDecimal: (value1: Decimal.Value, value2: Decimal.Value) => Decimal.Instance;
+
+type AdjustResult = {
+    isAdjustCoinA: boolean;
+    isAdjustCoinB: boolean;
+};
+type BuildCoinResult = {
+    targetCoin: TransactionArgument;
+    remainCoins: CoinAsset[];
+    isMintZeroCoin: boolean;
+    tragetCoinAmount: string;
+    originalSplitedCoin?: TransactionArgument;
+};
+type CoinInputInterval = {
+    amountSecond: bigint;
+    amountFirst: bigint;
+};
+declare function printTransaction(tx: Transaction, isPrint?: boolean): Promise<void>;
+declare class TransactionUtil {
+    /**
+     * adjust transaction for gas
+     * @param sdk
+     * @param amount
+     * @param tx
+     * @returns
+     */
+    static adjustTransactionForGas(sdk: DeepbookUtilsSDK, allCoins: CoinAsset[], amount: bigint, tx: Transaction): Promise<{
+        fixAmount: bigint;
+        newTx?: Transaction;
+    }>;
+    static buildCoinForAmount(tx: Transaction, allCoins: CoinAsset[], amount: bigint, coinType: string, buildVector?: boolean, fixAmount?: boolean): BuildCoinResult;
+    private static buildCoin;
+    private static buildZeroValueCoin;
+    static buildCoinForAmountInterval(tx: Transaction, allCoins: CoinAsset[], amounts: CoinInputInterval, coinType: string, buildVector?: boolean): BuildCoinResult;
+    static callMintZeroValueCoin: (txb: Transaction, coinType: string) => _mysten_sui_transactions.TransactionResult;
+    static buildCoinTypePair(coinTypes: string[], partitionQuantities: number[]): string[][];
+}
+
+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;
+declare function getObjectFields(resp: SuiObjectResponse | SuiObjectData): any | undefined;
+interface SuiObjectDataWithContent extends SuiObjectData {
+    content: SuiParsedData;
+}
+declare function hasPublicTransfer(data: SuiObjectResponse | SuiObjectData): 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): number;
+/**
+ * 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;
+
+declare const calculateRiskRatio: ({ totalAssetsValue, totalDebtValue }: {
+    totalAssetsValue: string;
+    totalDebtValue: string;
+}) => string;
+
+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 | null;
+    /**
+     * 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.
+     */
+    /**
+     * 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;
+}
+
+export { AdjustResult, Balances, BigNumber, BuildCoinResult, CLOCK_ADDRESS, CachedContent, DeepbookUtilsSDK as CetusClmmSDK, ClmmExpectSwapModule, ClmmFetcherModule, ClmmIntegratePoolModule, ClmmIntegratePoolV2Module, ClmmIntegrateRouterModule, ClmmIntegrateRouterWithPartnerModule, ClmmIntegrateUtilsModule, CoinAsset, CoinAssist, CoinConfig, CoinInfoAddress, CoinStoreAddress, 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, DataPage, DeepbookClobV2Moudle, DeepbookCustodianV2Moudle, DeepbookEndpointsV2Moudle, DeepbookUtilsModule, GAS_SYMBOL, GAS_TYPE_ARG, GAS_TYPE_ARG_LONG, MarginCoinInfo, MarginPoolInfo, MarginUtilsModule, NFT, NORMALIZED_SUI_COIN_TYPE, OrderDeepPrice, OrderFee, OrderType, Package, PageQuery, PaginationArgs, PoolInfo, RpcModule, SUI_SYSTEM_STATE_OBJECT_ID, SdkOptions, StateAccount, SuiAddressType, SuiBasicTypes, SuiInputTypes, SuiObjectDataWithContent, SuiObjectIdType, SuiResource, SuiStructTag, SuiTxArg, Token, TransactionUtil, addHexPrefix, asIntN, asUintN, bufferToHex, cacheTime24h, cacheTime5min, calculateRiskRatio, checkAddress, composeType, d, decimalsMultiplier, DeepbookUtilsSDK as default, extractAddressFromType, extractStructTagFromType, fixCoinType, fixDown, fixSuiObjectId, fromDecimalsAmount, getDefaultSuiInputType, getFutureTime, getMoveObject, getMoveObjectType, getMovePackageContent, getObjectDeletedResponse, getObjectDisplay, getObjectFields, getObjectId, getObjectNotExistsResponse, getObjectOwner, getObjectPreviousTransactionDigest, getObjectReference, getObjectType, getObjectVersion, getSuiObjectData, hasPublicTransfer, hexToNumber, hexToString, isSortedSymbols, isSuiObjectResponse, maxDecimal, normalizeCoinType, patchFixSuiObjectId, printTransaction, removeHexPrefix, secretKeyToEd25519Keypair, secretKeyToSecp256k1Keypair, shortAddress, shortString, toBuffer, toDecimalsAmount, utf8to16 };