@cetusprotocol/dlmm-sdk 0.0.0-experimental-20250925173459

package/src/utils/ilmUtils.ts

@@ -0,0 +1,187 @@
+import { d } from '@cetusprotocol/common-sdk'
+import { Axis, IlmInputOptions, IlmInputResult, TokenTable } from '../types/ilm'
+import { BinUtils } from './binUtils'
+
+export class IlmUtils {
+  static calculateIlm(options: IlmInputOptions): IlmInputResult {
+    const { curvature, initial_price, max_price, bin_step, total_supply, pool_share_percentage, config } = options
+    const { price_curve_points_num, liquidity_distribution_num, tokens_table_num, price_table_num } = config
+    if (d(pool_share_percentage).lt(0) || d(pool_share_percentage).gt(100)) {
+      throw new Error('Pool Share Percentage must be greater than 0 and less than 100.')
+    }
+
+    let flat = false
+
+    if (d(max_price).lt(d(initial_price))) {
+      throw new Error('Maximum Price must be greater or equal to Initial Price.')
+    } else if (d(max_price).eq(initial_price) && !d(curvature).eq(0)) {
+      throw new Error('Curvature must be 0 when Maximum and Initial Price are equal.')
+    } else if (!d(max_price).eq(initial_price) && d(curvature).eq(0)) {
+      throw new Error('Maximum and Initial Price must be equal when Curvature is 0.')
+    } else if (d(max_price).eq(initial_price) && d(curvature).eq(0)) {
+      flat = true
+    }
+
+    const myFormula = (c: string) => {
+      // f * Math.pow((c / A), k) + i;
+      return d(price_diff).mul(d(c).div(pool_supply).pow(curvature)).add(d(initial_price)).toString()
+    }
+
+    const integrate = (upper: number, lower: number) => {
+      let u = d(price_diff)
+        .mul(d(pool_supply).pow(-curvature))
+        .mul(d(upper).pow(curvature + 1))
+        .div(curvature + 1)
+        .add(d(initial_price).mul(upper))
+      let l = d(price_diff)
+        .mul(d(pool_supply).pow(-curvature))
+        .mul(d(lower).pow(curvature + 1))
+        .div(curvature + 1)
+        .add(d(initial_price).mul(lower))
+      return u.sub(l)
+    }
+
+    const reverse_formula = (price: string) => {
+      //  A * Math.pow(((p- i) / f), 1 / k);
+      return d(pool_supply)
+        .mul(
+          d(price)
+            .sub(initial_price)
+            .div(price_diff)
+            .pow(1 / curvature)
+        )
+        .toString()
+    }
+
+    const liquidity = (price: string) => {
+      //  A * Math.pow((p - i), (1 / k) - 1) / (k * Math.pow(f, 1 / k));
+      return d(pool_supply)
+        .mul(
+          d(price)
+            .sub(initial_price)
+            .pow(1 / curvature - 1)
+        )
+        .div(d(curvature).mul(d(price_diff).pow(1 / curvature)))
+        .toString()
+    }
+
+    const binTokens = (price: string) => {
+      return d(price)
+        .sub(initial_price)
+        .div(price_diff)
+        .pow(1 / curvature)
+        .mul(pool_supply)
+    }
+
+    const pool_supply = d(total_supply).mul(pool_share_percentage).div(100) // A
+    const price_diff = d(max_price).sub(d(initial_price)).toFixed(8) // f
+
+    const prices: string[] = []
+    const heights: string[] = []
+
+    let minBinId = BinUtils.getBinIdFromLamportPrice(initial_price, bin_step, false)
+    let maxBinId = BinUtils.getBinIdFromLamportPrice(max_price, bin_step, false)
+    let total = d(0)
+
+    let binFlag = minBinId
+    if (flat) {
+      prices.push(initial_price)
+      heights.push(d(initial_price).mul(pool_supply).toString())
+    } else {
+      while (binFlag <= maxBinId) {
+        const price = BinUtils.getPricePerLamportFromBinId(binFlag, bin_step)
+        const nextPrice = BinUtils.getPricePerLamportFromBinId(binFlag + 1, bin_step)
+        const tokenDiff = binTokens(nextPrice).sub(binTokens(price))
+        total = total.add(tokenDiff)
+        heights.push(d(tokenDiff).mul(price).toString())
+        prices.push(price)
+        binFlag++
+      }
+    }
+    const result: IlmInputResult = {
+      price_curve: [],
+      liquidity_curve: [],
+      dlmm_bins: [],
+      tokens_table: [],
+      price_table: [],
+    }
+    var LDstep = d(price_diff).div(100)
+
+    // price curve
+    const pricePoints: Axis[] = []
+    for (let index = 0; index < price_curve_points_num; index++) {
+      const x = d(index)
+        .mul(pool_supply)
+        .div(price_curve_points_num - 1)
+        .toString()
+      const y = flat ? max_price : myFormula(x)
+      pricePoints.push({ x, y })
+    }
+    result.price_curve = pricePoints
+
+    // liquidity curve
+    let liquidityPoints: Axis[] = []
+    if (flat) {
+      liquidityPoints = [
+        { x: initial_price, y: '0' },
+        { x: initial_price, y: d(pool_supply).div(2).toString() },
+        { x: initial_price, y: pool_supply.toString() },
+      ]
+    } else {
+      for (let index = 0; index < liquidity_distribution_num; index++) {
+        const x = d(initial_price)
+          .add(d(index).mul(d(LDstep)))
+          .toFixed(9)
+        const y = liquidity(x)
+        liquidityPoints.push({ x, y })
+      }
+    }
+    result.liquidity_curve = liquidityPoints
+
+    // dlmm bins
+    const dlmmBins: Axis[] = []
+    prices.forEach((price, index) => {
+      const x = price
+      const y = heights[index]
+      dlmmBins.push({ x, y })
+    })
+    result.dlmm_bins = dlmmBins
+
+    // Tokens Table
+    const tokensTable: TokenTable[] = []
+    let tokensWithdrawn = d(0)
+    let step = d(pool_supply).div(tokens_table_num).toFixed(5)
+    while (tokensWithdrawn.lte(pool_supply)) {
+      const price = d(myFormula(tokensWithdrawn.toString())).toFixed(8)
+      const n = tokensWithdrawn.toFixed(8)
+      const amountUsd = integrate(Number(n), 0)
+      tokensTable.push({ withdrawn: n, price, usdc_in_pool: amountUsd.toString() })
+      tokensWithdrawn = tokensWithdrawn.add(step)
+    }
+    result.tokens_table = tokensTable
+
+    // Price Table
+    const step2 = d(price_diff).mul(10000000000).floor().div(100000000000)
+    const priceTable: TokenTable[] = []
+    if (flat) {
+      priceTable.push({
+        withdrawn: pool_supply.toString(),
+        price: initial_price,
+        usdc_in_pool: d(pool_supply).mul(initial_price).toString(),
+      })
+    } else {
+      let r = d(0)
+      let price = d(initial_price)
+      while (r.lte(price_table_num)) {
+        const tokensWithdrawn = d(reverse_formula(price.toFixed(8))).toFixed(8)
+        const amountUsd = integrate(Number(tokensWithdrawn), 0).toFixed(8)
+        priceTable.push({ withdrawn: tokensWithdrawn, price: price.toFixed(8), usdc_in_pool: amountUsd })
+        price = d(price).add(step2)
+        r = r.add(d(1))
+      }
+    }
+    result.price_table = priceTable
+
+    return result
+  }
+}

package/src/utils/index.ts

@@ -0,0 +1,6 @@
+export * from './parseData'
+export * from './binUtils'
+export * from './weightUtils'
+export * from './strategyUtils'
+export * from './feeUtils'
+export * from './ilmUtils'

package/src/utils/parseData.ts

@@ -0,0 +1,519 @@
+import {
+  asIntN,
+  d,
+  DETAILS_KEYS,
+  extractStructTagFromType,
+  fixCoinType,
+  getObjectFields,
+  getObjectType,
+  MathUtil,
+} from '@cetusprotocol/common-sdk'
+import { DevInspectResults, SuiEvent, SuiObjectResponse, SuiTransactionBlockResponse } from '@mysten/sui/client'
+import BN from 'bn.js'
+import Decimal from 'decimal.js'
+import { DlmmErrorCode, handleError, DlmmError } from '../errors/errors'
+import {
+  BinAmount,
+  BinLiquidityInfo,
+  BinManager,
+  BinSwap,
+  DlmmBasePool,
+  DlmmPool,
+  DlmmPosition,
+  Partner,
+  PoolTransactionInfo,
+  PositionFee,
+  PositionManager,
+  PositionReward,
+  PreSwapQuote,
+  Reward,
+  RewardInfo,
+  RewardManager,
+  RewardPeriodEmission,
+  RewardPeriodEmissionFormat,
+  StrategyType,
+  VariableParameters,
+} from '../types/dlmm'
+import { BinUtils } from './binUtils'
+import { BASIS_POINT } from '../types/constants'
+import { bcs } from '@mysten/sui/bcs'
+
+/**
+ * Parse the DLMM base pool data
+ * @param data - The DLMM base pool data
+ * @returns The DLMM base pool
+ */
+export function parseDlmmBasePool(data: SuiEvent): DlmmBasePool {
+  try {
+    const fields = data.parsedJson as any
+    const pool: DlmmBasePool = {
+      id: fields.pool_id,
+      bin_step: Number(fields.bin_step),
+      coin_type_a: fixCoinType(fields.coin_type_a, false),
+      coin_type_b: fixCoinType(fields.coin_type_b, false),
+    }
+
+    return pool
+  } catch (error) {
+    return handleError(DlmmErrorCode.ParseError, error as Error, {
+      [DETAILS_KEYS.METHOD_NAME]: 'parseDlmmBasePool',
+      [DETAILS_KEYS.REQUEST_PARAMS]: data,
+    })
+  }
+}
+
+/**
+ * Parse the DLMM pool data
+ * @param data - The DLMM pool data
+ * @returns The DLMM pool
+ */
+export function parseDlmmPool(data: SuiObjectResponse): DlmmPool {
+  try {
+    const fields = getObjectFields(data)
+    const type = getObjectType(data) as string
+    const formatType = extractStructTagFromType(type)
+
+    const bin_manager: BinManager = {
+      bin_step: fields.bin_manager.fields.bin_step,
+      bin_manager_handle: fields.bin_manager.fields.bins.fields.id.id,
+      size: fields.bin_manager.fields.bins.fields.size,
+    }
+
+    const position_manager: PositionManager = {
+      bin_step: fields.position_manager.fields.bin_step,
+      position_index: fields.position_manager.fields.position_index,
+      position_handle: fields.position_manager.fields.positions.fields.id.id,
+      size: fields.position_manager.fields.positions.fields.size,
+    }
+
+    const reward_manager_fields = fields.reward_manager.fields
+
+    const rewards = reward_manager_fields.rewards.map((reward: any) => {
+      const current_reward_rate = reward.fields.current_emission_rate
+      const emissions_per_second = MathUtil.fromX64(new BN(current_reward_rate))
+      const emissions_per_day = Math.floor(emissions_per_second.toNumber() * 60 * 60 * 24).toString()
+
+      const info: Reward = {
+        reward_coin: fixCoinType(reward.fields.reward_coin.fields.name, false),
+        emissions_per_second: emissions_per_second.toString(),
+        emissions_per_day,
+        period_emission_rates: {
+          id: reward.fields.period_emission_rates.fields.id.id,
+          size: reward.fields.period_emission_rates.fields.size,
+        },
+      }
+      return info
+    })
+    const reward_manager: RewardManager = {
+      is_public: reward_manager_fields.is_public,
+      emergency_reward_pause: reward_manager_fields.emergency_reward_pause,
+      vault: {
+        id: reward_manager_fields.vault.fields.id.id,
+        size: reward_manager_fields.vault.fields.size,
+      },
+      rewards,
+      last_updated_time: reward_manager_fields.last_updated_time,
+    }
+
+    const variable_parameters: VariableParameters = {
+      volatility_accumulator: fields.v_parameters.fields.volatility_accumulator,
+      volatility_reference: fields.v_parameters.fields.volatility_reference,
+      index_reference: asIntN(BigInt(fields.v_parameters.fields.index_reference.fields.bits)),
+      last_update_timestamp: fields.v_parameters.fields.last_update_timestamp,
+      bin_step_config: fields.v_parameters.fields.bin_step_config.fields,
+    }
+
+    const pool: DlmmPool = {
+      id: fields.id.id,
+      bin_step: Number(fields.bin_step),
+      coin_type_a: fixCoinType(formatType.type_arguments[0], false),
+      coin_type_b: fixCoinType(formatType.type_arguments[1], false),
+      pool_type: type,
+      index: Number(fields.index),
+      bin_manager,
+      variable_parameters,
+      active_id: asIntN(BigInt(fields.active_id.fields.bits)),
+      permissions: fields.permissions.fields,
+      balance_a: fields.balance_a,
+      balance_b: fields.balance_b,
+      base_fee_rate: fields.base_fee_rate,
+      protocol_fee_a: fields.protocol_fee_a,
+      protocol_fee_b: fields.protocol_fee_b,
+      url: fields.url,
+      reward_manager,
+      position_manager,
+    }
+    pool.bin_step = pool.bin_manager.bin_step
+    return pool
+  } catch (error) {
+    console.log('🚀 ~ parseDlmmPool ~ error:', error)
+    return handleError(DlmmErrorCode.ParseError, error as Error, {
+      [DETAILS_KEYS.METHOD_NAME]: 'parseDlmmPool',
+      [DETAILS_KEYS.REQUEST_PARAMS]: data,
+    })
+  }
+}
+
+export function parsePartner(data: SuiObjectResponse): Partner {
+  const fields = getObjectFields(data)
+  const type = getObjectType(data) as string
+  const formatType = extractStructTagFromType(type)
+
+  const partner: Partner = {
+    id: fields.id.id,
+    name: fields.name,
+    ref_fee_rate: d(fields.ref_fee_rate).div(BASIS_POINT).toNumber(),
+    start_time: Number(fields.start_time),
+    end_time: Number(fields.end_time),
+    balances: {
+      id: fields.balances.fields.id.id,
+      size: fields.balances.fields.size,
+    },
+    type: formatType.full_address,
+  }
+
+  return partner
+}
+
+export function parseDlmmPosition(data: SuiObjectResponse): DlmmPosition {
+  try {
+    const fields = getObjectFields(data)
+    const position: DlmmPosition = {
+      uri: fields.uri,
+      index: fields.index,
+      id: fields.id.id,
+      name: fields.name,
+      pool_id: fields.pool_id,
+      lower_bin_id: asIntN(BigInt(fields.lower_bin_id.fields.bits)),
+      upper_bin_id: asIntN(BigInt(fields.upper_bin_id.fields.bits)),
+      liquidity_shares: fields.liquidity_shares,
+      description: fields.description,
+      coin_type_a: fixCoinType(fields.coin_type_a, false),
+      coin_type_b: fixCoinType(fields.coin_type_b, false),
+    }
+
+    return position
+  } catch (error) {
+    console.log('🚀 ~ parseDlmmPosition ~ error:', error)
+    return handleError(DlmmErrorCode.ParseError, error as Error, {
+      [DETAILS_KEYS.METHOD_NAME]: 'parseDlmmPosition',
+      [DETAILS_KEYS.REQUEST_PARAMS]: data,
+    })
+  }
+}
+
+export function parseLiquidityShares(
+  liquidity_shares: string[],
+  bin_step: number,
+  lower_bin_id: number,
+  active_bin: BinAmount
+): BinLiquidityInfo {
+  const bins = liquidity_shares.map((liquidity, index) => {
+    const bin_id = lower_bin_id + index
+    const price_per_lamport = BinUtils.getPricePerLamportFromBinId(bin_id, bin_step)
+    if (bin_id === active_bin.bin_id) {
+      const { amount_a, amount_b } = BinUtils.calculateOutByShare(active_bin, liquidity)
+      return {
+        bin_id,
+        amount_a,
+        amount_b,
+        liquidity,
+        price_per_lamport,
+      }
+    }
+
+    if (bin_id < active_bin.bin_id) {
+      const amount_b = BinUtils.getAmountBFromLiquidity(liquidity)
+      return {
+        bin_id,
+        amount_a: '0',
+        amount_b,
+        liquidity,
+        price_per_lamport,
+      }
+    }
+
+    const q_price = BinUtils.getQPriceFromId(bin_id, bin_step)
+    const amount_a = BinUtils.getAmountAFromLiquidity(liquidity, q_price)
+    return {
+      bin_id,
+      amount_a,
+      amount_b: '0',
+      liquidity,
+      price_per_lamport,
+    }
+  })
+
+  const amount_a = bins
+    .reduce((acc, bin) => {
+      return acc.add(new Decimal(bin.amount_a))
+    }, new Decimal(0))
+    .toFixed(0)
+
+  const amount_b = bins
+    .reduce((acc, bin) => {
+      return acc.add(new Decimal(bin.amount_b))
+    }, new Decimal(0))
+    .toFixed(0)
+
+  return {
+    bins,
+    amount_a,
+    amount_b,
+  }
+}
+
+export function parseBinInfoList(res: DevInspectResults): BinAmount[] {
+  try {
+    const bcsCoinAmount = bcs.struct('BinAmount', {
+      id: bcs.struct('I32', {
+        bits: bcs.u32(),
+      }),
+      amount_a: bcs.u64(),
+      amount_b: bcs.u64(),
+      price: bcs.u128(),
+      liquidity_supply: bcs.u128(),
+      rewards_growth_global: bcs.vector(bcs.u128()),
+      fee_a_growth_global: bcs.u128(),
+      fee_b_growth_global: bcs.u128(),
+    })
+
+    const bin_amounts = bcs.vector(bcsCoinAmount).parse(Uint8Array.from(res.results![0].returnValues![0][0]))
+
+    return bin_amounts.map((bin_amount) => {
+      const bin_id = asIntN(BigInt(bin_amount.id.bits))
+      return {
+        bin_id,
+        amount_a: bin_amount.amount_a,
+        amount_b: bin_amount.amount_b,
+        liquidity: bin_amount.liquidity_supply,
+        price_per_lamport: BinUtils.getPricePerLamportFromQPrice(bin_amount.price),
+      }
+    })
+  } catch (error) {
+    console.log('🚀 ~ parseBinInfo ~ error:', error)
+    return []
+  }
+}
+
+export function parseBinInfo(fields: any): BinAmount {
+  try {
+    const bin_id = asIntN(BigInt(fields.id.fields.bits))
+    const bin_amount: BinAmount = {
+      bin_id,
+      amount_a: fields.amount_a,
+      amount_b: fields.amount_b,
+      liquidity: fields.liquidity_supply,
+      price_per_lamport: BinUtils.getPricePerLamportFromQPrice(fields.price),
+    }
+
+    return bin_amount
+  } catch (error) {
+    console.log('🚀 ~ parseBinInfo ~ error:', error)
+    return handleError(DlmmErrorCode.ParseError, error as Error, {
+      [DETAILS_KEYS.METHOD_NAME]: 'parseBinInfo',
+      [DETAILS_KEYS.REQUEST_PARAMS]: {
+        fields,
+      },
+    })
+  }
+}
+
+export function parsedDlmmPosFeeData(simulate_res: DevInspectResults) {
+  const feeData: Record<string, PositionFee> = {}
+  const feeValueData: any[] = simulate_res.events?.filter((item: any) => {
+    return item.type.includes('pool::CollectFeeEvent')
+  })
+
+  for (let i = 0; i < feeValueData.length; i += 1) {
+    const { parsedJson } = feeValueData[i]
+    const posObj = {
+      position_id: parsedJson.position,
+      fee_owned_a: parsedJson.fee_a,
+      fee_owned_b: parsedJson.fee_b,
+    }
+    feeData[parsedJson.position] = posObj
+  }
+
+  return feeData
+}
+
+export function parsedDlmmPosRewardData(simulate_res: DevInspectResults) {
+  const rewarderData: Record<string, PositionReward> = {}
+  const rewarderValueData: any[] = simulate_res.events?.filter((item: any) => {
+    return item.type.includes('pool::CollectRewardEvent')
+  })
+
+  for (let i = 0; i < rewarderValueData.length; i += 1) {
+    const { parsedJson } = rewarderValueData[i]
+    const position_id = parsedJson.position
+    const reward_coin = parsedJson.reward
+    const reward_amount = parsedJson.amount
+    const rewardInfo: RewardInfo = {
+      coin_type: fixCoinType(reward_coin.name, false),
+      reward_owned: reward_amount,
+    }
+    let rewarder = rewarderData[position_id]
+    if (rewarder) {
+      rewarder.rewards.push(rewardInfo)
+    } else {
+      rewarder = {
+        position_id,
+        rewards: [rewardInfo],
+      }
+    }
+    rewarderData[position_id] = rewarder
+  }
+
+  return rewarderData
+}
+
+export function parsedSwapQuoteData(simulate_res: DevInspectResults, a2b: boolean): PreSwapQuote | undefined {
+  const rewarderValueData: any[] = simulate_res.events?.filter((item: any) => {
+    return item.type.includes('pool::SwapEvent')
+  })
+
+  for (let i = 0; i < rewarderValueData.length; i += 1) {
+    const { parsedJson } = rewarderValueData[i]
+    const { partner, pool, amount_in, amount_out, fee, ref_fee, bin_swaps, from, target } = parsedJson
+    const bin_swaps_info: BinSwap[] = bin_swaps.map((bin_swap: any) => {
+      return {
+        bin_id: bin_swap.bin_id.bits,
+        in_amount: bin_swap.amount_in,
+        out_amount: bin_swap.amount_out,
+        fee: bin_swap.fee,
+        var_fee_rate: bin_swap.var_fee_rate,
+      }
+    })
+    const info: PreSwapQuote = {
+      pool_id: pool,
+      a2b,
+      in_amount: amount_in,
+      out_amount: amount_out,
+      ref_fee_amount: ref_fee,
+      fee_amount: fee,
+      bin_swaps: bin_swaps_info,
+      partner,
+      from_coin_type: fixCoinType(from.name, false),
+      to_coin_type: fixCoinType(target.name, false),
+    }
+
+    return info
+  }
+  return undefined
+}
+
+export function parseStrategyType(strategy_type: StrategyType): number {
+  switch (strategy_type) {
+    case StrategyType.Spot:
+      return 0
+    case StrategyType.Curve:
+      return 1
+    case StrategyType.BidAsk:
+      return 2
+  }
+}
+export const poolFilterEvenTypes = ['RemoveLiquidityEvent', 'SwapEvent', 'AddLiquidityEvent', 'ClosePositionEvent']
+export function parsePoolTransactionInfo(data: SuiTransactionBlockResponse, txIndex: number, package_id: string, pool_id: string) {
+  const list: PoolTransactionInfo[] = []
+  const { timestampMs, events } = data
+
+  events?.forEach((event: any, index) => {
+    const { name: type, address: package_address } = extractStructTagFromType(event.type)
+    if (poolFilterEvenTypes.includes(type) && package_address === package_id && pool_id === event.parsedJson.pool) {
+      const info: PoolTransactionInfo = {
+        tx: event.id.txDigest,
+        sender: event.sender,
+        type: event.type,
+        block_time: timestampMs || '0',
+        index: `${txIndex}_${index}`,
+        parsed_json: event.parsedJson,
+      }
+      list.push(info)
+    }
+  })
+
+  return list
+}
+
+export function generateRewardSchedule(baseTime: number, maxIntervals: number, timeInterval: number): number[] {
+  const result: number[] = []
+
+  let intervals = 0 // Start from 0 to include base time if needed
+  const baseDateTime = new Date(baseTime * 1000).getTime() // Convert seconds to milliseconds
+  const nowTime = new Date().getTime()
+  while (true) {
+    const rewardTime = baseDateTime + intervals * timeInterval
+
+    if (rewardTime >= nowTime) {
+      result.push(rewardTime)
+    }
+
+    if (intervals >= maxIntervals) {
+      break
+    }
+
+    intervals += 1
+  }
+
+  return result
+}
+
+export function parseRewardPeriodEmission(
+  periodEmissionList: RewardPeriodEmission[],
+  startTimeInSeconds: number,
+  endTimeInSeconds: number,
+  durationSeconds: number
+) {
+  const result: RewardPeriodEmissionFormat[] = []
+  for (let time = startTimeInSeconds; time <= endTimeInSeconds; time += durationSeconds) {
+    const findRewardPeriodEmission = periodEmissionList.findLast((period) => d(time).gte(period.time))
+    if (findRewardPeriodEmission) {
+      result.push({
+        time: time.toString(),
+        emissions_per_second: findRewardPeriodEmission.emissions_per_second,
+        emissions_per_day: findRewardPeriodEmission.emissions_per_day,
+        visualized_time: new Date(time * 1000).toLocaleString(),
+      })
+    } else {
+      result.push({
+        emissions_per_day: '0',
+        time: time.toString(),
+        emissions_per_second: '0',
+        visualized_time: new Date(time * 1000).toLocaleString(),
+      })
+    }
+  }
+  return result
+}
+
+export function parseCurrentRewardPeriodEmission(periodEmissionList: RewardPeriodEmission[]): RewardPeriodEmission | undefined {
+  if (periodEmissionList.length === 0) {
+    return undefined
+  }
+  const currentTime = new Date().getTime() / 1000
+  const findRewardPeriodEmission = periodEmissionList.findLast((period) => d(currentTime).gte(period.time))
+  if (findRewardPeriodEmission) {
+    return findRewardPeriodEmission
+  }
+  return periodEmissionList[periodEmissionList.length - 1]
+}
+
+export function safeMulAmount(amount: Decimal, rate: Decimal): Decimal {
+  const result = amount.mul(rate)
+  if (result.gt(0) && result.lt(1)) {
+    throw new DlmmError(`Multiplication ${result} is less than 1`, DlmmErrorCode.AmountTooSmall)
+  }
+  return result.floor()
+}
+
+export function getRouterModule(strategy_type: StrategyType) {
+  switch (strategy_type) {
+    case StrategyType.Spot:
+      return 'spot'
+    case StrategyType.Curve:
+      return 'curve'
+    case StrategyType.BidAsk:
+      return 'bid_ask'
+  }
+}