@cetusprotocol/dlmm-sdk 0.0.1

package/src/modules/positionModule.ts

@@ -0,0 +1,888 @@
+import { asUintN, CLOCK_ADDRESS, CoinAssist, d, DETAILS_KEYS, getPackagerConfigs, IModule } from '@cetusprotocol/common-sdk'
+import { Transaction, TransactionObjectArgument, TransactionResult } from '@mysten/sui/transactions'
+import { normalizeSuiAddress } from '@mysten/sui/utils'
+import { DlmmErrorCode, handleError } from '../errors/errors'
+import { CetusDlmmSDK } from '../sdk'
+import { BASIS_POINT, MAX_BIN_PER_POSITION } from '../types/constants'
+import {
+  AddLiquidityOption,
+  BinAmount,
+  BinLiquidityInfo,
+  CalculateAddLiquidityAutoFillOption,
+  CalculateAddLiquidityOption,
+  CalculateRemoveLiquidityBothOption,
+  CalculateRemoveLiquidityOnlyOption,
+  ClosePositionOption,
+  CollectFeeOption,
+  CollectRewardAndFeeOption,
+  CollectRewardOption,
+  DlmmPosition,
+  OpenAndAddLiquidityOption,
+  OpenAndAddLiquidityWithPriceOption,
+  PositionFee,
+  PositionReward,
+  RemoveLiquidityOption,
+  StrategyType,
+  UpdatePositionFeeAndRewardsOption,
+  ValidateActiveIdSlippageOption,
+} from '../types/dlmm'
+import {
+  BinUtils,
+  getRouterModule,
+  parsedDlmmPosFeeData,
+  parsedDlmmPosRewardData,
+  parseDlmmPosition,
+  parseStrategyType,
+  StrategyUtils,
+} from '../utils'
+import Decimal from 'decimal.js'
+
+export class PositionModule implements IModule<CetusDlmmSDK> {
+  protected _sdk: CetusDlmmSDK
+
+  constructor(sdk: CetusDlmmSDK) {
+    this._sdk = sdk
+  }
+
+  get sdk() {
+    return this._sdk
+  }
+
+  buildPositionType(): string {
+    const package_id = this._sdk.sdkOptions.dlmm_pool.package_id
+    return `${package_id}::position::Position`
+  }
+
+  async getOwnerPositionList(owner: string): Promise<DlmmPosition[]> {
+    const list: DlmmPosition[] = []
+    try {
+      const res = await this._sdk.FullClient.getOwnedObjectsByPage(owner, {
+        options: { showType: true, showContent: true, showOwner: true },
+        filter: {
+          StructType: this.buildPositionType(),
+        },
+      })
+
+      res.data.forEach((obj) => {
+        list.push(parseDlmmPosition(obj))
+      })
+    } catch (error) {
+      console.log('🚀 ~ PositionModule ~ getOwnerPositionList ~ error:', error)
+      handleError(DlmmErrorCode.GetObjectError, error as Error, {
+        [DETAILS_KEYS.METHOD_NAME]: 'getOwnerPositionList',
+        [DETAILS_KEYS.REQUEST_PARAMS]: owner,
+      })
+    }
+
+    return list
+  }
+
+  async getPosition(position_id: string): Promise<DlmmPosition> {
+    try {
+      const res = await this._sdk.FullClient.getObject({ id: position_id, options: { showType: true, showContent: true, showOwner: true } })
+      return parseDlmmPosition(res)
+    } catch (error) {
+      console.log('🚀 ~ PositionModule ~ getPosition ~ error:', error)
+      return handleError(DlmmErrorCode.GetObjectError, error as Error, {
+        [DETAILS_KEYS.METHOD_NAME]: 'getPosition',
+        [DETAILS_KEYS.REQUEST_PARAMS]: position_id,
+      })
+    }
+  }
+
+  /**
+   * Collect fee
+   * @param option - The option for collecting fee
+   * @param tx - The transaction object
+   * @returns The transaction object
+   */
+  collectFeePayload(option: CollectFeeOption, tx?: Transaction): Transaction {
+    const { pool_id, position_id, coin_type_a, coin_type_b } = option
+    const { dlmm_pool } = this.sdk.sdkOptions
+    const { versioned_id, global_config_id } = getPackagerConfigs(dlmm_pool)
+
+    tx = tx || new Transaction()
+
+    const [fee_a_balance, fee_b_balance] = tx.moveCall({
+      target: `${dlmm_pool.published_at}::pool::collect_position_fee`,
+      arguments: [tx.object(pool_id), tx.object(position_id), tx.object(global_config_id), tx.object(versioned_id)],
+      typeArguments: [coin_type_a, coin_type_b],
+    })
+
+    const fee_a_obj = CoinAssist.fromBalance(fee_a_balance, coin_type_a, tx)
+    const fee_b_obj = CoinAssist.fromBalance(fee_b_balance, coin_type_b, tx)
+    tx.transferObjects([fee_a_obj, fee_b_obj], this.sdk.getSenderAddress())
+
+    return tx
+  }
+
+  /**
+   * 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) {
+    const { dlmm_pool } = this.sdk.sdkOptions
+    const { versioned_id, global_config_id } = getPackagerConfigs(dlmm_pool)
+    const { pool_id, position_id, coin_type_a, coin_type_b } = option
+    tx.moveCall({
+      target: `${dlmm_pool.published_at}::pool::update_position_fee_and_rewards`,
+      arguments: [
+        tx.object(pool_id),
+        tx.pure.id(position_id),
+        tx.object(global_config_id),
+        tx.object(versioned_id),
+        tx.object(CLOCK_ADDRESS),
+      ],
+      typeArguments: [coin_type_a, coin_type_b],
+    })
+
+    return tx
+  }
+
+  /**
+   * Collect reward
+   * @param options - The option for collecting reward
+   * @param tx - The transaction object
+   * @returns The transaction object
+   */
+  collectRewardPayload(options: CollectRewardOption[], tx?: Transaction): Transaction {
+    const { dlmm_pool } = this.sdk.sdkOptions
+    const { versioned_id, global_config_id } = getPackagerConfigs(dlmm_pool)
+
+    tx = tx || new Transaction()
+
+    options.forEach((option) => {
+      const { pool_id, position_id, reward_coins, coin_type_a, coin_type_b } = option
+
+      reward_coins.forEach((reward_coin) => {
+        const reward_coin_balance = tx.moveCall({
+          target: `${dlmm_pool.published_at}::pool::collect_position_reward`,
+          arguments: [tx.object(pool_id), tx.object(position_id), tx.object(global_config_id), tx.object(versioned_id)],
+          typeArguments: [coin_type_a, coin_type_b, reward_coin],
+        })
+
+        const reward_coin_obj = CoinAssist.fromBalance(reward_coin_balance, reward_coin, tx)
+        tx.transferObjects([reward_coin_obj], this.sdk.getSenderAddress())
+      })
+    })
+
+    return tx
+  }
+
+  collectRewardAndFeePayload(options: CollectRewardAndFeeOption[], tx?: Transaction): Transaction {
+    tx = tx || new Transaction()
+
+    options.forEach((option) => {
+      const { pool_id, position_id, reward_coins, coin_type_a, coin_type_b } = option
+
+      this.updatePositionFeeAndRewards({ pool_id, position_id, coin_type_a, coin_type_b }, tx)
+
+      this.collectFeePayload({ pool_id, position_id, coin_type_a, coin_type_b }, tx)
+      this.collectRewardPayload([{ pool_id, position_id, reward_coins, coin_type_a, coin_type_b }], tx)
+    })
+
+    return tx
+  }
+
+  /**
+   * 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 {
+    const { pool_id, active_id, max_price_slippage, bin_step, coin_type_a, coin_type_b } = options
+    const { dlmm_router } = this.sdk.sdkOptions
+
+    const bin_shift = BinUtils.getBinShift(active_id, bin_step, max_price_slippage)
+    const active_id_u32 = Number(asUintN(BigInt(active_id)))
+
+    tx.moveCall({
+      target: `${dlmm_router.published_at}::utils::validate_active_id_slippage`,
+      arguments: [
+        typeof pool_id === 'string' ? tx.object(pool_id) : pool_id,
+        tx.pure.u32(Number(active_id_u32)),
+        tx.pure.u32(Number(bin_shift)),
+      ],
+      typeArguments: [coin_type_a, coin_type_b],
+    })
+
+    return tx
+  }
+
+  /**
+   * Close a position
+   * @param option - The option for closing a position
+   * @returns The transaction object
+   */
+  closePositionPayload(option: ClosePositionOption, tx?: Transaction): Transaction {
+    const { pool_id, position_id, reward_coins, coin_type_a, coin_type_b } = option
+    const { dlmm_pool } = this.sdk.sdkOptions
+    const { versioned_id, global_config_id } = getPackagerConfigs(dlmm_pool)
+
+    tx = tx || new Transaction()
+
+    this.updatePositionFeeAndRewards({ pool_id, position_id, coin_type_a, coin_type_b }, tx)
+
+    this.collectRewardPayload([{ pool_id, position_id, reward_coins, coin_type_a, coin_type_b }], tx)
+
+    const [close_position_cert, coin_a_balance, coin_b_balance] = tx.moveCall({
+      target: `${dlmm_pool.published_at}::pool::close_position`,
+      arguments: [
+        tx.object(pool_id),
+        tx.object(position_id),
+        tx.object(global_config_id),
+        tx.object(versioned_id),
+        tx.object(CLOCK_ADDRESS),
+      ],
+      typeArguments: [coin_type_a, coin_type_b],
+    })
+
+    const coin_a_obj = CoinAssist.fromBalance(coin_a_balance, coin_type_a, tx)
+    const coin_b_obj = CoinAssist.fromBalance(coin_b_balance, coin_type_b, tx)
+
+    tx.moveCall({
+      target: `${dlmm_pool.published_at}::pool::destroy_close_position_cert`,
+      arguments: [close_position_cert, tx.object(versioned_id)],
+      typeArguments: [],
+    })
+
+    tx.transferObjects([coin_a_obj, coin_b_obj], this.sdk.getSenderAddress())
+
+    return tx
+  }
+
+  /**
+   * 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
+   */
+  async getActiveBinIfInRange(
+    bin_manager_handle: string,
+    lower_bin_id: number,
+    upper_bin_id: number,
+    active_id: number,
+    bin_step: number,
+    force_refresh = false
+  ): Promise<BinAmount | undefined> {
+    if (active_id <= upper_bin_id && active_id >= lower_bin_id) {
+      const bin_info = await this._sdk.Pool.getBinInfo(bin_manager_handle, active_id, bin_step, force_refresh)
+      return bin_info
+    }
+    return 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 {
+    const { bins, active_id, coin_amount } = option
+    const isBothSide = 'fix_amount_a' in option
+
+    const bins_b = bins.filter((bin) => bin.bin_id < active_id)
+    const bins_a = bins.filter((bin) => bin.bin_id > active_id)
+
+    let total_amount = d(0)
+    let amount_rate = d(0)
+    let used_bins: BinAmount[] = []
+
+    if (isBothSide) {
+      used_bins = [...bins]
+      const { fix_amount_a } = option
+      const active_bin = bins.find((bin) => bin.bin_id === active_id)
+      const total_amount_a = bins_a.reduce((acc, bin) => d(acc).plus(bin.amount_a), d(0)).add(active_bin?.amount_a || '0')
+      const total_amount_b = bins_b.reduce((acc, bin) => d(acc).plus(bin.amount_b), d(0)).add(active_bin?.amount_b || '0')
+      total_amount = fix_amount_a ? total_amount_a : total_amount_b
+
+      amount_rate = d(coin_amount).gte(total_amount) ? d(1) : d(coin_amount).div(total_amount)
+    } else {
+      const { is_only_a } = option
+      used_bins = is_only_a ? bins_a : bins_b
+      total_amount = used_bins.reduce((acc, bin) => d(acc).plus(is_only_a ? bin.amount_a : bin.amount_b), d(0))
+
+      amount_rate = d(coin_amount).gte(total_amount) ? d(1) : d(coin_amount).div(total_amount)
+    }
+
+    if (d(total_amount).isZero()) {
+      return handleError(DlmmErrorCode.InsufficientLiquidity, new Error('Insufficient liquidity'), {
+        [DETAILS_KEYS.METHOD_NAME]: 'calculateRemoveLiquidityResult',
+        [DETAILS_KEYS.REQUEST_PARAMS]: option,
+      })
+    }
+
+    const info = BinUtils.processBinsByRate([...used_bins], amount_rate.toFixed())
+    // If the proportional allocation results in an invalid amount, iterate through the bins and remove them one by one
+    if (info.has_invalid_amount) {
+      let remaining_amount = d(coin_amount)
+      const processed_bins: BinAmount[] = []
+      const is_amount_a = isBothSide ? option.fix_amount_a : option.is_only_a
+      for (const bin of used_bins) {
+        if (remaining_amount.lte(0)) break
+
+        const bin_amount = is_amount_a ? bin.amount_a : bin.amount_b
+        const bin_amount_other = is_amount_a ? bin.amount_b : bin.amount_a
+
+        let rate = d(d(remaining_amount).div(bin_amount).toFixed(9, Decimal.ROUND_UP))
+        rate = rate.gt(1) ? d(1) : rate
+        let amount_to_remove = d(bin_amount).mul(rate)
+        remaining_amount = remaining_amount.minus(amount_to_remove)
+
+        const amount_to_remove_other = d(bin_amount_other).mul(rate)
+        const liquidity_to_remove = d(bin.liquidity!).mul(rate)
+
+        processed_bins.push({
+          ...bin,
+          amount_a: is_amount_a ? amount_to_remove.toFixed(0) : amount_to_remove_other.toFixed(0),
+          amount_b: is_amount_a ? amount_to_remove_other.toFixed(0) : amount_to_remove.toFixed(0),
+          liquidity: liquidity_to_remove.toFixed(0),
+        })
+      }
+
+      return {
+        bins: processed_bins,
+        amount_a: processed_bins.reduce((acc, bin) => d(acc).plus(bin.amount_a), d(0)).toFixed(0),
+        amount_b: processed_bins.reduce((acc, bin) => d(acc).plus(bin.amount_b), d(0)).toFixed(0),
+      }
+    }
+
+    return info.bins
+  }
+
+  /**
+   * 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 {
+    const isAutoFill = 'fix_amount_a' in option
+    const { active_id, bin_step, lower_bin_id, upper_bin_id, amount_a_in_active_bin, amount_b_in_active_bin, strategy_type } = option
+
+    if (isAutoFill) {
+      const { coin_amount, fix_amount_a } = option
+      return StrategyUtils.autoFillCoinByStrategy(
+        active_id,
+        bin_step,
+        coin_amount,
+        fix_amount_a,
+        amount_a_in_active_bin,
+        amount_b_in_active_bin,
+        lower_bin_id,
+        upper_bin_id,
+        strategy_type
+      )
+    } else {
+      return StrategyUtils.toAmountsBothSideByStrategy(
+        active_id,
+        bin_step,
+        lower_bin_id,
+        upper_bin_id,
+        option.amount_a,
+        option.amount_b,
+        amount_a_in_active_bin,
+        amount_b_in_active_bin,
+        strategy_type
+      )
+    }
+  }
+
+  /**
+   * Remove liquidity
+   * @param option - The option for removing liquidity
+   * @returns The transaction
+   */
+  removeLiquidityPayload(option: RemoveLiquidityOption): Transaction {
+    const {
+      pool_id,
+      position_id,
+      bin_infos,
+      reward_coins,
+      slippage,
+      coin_type_a,
+      coin_type_b,
+      active_id,
+      collect_fee,
+      bin_step,
+      remove_percent,
+    } = option
+    const { dlmm_pool } = this.sdk.sdkOptions
+    const { bins } = bin_infos
+    const tx = new Transaction()
+
+    if (collect_fee || reward_coins.length > 0) {
+      this.updatePositionFeeAndRewards({ pool_id, position_id, coin_type_a, coin_type_b }, tx)
+    }
+    if (collect_fee) {
+      this.collectFeePayload({ pool_id, position_id, coin_type_a, coin_type_b }, tx)
+    }
+
+    this.collectRewardPayload([{ pool_id, position_id, reward_coins, coin_type_a, coin_type_b }], tx)
+
+    const { versioned_id, global_config_id } = getPackagerConfigs(dlmm_pool)
+
+    if (remove_percent) {
+      const min_bin_id_u32 = asUintN(BigInt(bins[0].bin_id))
+      const max_bin_id_u32 = asUintN(BigInt(bins[bins.length - 1].bin_id))
+      const remove_percent_fixed = Number(d(remove_percent).mul(BASIS_POINT).toFixed(0))
+      const [coin_a_balance, coin_b_balance] = tx.moveCall({
+        target: `${dlmm_pool.published_at}::pool::remove_liquidity_by_percent`,
+        arguments: [
+          tx.object(pool_id),
+          tx.object(position_id),
+          tx.pure.u32(Number(min_bin_id_u32)),
+          tx.pure.u32(Number(max_bin_id_u32)),
+          tx.pure.u16(remove_percent_fixed),
+          tx.object(global_config_id),
+          tx.object(versioned_id),
+          tx.object(CLOCK_ADDRESS),
+        ],
+        typeArguments: [coin_type_a, coin_type_b],
+      })
+      const coin_a_obj = CoinAssist.fromBalance(coin_a_balance, coin_type_a, tx)
+      const coin_b_obj = CoinAssist.fromBalance(coin_b_balance, coin_type_b, tx)
+      tx.transferObjects([coin_a_obj, coin_b_obj], this.sdk.getSenderAddress())
+    } else {
+      const bin_amounts = tx.pure.vector(
+        'u32',
+        bins.map((bin) => Number(asUintN(BigInt(bin.bin_id))))
+      )
+      const remove_liquiditys = tx.pure.vector(
+        'u128',
+        bins.map((bin) => bin.liquidity!)
+      )
+
+      const [coin_a_balance, coin_b_balance] = tx.moveCall({
+        target: `${dlmm_pool.published_at}::pool::remove_liquidity`,
+        arguments: [
+          tx.object(pool_id),
+          tx.object(position_id),
+          bin_amounts,
+          remove_liquiditys,
+          tx.object(global_config_id),
+          tx.object(versioned_id),
+          tx.object(CLOCK_ADDRESS),
+        ],
+        typeArguments: [coin_type_a, coin_type_b],
+      })
+      const coin_a_obj = CoinAssist.fromBalance(coin_a_balance, coin_type_a, tx)
+      const coin_b_obj = CoinAssist.fromBalance(coin_b_balance, coin_type_b, tx)
+      tx.transferObjects([coin_a_obj, coin_b_obj], this.sdk.getSenderAddress())
+    }
+
+    // validate the active id slippage
+    this.validateActiveIdSlippage({ pool_id, active_id, max_price_slippage: slippage, bin_step, coin_type_a, coin_type_b }, tx)
+
+    return tx
+  }
+
+  /**
+   * Add liquidity with price
+   * @param option - The option for adding liquidity with price
+   * @returns The transaction
+   */
+  addLiquidityWithPricePayload(option: OpenAndAddLiquidityWithPriceOption): Transaction {
+    const {
+      pool_id,
+      bin_infos,
+      coin_type_a,
+      coin_type_b,
+      price_base_coin,
+      price,
+      lower_price,
+      upper_price,
+      bin_step,
+      strategy_type,
+      amount_a_in_active_bin,
+      amount_b_in_active_bin,
+      decimals_a,
+      decimals_b,
+      use_bin_infos,
+      max_price_slippage,
+    } = option
+    let lower_bin_id
+    let upper_bin_id
+    let active_id
+    let new_bin_infos: BinLiquidityInfo = bin_infos
+
+    const is_coin_a_base = price_base_coin === 'coin_a'
+
+    if (is_coin_a_base) {
+      lower_bin_id = BinUtils.getBinIdFromPrice(lower_price, bin_step, false, decimals_a, decimals_b)
+      upper_bin_id = BinUtils.getBinIdFromPrice(upper_price, bin_step, true, decimals_a, decimals_b)
+      active_id = BinUtils.getBinIdFromPrice(price, bin_step, true, decimals_a, decimals_b)
+    } else {
+      lower_bin_id = BinUtils.getBinIdFromPrice(d(1).div(upper_price).toString(), bin_step, false, decimals_a, decimals_b)
+      upper_bin_id = BinUtils.getBinIdFromPrice(d(1).div(lower_price).toString(), bin_step, true, decimals_a, decimals_b)
+      active_id = BinUtils.getBinIdFromPrice(d(1).div(price).toString(), bin_step, false, decimals_a, decimals_b)
+
+      const calculateOption: CalculateAddLiquidityOption = {
+        amount_a: bin_infos.amount_b,
+        amount_b: bin_infos.amount_a,
+        active_id,
+        bin_step,
+        lower_bin_id,
+        upper_bin_id,
+        amount_a_in_active_bin,
+        amount_b_in_active_bin,
+        strategy_type: strategy_type,
+      }
+
+      new_bin_infos = this.sdk.Position.calculateAddLiquidityInfo(calculateOption)
+    }
+
+    const openAndAddLiquidityOption: OpenAndAddLiquidityOption = {
+      pool_id,
+      active_id,
+      bin_infos: new_bin_infos,
+      coin_type_a,
+      coin_type_b,
+      lower_bin_id,
+      upper_bin_id,
+      strategy_type,
+      use_bin_infos,
+      max_price_slippage,
+      bin_step,
+    }
+
+    return this.addLiquidityPayload(openAndAddLiquidityOption)
+  }
+
+  /**
+   * Add liquidity
+   * @param option - The option for adding liquidity
+   * @returns The transaction object
+   */
+  addLiquidityPayload(option: AddLiquidityOption | OpenAndAddLiquidityOption, tx?: Transaction): Transaction {
+    const {
+      pool_id,
+      bin_infos,
+      coin_type_a,
+      coin_type_b,
+      active_id,
+      strategy_type,
+      max_price_slippage,
+      bin_step,
+      use_bin_infos = false,
+    } = option
+    tx = tx || new Transaction()
+
+    const isOpenPosition = 'lower_bin_id' in option
+
+    const liquidity_bins: BinLiquidityInfo[] = []
+
+    if (isOpenPosition) {
+      const position_bins = BinUtils.splitBinLiquidityInfo(bin_infos, option.lower_bin_id, option.upper_bin_id)
+      liquidity_bins.push(...position_bins)
+    } else {
+      const position_id = option.position_id
+      liquidity_bins.push(bin_infos)
+
+      if (option.collect_fee || option.reward_coins.length > 0) {
+        this.updatePositionFeeAndRewards({ pool_id: pool_id as string, position_id, coin_type_a, coin_type_b }, tx)
+      }
+
+      if (option.collect_fee) {
+        this.collectFeePayload({ pool_id: pool_id as string, position_id, coin_type_a, coin_type_b }, tx)
+      }
+
+      if (option.reward_coins.length > 0) {
+        this.collectRewardPayload(
+          [{ pool_id: pool_id as string, position_id, reward_coins: option.reward_coins, coin_type_a, coin_type_b }],
+          tx
+        )
+      }
+    }
+
+    liquidity_bins.forEach((liquidity_bin, index) => {
+      console.log('🚀 ~ PositionModule ~ addLiquidityPayload ~ liquidity_bin:', index, liquidity_bin)
+      const { amount_a, amount_b, bins } = liquidity_bin
+
+      const coin_a_obj_id = CoinAssist.buildCoinWithBalance(BigInt(amount_a), coin_type_a, tx)
+      const coin_b_obj_id = CoinAssist.buildCoinWithBalance(BigInt(amount_b), coin_type_b, tx)
+
+      if (use_bin_infos) {
+        this.addLiquidityInternal({
+          pool_id,
+          coin_type_a,
+          coin_type_b,
+          active_id,
+          liquidity_bin,
+          tx,
+          coin_a_obj_id,
+          coin_b_obj_id,
+          position_id: isOpenPosition ? undefined : option.position_id,
+          max_price_slippage,
+          bin_step,
+        })
+      } else {
+        this.addLiquidityStrategyInternal({
+          pool_id,
+          coin_type_a,
+          coin_type_b,
+          active_id,
+          liquidity_bin,
+          tx,
+          max_price_slippage,
+          bin_step,
+          coin_a_obj_id,
+          coin_b_obj_id,
+          strategy_type,
+          position_id: isOpenPosition ? undefined : option.position_id,
+        })
+      }
+    })
+
+    return tx
+  }
+
+  private addLiquidityStrategyInternal(option: {
+    pool_id: string | TransactionObjectArgument
+    coin_type_a: string
+    coin_type_b: string
+    active_id: number
+    liquidity_bin: BinLiquidityInfo
+    tx: Transaction
+    coin_a_obj_id: TransactionObjectArgument
+    coin_b_obj_id: TransactionObjectArgument
+    position_id?: string
+    strategy_type: StrategyType
+    max_price_slippage: number
+    bin_step: number
+  }): Transaction {
+    const {
+      max_price_slippage,
+      bin_step,
+      position_id,
+      pool_id,
+      coin_type_a,
+      coin_type_b,
+      active_id,
+      liquidity_bin,
+      tx,
+      coin_a_obj_id,
+      coin_b_obj_id,
+      strategy_type,
+    } = option
+
+    const { dlmm_pool, dlmm_router } = this.sdk.sdkOptions
+    const { versioned_id, global_config_id } = getPackagerConfigs(dlmm_pool)
+
+    const { bins, amount_a, amount_b } = liquidity_bin
+
+    let position: string | undefined | TransactionObjectArgument = position_id
+
+    const lower_bin_id = bins[0].bin_id
+    const upper_bin_id = bins[bins.length - 1].bin_id
+    const lower_bin_id_u32 = asUintN(BigInt(lower_bin_id))
+
+    const active_id_u32 = Number(asUintN(BigInt(active_id)))
+    const bin_shift = BinUtils.getBinShift(active_id, bin_step, max_price_slippage)
+    const routerModule = getRouterModule(strategy_type)
+
+    if (position_id === undefined) {
+      const width = upper_bin_id - lower_bin_id + 1
+      if (width > MAX_BIN_PER_POSITION) {
+        handleError(DlmmErrorCode.InvalidBinWidth, new Error('Width is too large'), {
+          [DETAILS_KEYS.METHOD_NAME]: 'openPosition',
+        })
+      }
+
+      position = tx.moveCall({
+        target: `${dlmm_router.published_at}::${routerModule}::open_position`,
+        arguments: [
+          typeof pool_id === 'string' ? tx.object(pool_id) : pool_id,
+          coin_a_obj_id,
+          coin_b_obj_id,
+          tx.pure.u64(amount_a),
+          tx.pure.u64(amount_b),
+          tx.pure.u32(Number(lower_bin_id_u32)),
+          tx.pure.u16(Number(width)),
+          tx.pure.u32(Number(active_id_u32)),
+          tx.pure.u32(Number(bin_shift)),
+          tx.object(global_config_id),
+          tx.object(versioned_id),
+          tx.object(CLOCK_ADDRESS),
+        ],
+        typeArguments: [coin_type_a, coin_type_b],
+      })
+    } else {
+      const valid_bins = bins.filter((bin) => bin.amount_a !== '0' || bin.amount_b !== '0')
+      if (valid_bins.length === 0) {
+        return handleError(DlmmErrorCode.InvalidParams, new Error('No bins to add liquidity'), {
+          [DETAILS_KEYS.METHOD_NAME]: 'addLiquidityStrategyInternal',
+          [DETAILS_KEYS.REQUEST_PARAMS]: option,
+        })
+      }
+      const valid_lower_bin_id_u32 = asUintN(BigInt(valid_bins[0].bin_id))
+      const valid_upper_bin_id_u32 = asUintN(BigInt(valid_bins[valid_bins.length - 1].bin_id))
+
+      tx.moveCall({
+        target: `${dlmm_router.published_at}::${routerModule}::add_liquidity`,
+        arguments: [
+          typeof pool_id === 'string' ? tx.object(pool_id) : pool_id,
+          tx.object(position_id!),
+          coin_a_obj_id,
+          coin_b_obj_id,
+          tx.pure.u64(amount_a),
+          tx.pure.u64(amount_b),
+          tx.pure.u32(Number(valid_lower_bin_id_u32)),
+          tx.pure.u32(Number(valid_upper_bin_id_u32)),
+          tx.pure.u32(Number(active_id_u32)),
+          tx.pure.u32(Number(bin_shift)),
+          tx.object(global_config_id),
+          tx.object(versioned_id),
+          tx.object(CLOCK_ADDRESS),
+        ],
+        typeArguments: [coin_type_a, coin_type_b],
+      })
+    }
+
+    if (position) {
+      tx.transferObjects([position, coin_a_obj_id, coin_b_obj_id], this.sdk.getSenderAddress())
+    } else {
+      tx.transferObjects([coin_a_obj_id, coin_b_obj_id], this.sdk.getSenderAddress())
+    }
+
+    return tx
+  }
+
+  private addLiquidityInternal(option: {
+    pool_id: string | TransactionObjectArgument
+    coin_type_a: string
+    coin_type_b: string
+    active_id: number
+    liquidity_bin: BinLiquidityInfo
+    tx: Transaction
+    coin_a_obj_id: TransactionObjectArgument
+    coin_b_obj_id: TransactionObjectArgument
+    position_id?: string
+    max_price_slippage: number
+    bin_step: number
+  }): Transaction {
+    const {
+      position_id,
+      pool_id,
+      coin_type_a,
+      coin_type_b,
+      active_id,
+      liquidity_bin,
+      tx,
+      coin_a_obj_id,
+      coin_b_obj_id,
+      max_price_slippage,
+      bin_step,
+    } = option
+    const { bins } = liquidity_bin
+
+    const { dlmm_pool, dlmm_router } = this.sdk.sdkOptions
+    const { versioned_id, global_config_id } = getPackagerConfigs(dlmm_pool)
+    const amounts_a = tx.pure.vector(
+      'u64',
+      bins.map((bin) => bin.amount_a)
+    )
+    const amounts_b = tx.pure.vector(
+      'u64',
+      bins.map((bin) => bin.amount_b)
+    )
+
+    const bin_ids = tx.makeMoveVec({
+      elements: bins.map((bin) => tx.pure.u32(Number(asUintN(BigInt(bin.bin_id))))),
+      type: 'u32',
+    })
+    const lower_bin_id = liquidity_bin.bins[0].bin_id
+    const upper_bin_id = liquidity_bin.bins[liquidity_bin.bins.length - 1].bin_id
+    if (position_id === undefined) {
+      const width = upper_bin_id - lower_bin_id + 1
+      if (width > MAX_BIN_PER_POSITION) {
+        handleError(DlmmErrorCode.InvalidBinWidth, new Error('Width is too large'), {
+          [DETAILS_KEYS.METHOD_NAME]: 'openPosition',
+        })
+      }
+      const open_position_id = tx.moveCall({
+        target: `${dlmm_router.published_at}::add_liquidity::open_position`,
+        arguments: [
+          typeof pool_id === 'string' ? tx.object(pool_id) : pool_id,
+          coin_a_obj_id,
+          coin_b_obj_id,
+          bin_ids,
+          amounts_a,
+          amounts_b,
+          tx.object(global_config_id),
+          tx.object(versioned_id),
+          tx.object(CLOCK_ADDRESS),
+        ],
+        typeArguments: [coin_type_a, coin_type_b],
+      })
+      // validate the active id slippage
+      if (active_id >= lower_bin_id && active_id <= upper_bin_id) {
+        this.validateActiveIdSlippage({ pool_id, active_id, max_price_slippage, bin_step, coin_type_a, coin_type_b }, tx)
+      }
+      tx.transferObjects([coin_a_obj_id, coin_b_obj_id, open_position_id], this.sdk.getSenderAddress())
+    } else {
+      tx.moveCall({
+        target: `${dlmm_router.published_at}::add_liquidity::add_liquidity`,
+        arguments: [
+          typeof pool_id === 'string' ? tx.object(pool_id) : pool_id,
+          tx.object(position_id!),
+          coin_a_obj_id,
+          coin_b_obj_id,
+          bin_ids,
+          amounts_a,
+          amounts_b,
+          tx.object(global_config_id),
+          tx.object(versioned_id),
+          tx.object(CLOCK_ADDRESS),
+        ],
+        typeArguments: [coin_type_a, coin_type_b],
+      })
+      // validate the active id slippage
+      if (active_id >= lower_bin_id && active_id <= upper_bin_id) {
+        this.validateActiveIdSlippage({ pool_id, active_id, max_price_slippage, bin_step, coin_type_a, coin_type_b }, tx)
+      }
+      tx.transferObjects([coin_a_obj_id, coin_b_obj_id], this.sdk.getSenderAddress())
+    }
+
+    return tx
+  }
+
+  /**
+   * 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
+   */
+  async fetchPositionFeeAndReward(
+    options: CollectRewardAndFeeOption[]
+  ): Promise<{ feeData: Record<string, PositionFee>; rewardData: Record<string, PositionReward> }> {
+    const tx = new Transaction()
+    this.collectRewardAndFeePayload(options, tx)
+
+    const simulateRes = await this.sdk.FullClient.devInspectTransactionBlock({
+      transactionBlock: tx,
+      sender: normalizeSuiAddress('0x0'),
+    })
+
+    if (simulateRes.error != null) {
+      return handleError(DlmmErrorCode.FetchError, new Error(simulateRes.error), {
+        [DETAILS_KEYS.METHOD_NAME]: 'fetchPositionFeeAndReward',
+        [DETAILS_KEYS.REQUEST_PARAMS]: {
+          options,
+          totalOptions: options.length,
+        },
+      })
+    }
+
+    const feeData = parsedDlmmPosFeeData(simulateRes)
+    const rewardData = parsedDlmmPosRewardData(simulateRes)
+
+    return {
+      feeData,
+      rewardData,
+    }
+  }
+}