@cetusprotocol/dlmm-sdk 0.0.1

package/dist/index.d.mts

@@ -0,0 +1,1015 @@
+import { CoinPairType, TableHandle, IModule, PaginationArgs, DataPage, PageQuery, SdkWrapper, BaseSdkOptions, Package } from '@cetusprotocol/common-sdk';
+import { TransactionObjectArgument, Transaction } from '@mysten/sui/transactions';
+import { SuiEvent, SuiObjectResponse, DevInspectResults, SuiTransactionBlockResponse } from '@mysten/sui/client';
+import Decimal from 'decimal.js';
+import BN from 'bn.js';
+
+type DlmmConfigs = {
+    registry_id: string;
+    pools_id: string;
+    partners_id: string;
+    global_config_id: string;
+    versioned_id: string;
+    admin_cap_id: string;
+};
+type BinStepConfig = {
+    bin_step: number;
+    base_factor: number;
+    filter_period: number;
+    decay_period: number;
+    reduction_factor: number;
+    variable_fee_control: string;
+    max_volatility_accumulator: string;
+    protocol_fee_rate: string;
+};
+type BinManager = {
+    bin_step: number;
+    bin_manager_handle: string;
+    size: string;
+};
+type VariableParameters = {
+    volatility_accumulator: string;
+    volatility_reference: string;
+    index_reference: number;
+    last_update_timestamp: string;
+    bin_step_config: BinStepConfig;
+};
+type Reward = {
+    reward_coin: string;
+    emissions_per_second: string;
+    emissions_per_day: string;
+    period_emission_rates: TableHandle;
+};
+type RewardManager = {
+    is_public: boolean;
+    vault: TableHandle;
+    rewards: Reward[];
+    emergency_reward_pause: boolean;
+    last_updated_time: string;
+};
+type PositionManager = {
+    bin_step: number;
+    position_index: number;
+    position_handle: string;
+    size: number;
+};
+type DlmmBasePool = {
+    id: string;
+    bin_step: number;
+} & CoinPairType;
+type PoolPermissions = {
+    disable_add: boolean;
+    disable_remove: boolean;
+    disable_swap: boolean;
+    disable_collect_fee: boolean;
+    disable_collect_reward: boolean;
+    disable_add_reward: boolean;
+};
+type DlmmPool = {
+    pool_type: string;
+    index: number;
+    bin_manager: BinManager;
+    variable_parameters: VariableParameters;
+    active_id: number;
+    permissions: PoolPermissions;
+    balance_a: string;
+    balance_b: string;
+    base_fee_rate: string;
+    protocol_fee_a: string;
+    protocol_fee_b: string;
+    url: string;
+    reward_manager: RewardManager;
+    position_manager: PositionManager;
+} & DlmmBasePool;
+type DlmmPosition = {
+    id: string;
+    pool_id: string;
+    index: number;
+    description: string;
+    uri: string;
+    liquidity_shares: string[];
+    lower_bin_id: number;
+    upper_bin_id: number;
+    name: string;
+} & CoinPairType;
+type BinWeight = {
+    bin_id: number;
+    weight: number;
+};
+type BinAmount = {
+    bin_id: number;
+    amount_a: string;
+    amount_b: string;
+    liquidity?: string;
+    price_per_lamport: string;
+};
+type BinLiquidityInfo = {
+    bins: BinAmount[];
+    amount_a: string;
+    amount_b: string;
+};
+declare enum StrategyType {
+    Spot = 0,
+    Curve = 1,
+    BidAsk = 2
+}
+type ClosePositionOption = {
+    pool_id: string;
+    position_id: string;
+    reward_coins: string[];
+} & CoinPairType;
+type BaseCreatePoolOption = {
+    bin_step: number;
+    base_factor: number;
+    url?: string;
+} & CoinPairType;
+type BaseCreatePoolAndAddOption = {
+    bin_infos: BinLiquidityInfo;
+    strategy_type: StrategyType;
+    use_bin_infos?: boolean;
+} & BaseCreatePoolOption;
+type CreatePoolAndAddOption = {
+    active_id: number;
+    lower_bin_id: number;
+    upper_bin_id: number;
+} & BaseCreatePoolAndAddOption;
+type CreatePoolOption = {
+    active_id: number;
+} & BaseCreatePoolOption;
+type CreatePoolAndAddWithPriceOption = {
+    price_base_coin: 'coin_a' | 'coin_b';
+    price: string;
+    lower_price: string;
+    upper_price: string;
+    strategy_type: StrategyType;
+    decimals_a: number;
+    decimals_b: number;
+} & BaseCreatePoolAndAddOption;
+type BaseAddLiquidityOption = {
+    pool_id: string | TransactionObjectArgument;
+    bin_infos: BinLiquidityInfo;
+    strategy_type: StrategyType;
+    max_price_slippage: number;
+    active_id: number;
+    bin_step: number;
+    /**
+     * Controls whether to use pre-calculated bin_infos or let the contract calculate based on strategy_type.
+     * - true: Use bin_infos to add liquidity to each bin
+     * - false: Pass strategy_type to contract for automatic liquidity distribution calculation
+     */
+    use_bin_infos?: boolean;
+} & CoinPairType;
+type BaseCalculateAddLiquidityOption = {
+    active_id: number;
+    bin_step: number;
+    lower_bin_id: number;
+    upper_bin_id: number;
+    amount_a_in_active_bin: string;
+    amount_b_in_active_bin: string;
+    strategy_type: StrategyType;
+};
+type CalculateAddLiquidityOption = {
+    amount_a: string;
+    amount_b: string;
+} & BaseCalculateAddLiquidityOption;
+type CalculateAddLiquidityAutoFillOption = {
+    coin_amount: string;
+    fix_amount_a: boolean;
+} & BaseCalculateAddLiquidityOption;
+type AddLiquidityOption = BaseAddLiquidityOption & {
+    position_id: string;
+    collect_fee: boolean;
+    reward_coins: string[];
+};
+type OpenAndAddLiquidityOption = BaseAddLiquidityOption & {
+    lower_bin_id: number;
+    upper_bin_id: number;
+};
+type OpenAndAddLiquidityWithPriceOption = BaseAddLiquidityOption & {
+    price_base_coin: 'coin_a' | 'coin_b';
+    price: string;
+    lower_price: string;
+    upper_price: string;
+    amount_a_in_active_bin: string;
+    amount_b_in_active_bin: string;
+    strategy_type: StrategyType;
+    decimals_a: number;
+    decimals_b: number;
+    max_price_slippage: number;
+};
+type OpenPositionOption = {
+    pool_id: string;
+    lower_bin_id: number;
+    upper_bin_id: number;
+} & CoinPairType;
+type CalculateRemoveLiquidityBothOption = {
+    bins: BinAmount[];
+    active_id: number;
+    fix_amount_a: boolean;
+    coin_amount: string;
+};
+type CalculateRemoveLiquidityOnlyOption = {
+    bins: BinAmount[];
+    active_id: number;
+    is_only_a: boolean;
+    coin_amount: string;
+};
+type RemoveLiquidityOption = {
+    pool_id: string;
+    position_id: string;
+    active_id: number;
+    bin_step: number;
+    bin_infos: BinLiquidityInfo;
+    slippage: number;
+    reward_coins: string[];
+    collect_fee: boolean;
+    remove_percent?: number;
+} & CoinPairType;
+type CollectRewardOption = {
+    pool_id: string;
+    position_id: string;
+    reward_coins: string[];
+} & CoinPairType;
+type CollectFeeOption = {
+    pool_id: string;
+    position_id: string;
+} & CoinPairType;
+type CollectRewardAndFeeOption = {
+    pool_id: string;
+    position_id: string;
+    reward_coins: string[];
+} & CoinPairType;
+type BinSwap = {
+    bin_id: number;
+    in_amount: string;
+    out_amount: string;
+    fee: string;
+    var_fee_rate: string;
+};
+type PreSwapQuote = {
+    pool_id: string;
+    a2b: boolean;
+    in_amount: string;
+    out_amount: string;
+    ref_fee_amount: string;
+    fee_amount: string;
+    partner: string;
+    from_coin_type: string;
+    to_coin_type: string;
+    bin_swaps: BinSwap[];
+};
+type PreSwapOption = {
+    pool_id: string;
+    a2b: boolean;
+    by_amount_in: boolean;
+    in_amount: string;
+} & CoinPairType;
+type SwapOption = {
+    quote_obj: PreSwapQuote;
+    by_amount_in: boolean;
+    partner?: string;
+    slippage: number;
+} & CoinPairType;
+type PositionFee = {
+    position_id: string;
+    fee_owned_a: string;
+    fee_owned_b: string;
+};
+type RewardInfo = {
+    coin_type: string;
+    reward_owned: string;
+};
+type PositionReward = {
+    position_id: string;
+    rewards: RewardInfo[];
+};
+type CreatePartnerOption = {
+    name: string;
+    ref_fee_rate: number;
+    start_time: number;
+    end_time: number;
+    recipient: string;
+};
+type UpdateRefFeeRateOption = {
+    partner_id: string;
+    ref_fee_rate: number;
+};
+type UpdateTimeRangeOption = {
+    partner_id: string;
+    start_time: number;
+    end_time: number;
+};
+type ClaimRefFeeOption = {
+    partner_id: string;
+    partner_cap_id?: string;
+    fee_coin_types: string[];
+};
+type Partner = {
+    id: string;
+    name: string;
+    ref_fee_rate: number;
+    start_time: number;
+    end_time: number;
+    balances: TableHandle;
+    type: string;
+};
+type PoolTransactionInfo = {
+    index: string;
+    tx: string;
+    sender: string;
+    type: string;
+    block_time: string;
+    parsed_json: any;
+};
+type AddRewardOption = {
+    pool_id: string;
+    reward_coin_type: string;
+    reward_amount: string;
+    start_time_seconds?: number;
+    end_time_seconds: number;
+} & CoinPairType;
+type InitRewardOption = {
+    pool_id: string;
+    reward_coin_types: string[];
+} & CoinPairType;
+type RewardWhiteListOption = {
+    reward_coin_types: string[];
+    type: 'add' | 'remove';
+};
+type RewardAccessOption = {
+    pool_id: string;
+    type: 'to_public' | 'to_private';
+} & CoinPairType;
+type ValidateActiveIdSlippageOption = {
+    pool_id: string | TransactionObjectArgument;
+    active_id: number;
+    bin_step: number;
+    max_price_slippage: number;
+} & CoinPairType;
+type DlmmGlobalConfig = {
+    id: string;
+    acl: TableHandle;
+    allowed_list: TableHandle;
+    denied_list: TableHandle;
+    bin_steps: TableHandle;
+    reward_white_list: string[];
+    blocked_position: TableHandle;
+    blocked_user: TableHandle;
+    min_reward_duration: number;
+    non_manager_initialize_reward_cap: number;
+    reward_public: boolean;
+};
+type UpdatePositionFeeAndRewardsOption = {
+    pool_id: string;
+    position_id: string;
+} & CoinPairType;
+type RewardPeriodEmission = {
+    emissions_per_second: string;
+    emissions_per_day: string;
+    emissions_per: string;
+    time: string;
+    visualized_time: string;
+};
+type RewardPeriodEmissionFormat = {
+    emissions_per_second: string;
+    emissions_per_day: string;
+    time: string;
+    visualized_time: string;
+};
+type GetPoolBinInfoOption = {
+    pool_id: string;
+} & CoinPairType;
+type GetTotalFeeRateOption = {
+    pool_id: string;
+} & CoinPairType;
+type FeeRate = {
+    base_fee_rate: string;
+    var_fee_rate: string;
+    total_fee_rate: string;
+};
+
+declare class PoolModule implements IModule<CetusDlmmSDK> {
+    protected _sdk: CetusDlmmSDK;
+    constructor(sdk: CetusDlmmSDK);
+    get sdk(): CetusDlmmSDK;
+    /**
+     * Get the list of DLMM base pools
+     * @param pagination_args - The pagination arguments
+     * @returns The list of DLMM base pools
+     */
+    getBasePoolList(pagination_args?: PaginationArgs, force_refresh?: boolean): Promise<DataPage<DlmmBasePool>>;
+    /**
+     * Get the list of DLMM pools
+     * @param pagination_args - The pagination arguments
+     * @returns The list of DLMM pools
+     */
+    getPools(pagination_args?: PaginationArgs, force_refresh?: boolean): Promise<DataPage<DlmmPool>>;
+    /**
+     * Get the bin info by bin id
+     * @param bin_manager_handle - The bin manager handle
+     * @param bin_id - The bin id
+     * @param bin_step - The bin step
+     * @param force_refresh - Whether to force a refresh of the cache
+     * @returns The bin info
+     */
+    getBinInfo(bin_manager_handle: string, bin_id: number, bin_step: number, force_refresh?: boolean): Promise<BinAmount>;
+    getTotalFeeRate(option: GetTotalFeeRateOption): Promise<FeeRate>;
+    getPoolBinInfo(option: GetPoolBinInfoOption): Promise<BinAmount[]>;
+    getPoolTransactionList({ pool_id, pagination_args, order, full_rpc_url, }: {
+        pool_id: string;
+        full_rpc_url?: string;
+        pagination_args: PageQuery;
+        order?: 'ascending' | 'descending' | null | undefined;
+    }): Promise<DataPage<PoolTransactionInfo>>;
+    /**
+     * Get the bin info by range (TODO:  need to optimize this method)
+     * @param bin_manager_handle - The bin manager handle
+     * @param lower_bin_id - The lower bin id
+     * @param upper_bin_id - The upper bin id
+     * @param bin_step - The bin step
+     * @returns The bin info by range
+     */
+    getRangeBinInfo(bin_manager_handle: string, lower_bin_id: number, upper_bin_id: number, bin_step: number): Promise<BinAmount[]>;
+    /**
+     * Get the list of DLMM pools by assign pool ids
+     * @param assign_pool_ids - The assign pool ids
+     * @returns The list of DLMM pools
+     */
+    getAssignPoolList(assign_pool_ids: string[]): Promise<DlmmPool[]>;
+    /**
+     * Get a DLMM pool by its object ID.
+     * @param {string} pool_id The object ID of the pool to get.
+     * @param {true} force_refresh Whether to force a refresh of the cache.
+     * @returns {Promise<DlmmPool>} A promise that resolves to a DlmmPool object.
+     */
+    getPool(pool_id: string, force_refresh?: boolean): Promise<DlmmPool>;
+    /**
+     * Create a pool and add liquidity with a given price
+     * @param option - The option for creating a pool and adding liquidity with a given price
+     * @returns The transaction for creating a pool and adding liquidity with a given price
+     */
+    createPoolAndAddWithPricePayload(option: CreatePoolAndAddWithPriceOption): Promise<Transaction>;
+    /**
+     * Create a pool
+     * @param option - The option for creating a pool
+     * @param tx - The transaction object
+     * @returns The transaction object
+     */
+    createPoolPayload(option: CreatePoolOption, tx: Transaction): Promise<TransactionObjectArgument>;
+    /**
+     * Create a pool and add liquidity
+     * @param option - The option for creating a pool and adding liquidity
+     * @returns The transaction for creating a pool and adding liquidity
+     */
+    createPoolAndAddLiquidityPayload(option: CreatePoolAndAddOption): Promise<Transaction>;
+}
+
+declare class PositionModule implements IModule<CetusDlmmSDK> {
+    protected _sdk: CetusDlmmSDK;
+    constructor(sdk: CetusDlmmSDK);
+    get sdk(): CetusDlmmSDK;
+    buildPositionType(): string;
+    getOwnerPositionList(owner: string): Promise<DlmmPosition[]>;
+    getPosition(position_id: string): Promise<DlmmPosition>;
+    /**
+     * Collect fee
+     * @param option - The option for collecting fee
+     * @param tx - The transaction object
+     * @returns The transaction object
+     */
+    collectFeePayload(option: CollectFeeOption, tx?: Transaction): Transaction;
+    /**
+     * Update the fee and rewards of the position
+     * @param option - The option for updating the fee and rewards of the position
+     * @param tx - The transaction object
+     * @returns The transaction object
+     */
+    updatePositionFeeAndRewards(option: UpdatePositionFeeAndRewardsOption, tx: Transaction): Transaction;
+    /**
+     * Collect reward
+     * @param options - The option for collecting reward
+     * @param tx - The transaction object
+     * @returns The transaction object
+     */
+    collectRewardPayload(options: CollectRewardOption[], tx?: Transaction): Transaction;
+    collectRewardAndFeePayload(options: CollectRewardAndFeeOption[], tx?: Transaction): Transaction;
+    /**
+     * Validate the active id slippage
+     * @param options - The option for validating the active id slippage
+     * @param tx - The transaction object
+     * @returns The transaction object
+     */
+    validateActiveIdSlippage(options: ValidateActiveIdSlippageOption, tx: Transaction): Transaction;
+    /**
+     * Close a position
+     * @param option - The option for closing a position
+     * @returns The transaction object
+     */
+    closePositionPayload(option: ClosePositionOption, tx?: Transaction): Transaction;
+    /**
+     * Get the amounts in the active bin if in range
+     * @param bin_manager_handle - The bin manager handle
+     * @param lower_bin_id - The lower bin id
+     * @param upper_bin_id - The upper bin id
+     * @param active_id - The active id
+     * @returns The amounts in the active bin if in range
+     */
+    getActiveBinIfInRange(bin_manager_handle: string, lower_bin_id: number, upper_bin_id: number, active_id: number, bin_step: number, force_refresh?: boolean): Promise<BinAmount | undefined>;
+    /**
+     * Calculate the result of removing liquidity
+     * @param option - The option for calculating the result of removing liquidity
+     * @returns The result of removing liquidity
+     */
+    calculateRemoveLiquidityInfo(option: CalculateRemoveLiquidityBothOption | CalculateRemoveLiquidityOnlyOption): BinLiquidityInfo;
+    /**
+     * Calculate the result of adding liquidity
+     * @param option - The option for calculating the result of adding liquidity
+     * @returns The result of adding liquidity
+     */
+    calculateAddLiquidityInfo(option: CalculateAddLiquidityOption | CalculateAddLiquidityAutoFillOption): BinLiquidityInfo;
+    /**
+     * Remove liquidity
+     * @param option - The option for removing liquidity
+     * @returns The transaction
+     */
+    removeLiquidityPayload(option: RemoveLiquidityOption): Transaction;
+    /**
+     * Add liquidity with price
+     * @param option - The option for adding liquidity with price
+     * @returns The transaction
+     */
+    addLiquidityWithPricePayload(option: OpenAndAddLiquidityWithPriceOption): Transaction;
+    /**
+     * Add liquidity
+     * @param option - The option for adding liquidity
+     * @returns The transaction object
+     */
+    addLiquidityPayload(option: AddLiquidityOption | OpenAndAddLiquidityOption, tx?: Transaction): Transaction;
+    private addLiquidityStrategyInternal;
+    private addLiquidityInternal;
+    /**
+     * Fetch the fee and reward of the position
+     * @param options - The option for fetching the fee and reward of the position
+     * @returns The fee and reward of the position
+     */
+    fetchPositionFeeAndReward(options: CollectRewardAndFeeOption[]): Promise<{
+        feeData: Record<string, PositionFee>;
+        rewardData: Record<string, PositionReward>;
+    }>;
+}
+
+declare class SwapModule implements IModule<CetusDlmmSDK> {
+    protected _sdk: CetusDlmmSDK;
+    constructor(sdk: CetusDlmmSDK);
+    get sdk(): CetusDlmmSDK;
+    preSwapQuote(option: PreSwapOption): Promise<PreSwapQuote>;
+    swapPayload(option: SwapOption): Transaction;
+}
+
+declare class PartnerModule implements IModule<CetusDlmmSDK> {
+    protected _sdk: CetusDlmmSDK;
+    constructor(sdk: CetusDlmmSDK);
+    get sdk(): CetusDlmmSDK;
+    /**
+     * Get a list of partners.
+     * @returns {Promise<Partner[]>} A promise that resolves to an array of Partner objects.
+     */
+    getPartnerList(): Promise<Partner[]>;
+    /**
+     * Get the partner cap ID for a given owner and partner ID.
+     * @param owner - The owner of the partner.
+     * @param partner_id - The ID of the partner.
+     * @returns A promise that resolves to the partner cap ID or undefined if not found.
+     */
+    getPartnerCapId(owner: string, partner_id: string): Promise<string>;
+    /**
+     * Get the balance of a partner
+     * @param partner_balance_handle - The handle of the partner balance
+     * @returns A promise that resolves to an array of { coin_type: string; balance: string } objects.
+     */
+    getPartnerBalance(partner_balance_handle: string): Promise<{
+        coin_type: string;
+        balance: string;
+    }[]>;
+    /**
+     * Get a partner by its object ID.
+     * @param {string} partner_id The object ID of the partner to get.
+     * @returns {Promise<Partner>} A promise that resolves to a Partner object.
+     */
+    getPartner(partner_id: string): Promise<Partner>;
+    /**
+     * Update the ref fee rate of a partner
+     * @param option - The option for updating the ref fee rate
+     * @returns The transaction for updating the ref fee rate
+     */
+    updateRefFeeRatePayload(option: UpdateRefFeeRateOption, tx?: Transaction): Transaction;
+    /**
+     * Create a claim ref fee payload
+     * @param option - The option for claiming ref fee
+     * @returns The transaction for claiming ref fee
+     */
+    claimRefFeePayload(option: ClaimRefFeeOption): Promise<Transaction>;
+    updateTimeRangePayload(option: UpdateTimeRangeOption, tx?: Transaction): Transaction;
+    /**
+     * Create a partner
+     * @param option - The option for creating a partner
+     * @returns The transaction for creating a partner
+     */
+    createPartnerPayload(option: CreatePartnerOption): Transaction;
+}
+
+declare class RewardModule implements IModule<CetusDlmmSDK> {
+    protected _sdk: CetusDlmmSDK;
+    constructor(sdk: CetusDlmmSDK);
+    get sdk(): CetusDlmmSDK;
+    getRewardPeriodEmission(period_emission_handle: string, curr_emission_per_second: string, last_updated_time: number): Promise<RewardPeriodEmission[]>;
+    /**
+     * Add reward to a pool
+     * @param options - The options for adding reward
+     * @returns The transaction for adding reward
+     */
+    addRewardPayload(option: AddRewardOption, tx?: Transaction): Transaction;
+    /**
+     * Initialize reward for a pool
+     * @param option - The option for initializing reward
+     * @param tx - The transaction to add the reward to
+     * @returns The transaction for initializing reward
+     */
+    initRewardPayload(option: InitRewardOption, tx?: Transaction): Transaction;
+    /**
+     * Build the payload for making reward public or private
+     * @param option - The option for making reward public or private
+     * @param tx - The transaction to make the reward public or private
+     * @returns The transaction for making reward public or private
+     */
+    buildRewardAccessPayload(option: RewardAccessOption, tx?: Transaction): Transaction;
+}
+
+declare class ConfigModule implements IModule<CetusDlmmSDK> {
+    protected _sdk: CetusDlmmSDK;
+    constructor(sdk: CetusDlmmSDK);
+    get sdk(): CetusDlmmSDK;
+    /**
+     * Build the payload for adding or removing reward white list
+     * @param option - The option for adding or removing reward white list
+     * @param tx - The transaction to add the reward white list to
+     * @returns The transaction for adding or removing reward white list
+     */
+    buildRewardWhiteListPayload(option: RewardWhiteListOption, tx?: Transaction): Transaction;
+    getBinStepConfigList(bin_steps_handle: string): Promise<BinStepConfig[]>;
+    /**
+     * Get the list of bin step configs
+     * @returns The list of bin step configs
+     */
+    getDlmmGlobalConfig(): Promise<DlmmGlobalConfig>;
+    /**
+     * Fetch the configs of the dlmm SDK
+     * @returns The configs of the dlmm
+     */
+    fetchDlmmSdkConfigs(): Promise<DlmmConfigs>;
+}
+
+/**
+ * Represents options and configurations for an SDK.
+ */
+interface SdkOptions extends BaseSdkOptions {
+    dlmm_pool: Package<DlmmConfigs>;
+    dlmm_router: Package;
+    faucet?: Package;
+}
+/**
+ * The entry class of CetusDcaSDK, which is almost responsible for all interactions with dca.
+ */
+declare class CetusDlmmSDK extends SdkWrapper<SdkOptions> {
+    protected _pool: PoolModule;
+    protected _position: PositionModule;
+    protected _swap: SwapModule;
+    protected _partner: PartnerModule;
+    protected _reward: RewardModule;
+    protected _config: ConfigModule;
+    constructor(options: SdkOptions);
+    get Pool(): PoolModule;
+    get Position(): PositionModule;
+    get Swap(): SwapModule;
+    get Partner(): PartnerModule;
+    get Reward(): RewardModule;
+    get Config(): ConfigModule;
+    /**
+     * Static factory method to initialize the SDK
+     * @param options SDK initialization options
+     * @returns An instance of CetusBurnDK
+     */
+    static createSDK(options: BaseSdkOptions): CetusDlmmSDK;
+    /**
+     * Create a custom SDK instance with the given options
+     * @param options The options for the SDK
+     * @returns An instance of CetusBurnSDK
+     */
+    static createCustomSDK<T extends BaseSdkOptions>(options: T & SdkOptions): CetusDlmmSDK;
+}
+
+/**
+ * Parse the DLMM base pool data
+ * @param data - The DLMM base pool data
+ * @returns The DLMM base pool
+ */
+declare function parseDlmmBasePool(data: SuiEvent): DlmmBasePool;
+/**
+ * Parse the DLMM pool data
+ * @param data - The DLMM pool data
+ * @returns The DLMM pool
+ */
+declare function parseDlmmPool(data: SuiObjectResponse): DlmmPool;
+declare function parsePartner(data: SuiObjectResponse): Partner;
+declare function parseDlmmPosition(data: SuiObjectResponse): DlmmPosition;
+declare function parseLiquidityShares(liquidity_shares: string[], bin_step: number, lower_bin_id: number, active_bin: BinAmount): BinLiquidityInfo;
+declare function parseBinInfoList(res: DevInspectResults): BinAmount[];
+declare function parseBinInfo(fields: any): BinAmount;
+declare function parsedDlmmPosFeeData(simulate_res: DevInspectResults): Record<string, PositionFee>;
+declare function parsedDlmmPosRewardData(simulate_res: DevInspectResults): Record<string, PositionReward>;
+declare function parsedSwapQuoteData(simulate_res: DevInspectResults, a2b: boolean): PreSwapQuote | undefined;
+declare function parseStrategyType(strategy_type: StrategyType): number;
+declare const poolFilterEvenTypes: string[];
+declare function parsePoolTransactionInfo(data: SuiTransactionBlockResponse, txIndex: number, package_id: string, pool_id: string): PoolTransactionInfo[];
+declare function generateRewardSchedule(baseTime: number, maxIntervals: number, timeInterval: number): number[];
+declare function parseRewardPeriodEmission(periodEmissionList: RewardPeriodEmission[], startTimeInSeconds: number, endTimeInSeconds: number, durationSeconds: number): RewardPeriodEmissionFormat[];
+declare function parseCurrentRewardPeriodEmission(periodEmissionList: RewardPeriodEmission[]): RewardPeriodEmission | undefined;
+declare function safeMulAmount(amount: Decimal, rate: Decimal): Decimal;
+declare function getRouterModule(strategy_type: StrategyType): "spot" | "curve" | "bid_ask";
+
+declare const SCALE_OFFSET = 64;
+declare const ONE: BN;
+declare class BinUtils {
+    /**
+     * Split bins into multiple smaller positions based on MAX_BIN_PER_POSITION
+     * @param bins - The bins to split
+     * @param lower_bin_id - The lower bin id
+     * @param upper_bin_id - The upper bin id
+     * @returns Array of bin info objects for each position
+     */
+    static splitBinLiquidityInfo(liquidity_bins: BinLiquidityInfo, lower_bin_id: number, upper_bin_id: number): BinLiquidityInfo[];
+    /**
+     * Process bins by rate
+     * @param bins - The bins to be processed
+     * @param rate - The rate to be applied
+     * @returns The processed bins
+     */
+    static processBinsByRate(bins: BinAmount[], rate: string): {
+        bins: BinLiquidityInfo;
+        has_invalid_amount: boolean;
+    };
+    /**
+     * Calculate the amount of token A and token B to be removed from a bin
+     * @param bin - The bin information
+     * @param remove_liquidity - The amount of liquidity to be removed
+     * @returns The amount of token A and token B to be removed
+     */
+    static calculateOutByShare(bin: BinAmount, remove_liquidity: string): {
+        amount_a: string;
+        amount_b: string;
+    };
+    /**
+     * Get the number of positions in a range of bin ids
+     * @param lower_bin_id - The lower bin id
+     * @param upper_bin_id - The upper bin id
+     * @returns The number of positions
+     */
+    static getPositionCount(lower_bin_id: number, upper_bin_id: number): number;
+    /**
+     * Calculate the amount of liquidity following the constant sum formula `L = price * x + y`
+     * @param amount_a
+     * @param amount_b
+     * @param qPrice Price is in Q64x64
+     * @returns
+     */
+    static getLiquidity(amount_a: string, amount_b: string, qPrice: string): string;
+    /**
+     * Calculate amount_a from liquidity when all liquidity is in token A
+     * @param liquidity - The liquidity amount
+     * @param qPrice - Price in Q64x64 format
+     * @returns The amount of token A
+     */
+    static getAmountAFromLiquidity(liquidity: string, qPrice: string): string;
+    /**
+     * Calculate amount_b from liquidity when all liquidity is in token B
+     * @param liquidity - The liquidity amount
+     * @returns The amount of token B
+     */
+    static getAmountBFromLiquidity(liquidity: string): string;
+    /**
+     * Calculate amounts from liquidity using the same logic as Move code
+     * @param amount_a - Current amount of token A in the bin
+     * @param amount_b - Current amount of token B in the bin
+     * @param delta_liquidity - The liquidity delta to calculate amounts for
+     * @param liquidity_supply - Total liquidity supply in the bin
+     * @returns [amount_a_out, amount_b_out]
+     */
+    static getAmountsFromLiquidity(amount_a: string, amount_b: string, delta_liquidity: string, liquidity_supply: string): [string, string];
+    /**
+     * Get the price of a bin by bin id
+     * @param bin_id - The bin id
+     * @param bin_step - The bin step
+     * @param decimal_a - The decimal of the token a
+     * @param decimal_b - The decimal of the token b
+     * @returns The price of the bin
+     */
+    static getPriceFromBinId(bin_id: number, bin_step: number, decimal_a: number, decimal_b: number): string;
+    /**
+     * Get the price per lamport of a bin by bin id
+     * @param bin_id - The bin id
+     * @param bin_step - The bin step
+     * @returns The price per lamport of the bin
+     */
+    static getPricePerLamportFromBinId(bin_id: number, bin_step: number): string;
+    /**
+     * Get the bin id from a price
+     * @param price - The price
+     * @param binStep - The bin step
+     * @param min - Whether to use the minimum or maximum bin id
+     * @param decimal_a - The decimal of the token a
+     * @param decimal_b - The decimal of the token b
+     * @returns The bin id
+     */
+    static getBinIdFromPrice(price: string, binStep: number, min: boolean, decimal_a: number, decimal_b: number): number;
+    /**
+     * Get the bin id from a price per lamport
+     * @param pricePerLamport - The price per lamport
+     * @param binStep - The bin step
+     * @param min - Whether to use the minimum or maximum bin id
+     * @returns The bin id
+     */
+    static getBinIdFromLamportPrice(pricePerLamport: string, binStep: number, min: boolean): number;
+    /**
+     * Get the price per lamport
+     * @param decimal_a - The decimal of the token a
+     * @param decimal_b - The decimal of the token b
+     * @param price - The price
+     * @returns The price per lamport
+     */
+    static getPricePerLamport(decimal_a: number, decimal_b: number, price: string): string;
+    /**
+     * Convert price per lamport back to original price
+     * @param decimal_a - The decimal of the token a
+     * @param decimal_b - The decimal of the token b
+     * @param pricePerLamport - The price per lamport
+     * @returns The original price
+     */
+    static getPriceFromLamport(decimal_a: number, decimal_b: number, pricePerLamport: string): string;
+    /**
+     * Get the reverse price
+     * @param price - The price
+     * @returns The reverse price
+     */
+    static getReversePrice(price: string): string;
+    /**
+     * Get the price of a bin by bin id
+     * @param binId - The bin id
+     * @param binStep - The bin step
+     * @returns The price of the bin
+     */
+    static getQPriceFromId(binId: number, binStep: number): string;
+    /**
+     * Convert QPrice (Q64x64 format) to actual price
+     * @param qPrice - The price in Q64x64 format
+     * @returns The actual price
+     */
+    static getPricePerLamportFromQPrice(qPrice: string): string;
+    static pow(base: BN, exp: BN): BN;
+    /**
+     * Converts a bin ID to a score by adding the bin bound and validating the range
+     * @param binId - The bin ID to convert
+     * @returns The calculated bin score
+     * @throws Error if the bin ID is invalid
+     */
+    static binScore(binId: number): string;
+    /**
+     * Converts a score back to bin ID by subtracting the bin bound
+     * @param score - The score to convert
+     * @returns The calculated bin ID
+     * @throws Error if the score is invalid
+     */
+    static scoreToBinId(score: string): number;
+    /**
+     * Resolves the bin position from a score.
+     *
+     * @param score - The score to resolve
+     * @returns Tuple of [group index, offset in group]
+     */
+    static resolveBinPosition(score: string): [string, number];
+    static findMinMaxBinId(binStep: number): {
+        minBinId: number;
+        maxBinId: number;
+    };
+    static getBinShift(active_id: number, bin_step: number, max_price_slippage: number): number;
+}
+
+declare class WeightUtils {
+    static toWeightSpotBalanced(min_bin_id: number, max_bin_id: number): BinWeight[];
+    static toWeightDescendingOrder(min_bin_id: number, max_bin_id: number): BinWeight[];
+    static toWeightAscendingOrder(min_bin_id: number, max_bin_id: number): BinWeight[];
+    static toWeightCurve(min_bin_id: number, max_bin_id: number, active_id: number): BinWeight[];
+    static toWeightBidAsk(min_bin_id: number, max_bin_id: number, active_id: number): BinWeight[];
+    /**
+     * Distribute totalAmount to all bid side bins according to given distributions.
+     * @param active_id - active bin id
+     * @param amount_b - total amount of coin b to be distributed
+     * @param distributions - weight distribution of each bin
+     * @returns array of {binId, amount} where amount is the amount of coin b in each bin
+     */
+    static toAmountBidSide(active_id: number, amount_b: string, bin_step: number, distributions: BinWeight[], contain_active_bin?: boolean): BinLiquidityInfo;
+    /**
+     * Distribute totalAmount to all ask side bins according to given distributions.
+     * @param active_id active bin id
+     * @param amount_a total amount of coin a to be distributed
+     * @param distributions weight distribution of each bin
+     * @returns array of {binId, amount} where amount is the amount of coin a in each bin
+     */
+    static toAmountAskSide(active_id: number, bin_step: number, amount_a: string, distributions: BinWeight[], contain_active_bin?: boolean): BinLiquidityInfo;
+    /**
+     * Distributes the given amounts of tokens X and Y to both bid and ask side bins
+     * based on the provided weight distributions.
+     *
+     * @param activeId - The id of the active bin.
+     * @param binStep - The step interval between bin ids.
+     * @param amountX - Total amount of token X to distribute.
+     * @param amountY - Total amount of token Y to distribute.
+     * @param amountXInActiveBin - Amount of token X already in the active bin.
+     * @param amountYInActiveBin - Amount of token Y already in the active bin.
+     * @param distributions - Array of bins with their respective weight distributions.
+     * @param mintX - Mint information for token X. Get from DLMM instance.
+     * @param mintY - Mint information for token Y. Get from DLMM instance.
+     * @param clock - Clock instance. Get from DLMM instance.
+     * @returns An array of objects containing binId, amountX, and amountY for each bin.
+     */
+    static toAmountBothSide(active_id: number, bin_step: number, amount_a: string, amount_b: string, amount_a_in_active_bin: string, amount_b_in_active_bin: string, distributions: BinWeight[]): BinLiquidityInfo;
+    /**
+     * Distributes the given amount of coin B to both bid and ask side bins
+     * based on the provided weight distributions.
+     *
+     * @param active_id - The id of the active bin.
+     * @param bin_step - The step interval between bin ids.
+     * @param amount_a - Total amount of coin A to distribute.
+     * @param amount_a_in_active_bin - Amount of coin A already in the active bin.
+     * @param amount_b_in_active_bin - Amount of coin B already in the active bin.
+     * @param distributions - Array of bins with their respective weight distributions.
+     * @returns An array of objects containing binId, amountA, and amountB for each bin.
+     */
+    static autoFillCoinByWeight(active_id: number, bin_step: number, amount: string, fix_amount_a: boolean, amount_a_in_active_bin: string, amount_b_in_active_bin: string, distributions: BinWeight[]): BinLiquidityInfo;
+    static calculateTotalWeights(bin_step: number, distributions: BinWeight[], active_id: number, activeBin?: BinWeight, amount_a_in_active_bin?: string, amount_b_in_active_bin?: string, is_only_amount?: 'a' | 'b'): {
+        totalWeightA: Decimal;
+        totalWeightB: Decimal;
+        activeWeightA: Decimal;
+        activeWeightB: Decimal;
+    };
+}
+
+declare class StrategyUtils {
+    /**
+     * Given a strategy type and amounts of X and Y, returns the distribution of liquidity.
+     * @param active_id The bin id of the active bin.
+     * @param bin_step The step size of each bin.
+     * @param min_bin_id The min bin id.
+     * @param max_bin_id The max bin id.
+     * @param amount_a The amount of X token to deposit.
+     * @param amount_b The amount of Y token to deposit.
+     * @param amount_a_in_active_bin The amount of X token in the active bin.
+     * @param amount_b_in_active_bin The amount of Y token in the active bin.
+     * @param strategy_type The strategy type.
+     * @returns The distribution of liquidity.
+     */
+    static toAmountsBothSideByStrategy(active_id: number, bin_step: number, min_bin_id: number, max_bin_id: number, amount_a: string, amount_b: string, amount_a_in_active_bin: string, amount_b_in_active_bin: string, strategy_type: StrategyType): BinLiquidityInfo;
+    static autoFillCoinByStrategy(active_id: number, bin_step: number, amount: string, fix_amount_a: boolean, amount_a_in_active_bin: string, amount_b_in_active_bin: string, min_bin_id: number, max_bin_id: number, strategy_type: StrategyType): BinLiquidityInfo;
+}
+
+declare class FeeUtils {
+    static getVariableFee(variableParameters: VariableParameters): string;
+    static calculateCompositionFee(amount: string, total_fee_rate: string): string;
+    static calculateProtocolFee(fee_amount: string, protocol_fee_rate: string): string;
+    static getProtocolFees(fee_a: string, fee_b: string, protocol_fee_rate: string): {
+        protocol_fee_a: string;
+        protocol_fee_b: string;
+    };
+    static getCompositionFees(active_bin: BinAmount, used_bin: BinAmount, binStepConfig: BinStepConfig, variableParameters: VariableParameters): {
+        fees_a: string;
+        fees_b: string;
+    };
+}
+
+declare const MAX_BIN_PER_POSITION = 1000;
+declare const MIN_BIN_ID = -443636;
+declare const MAX_BIN_ID = 443636;
+declare const BASIS_POINT_MAX = 10000;
+declare const DEFAULT_MAX_WEIGHT = 2000;
+declare const DEFAULT_MIN_WEIGHT = 200;
+declare const BIN_BOUND = 443636n;
+declare const MAX_FEE_RATE = 100000000;
+declare const FEE_PRECISION = 1000000000;
+declare const BASIS_POINT = 10000;
+declare const REWARD_PERIOD: number;
+declare const REWARD_PERIOD_START_AT = 1747627200;
+
+declare const dlmmMainnet: SdkOptions;
+
+declare const dlmmTestnet: SdkOptions;
+
+export { type AddLiquidityOption, type AddRewardOption, BASIS_POINT, BASIS_POINT_MAX, BIN_BOUND, type BaseAddLiquidityOption, type BaseCalculateAddLiquidityOption, type BaseCreatePoolAndAddOption, type BaseCreatePoolOption, type BinAmount, type BinLiquidityInfo, type BinManager, type BinStepConfig, type BinSwap, BinUtils, type BinWeight, type CalculateAddLiquidityAutoFillOption, type CalculateAddLiquidityOption, type CalculateRemoveLiquidityBothOption, type CalculateRemoveLiquidityOnlyOption, CetusDlmmSDK, type ClaimRefFeeOption, type ClosePositionOption, type CollectFeeOption, type CollectRewardAndFeeOption, type CollectRewardOption, type CreatePartnerOption, type CreatePoolAndAddOption, type CreatePoolAndAddWithPriceOption, type CreatePoolOption, DEFAULT_MAX_WEIGHT, DEFAULT_MIN_WEIGHT, type DlmmBasePool, type DlmmConfigs, type DlmmGlobalConfig, type DlmmPool, type DlmmPosition, FEE_PRECISION, type FeeRate, FeeUtils, type GetPoolBinInfoOption, type GetTotalFeeRateOption, type InitRewardOption, MAX_BIN_ID, MAX_BIN_PER_POSITION, MAX_FEE_RATE, MIN_BIN_ID, ONE, type OpenAndAddLiquidityOption, type OpenAndAddLiquidityWithPriceOption, type OpenPositionOption, type Partner, PoolModule, type PoolPermissions, type PoolTransactionInfo, type PositionFee, type PositionManager, type PositionReward, type PreSwapOption, type PreSwapQuote, REWARD_PERIOD, REWARD_PERIOD_START_AT, type RemoveLiquidityOption, type Reward, type RewardAccessOption, type RewardInfo, type RewardManager, type RewardPeriodEmission, type RewardPeriodEmissionFormat, type RewardWhiteListOption, SCALE_OFFSET, type SdkOptions, StrategyType, StrategyUtils, type SwapOption, type UpdatePositionFeeAndRewardsOption, type UpdateRefFeeRateOption, type UpdateTimeRangeOption, type ValidateActiveIdSlippageOption, type VariableParameters, WeightUtils, CetusDlmmSDK as default, dlmmMainnet, dlmmTestnet, generateRewardSchedule, getRouterModule, parseBinInfo, parseBinInfoList, parseCurrentRewardPeriodEmission, parseDlmmBasePool, parseDlmmPool, parseDlmmPosition, parseLiquidityShares, parsePartner, parsePoolTransactionInfo, parseRewardPeriodEmission, parseStrategyType, parsedDlmmPosFeeData, parsedDlmmPosRewardData, parsedSwapQuoteData, poolFilterEvenTypes, safeMulAmount };