@cetusprotocol/sui-clmm-sdk 1.0.0

package/tests/add_liquidity_fix_token.test.ts

@@ -0,0 +1,182 @@
+import { Ed25519Keypair } from '@mysten/sui/keypairs/ed25519'
+import BN from 'bn.js'
+import { ClmmPoolUtil, printTransaction, TickMath, toDecimalsAmount } from '@cetusprotocol/common-sdk'
+import { buildTestAccount } from '@cetusprotocol/test-utils'
+import 'isomorphic-fetch'
+import { AddLiquidityFixTokenParams, CustomRangeParams, FullRangeParams } from '../src'
+import { CetusClmmSDK } from '../src/sdk'
+
+let send_key_pair: Ed25519Keypair
+const poolId = '0xb8d7d9e66a60c239e7a60110efcf8de6c705580ed924d0dde141f4a0e2c90105'
+const position_nft_id = '0xcf995f40b0f9c40a8b03e0b9d9554fea2bc12a18fe63db3a04c59c46be5c10be'
+
+describe('add_liquidity_fix_token', () => {
+  const sdk = CetusClmmSDK.createSDK({ env: 'mainnet' })
+
+  beforeEach(async () => {
+    send_key_pair = buildTestAccount()
+    sdk.setSenderAddress(send_key_pair.getPublicKey().toSuiAddress())
+  })
+
+  test('1: custom tick range open_and_add_liquidity_fix_token', async () => {
+    const pool = await sdk.Pool.getPool(poolId)
+    const tick_lower_index = TickMath.getPrevInitializeTickIndex(
+      new BN(pool.current_tick_index).toNumber(),
+      new BN(pool.tick_spacing).toNumber()
+    )
+    const tick_upper_index = TickMath.getNextInitializeTickIndex(
+      new BN(pool.current_tick_index).toNumber(),
+      new BN(pool.tick_spacing).toNumber()
+    )
+    const coinAmount = new BN(100)
+    const fix_amount_a = true
+    const slippage = 0.01
+    const curSqrtPrice = new BN(pool.current_sqrt_price)
+
+    const liquidityInput = ClmmPoolUtil.estLiquidityAndCoinAmountFromOneAmounts(
+      tick_lower_index,
+      tick_upper_index,
+      coinAmount,
+      fix_amount_a,
+      true,
+      slippage,
+      curSqrtPrice
+    )
+
+    const amount_a = fix_amount_a ? coinAmount.toNumber() : Number(liquidityInput.coin_amount_limit_a)
+    const amount_b = fix_amount_a ? Number(liquidityInput.coin_amount_limit_b) : coinAmount.toNumber()
+
+    console.log('amount: ', { amount_a, amount_b })
+
+    const addLiquidityPayloadParams: AddLiquidityFixTokenParams = {
+      coin_type_a: pool.coin_type_a,
+      coin_type_b: pool.coin_type_b,
+      pool_id: pool.id,
+      tick_lower: tick_lower_index.toString(),
+      tick_upper: tick_upper_index.toString(),
+      fix_amount_a,
+      amount_a,
+      amount_b,
+      slippage,
+      is_open: true,
+      rewarder_coin_types: [],
+      collect_fee: false,
+      pos_id: '',
+    }
+    const createAddLiquidityTransactionPayload = await sdk.Position.createAddLiquidityFixTokenPayload(addLiquidityPayloadParams, {
+      slippage: slippage,
+      cur_sqrt_price: curSqrtPrice,
+    })
+
+    printTransaction(createAddLiquidityTransactionPayload)
+    const transferTxn = await sdk.FullClient.executeTx(send_key_pair, createAddLiquidityTransactionPayload, true)
+    console.log('open_and_add_liquidity_fix_token: ', transferTxn)
+  })
+
+  test('2:  add_liquidity_fix_token', async () => {
+    const pool = await sdk.Pool.getPool(poolId)
+    const position = await sdk.Position.getPositionById(position_nft_id)
+    const tick_lower_index = position.tick_lower_index
+    const tick_upper_index = position.tick_upper_index
+    const coinAmount = new BN(500)
+    const fix_amount_a = true
+    const slippage = 0.1
+    const curSqrtPrice = new BN(pool.current_sqrt_price)
+
+    const liquidityInput = ClmmPoolUtil.estLiquidityAndCoinAmountFromOneAmounts(
+      tick_lower_index,
+      tick_upper_index,
+      coinAmount,
+      fix_amount_a,
+      true,
+      slippage,
+      curSqrtPrice
+    )
+
+    const amount_a = fix_amount_a ? coinAmount.toNumber() : Number(liquidityInput.coin_amount_limit_a)
+    const amount_b = fix_amount_a ? Number(liquidityInput.coin_amount_limit_b) : coinAmount.toNumber()
+
+    console.log('amount: ', { amount_a, amount_b })
+
+    const addLiquidityPayloadParams: AddLiquidityFixTokenParams = {
+      coin_type_a: pool.coin_type_a,
+      coin_type_b: pool.coin_type_b,
+      pool_id: pool.id,
+      tick_lower: tick_lower_index.toString(),
+      tick_upper: tick_upper_index.toString(),
+      fix_amount_a,
+      amount_a,
+      amount_b,
+      slippage,
+      is_open: false,
+      pos_id: position.pos_object_id,
+      rewarder_coin_types: [],
+      collect_fee: true,
+    }
+    const addLiquidityPayload = await sdk.Position.createAddLiquidityFixTokenPayload(addLiquidityPayloadParams)
+
+    printTransaction(addLiquidityPayload)
+
+    const transferTxn = await sdk.FullClient.executeTx(send_key_pair, addLiquidityPayload, true)
+    console.log('add_liquidity_fix_token: ', transferTxn)
+  })
+
+  test('3: custom price range open and add liquidity ', async () => {
+    const params: CustomRangeParams = {
+      is_full_range: false,
+      min_price: '0.2',
+      max_price: '0.7',
+      coin_decimals_a: 6,
+      coin_decimals_b: 9,
+      price_base_coin: 'coin_a',
+    }
+
+    const result = await sdk.Position.calculateAddLiquidityResultWithPrice({
+      add_mode_params: params,
+      pool_id: poolId,
+      slippage: 0.01,
+      coin_amount: toDecimalsAmount(1, 6).toString(),
+      fix_amount_a: true,
+    })
+
+    console.log('result: ', result)
+
+    const payload = await sdk.Position.createAddLiquidityFixCoinWithPricePayload({
+      pool_id: poolId,
+      calculate_result: result,
+      add_mode_params: params,
+    })
+
+    printTransaction(payload)
+
+    const transfer_txn = await sdk.FullClient.executeTx(send_key_pair, payload, true)
+    console.log('createAddLiquidityPayload: ', transfer_txn)
+  })
+
+  test('4: full range price range open and add liquidity ', async () => {
+    const params: FullRangeParams = {
+      is_full_range: true,
+    }
+
+    const result = await sdk.Position.calculateAddLiquidityResultWithPrice({
+      add_mode_params: params,
+      pool_id: poolId,
+      slippage: 0.01,
+      coin_amount: toDecimalsAmount(1, 6).toString(),
+      fix_amount_a: true,
+    })
+
+    console.log('result: ', result)
+
+    const payload = await sdk.Position.createAddLiquidityFixCoinWithPricePayload({
+      pool_id: poolId,
+      calculate_result: result,
+      add_mode_params: params,
+    })
+
+    printTransaction(payload)
+
+    const transfer_txn = await sdk.FullClient.executeTx(send_key_pair, payload, false)
+    console.log('createAddLiquidityPayload: ', transfer_txn)
+  })
+})

package/tests/apr.test.ts

@@ -0,0 +1,71 @@
+import BN from 'bn.js'
+import { estPositionAPRWithDeltaMethod, estPositionAPRWithMultiMethod } from '../src/math/apr'
+
+describe('APR function test', () => {
+  test('test estPositionAPRWithDeltaMethod', async () => {
+    const currentTickIndex = -1
+    const lowerTickIndex = -443636
+    const upperTickIndex = 443636
+    const currentSqrtPriceX64 = new BN('18446460903430917184')
+    const poolLiquidity = new BN('560867872160365128')
+    const decimalsA = 6
+    const decimalsB = 6
+    const decimalsRewarder0 = 6
+    const decimalsRewarder1 = 6
+    const decimalsRewarder2 = 6
+    const feeRate = 100
+    const amountA_str = '1000.000034'
+    const amountB_str = '999.969333'
+    const poolAmountA = new BN(120754054325992)
+    const poolAmountB = new BN(1000205276004441)
+    const swapVolume_str = '7588147.89'
+    const poolRewarders0_str = '30000000'
+    const poolRewarders1_str = '52000000'
+    const poolRewarders2_str = '35000000'
+    const coinAPrice_str = '0.949513'
+    const coinBPrice_str = '1.001'
+    const rewarder0Price_str = '13.252911'
+    const rewarder1Price_str = '0.949513'
+    const rewarder2Price_str = '1.001'
+
+    const res = estPositionAPRWithDeltaMethod(
+      currentTickIndex,
+      lowerTickIndex,
+      upperTickIndex,
+      currentSqrtPriceX64,
+      poolLiquidity,
+      decimalsA,
+      decimalsB,
+      decimalsRewarder0,
+      decimalsRewarder1,
+      decimalsRewarder2,
+      feeRate,
+      amountA_str,
+      amountB_str,
+      poolAmountA,
+      poolAmountB,
+      swapVolume_str,
+      poolRewarders0_str,
+      poolRewarders1_str,
+      poolRewarders2_str,
+      coinAPrice_str,
+      coinBPrice_str,
+      rewarder0Price_str,
+      rewarder1Price_str,
+      rewarder2Price_str
+    )
+
+    console.log('res: ', res)
+  })
+
+  test('test estPositionAPRWithDeltaMethod', async () => {
+    const lowerUserPrice = 0.85
+    const upperUserPrice = 0.99
+    const lowerHistPrice = 0.06
+    const upperHistPrice = 1
+
+    const res = estPositionAPRWithMultiMethod(lowerUserPrice, upperUserPrice, lowerHistPrice, upperHistPrice)
+
+    console.log('res: ', res)
+  })
+})

package/tests/cetus_config.test.ts

@@ -0,0 +1,26 @@
+import 'isomorphic-fetch'
+import { CetusClmmSDK } from '../src/sdk'
+
+describe('Config Module', () => {
+  const sdk = CetusClmmSDK.createSDK({ env: 'mainnet' })
+
+  test('getTokenListByCoinTypes', async () => {
+    const tokenMap = await sdk.CetusConfig.getTokenListByCoinTypes(['0x2::sui::SUI'])
+    console.log('tokenMap: ', tokenMap)
+  })
+
+  test('getCoinConfigs', async () => {
+    const coin_list = await sdk.CetusConfig.getCoinConfigs(true)
+    console.log('coin_list: ', coin_list)
+  })
+
+  test('getClmmPoolConfigs', async () => {
+    const pool_list = await sdk.CetusConfig.getClmmPoolConfigs()
+    console.log('pool_list: ', pool_list)
+  })
+
+  test('getLaunchpadPoolConfigs', async () => {
+    const pool_list = await sdk.CetusConfig.getLaunchpadPoolConfigs()
+    console.log('pool_list: ', pool_list)
+  })
+})

package/tests/collect_fees.test.ts

@@ -0,0 +1,11 @@
+import 'isomorphic-fetch'
+import { CetusClmmSDK } from '../src/sdk'
+
+describe('collect fees', () => {
+  const sdk = CetusClmmSDK.createSDK({ env: 'mainnet' })
+
+  test('batchFetchPositionFees', async () => {
+    const res = await sdk.Position.batchFetchPositionFees(['0xcf995f40b0f9c40a8b03e0b9d9554fea2bc12a18fe63db3a04c59c46be5c10be'])
+    console.log('res####', res)
+  })
+})

package/tests/pool.test.ts

@@ -0,0 +1,267 @@
+import BN from 'bn.js'
+import { ClmmPoolUtil, d, isSortedSymbols, printTransaction, TickMath } from '@cetusprotocol/common-sdk'
+import { buildTestAccount } from '@cetusprotocol/test-utils'
+import 'isomorphic-fetch'
+// import { CetusClmmSDK } from '../dist/index.js'
+import { CetusClmmSDK } from '../src'
+import { CreatePoolCustomRangeParams, FullRangeParams } from '../src/types/clmm_type'
+import { buildTransferCoin } from '../src/utils'
+import { SuiClient } from '@mysten/sui/client'
+
+// import { buildTransferCoin, PositionUtils } from '../dist/index.js'
+// import { CreatePoolCustomRangeParams, FullRangeParams } from '../dist/index.js'
+
+const poolId = '0xb8d7d9e66a60c239e7a60110efcf8de6c705580ed924d0dde141f4a0e2c90105'
+describe('Pool Module', () => {
+  let send_key_pair = buildTestAccount()
+  const sdk = CetusClmmSDK.createSDK({ env: 'mainnet', sui_client: new SuiClient({ url: 'https://fullnode.mainnet.sui.io:443' }) })
+  sdk.setSenderAddress(send_key_pair.getPublicKey().toSuiAddress())
+
+  test('getAllPools', async () => {
+    const pools = await sdk.Pool.getPoolsWithPage()
+    console.log(pools)
+  })
+
+  test('getAssignPools', async () => {
+    const pools = await sdk.Pool.getAssignPools(['0xcf994611fd4c48e277ce3ffd4d4364c914af2c3cbb05f7bf6facd371de688630'])
+    console.log(pools)
+  })
+
+  test('getPoolTransactionList', async () => {
+    const res = await sdk.Pool.getPoolTransactionList({
+      pool_id: '0xb8d7d9e66a60c239e7a60110efcf8de6c705580ed924d0dde141f4a0e2c90105',
+      pagination_args: {
+        limit: 10,
+      },
+    })
+    console.log('res', res)
+  })
+
+  test('getSinglePool', async () => {
+    const pool = await sdk.Pool.getPool('0xcf994611fd4c48e277ce3ffd4d4364c914af2c3cbb05f7bf6facd371de688630')
+    console.log('pool', pool)
+  })
+
+  test('doCreatePools', async () => {
+    const tick_spacing = 2
+    const initialize_price = 1
+    const coin_a_decimals = 6
+    const coin_b_decimals = 6
+    const coin_type_a = `${sdk.sdkOptions.cetus_config?.package_id}::usdt::USDT`
+    const coin_type_b = `{sdk.sdkOptions.faucet?.package_id}::usdc::USDC`
+
+    const createPoolTransactionPayload = await sdk.Pool.createPoolPayload({
+      tick_spacing: tick_spacing,
+      initialize_sqrt_price: TickMath.priceToSqrtPriceX64(d(initialize_price), coin_a_decimals, coin_b_decimals).toString(),
+      uri: '',
+      coin_type_a: coin_type_a,
+      coin_type_b: coin_type_b,
+      fix_amount_a: true,
+      amount_a: '100000000',
+      amount_b: '100000000',
+      metadata_a: '0x2c5f33af93f6511df699aaaa5822d823aac6ed99d4a0de2a4a50b3afa0172e24',
+      metadata_b: '0x9258181f5ceac8dbffb7030890243caed69a9599d2886d957a9cb7656af3bdb3',
+      tick_lower: -443520,
+      tick_upper: 443520,
+    })
+
+    printTransaction(createPoolTransactionPayload)
+    const transferTxn = await sdk.FullClient.sendTransaction(buildTestAccount(), createPoolTransactionPayload)
+    console.log('doCreatePool: ', transferTxn)
+  })
+
+  test('get partner ref fee', async () => {
+    const refFee = await sdk.Pool.getPartnerRefFeeAmount('0x0c1e5401e40129da6a65a973b12a034e6c78b7b0b27c3a07213bc5ce3fa3d881')
+    console.log('ref fee:', refFee)
+  })
+
+  test('claim partner ref fee', async () => {
+    const partnerCap = 'xxx'
+    const partner = 'xxx'
+    const claimRefFeePayload = await sdk.Pool.claimPartnerRefFeePayload(partnerCap, partner, '0x2::sui::SUI')
+    const transferTxn = await sdk.FullClient.sendTransaction(buildTestAccount(), claimRefFeePayload)
+    console.log('doCreatePool: ', JSON.stringify(transferTxn))
+  })
+
+  test('get pool by coin types', async () => {
+    const coinA = '0x5d4b302506645c37ff133b98c4b50a5ae14841659738d6d733d59d0d217a93bf::coin::COIN'
+    const coinB = '0xc060006111016b8a020ad5b33834984a437aaa7d3c74c18e09a95d48aceab08c::coin::COIN'
+
+    const pools = await sdk.Pool.getPoolByCoins([coinA, coinB])
+    expect(pools.length).toBeGreaterThan(0)
+
+    const coinC = '0x5d4b302506645c37ff133b98c4b50a5ae14841659738d6d733d59d0d217a93bf::coin::COIN'
+    const coinD = '0x2::sui::SUI'
+
+    const pools2 = await sdk.Pool.getPoolByCoins([coinC, coinD])
+    expect(pools2.length).toBeGreaterThan(0)
+
+    const coinE = '0x0000000000000000000000000000000000000000000000000000000000000002::sui::SUI'
+
+    const pools3 = await sdk.Pool.getPoolByCoins([coinC, coinE])
+    expect(pools3.length).toEqual(pools2.length)
+
+    const coinCetus = '0x06864a6f921804860930db6ddbe2e16acdf8504495ea7481637a1c8b9a8fe54b::cetus::CETUS'
+    const coinBlub = '0xfa7ac3951fdca92c5200d468d31a365eb03b2be9936fde615e69f0c1274ad3a0::BLUB::BLUB'
+
+    const pools4 = await sdk.Pool.getPoolByCoins([coinCetus, coinBlub])
+    console.log('pools4', pools4)
+    expect(pools4.length).toEqual(pools2.length)
+  })
+
+  test('ClmmPoolUtil.estLiquidityAndCoinAmountFromOneAmounts: ', () => {
+    const lowerTick = -74078
+    const upperTick = -58716
+    const currentSqrtPrice = '979448777168348479'
+    const coinAmountA = new BN(100000000)
+    const { coin_amount_b } = ClmmPoolUtil.estLiquidityAndCoinAmountFromOneAmounts(
+      lowerTick,
+      upperTick,
+      coinAmountA,
+      true,
+      true,
+      0,
+      new BN(currentSqrtPrice)
+    )
+  })
+
+  test('isSortedSymbols', () => {
+    const p = isSortedSymbols(
+      '0x549e8b69270defbfafd4f94e17ec44cdbdd99820b33bda2278dea3b9a32d3f55::cert::CERT',
+      '0xdba34672e30cb065b1f93e3ab55318768fd6fef66c15942c9f7cb846e2f900e7::usdc::USDC'
+    )
+    console.log('🚀🚀🚀 ~ file: pool.test.ts:145 ~ test ~ p:', p)
+  })
+
+  test('createPoolTransactionPayload', async () => {
+    const payload = await sdk.Pool.createPoolPayload({
+      tick_spacing: 220,
+      initialize_sqrt_price: '18446744073709551616',
+      uri: '',
+      fix_amount_a: true,
+      amount_a: '100000000',
+      amount_b: '100000000',
+      coin_type_a: '0xbde4ba4c2e274a60ce15c1cfff9e5c42e41654ac8b6d906a57efa4bd3c29f47d::hasui::HASUI',
+      coin_type_b: '0x2::sui::SUI',
+      metadata_a: '0x2c5f33af93f6511df699aaaa5822d823aac6ed99d4a0de2a4a50b3afa0172e24',
+      metadata_b: '0x9258181f5ceac8dbffb7030890243caed69a9599d2886d957a9cb7656af3bdb3',
+      tick_lower: -443520,
+      tick_upper: 443520,
+    })
+    const cPrice = TickMath.sqrtPriceX64ToPrice(new BN('184467440737095516'), 9, 6)
+    console.log('🚀🚀🚀 ~ file: pool.test.ts:168 ~ test ~ cPrice:', cPrice.toString())
+    printTransaction(payload)
+    const transferTxn = await sdk.FullClient.dryRunTransactionBlock({
+      transactionBlock: await payload.build({ client: sdk.FullClient }),
+    })
+
+    console.log('🚀🚀🚀 ~ file: pool.test.ts:168 ~ test ~ transferTxn:', transferTxn)
+  })
+
+  test('createPoolTransactionRowPayload', async () => {
+    const coinTypeA = '0x06864a6f921804860930db6ddbe2e16acdf8504495ea7481637a1c8b9a8fe54b::cetus::CETUS'
+    const coinTypeB = '0xfa7ac3951fdca92c5200d468d31a365eb03b2be9936fde615e69f0c1274ad3a0::BLUB::BLUB'
+
+    const coinMetadataA = await sdk.FullClient.fetchCoinMetadata(coinTypeA)
+    const coinMetadataB = await sdk.FullClient.fetchCoinMetadata(coinTypeB)
+
+    const { tx, pos_id, remain_coin_a, remain_coin_b, remain_coin_type_a, remain_coin_type_b } = await sdk.Pool.createPoolRowPayload({
+      tick_spacing: 20,
+      initialize_sqrt_price: '31366801070720067977',
+      uri: '',
+      fix_amount_a: true,
+      amount_a: '100000000',
+      amount_b: '1000000000',
+      coin_type_a: coinTypeA,
+      coin_type_b: coinTypeB,
+      metadata_a: coinMetadataA!.id!,
+      metadata_b: coinMetadataB!.id!,
+      tick_lower: -440000,
+      tick_upper: 440000,
+    })
+    const cPrice = TickMath.sqrtPriceX64ToPrice(new BN('184467440737095516'), 0, 9)
+    console.log('🚀🚀🚀 ~ file: pool.test.ts:168 ~ test ~ cPrice:', cPrice.toString())
+    printTransaction(tx)
+
+    buildTransferCoin(sdk, tx, remain_coin_a, remain_coin_type_a)
+    buildTransferCoin(sdk, tx, remain_coin_b, remain_coin_type_b)
+
+    tx.transferObjects([pos_id], sdk.getSenderAddress())
+    const transferTxn = await sdk.FullClient.executeTx(send_key_pair, tx, true)
+    console.log('doCreatePool: ', transferTxn)
+  })
+
+  test('custom price range create pool return position', async () => {
+    const tick_spacing = 220
+    const modeParams: CreatePoolCustomRangeParams = {
+      is_full_range: false,
+      min_price: '0.2',
+      max_price: '0.7',
+    }
+    const result = await sdk.Pool.calculateCreatePoolWithPrice({
+      tick_spacing,
+      current_price: '0.5',
+      coin_amount: '1000000',
+      fix_amount_a: true,
+      add_mode_params: modeParams,
+      coin_decimals_a: 6,
+      coin_decimals_b: 9,
+      price_base_coin: 'coin_a',
+      slippage: 0.05,
+    })
+    console.log('🚀 ~ test ~ result:', result)
+
+    const coin_type_a = '0xdba34672e30cb065b1f93e3ab55318768fd6fef66c15942c9f7cb846e2f900e7::usdc::USDC'
+    const coin_type_b = '0x2::sui::SUI'
+
+    const { tx, pos_id, remain_coin_a, remain_coin_b, remain_coin_type_a, remain_coin_type_b } =
+      await sdk.Pool.createPoolWithPriceReturnPositionPayload({
+        tick_spacing,
+        calculate_result: result,
+        add_mode_params: modeParams,
+        coin_type_a,
+        coin_type_b,
+      })
+
+    buildTransferCoin(sdk, tx, remain_coin_a, remain_coin_type_a)
+    buildTransferCoin(sdk, tx, remain_coin_b, remain_coin_type_b)
+
+    tx.transferObjects([pos_id], sdk.getSenderAddress())
+    const transferTxn = await sdk.FullClient.executeTx(send_key_pair, tx, true)
+    console.log('doCreatePool: ', transferTxn)
+  })
+
+  test('full price range create pool', async () => {
+    const tick_spacing = 220
+    const modeParams: FullRangeParams = {
+      is_full_range: true,
+    }
+
+    const result = await sdk.Pool.calculateCreatePoolWithPrice({
+      tick_spacing,
+      current_price: '0.5',
+      coin_amount: '1000000',
+      fix_amount_a: true,
+      add_mode_params: modeParams,
+      coin_decimals_a: 6,
+      coin_decimals_b: 9,
+      price_base_coin: 'coin_a',
+      slippage: 0.05,
+    })
+    console.log('🚀 ~ test ~ result:', result)
+
+    const coin_type_a = '0xdba34672e30cb065b1f93e3ab55318768fd6fef66c15942c9f7cb846e2f900e7::usdc::USDC'
+    const coin_type_b = '0x2::sui::SUI'
+
+    const tx = await sdk.Pool.createPoolWithPricePayload({
+      tick_spacing,
+      calculate_result: result,
+      add_mode_params: modeParams,
+      coin_type_a,
+      coin_type_b,
+    })
+
+    const transferTxn = await sdk.FullClient.executeTx(send_key_pair, tx, true)
+    console.log('doCreatePool: ', transferTxn)
+  })
+})