@cetusprotocol/dlmm-sdk 0.0.2 → 0.0.3

package/src/utils/strategyUtils.ts

@@ -1,8 +1,83 @@
 import { d } from '@cetusprotocol/common-sdk'
-import { BinAmount, BinLiquidityInfo, StrategyType } from '../types/dlmm'
+import { BinAmount, BinLiquidityInfo, StrategyType, WeightsInfo } from '../types/dlmm'
 import { WeightUtils } from './weightUtils'
+import { BinUtils, SCALE_OFFSET } from './binUtils'
+import { safeAmount, safeMulAmount } from './parseData'
+import Decimal from 'decimal.js'
 
 export class StrategyUtils {
+  static toAmountsByWeights(weights_info: WeightsInfo): BinLiquidityInfo {
+    const {
+      total_weight_a,
+      total_weight_b,
+      weights,
+      weight_per_prices,
+      total_amount_a,
+      total_amount_b,
+      active_weight_a,
+      active_weight_b,
+      lower_bin_id,
+      upper_bin_id,
+      active_id,
+      bin_step,
+    } = weights_info
+
+    const ky = total_weight_b.isZero()
+      ? d(0)
+      : d(total_amount_b)
+          .mul(d(2).pow(SCALE_OFFSET * 2))
+          .div(total_weight_b)
+          .floor()
+
+    const kx = total_weight_a.isZero()
+      ? d(0)
+      : d(total_amount_a)
+          .mul(d(2).pow(SCALE_OFFSET * 2))
+          .div(total_weight_a)
+          .floor()
+
+    const amount_a_in_active_id = safeAmount(kx.mul(active_weight_a).div(d(2).pow(SCALE_OFFSET * 2)))
+    const amount_b_in_active_id = safeAmount(ky.mul(active_weight_b).div(d(2).pow(SCALE_OFFSET * 2)))
+
+    const bin_count = upper_bin_id - lower_bin_id + 1
+    let bin_id = lower_bin_id
+    let idx = 0
+    const bin_amounts: BinAmount[] = []
+    while (idx < bin_count) {
+      let amount_a_in_bin = d(0)
+      let amount_b_in_bin = d(0)
+
+      const qPrice = BinUtils.getQPriceFromId(bin_id, bin_step)
+
+      if (bin_id < active_id) {
+        amount_b_in_bin = safeAmount(ky.mul(weights[idx]).div(d(2).pow(SCALE_OFFSET)))
+      } else if (bin_id > active_id) {
+        amount_a_in_bin = safeAmount(kx.mul(weight_per_prices[idx]).div(d(2).pow(SCALE_OFFSET * 2)))
+      } else {
+        amount_a_in_bin = amount_a_in_active_id
+        amount_b_in_bin = amount_b_in_active_id
+      }
+      const liquidity = BinUtils.getLiquidity(amount_a_in_bin.toString(), amount_b_in_bin.toString(), qPrice)
+
+      bin_amounts.push({
+        bin_id,
+        amount_a: amount_a_in_bin.toString(),
+        amount_b: amount_b_in_bin.toString(),
+        price_per_lamport: BinUtils.getPricePerLamportFromBinId(bin_id, bin_step),
+        liquidity,
+      })
+      bin_id += 1
+      idx += 1
+    }
+
+    const info: BinLiquidityInfo = {
+      bins: bin_amounts,
+      amount_a: total_amount_a.toString(),
+      amount_b: total_amount_b.toString(),
+    }
+    return info
+  }
+
   /**
    * 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.
@@ -23,61 +98,32 @@ export class StrategyUtils {
     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
+    strategy_type: StrategyType,
+    active_bin_of_pool?: BinAmount
   ): BinLiquidityInfo {
-    switch (strategy_type) {
-      case StrategyType.Spot: {
-        let weights = WeightUtils.toWeightSpotBalanced(min_bin_id, max_bin_id)
-        return WeightUtils.toAmountBothSide(
-          active_id,
-          bin_step,
-          amount_a,
-          amount_b,
-          amount_a_in_active_bin,
-          amount_b_in_active_bin,
-          weights
-        )
-      }
-      case StrategyType.Curve: {
-        let weights = WeightUtils.toWeightCurve(min_bin_id, max_bin_id, active_id)
-        return WeightUtils.toAmountBothSide(
-          active_id,
-          bin_step,
-          amount_a,
-          amount_b,
-          amount_a_in_active_bin,
-          amount_b_in_active_bin,
-          weights
-        )
-      }
-      case StrategyType.BidAsk: {
-        let weights = WeightUtils.toWeightBidAsk(min_bin_id, max_bin_id, active_id)
-        return WeightUtils.toAmountBothSide(
-          active_id,
-          bin_step,
-          amount_a,
-          amount_b,
-          amount_a_in_active_bin,
-          amount_b_in_active_bin,
-          weights
-        )
-      }
-    }
+    const weights = WeightUtils.toWeight({
+      strategy_type,
+      active_id,
+      bin_step,
+      lower_bin_id: min_bin_id,
+      upper_bin_id: max_bin_id,
+      total_amount_a: amount_a,
+      total_amount_b: amount_b,
+      active_bin_of_pool,
+    })
+
+    return this.toAmountsByWeights(weights)
   }
 
-  // only apply for
   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
+    strategy_type: StrategyType,
+    active_bin_of_pool?: BinAmount
   ): BinLiquidityInfo {
     switch (strategy_type) {
       case StrategyType.Spot: {
@@ -87,8 +133,8 @@ export class StrategyUtils {
           bin_step,
           amount,
           fix_amount_a,
-          amount_a_in_active_bin,
-          amount_b_in_active_bin,
+          active_bin_of_pool?.amount_a || '0',
+          active_bin_of_pool?.amount_b || '0',
           weights
         )
       }
@@ -99,8 +145,8 @@ export class StrategyUtils {
           bin_step,
           amount,
           fix_amount_a,
-          amount_a_in_active_bin,
-          amount_b_in_active_bin,
+          active_bin_of_pool?.amount_a || '0',
+          active_bin_of_pool?.amount_b || '0',
           weights
         )
       }
@@ -111,11 +157,46 @@ export class StrategyUtils {
           bin_step,
           amount,
           fix_amount_a,
-          amount_a_in_active_bin,
-          amount_b_in_active_bin,
+          active_bin_of_pool?.amount_a || '0',
+          active_bin_of_pool?.amount_b || '0',
           weights
         )
       }
     }
   }
+
+  // only apply for
+  static autoFillCoinByStrategyV2(
+    active_id: number,
+    bin_step: number,
+    amount: string,
+    fix_amount_a: boolean,
+    min_bin_id: number,
+    max_bin_id: number,
+    strategy_type: StrategyType,
+    active_bin_of_pool?: BinAmount
+  ): BinLiquidityInfo {
+    const info = this.autoFillCoinByStrategy(
+      active_id,
+      bin_step,
+      amount,
+      fix_amount_a,
+      min_bin_id,
+      max_bin_id,
+      strategy_type,
+      active_bin_of_pool
+    )
+    const weights = WeightUtils.toWeight({
+      strategy_type,
+      active_id,
+      bin_step,
+      lower_bin_id: min_bin_id,
+      upper_bin_id: max_bin_id,
+      total_amount_a: fix_amount_a ? amount : info.amount_a,
+      total_amount_b: fix_amount_a ? info.amount_b : amount,
+      active_bin_of_pool,
+    })
+
+    return this.toAmountsByWeights(weights)
+  }
 }

package/src/utils/weightUtils.ts

@@ -1,12 +1,127 @@
-import { d, DETAILS_KEYS } from '@cetusprotocol/common-sdk'
-import { BinAmount, BinLiquidityInfo, BinWeight, StrategyType } from '../types/dlmm'
+import { d } from '@cetusprotocol/common-sdk'
+import { BinLiquidityInfo, BinWeight, StrategyType, WeightsInfo, WeightsOptions } from '../types/dlmm'
 import Decimal from 'decimal.js'
-import { DlmmErrorCode, handleError } from '../errors/errors'
 import { DEFAULT_MAX_WEIGHT, DEFAULT_MIN_WEIGHT } from '../types/constants'
-import { BinUtils } from './binUtils'
+import { BinUtils, SCALE_OFFSET } from './binUtils'
 import { safeMulAmount } from './parseData'
 
 export class WeightUtils {
+  static toWeight(options: WeightsOptions): WeightsInfo {
+    console.log('🚀 ~ WeightUtils ~ toWeight ~ options:', options)
+
+    const { strategy_type, active_id, bin_step, lower_bin_id, upper_bin_id, total_amount_a, total_amount_b, active_bin_of_pool } = options
+    const single_side = active_id < lower_bin_id || active_id > upper_bin_id
+    const active_bin_price = BinUtils.getQPriceFromId(active_id, bin_step)
+
+    let active_weight_a = d(0)
+    let active_weight_b = d(0)
+
+    let base_weight = d(DEFAULT_MIN_WEIGHT)
+    if (strategy_type === StrategyType.BidAsk) {
+      base_weight = d(DEFAULT_MIN_WEIGHT)
+    } else if (strategy_type === StrategyType.Curve) {
+      base_weight = d(DEFAULT_MAX_WEIGHT)
+    } else if (strategy_type === StrategyType.Spot) {
+      base_weight = d(1)
+    }
+
+    if (!single_side && active_bin_of_pool) {
+      const weights = this.calculateActiveWeights(active_bin_of_pool.amount_a, active_bin_of_pool.amount_b, active_bin_price, base_weight)
+      active_weight_a = weights.active_weight_a
+      active_weight_b = weights.active_weight_b
+    }
+
+    if (active_id === lower_bin_id && d(total_amount_b).isZero()) {
+      active_weight_a = d(base_weight)
+        .mul(d(2).pow(SCALE_OFFSET * 2))
+        .div(d(active_bin_price))
+        .floor()
+      active_weight_b = d(0)
+    }
+    if (active_id === upper_bin_id && d(total_amount_a).isZero()) {
+      active_weight_b = d(base_weight).mul(d(2).pow(SCALE_OFFSET)).floor()
+      active_weight_a = d(0)
+    }
+
+    if (active_id > lower_bin_id && active_id < upper_bin_id) {
+      if (d(total_amount_a).isZero()) {
+        active_weight_b = d(base_weight).mul(d(2).pow(SCALE_OFFSET)).floor()
+        active_weight_a = d(0)
+      }
+      if (d(total_amount_b).isZero()) {
+        active_weight_a = d(base_weight)
+          .mul(d(2).pow(SCALE_OFFSET * 2))
+          .div(d(active_bin_price))
+          .floor()
+        active_weight_b = d(0)
+      }
+    }
+    let total_weight_a = single_side ? d(0) : active_weight_a
+    let total_weight_b = single_side ? d(0) : active_weight_b
+
+    const diff_weight = d(DEFAULT_MAX_WEIGHT).sub(d(DEFAULT_MIN_WEIGHT)).floor()
+
+    const diff_min_weight = active_id > lower_bin_id ? diff_weight.div(d(active_id - lower_bin_id)).floor() : d(0)
+
+    const diff_max_weight = upper_bin_id > active_id ? diff_weight.div(d(upper_bin_id - active_id)).floor() : d(0)
+
+    let bin_id = lower_bin_id
+    let weights: Decimal[] = []
+    let weight_per_prices: Decimal[] = []
+
+    while (bin_id <= upper_bin_id) {
+      let weight: Decimal = d(0)
+      if (bin_id < active_id) {
+        const delta_bin = active_id - bin_id
+        if (strategy_type === StrategyType.Spot) {
+          weight = d(1)
+        } else if (strategy_type === StrategyType.BidAsk) {
+          weight = d(base_weight).add(diff_min_weight.mul(delta_bin)).floor()
+        } else if (strategy_type === StrategyType.Curve) {
+          weight = d(base_weight).sub(diff_min_weight.mul(delta_bin)).floor()
+        }
+      } else if (bin_id > active_id) {
+        const delta_bin = bin_id - active_id
+        if (strategy_type === StrategyType.Spot) {
+          weight = d(1)
+        } else if (strategy_type === StrategyType.BidAsk) {
+          weight = d(base_weight).add(diff_max_weight.mul(delta_bin)).floor()
+        } else if (strategy_type === StrategyType.Curve) {
+          weight = d(base_weight).sub(diff_max_weight.mul(delta_bin)).floor()
+        }
+      } else {
+        weight = base_weight
+      }
+      weights.push(weight)
+
+      if (bin_id < active_id) {
+        total_weight_b = total_weight_b.add(weight.mul(d(2).pow(SCALE_OFFSET))).floor()
+        weight_per_prices.push(d(0))
+      } else if (bin_id > active_id) {
+        const weight_per_price = weight
+          .mul(d(2).pow(SCALE_OFFSET * 2))
+          .div(BinUtils.getQPriceFromId(bin_id, bin_step))
+          .floor()
+        weight_per_prices.push(weight_per_price)
+        total_weight_a = total_weight_a.add(weight_per_price).floor()
+      } else {
+        weight_per_prices.push(d(0))
+      }
+
+      bin_id += 1
+    }
+
+    return {
+      ...options,
+      total_weight_a,
+      total_weight_b,
+      active_weight_a,
+      active_weight_b,
+      weights,
+      weight_per_prices,
+    }
+  }
+
   static toWeightSpotBalanced(min_bin_id: number, max_bin_id: number): BinWeight[] {
     let distributions = []
     for (let i = min_bin_id; i <= max_bin_id; i++) {
@@ -446,9 +561,9 @@ export class WeightUtils {
     let k = d(0)
 
     if (fix_amount_a) {
-      k = totalWeightA.isZero() ? new Decimal(1) : new Decimal(amount).div(totalWeightA)
+      k = totalWeightA.isZero() ? new Decimal(0) : new Decimal(amount).div(totalWeightA)
     } else {
-      k = totalWeightB.isZero() ? new Decimal(1) : new Decimal(amount).div(totalWeightB)
+      k = totalWeightB.isZero() ? new Decimal(0) : new Decimal(amount).div(totalWeightB)
     }
     const other_amount = safeMulAmount(k, fix_amount_a ? totalWeightB : totalWeightA).toString()
 
@@ -463,6 +578,52 @@ export class WeightUtils {
     )
   }
 
+  static calculateActiveWeights(
+    amount_a_in_active_id: string,
+    amount_b_in_active_id: string,
+    active_bin_price: string,
+    base_weight: Decimal
+  ): { active_weight_a: Decimal; active_weight_b: Decimal } {
+    const p0 = d(active_bin_price)
+    const amountA = d(amount_a_in_active_id)
+    const amountB = d(amount_b_in_active_id)
+
+    let active_weight_a: Decimal = d(0)
+    let active_weight_b: Decimal = d(0)
+
+    if (amountA.isZero() && amountB.isZero()) {
+      active_weight_a = d(base_weight)
+        .mul(d(2).pow(SCALE_OFFSET * 2))
+        .div(p0.mul(2))
+        .floor()
+      active_weight_b = d(base_weight).mul(d(2).pow(SCALE_OFFSET)).div(2).floor()
+    } else {
+      // Calculate wx0
+      if (amountA.isZero()) {
+        active_weight_a = d(0)
+      } else {
+        const m = amountB.mul(d(2).pow(SCALE_OFFSET)).div(amountA)
+        active_weight_a = d(base_weight)
+          .mul(d(2).pow(SCALE_OFFSET * 2))
+          .div(p0.add(m))
+          .floor()
+      }
+
+      // Calculate wy0
+      if (amountB.isZero()) {
+        active_weight_b = d(0)
+      } else {
+        const m = d(2).pow(SCALE_OFFSET).add(p0.mul(amountA).div(amountB)).floor()
+        active_weight_b = d(base_weight)
+          .mul(d(2).pow(SCALE_OFFSET * 2))
+          .div(m)
+          .floor()
+      }
+    }
+
+    return { active_weight_a, active_weight_b }
+  }
+
   static calculateTotalWeights(
     bin_step: number,
     distributions: BinWeight[],

package/tests/add_liquidity_bidask.test.ts

@@ -12,8 +12,8 @@ import {
 } from '../src/types/dlmm'
 import { printTransaction } from '@cetusprotocol/common-sdk'
 
-const pool_id = '0x56d2a3270238f1347fa6fb94836da8afd2415c49ab7bb843996fe5c6a807dc5a'
-const position_id = '0x081a3fda4c7df0fc86ff7f69809434ac096911eb7b5e81865cdd1bf8858214fa'
+const pool_id = '0x6ae0b7d9fe4f3ed5ea187c357a4c6c5a192a199d899a58d1f559a6501082f3bf'
+const position_id = '0x85f39912b4eca99e076a925749552fe7a4b2dc882005e21070ba3f2e43b11f3d'
 
 describe('dlmm add liquidity bid ask', () => {
   const sdk = CetusDlmmSDK.createSDK({ env: 'testnet', full_rpc_url: 'https://rpc-testnet.suiscan.xyz' })
@@ -45,17 +45,17 @@ describe('dlmm add liquidity bid ask', () => {
     )
 
     const calculateOption: CalculateAddLiquidityOption = {
+      pool_id,
       amount_a,
       amount_b,
       active_id,
       bin_step,
       lower_bin_id,
       upper_bin_id,
-      amount_a_in_active_bin: amounts_in_active_bin?.amount_a || '0',
-      amount_b_in_active_bin: amounts_in_active_bin?.amount_b || '0',
+      active_bin_of_pool: amounts_in_active_bin,
       strategy_type: StrategyType.BidAsk,
     }
-    const bin_infos = sdk.Position.calculateAddLiquidityInfo(calculateOption)
+    const bin_infos = await sdk.Position.calculateAddLiquidityInfo(calculateOption)
     console.log('🚀 ~ test ~ bin_infos:', bin_infos)
 
     const addOption: OpenAndAddLiquidityOption = {
@@ -66,10 +66,14 @@ describe('dlmm add liquidity bid ask', () => {
       lower_bin_id,
       upper_bin_id,
       active_id,
+      use_bin_infos: false,
+      strategy_type: StrategyType.BidAsk,
+      max_price_slippage: 0.01,
+      bin_step,
     }
     const tx = sdk.Position.addLiquidityPayload(addOption)
 
-    printTransaction(tx)
+    // printTransaction(tx)
 
     const res = await sdk.FullClient.executeTx(send_key_pair, tx, false)
     console.log('🚀 ~ test ~ res:', res)
@@ -92,21 +96,21 @@ describe('dlmm add liquidity bid ask', () => {
       bin_step
     )
 
-    const amount_a = '1000000'
-    const amount_b = '1200000'
+    const amount_a = '100000000'
+    const amount_b = '120000000'
 
     const calculateOption: CalculateAddLiquidityOption = {
+      pool_id,
       amount_a,
       amount_b,
       active_id,
       bin_step,
       lower_bin_id,
       upper_bin_id,
-      amount_a_in_active_bin: amounts_in_active_bin?.amount_a || '0',
-      amount_b_in_active_bin: amounts_in_active_bin?.amount_b || '0',
+      active_bin_of_pool: amounts_in_active_bin,
       strategy_type: StrategyType.BidAsk,
     }
-    const bin_infos = sdk.Position.calculateAddLiquidityInfo(calculateOption)
+    const bin_infos = await sdk.Position.calculateAddLiquidityInfo(calculateOption)
     console.log('🚀 ~ test ~ bin_infos:', bin_infos)
 
     const addOption: AddLiquidityOption = {
@@ -118,6 +122,10 @@ describe('dlmm add liquidity bid ask', () => {
       position_id,
       collect_fee: true,
       reward_coins: [],
+      strategy_type: StrategyType.BidAsk,
+      use_bin_infos: false,
+      max_price_slippage: 0.01,
+      bin_step,
     }
     const tx = sdk.Position.addLiquidityPayload(addOption)
 
@@ -147,17 +155,17 @@ describe('dlmm add liquidity bid ask', () => {
     const coin_amount = '2000000'
 
     const calculateOption: CalculateAddLiquidityAutoFillOption = {
+      pool_id,
       coin_amount,
       fix_amount_a: true,
       active_id,
       bin_step,
       lower_bin_id,
       upper_bin_id,
-      amount_a_in_active_bin: amounts_in_active_bin?.amount_a || '0',
-      amount_b_in_active_bin: amounts_in_active_bin?.amount_b || '0',
+      active_bin_of_pool: amounts_in_active_bin,
       strategy_type: StrategyType.BidAsk,
     }
-    const bin_infos = sdk.Position.calculateAddLiquidityInfo(calculateOption)
+    const bin_infos = await sdk.Position.calculateAddLiquidityInfo(calculateOption)
     console.log('🚀 ~ test ~ bin_infos:', bin_infos)
 
     const addOption: AddLiquidityOption = {
@@ -169,6 +177,10 @@ describe('dlmm add liquidity bid ask', () => {
       position_id,
       collect_fee: true,
       reward_coins: [],
+      strategy_type: StrategyType.BidAsk,
+      use_bin_infos: false,
+      max_price_slippage: 0.01,
+      bin_step,
     }
     const tx = sdk.Position.addLiquidityPayload(addOption)
 

package/tests/add_liquidity_curve.test.ts

@@ -12,7 +12,7 @@ import {
 } from '../src/types/dlmm'
 import { printTransaction } from '@cetusprotocol/common-sdk'
 
-const pool_id = '0x5156119a3cc1143ac65c24f3e7e0b339b74ea057ff5e3a1532b407a749193394'
+const pool_id = '0x6ae0b7d9fe4f3ed5ea187c357a4c6c5a192a199d899a58d1f559a6501082f3bf'
 const position_id = '0xbf3a7a03dbb80e37c44b3dac20cf675b69e5c1ca866538853522ccec934ef554'
 
 describe('dlmm add liquidity curve', () => {
@@ -33,8 +33,8 @@ describe('dlmm add liquidity curve', () => {
     const { active_id, bin_step } = pool
     const amount_a = '10000000'
     const amount_b = '10000000'
-    const lower_bin_id = active_id - 100
-    const upper_bin_id = active_id + 1300
+    const lower_bin_id = active_id - 10
+    const upper_bin_id = active_id + 10
 
     const amounts_in_active_bin = await sdk.Position.getActiveBinIfInRange(
       pool.bin_manager.bin_manager_handle,
@@ -45,17 +45,17 @@ describe('dlmm add liquidity curve', () => {
     )
 
     const calculateOption: CalculateAddLiquidityOption = {
+      pool_id,
       amount_a,
       amount_b,
       active_id,
       bin_step,
       lower_bin_id,
       upper_bin_id,
-      amount_a_in_active_bin: amounts_in_active_bin?.amount_a || '0',
-      amount_b_in_active_bin: amounts_in_active_bin?.amount_b || '0',
+      active_bin_of_pool: amounts_in_active_bin,
       strategy_type: StrategyType.Curve,
     }
-    const bin_infos = sdk.Position.calculateAddLiquidityInfo(calculateOption)
+    const bin_infos = await sdk.Position.calculateAddLiquidityInfo(calculateOption)
     console.log('🚀 ~ test ~ bin_infos:', bin_infos)
 
     const addOption: OpenAndAddLiquidityOption = {
@@ -75,7 +75,7 @@ describe('dlmm add liquidity curve', () => {
     tx.setGasBudget(10000000000)
     printTransaction(tx)
 
-    const res = await sdk.FullClient.executeTx(send_key_pair, tx, true)
+    const res = await sdk.FullClient.executeTx(send_key_pair, tx, false)
     console.log('🚀 ~ test ~ res:', res)
   })
 
@@ -97,17 +97,17 @@ describe('dlmm add liquidity curve', () => {
     )
 
     const calculateOption: CalculateAddLiquidityOption = {
+      pool_id,
       amount_a,
       amount_b,
       active_id,
       bin_step,
       lower_bin_id,
       upper_bin_id,
-      amount_a_in_active_bin: amounts_in_active_bin?.amount_a || '0',
-      amount_b_in_active_bin: amounts_in_active_bin?.amount_b || '0',
+      active_bin_of_pool: amounts_in_active_bin,
       strategy_type: StrategyType.Curve,
     }
-    const bin_infos = sdk.Position.calculateAddLiquidityInfo(calculateOption)
+    const bin_infos = await sdk.Position.calculateAddLiquidityInfo(calculateOption)
     console.log('🚀 ~ test ~ bin_infos:', bin_infos)
 
     const addOption: OpenAndAddLiquidityOption = {
@@ -152,17 +152,17 @@ describe('dlmm add liquidity curve', () => {
     const amount_b = '1200000'
 
     const calculateOption: CalculateAddLiquidityOption = {
+      pool_id,
       amount_a,
       amount_b,
       active_id,
       bin_step,
       lower_bin_id,
       upper_bin_id,
-      amount_a_in_active_bin: amounts_in_active_bin?.amount_a || '0',
-      amount_b_in_active_bin: amounts_in_active_bin?.amount_b || '0',
+      active_bin_of_pool: amounts_in_active_bin,
       strategy_type: StrategyType.Curve,
     }
-    const bin_infos = sdk.Position.calculateAddLiquidityInfo(calculateOption)
+    const bin_infos = await sdk.Position.calculateAddLiquidityInfo(calculateOption)
     console.log('🚀 ~ test ~ bin_infos:', bin_infos)
 
     const addOption: AddLiquidityOption = {
@@ -207,17 +207,17 @@ describe('dlmm add liquidity curve', () => {
     const coin_amount = '2000000'
 
     const calculateOption: CalculateAddLiquidityAutoFillOption = {
+      pool_id,
       coin_amount,
       fix_amount_a: true,
       active_id,
       bin_step,
       lower_bin_id,
       upper_bin_id,
-      amount_a_in_active_bin: amounts_in_active_bin?.amount_a || '0',
-      amount_b_in_active_bin: amounts_in_active_bin?.amount_b || '0',
+      active_bin_of_pool: amounts_in_active_bin,
       strategy_type: StrategyType.Curve,
     }
-    const bin_infos = sdk.Position.calculateAddLiquidityInfo(calculateOption)
+    const bin_infos = await sdk.Position.calculateAddLiquidityInfo(calculateOption)
     console.log('🚀 ~ test ~ bin_infos:', bin_infos)
 
     const addOption: AddLiquidityOption = {