@kamino-finance/kliquidity-sdk 8.3.1 → 8.3.2

package/src/utils/orca.ts

@@ -1,8 +1,63 @@
-import { Address, getAddressEncoder, getProgramDerivedAddress } from '@solana/kit';
+import { BN } from '@coral-xyz/anchor';
+import {
+  address,
+  Address,
+  GetAccountInfoApi,
+  getAddressEncoder,
+  GetMultipleAccountsApi,
+  getProgramDerivedAddress,
+  Rpc,
+} from '@solana/kit';
 import { ProgramDerivedAddress } from '@solana/addresses/dist/types/program-derived-address';
+import { ONE_BN, U64_MAX, ZERO_BN } from '../constants';
+import { Percentage } from './types';
+import { DEFAULT_ADDRESS, IncreaseLiquidityQuoteParam } from '@orca-so/whirlpools';
+import { TickArray, Whirlpool } from '../@codegen/whirlpools/accounts';
+import {
+  _MAX_TICK_INDEX,
+  _MIN_TICK_INDEX,
+  getTickArrayStartTickIndex,
+  IncreaseLiquidityQuote,
+  tickIndexToPrice,
+  TransferFee,
+} from '@orca-so/whirlpools-core';
+import { increaseLiquidityQuoteA, increaseLiquidityQuoteB, increaseLiquidityQuote } from '@orca-so/whirlpools-core';
+import { Whirlpool as WhirlpoolAPIResponse, WhirlpoolReward } from '../services/OrcaWhirlpoolsResponse';
+import Decimal from 'decimal.js/decimal';
+import { getRemoveLiquidityQuote } from './whirlpools';
+import { FullBPS } from './CreationParameters';
+import { fetchMaybeTickArray, getTickArrayAddress } from '@orca-so/whirlpools-client';
+import { sleep } from './utils';
+import { ZERO } from './math';
 
+export const defaultSlippagePercentageBPS = 10;
 const addressEncoder = getAddressEncoder();
 
+const TICK_ARRAY_SIZE = 88;
+
+const SECONDS_PER_YEAR =
+  60 * // SECONDS
+  60 * // MINUTES
+  24 * // HOURS
+  365; // DAYS
+
+function estimateRewardApr(
+  reward: WhirlpoolReward,
+  rewardTokenDecimals: number,
+  concentratedValue: Decimal,
+  tokenPrices: Map<Address, Decimal>
+) {
+  const { mint } = reward;
+  const rewardTokenPrice = tokenPrices.get(address(mint));
+  const emissionsPerSecond = new Decimal(reward.emissionsPerSecond).div(new Decimal(10).pow(rewardTokenDecimals));
+  if (emissionsPerSecond.eq(ZERO) || !rewardTokenPrice) {
+    return 0;
+  }
+
+  const res = emissionsPerSecond.mul(SECONDS_PER_YEAR).mul(rewardTokenPrice).div(concentratedValue).toNumber();
+  return res;
+}
+
 export async function getTickArray(
   programId: Address,
   whirlpoolAddress: Address,
@@ -13,3 +68,324 @@ export async function getTickArray(
     programAddress: programId,
   });
 }
+
+export function getTokenAFromLiquidity(liquidity: BN, sqrtPrice0X64: BN, sqrtPrice1X64: BN, roundUp: boolean) {
+  const [sqrtPriceLowerX64, sqrtPriceUpperX64] = orderSqrtPrice(sqrtPrice0X64, sqrtPrice1X64);
+
+  const numerator = liquidity.mul(sqrtPriceUpperX64.sub(sqrtPriceLowerX64)).shln(64);
+  const denominator = sqrtPriceUpperX64.mul(sqrtPriceLowerX64);
+  if (roundUp) {
+    return divRoundUp(numerator, denominator);
+  } else {
+    return numerator.div(denominator);
+  }
+}
+
+export function getTokenBFromLiquidity(liquidity: BN, sqrtPrice0X64: BN, sqrtPrice1X64: BN, roundUp: boolean) {
+  const [sqrtPriceLowerX64, sqrtPriceUpperX64] = orderSqrtPrice(sqrtPrice0X64, sqrtPrice1X64);
+
+  const result = liquidity.mul(sqrtPriceUpperX64.sub(sqrtPriceLowerX64));
+  if (roundUp) {
+    return shiftRightRoundUp(result);
+  } else {
+    return result.shrn(64);
+  }
+}
+
+export function getNearestValidTickIndexFromTickIndex(tickIndex: number, tickSpacing: number): number {
+  return tickIndex - (tickIndex % tickSpacing);
+}
+
+export function getIncreaseLiquidityQuote(
+  param: IncreaseLiquidityQuoteParam,
+  pool: Whirlpool,
+  tickLowerIndex: number,
+  tickUpperIndex: number,
+  slippageToleranceBps: number,
+  transferFeeA: TransferFee | undefined,
+  transferFeeB: TransferFee | undefined
+): IncreaseLiquidityQuote {
+  if ('liquidity' in param) {
+    return increaseLiquidityQuote(
+      param.liquidity,
+      slippageToleranceBps,
+      BigInt(pool.sqrtPrice.toString()),
+      tickLowerIndex,
+      tickUpperIndex,
+      transferFeeA,
+      transferFeeB
+    );
+  } else if ('tokenA' in param) {
+    return increaseLiquidityQuoteA(
+      param.tokenA,
+      slippageToleranceBps,
+      BigInt(pool.sqrtPrice.toString()),
+      tickLowerIndex,
+      tickUpperIndex,
+      transferFeeA,
+      transferFeeB
+    );
+  } else {
+    return increaseLiquidityQuoteB(
+      param.tokenB,
+      slippageToleranceBps,
+      BigInt(pool.sqrtPrice.toString()),
+      tickLowerIndex,
+      tickUpperIndex,
+      transferFeeA,
+      transferFeeB
+    );
+  }
+}
+
+function orderSqrtPrice(sqrtPrice0X64: BN, sqrtPrice1X64: BN): [BN, BN] {
+  if (sqrtPrice0X64.lt(sqrtPrice1X64)) {
+    return [sqrtPrice0X64, sqrtPrice1X64];
+  } else {
+    return [sqrtPrice1X64, sqrtPrice0X64];
+  }
+}
+
+function shiftRightRoundUp(n: BN): BN {
+  let result = n.shrn(64);
+
+  if (n.mod(new BN(U64_MAX)).gt(ZERO_BN)) {
+    result = result.add(ONE_BN);
+  }
+
+  return result;
+}
+
+function divRoundUp(n0: BN, n1: BN): BN {
+  const hasRemainder = !n0.mod(n1).eq(ZERO_BN);
+  if (hasRemainder) {
+    return n0.div(n1).add(ONE_BN);
+  } else {
+    return n0.div(n1);
+  }
+}
+
+export function adjustForSlippage(n: BN, { numerator, denominator }: Percentage, adjustUp: boolean): BN {
+  if (adjustUp) {
+    return n.mul(denominator.add(numerator)).div(denominator);
+  } else {
+    return n.mul(denominator).div(denominator.add(numerator));
+  }
+}
+
+export type EstimatedAprs = {
+  fee: number;
+  rewards: number[];
+};
+
+export const ZERO_APR = {
+  fee: 0,
+  rewards: [0, 0, 0],
+};
+
+export function estimateAprsForPriceRange(
+  pool: WhirlpoolAPIResponse,
+  tokenPrices: Map<Address, Decimal>,
+  fees24h: number,
+  tickLowerIndex: number,
+  tickUpperIndex: number,
+  rewardsDecimals: Map<Address, number>
+): EstimatedAprs {
+  const tokenPriceA = tokenPrices.get(address(pool.tokenMintA));
+  const tokenPriceB = tokenPrices.get(address(pool.tokenMintB));
+
+  if (!fees24h || !tokenPriceA || !tokenPriceB || tickLowerIndex >= tickUpperIndex) {
+    return ZERO_APR;
+  }
+
+  // Value of liquidity if the entire liquidity were concentrated between tickLower/Upper
+  // Since this is virtual liquidity, concentratedValue should actually be less than totalValue
+  const { minTokenA, minTokenB } = getRemoveLiquidityQuote({
+    positionAddress: DEFAULT_ADDRESS,
+    tickCurrentIndex: pool.tickCurrentIndex,
+    sqrtPrice: new BN(pool.sqrtPrice.toString()),
+    tickLowerIndex,
+    tickUpperIndex,
+    liquidity: new BN(pool.liquidity.toString()),
+    slippageTolerance: { numerator: ZERO_BN, denominator: new BN(FullBPS) },
+  });
+  const tokenValueA = getTokenValue(minTokenA, pool.tokenA.decimals, tokenPriceA);
+  const tokenValueB = getTokenValue(minTokenB, pool.tokenB.decimals, tokenPriceB);
+  const concentratedValue = tokenValueA.add(tokenValueB);
+
+  const feesPerYear = new Decimal(fees24h).mul(365).div(new Decimal(10).pow(6)); // scale from lamports of USDC to tokens
+  const feeApr = feesPerYear.div(concentratedValue).toNumber();
+
+  const rewards = pool.rewards.map((reward) => {
+    if (rewardsDecimals.has(address(reward.mint))) {
+      return estimateRewardApr(reward, rewardsDecimals.get(address(reward.mint))!, concentratedValue, tokenPrices);
+    } else {
+      return 0;
+    }
+  });
+
+  return { fee: feeApr, rewards };
+}
+
+function getTokenValue(tokenAmount: BN, decimals: number, tokenPrice: Decimal): Decimal {
+  return tokenPrice.mul(new Decimal(tokenAmount.toString()).div(new Decimal(10).pow(decimals)));
+}
+
+export async function getLowestInitializedTickArrayTickIndex(
+  rpc: Rpc<GetAccountInfoApi>,
+  whirlpoolAddress: Address,
+  tickSpacing: number
+): Promise<number> {
+  const minTick = _MIN_TICK_INDEX();
+  let startTickIndex = getTickArrayStartTickIndex(minTick, tickSpacing);
+
+  // eslint-disable-next-line
+  while (true) {
+    const [tickArrayAddress] = await getTickArrayAddress(whirlpoolAddress, startTickIndex);
+    const tickArray = await fetchMaybeTickArray(rpc, tickArrayAddress);
+
+    if (tickArray.exists) {
+      return startTickIndex;
+    }
+
+    startTickIndex += TICK_ARRAY_SIZE * tickSpacing;
+    await sleep(500);
+  }
+}
+
+export async function getHighestInitializedTickArrayTickIndex(
+  rpc: Rpc<GetAccountInfoApi>,
+  whirlpoolAddress: Address,
+  tickSpacing: number
+): Promise<number> {
+  const maxTick = _MAX_TICK_INDEX();
+  let startTickIndex = getTickArrayStartTickIndex(maxTick, tickSpacing);
+
+  // eslint-disable-next-line
+  while (true) {
+    const [tickArrayAddress] = await getTickArrayAddress(whirlpoolAddress, startTickIndex);
+    const tickArray = await fetchMaybeTickArray(rpc, tickArrayAddress);
+
+    if (tickArray.exists) {
+      return startTickIndex;
+    }
+
+    startTickIndex -= TICK_ARRAY_SIZE * tickSpacing;
+    await sleep(500);
+  }
+}
+
+export type LiquidityDataPoint = {
+  liquidity: Decimal;
+  price: Decimal;
+  tickIndex: number;
+};
+export type WhirlpoolLiquidityDistribution = {
+  currentPrice: Decimal;
+  currentTickIndex: number;
+  datapoints: LiquidityDataPoint[];
+};
+
+export async function getLiquidityDistribution(
+  rpc: Rpc<GetMultipleAccountsApi>,
+  poolAddress: Address,
+  poolData: WhirlpoolAPIResponse,
+  tickLower: number,
+  tickUpper: number,
+  whirlpoolProgramId: Address
+): Promise<WhirlpoolLiquidityDistribution> {
+  const datapoints: LiquidityDataPoint[] = [];
+
+  const tokenDecimalsA = poolData.tokenA.decimals;
+  const tokenDecimalsB = poolData.tokenB.decimals;
+
+  const tickArrayAddresses = await getSurroundingTickArrayAddresses(
+    poolAddress,
+    poolData,
+    tickLower,
+    tickUpper,
+    whirlpoolProgramId
+  );
+  const tickArrays = await TickArray.fetchMultiple(rpc, tickArrayAddresses, whirlpoolProgramId);
+
+  const currentLiquidity = new Decimal(poolData.liquidity.toString());
+  let relativeLiquidity = currentLiquidity;
+  let minLiquidity = new Decimal(0);
+  let liquidity = new Decimal(0);
+
+  tickArrays.forEach((tickArray) => {
+    if (!tickArray) {
+      return;
+    }
+
+    const startIndex = tickArray.startTickIndex;
+    tickArray.ticks.forEach((tick, index) => {
+      const tickIndex = startIndex + index * poolData.tickSpacing;
+      const price = tickIndexToPrice(tickIndex, tokenDecimalsA, tokenDecimalsB);
+      const liquidityNet = new Decimal(tick.liquidityNet.toString());
+      liquidity = liquidity.add(liquidityNet);
+      datapoints.push({ liquidity: new Decimal(liquidity), price: new Decimal(price), tickIndex });
+
+      minLiquidity = liquidity.lt(minLiquidity) ? liquidity : minLiquidity;
+
+      if (tickIndex === poolData.tickCurrentIndex) {
+        relativeLiquidity = relativeLiquidity.sub(liquidityNet);
+      }
+    });
+  });
+
+  if (!relativeLiquidity.eq(currentLiquidity)) {
+    minLiquidity = minLiquidity.add(relativeLiquidity);
+    datapoints.forEach((datapoint) => {
+      datapoint.liquidity = datapoint.liquidity.add(relativeLiquidity);
+    });
+  }
+
+  if (minLiquidity.lt(0)) {
+    datapoints.forEach((datapoint) => {
+      datapoint.liquidity = datapoint.liquidity.add(minLiquidity.neg());
+    });
+  }
+
+  return {
+    currentPrice: new Decimal(poolData.price),
+    currentTickIndex: poolData.tickCurrentIndex,
+    datapoints,
+  };
+}
+
+async function getSurroundingTickArrayAddresses(
+  poolAddress: Address,
+  pool: WhirlpoolAPIResponse,
+  tickLower: number,
+  tickUpper: number,
+  programId: Address
+): Promise<Address[]> {
+  const tickArrayAddresses: Address[] = [];
+
+  let startIndex = getTickArrayStartTickIndex(tickLower, pool.tickSpacing);
+  while (startIndex <= tickUpper) {
+    const [address, _bump] = await getTickArrayPda(programId, poolAddress, startIndex);
+    tickArrayAddresses.push(address);
+
+    try {
+      startIndex = getTickArrayStartTickIndex(startIndex, pool.tickSpacing);
+    } catch (_e) {
+      return tickArrayAddresses;
+    }
+  }
+  return tickArrayAddresses;
+}
+
+export async function getTickArrayPda(
+  programId: Address,
+  poolAddress: Address,
+  startIndex: number
+): Promise<[Address, number]> {
+  const pdaWithBump = await getProgramDerivedAddress({
+    seeds: [Buffer.from('tick_array'), addressEncoder.encode(poolAddress), Buffer.from(startIndex.toString())],
+    programAddress: programId,
+  });
+
+  return [pdaWithBump[0], pdaWithBump[1]];
+}

package/src/utils/tokenUtils.ts

@@ -1,6 +1,5 @@
 import { Address, IInstruction, address, TransactionSigner, Rpc, GetAccountInfoApi, Account } from '@solana/kit';
 import { WhirlpoolStrategy } from '../@codegen/kliquidity/accounts';
-import { tickIndexToPrice } from '@orca-so/whirlpool-sdk';
 import Decimal from 'decimal.js';
 import { CollateralInfo } from '../@codegen/kliquidity/types';
 import { getPriceOfBinByBinIdWithDecimals } from './meteora';
@@ -15,6 +14,7 @@ import {
 } from '@solana-program/token-2022';
 import { SYSTEM_PROGRAM_ADDRESS } from '@solana-program/system';
 import { getSetComputeUnitLimitInstruction } from '@solana-program/compute-budget';
+import { tickIndexToPrice } from '@orca-so/whirlpools-core';
 
 export const SOL_MINTS = [
   address('So11111111111111111111111111111111111111111'),
@@ -52,7 +52,7 @@ export async function getAssociatedTokenAddress(
 
 export function createAssociatedTokenAccountInstruction(
   payer: TransactionSigner,
-  associatedToken: Address,
+  associatedTokenAddress: Address,
   owner: Address,
   mint: Address,
   programId: Address = TOKEN_PROGRAM_ADDRESS,
@@ -62,7 +62,7 @@ export function createAssociatedTokenAccountInstruction(
     {
       mint,
       owner,
-      ata: associatedToken,
+      ata: associatedTokenAddress,
       payer: payer,
       tokenProgram: programId,
       systemProgram: SYSTEM_PROGRAM_ADDRESS,
@@ -99,9 +99,9 @@ export function getStrategyPriceRangeRaydium(
   tokenBDecimals: number
 ) {
   const { priceLower, priceUpper } = getPriceLowerUpper(tickLowerIndex, tickUpperIndex, tokenADecimals, tokenBDecimals);
-  const poolPrice = tickIndexToPrice(tickCurrent, tokenADecimals, tokenBDecimals);
+  const poolPrice = new Decimal(tickIndexToPrice(tickCurrent, tokenADecimals, tokenBDecimals));
   const strategyOutOfRange = poolPrice.lt(priceLower) || poolPrice.gt(priceUpper);
-  return { priceLower, poolPrice, priceUpper, strategyOutOfRange };
+  return { priceLower: new Decimal(priceLower), poolPrice, priceUpper: new Decimal(priceUpper), strategyOutOfRange };
 }
 
 export function getStrategyPriceRangeMeteora(

package/src/utils/types.ts

@@ -1,3 +1,5 @@
+import { BN } from '@coral-xyz/anchor';
+
 import { address, Address, IInstruction, TransactionMessage, TransactionSigner } from '@solana/kit';
 import { WhirlpoolStrategy } from '../@codegen/kliquidity/accounts';
 import { Dex, collToLamportsDecimal } from './utils';
@@ -310,3 +312,8 @@ export interface InitPoolTickIfNeeded {
   tick: Address;
   initTickIx: IInstruction | undefined;
 }
+
+export type Percentage = {
+  numerator: BN;
+  denominator: BN;
+};

package/src/utils/utils.ts

@@ -19,19 +19,17 @@ import {
 import { RebalanceFieldInfo, RebalanceFieldsDict } from './types';
 import BN from 'bn.js';
 import { PoolPriceReferenceType, TwapPriceReferenceType } from './priceReferenceTypes';
-import { sqrtPriceX64ToPrice } from '@orca-so/whirlpool-sdk';
 import { U64_MAX } from '../constants/numericalValues';
 import { SqrtPriceMath } from '@raydium-io/raydium-sdk-v2/lib/raydium/clmm/utils/math';
 import { DEFAULT_PUBLIC_KEY } from '../constants/pubkeys';
 import { SYSTEM_PROGRAM_ADDRESS } from '@solana-program/system';
+import { sqrtPriceToPrice as orcaSqrtPriceToPrice } from '@orca-so/whirlpools-core';
 
 export const DollarBasedMintingMethod = new Decimal(0);
 export const ProportionalMintingMethod = new Decimal(1);
 
 export const RebalanceParamOffset = new Decimal(256);
 
-export const ZERO_BN = new BN(0);
-
 export function sleep(ms: number) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
@@ -272,7 +270,7 @@ export function isVaultInitialized(vault: Address, decimals: BN): boolean {
 export function sqrtPriceToPrice(sqrtPrice: BN, dexNo: number, decimalsA: number, decimalsB: number): Decimal {
   const dex = numberToDex(dexNo);
   if (dex == 'ORCA') {
-    return sqrtPriceX64ToPrice(sqrtPrice, decimalsA, decimalsB);
+    return new Decimal(orcaSqrtPriceToPrice(BigInt(sqrtPrice.toString()), decimalsA, decimalsB));
   }
   if (dex == 'RAYDIUM') {
     return SqrtPriceMath.sqrtPriceX64ToPrice(sqrtPrice, decimalsA, decimalsB);

package/src/utils/whirlpools.ts

@@ -2,19 +2,13 @@
 /**
  * Added roundUp flag to accurately estimate token holdings for deposits
  */
-import { tickIndexToSqrtPriceX64 } from '@orca-so/whirlpool-client-sdk';
+
 import { BN } from '@coral-xyz/anchor';
 import { Address } from '@solana/kit';
-import {
-  adjustForSlippage,
-  getTokenAFromLiquidity,
-  getTokenBFromLiquidity,
-  Percentage,
-  PositionStatus,
-  PositionUtil,
-  RemoveLiquidityQuote,
-} from '@orca-so/whirlpool-sdk';
-import { ZERO_BN } from './utils';
+import { positionStatus, tickIndexToSqrtPrice } from '@orca-so/whirlpools-core';
+import { ZERO_BN } from '../constants/numericalValues';
+import { adjustForSlippage, getTokenAFromLiquidity, getTokenBFromLiquidity } from './orca';
+import { Percentage } from './types';
 
 export type InternalRemoveLiquidityQuoteParam = {
   positionAddress: Address;
@@ -30,21 +24,17 @@ export function getRemoveLiquidityQuote(
   param: InternalRemoveLiquidityQuoteParam,
   roundUp: boolean = false
 ): RemoveLiquidityQuote {
-  const positionStatus = PositionUtil.getPositionStatus(
-    param.tickCurrentIndex,
-    param.tickLowerIndex,
-    param.tickUpperIndex
-  );
+  const posStatus = positionStatus(BigInt(param.sqrtPrice.toString()), param.tickLowerIndex, param.tickUpperIndex);
 
-  switch (positionStatus) {
-    case PositionStatus.BelowRange:
+  switch (posStatus) {
+    case 'priceBelowRange':
       return getRemoveLiquidityQuoteWhenPositionIsBelowRange(param, roundUp);
-    case PositionStatus.InRange:
+    case 'priceInRange':
       return getRemoveLiquidityQuoteWhenPositionIsInRange(param, roundUp);
-    case PositionStatus.AboveRange:
+    case 'priceAboveRange':
       return getRemoveLiquidityQuoteWhenPositionIsAboveRange(param, roundUp);
     default:
-      throw new Error(`type ${positionStatus} is an unknown PositionStatus`);
+      throw new Error(`type ${posStatus} is an unknown PositionStatus`);
   }
 }
 
@@ -54,10 +44,15 @@ function getRemoveLiquidityQuoteWhenPositionIsBelowRange(
 ): RemoveLiquidityQuote {
   const { positionAddress, tickLowerIndex, tickUpperIndex, liquidity, slippageTolerance } = param;
 
-  const sqrtPriceLowerX64 = tickIndexToSqrtPriceX64(tickLowerIndex);
-  const sqrtPriceUpperX64 = tickIndexToSqrtPriceX64(tickUpperIndex);
+  const sqrtPriceLowerX64 = tickIndexToSqrtPrice(tickLowerIndex);
+  const sqrtPriceUpperX64 = tickIndexToSqrtPrice(tickUpperIndex);
 
-  const estTokenA = getTokenAFromLiquidity(liquidity, sqrtPriceLowerX64, sqrtPriceUpperX64, roundUp);
+  const estTokenA = getTokenAFromLiquidity(
+    liquidity,
+    new BN(sqrtPriceLowerX64.toString()),
+    new BN(sqrtPriceUpperX64.toString()),
+    roundUp
+  );
   const minTokenA = adjustForSlippage(estTokenA, slippageTolerance, roundUp);
 
   return {
@@ -77,13 +72,23 @@ function getRemoveLiquidityQuoteWhenPositionIsInRange(
   const { positionAddress, sqrtPrice, tickLowerIndex, tickUpperIndex, liquidity, slippageTolerance } = param;
 
   const sqrtPriceX64 = sqrtPrice;
-  const sqrtPriceLowerX64 = tickIndexToSqrtPriceX64(tickLowerIndex);
-  const sqrtPriceUpperX64 = tickIndexToSqrtPriceX64(tickUpperIndex);
+  const sqrtPriceLowerX64 = tickIndexToSqrtPrice(tickLowerIndex);
+  const sqrtPriceUpperX64 = tickIndexToSqrtPrice(tickUpperIndex);
 
-  const estTokenA = getTokenAFromLiquidity(liquidity, sqrtPriceX64, sqrtPriceUpperX64, roundUp);
+  const estTokenA = getTokenAFromLiquidity(
+    liquidity,
+    new BN(sqrtPriceX64.toString()),
+    new BN(sqrtPriceUpperX64.toString()),
+    roundUp
+  );
   const minTokenA = adjustForSlippage(estTokenA, slippageTolerance, roundUp);
 
-  const estTokenB = getTokenBFromLiquidity(liquidity, sqrtPriceLowerX64, sqrtPriceX64, roundUp);
+  const estTokenB = getTokenBFromLiquidity(
+    liquidity,
+    new BN(sqrtPriceLowerX64.toString()),
+    new BN(sqrtPriceX64.toString()),
+    roundUp
+  );
   const minTokenB = adjustForSlippage(estTokenB, slippageTolerance, roundUp);
 
   return {
@@ -102,10 +107,15 @@ function getRemoveLiquidityQuoteWhenPositionIsAboveRange(
 ): RemoveLiquidityQuote {
   const { positionAddress, tickLowerIndex, tickUpperIndex, liquidity, slippageTolerance: slippageTolerance } = param;
 
-  const sqrtPriceLowerX64 = tickIndexToSqrtPriceX64(tickLowerIndex);
-  const sqrtPriceUpperX64 = tickIndexToSqrtPriceX64(tickUpperIndex);
+  const sqrtPriceLowerX64 = tickIndexToSqrtPrice(tickLowerIndex);
+  const sqrtPriceUpperX64 = tickIndexToSqrtPrice(tickUpperIndex);
 
-  const estTokenB = getTokenBFromLiquidity(liquidity, sqrtPriceLowerX64, sqrtPriceUpperX64, roundUp);
+  const estTokenB = getTokenBFromLiquidity(
+    liquidity,
+    new BN(sqrtPriceLowerX64.toString()),
+    new BN(sqrtPriceUpperX64.toString()),
+    roundUp
+  );
   const minTokenB = adjustForSlippage(estTokenB, slippageTolerance, roundUp);
 
   return {
@@ -117,3 +127,12 @@ function getRemoveLiquidityQuoteWhenPositionIsAboveRange(
     liquidity,
   };
 }
+
+export type RemoveLiquidityQuote = {
+  positionAddress: Address;
+  minTokenA: BN;
+  minTokenB: BN;
+  estTokenA: BN;
+  estTokenB: BN;
+  liquidity: BN;
+};