@meteora-ag/cp-amm-sdk 1.0.1-rc.32 → 1.0.1-rc.34

package/dist/index.mjs

@@ -21,7 +21,7 @@ var __async = (__this, __arguments, generator) => {
 };
 
 // src/CpAmm.ts
-import { Program, BN as BN9 } from "@coral-xyz/anchor";
+import { Program, BN as BN10 } from "@coral-xyz/anchor";
 import { NATIVE_MINT as NATIVE_MINT2, TOKEN_2022_PROGRAM_ID as TOKEN_2022_PROGRAM_ID2 } from "@solana/spl-token";
 import invariant from "invariant";
 
@@ -6371,10 +6371,10 @@ var FeeSchedulerMode = /* @__PURE__ */ ((FeeSchedulerMode2) => {
   FeeSchedulerMode2[FeeSchedulerMode2["Exponential"] = 1] = "Exponential";
   return FeeSchedulerMode2;
 })(FeeSchedulerMode || {});
-var CollectFeeMode = /* @__PURE__ */ ((CollectFeeMode3) => {
-  CollectFeeMode3[CollectFeeMode3["BothToken"] = 0] = "BothToken";
-  CollectFeeMode3[CollectFeeMode3["OnlyB"] = 1] = "OnlyB";
-  return CollectFeeMode3;
+var CollectFeeMode = /* @__PURE__ */ ((CollectFeeMode2) => {
+  CollectFeeMode2[CollectFeeMode2["BothToken"] = 0] = "BothToken";
+  CollectFeeMode2[CollectFeeMode2["OnlyB"] = 1] = "OnlyB";
+  return CollectFeeMode2;
 })(CollectFeeMode || {});
 var TradeDirection = /* @__PURE__ */ ((TradeDirection2) => {
   TradeDirection2[TradeDirection2["AtoB"] = 0] = "AtoB";
@@ -6745,14 +6745,6 @@ function pow(base, exp) {
 // src/math/mathUtils.ts
 import { BN as BN3 } from "@coral-xyz/anchor";
 import Decimal from "decimal.js";
-function mulShr(x, y, offset, rounding) {
-  const denominator = new BN3(1).shln(offset);
-  return mulDiv(x, y, denominator, rounding);
-}
-function shlDiv(x, y, offset, rounding) {
-  const scale = new BN3(1).shln(offset);
-  return mulDiv(x, scale, y, rounding);
-}
 function mulDiv(x, y, denominator, rounding) {
   const { div, mod } = x.mul(y).divmod(denominator);
   if (rounding == 0 /* Up */ && !mod.isZero()) {
@@ -6775,7 +6767,6 @@ function decimalToQ64(num) {
 
 // src/helpers/curve.ts
 import { BN as BN4 } from "@coral-xyz/anchor";
-import Decimal2 from "decimal.js";
 function getNextSqrtPrice(amount, sqrtPrice, liquidity, aToB) {
   let result;
   if (aToB) {
@@ -6788,65 +6779,35 @@ function getNextSqrtPrice(amount, sqrtPrice, liquidity, aToB) {
   }
   return result;
 }
-function getDeltaAmountA(lowerSqrtPrice, upperSqrtPrice, liquidity, rounding) {
-  const deltaSqrtPrice = upperSqrtPrice.sub(lowerSqrtPrice);
-  const prod = liquidity.mul(deltaSqrtPrice);
-  const denominator = lowerSqrtPrice.mul(upperSqrtPrice);
-  const result = shlDiv(prod, denominator, SCALE_OFFSET, rounding);
-  return result.shrn(SCALE_OFFSET);
+function getLiquidityDeltaFromAmountA(amountA, lowerSqrtPrice, upperSqrtPrice) {
+  const product = amountA.mul(lowerSqrtPrice).mul(upperSqrtPrice);
+  const denominator = upperSqrtPrice.sub(lowerSqrtPrice);
+  return product.div(denominator);
 }
-function getDeltaAmountB(lowerSqrtPrice, upperSqrtPrice, liquidity, rounding) {
-  const deltaSqrtPrice = upperSqrtPrice.sub(lowerSqrtPrice);
-  const prod = liquidity.mul(deltaSqrtPrice);
-  let result;
-  if (rounding == 0 /* Up */) {
-    const denominator = new BN4(1).shln(SCALE_OFFSET * 2);
-    result = divCeil(prod, denominator);
-  } else {
-    result = prod.shrn(SCALE_OFFSET * 2);
-  }
-  return result;
-}
-function getLiquidityDeltaFromAmountA(maxAmountA, lowerSqrtPrice, upperSqrtPrice) {
-  const prod = new Decimal2(
-    maxAmountA.mul(upperSqrtPrice.mul(lowerSqrtPrice)).toString()
-  );
-  const delta = new Decimal2(upperSqrtPrice.sub(lowerSqrtPrice).toString());
-  return new BN4(prod.div(delta).floor().toFixed());
-}
-function getLiquidityDeltaFromAmountB(maxAmountB, lowerSqrtPrice, upperSqrtPrice) {
-  const denominator = new Decimal2(
-    upperSqrtPrice.sub(lowerSqrtPrice).toString()
-  );
-  const prod = new Decimal2(maxAmountB.toString()).mul(
-    Decimal2.pow(2, SCALE_OFFSET * 2)
-  );
-  return new BN4(prod.div(denominator).floor().toFixed());
+function getLiquidityDeltaFromAmountB(amountB, lowerSqrtPrice, upperSqrtPrice) {
+  const denominator = upperSqrtPrice.sub(lowerSqrtPrice);
+  const product = amountB.shln(128);
+  return product.div(denominator);
 }
 function getAmountAFromLiquidityDelta(liquidity, currentSqrtPrice, maxSqrtPrice, rounding) {
-  const prod = new Decimal2(liquidity.toString()).mul(
-    new Decimal2(maxSqrtPrice.sub(currentSqrtPrice).toString())
-  );
+  const product = liquidity.mul(maxSqrtPrice.sub(currentSqrtPrice));
   const denominator = currentSqrtPrice.mul(maxSqrtPrice);
-  const result = prod.mul(Decimal2.pow(2, 64)).div(new Decimal2(denominator.toString()));
   if (rounding == 0 /* Up */) {
-    return result.div(Decimal2.pow(2, 64)).ceil().toFixed();
+    return product.add(denominator.sub(new BN4(1))).div(denominator);
   }
-  return result.div(Decimal2.pow(2, 64)).floor().toFixed();
+  return product.div(denominator);
 }
 function getAmountBFromLiquidityDelta(liquidity, currentSqrtPrice, minSqrtPrice, rounding) {
-  const delta = currentSqrtPrice.sub(minSqrtPrice);
-  const prod = new Decimal2(liquidity.toString()).mul(
-    new Decimal2(delta.toString())
-  );
+  const one = new BN4(1).shln(128);
+  const deltaPrice = currentSqrtPrice.sub(minSqrtPrice);
+  const result = liquidity.mul(deltaPrice);
   if (rounding == 0 /* Up */) {
-    return prod.div(Decimal2.pow(2, 128)).ceil().toFixed();
+    return result.add(one.sub(new BN4(1))).div(one);
   }
-  return prod.div(Decimal2.pow(2, 128)).floor().toFixed();
+  return result.shrn(128);
 }
 
 // src/helpers/fee.ts
-import Decimal3 from "decimal.js";
 function getBaseFeeNumerator(feeSchedulerMode, cliffFeeNumerator, period, reductionFactor) {
   let feeNumerator;
   if (feeSchedulerMode == 0 /* Linear */) {
@@ -6860,14 +6821,12 @@ function getBaseFeeNumerator(feeSchedulerMode, cliffFeeNumerator, period, reduct
   return feeNumerator;
 }
 function getDynamicFeeNumerator(volatilityAccumulator, binStep, variableFeeControl) {
-  const volatilityAccumulatorDecimal = new Decimal3(
-    volatilityAccumulator.toString()
-  ).div(Decimal3.pow(2, 64));
-  const squareVfaBin = volatilityAccumulatorDecimal.mul(new Decimal3(binStep.toString())).pow(2);
-  const vFee = squareVfaBin.mul(new Decimal3(variableFeeControl.toString()));
-  return new BN5(
-    vFee.add(99999999999).div(1e11).floor().toFixed()
-  );
+  if (variableFeeControl.isZero()) {
+    return new BN5(0);
+  }
+  const squareVfaBin = volatilityAccumulator.mul(new BN5(binStep)).pow(new BN5(2));
+  const vFee = variableFeeControl.mul(squareVfaBin);
+  return vFee.add(new BN5(99999999999)).div(new BN5(1e11));
 }
 function getFeeNumerator(currentPoint, activationPoint, numberOfPeriod, periodFrequency, feeSchedulerMode, cliffFeeNumerator, reductionFactor, dynamicFeeParams) {
   if (Number(periodFrequency) == 0) {
@@ -6918,12 +6877,12 @@ function getSwapAmount(inAmount, sqrtPrice, liquidity, tradeFeeNumerator, aToB,
     totalFee = getTotalFeeOnAmount(inAmount, tradeFeeNumerator);
     actualInAmount = inAmount.sub(totalFee);
   }
-  const outAmount = aToB ? getDeltaAmountB(
+  const outAmount = aToB ? getAmountBFromLiquidityDelta(
     getNextSqrtPrice(actualInAmount, sqrtPrice, liquidity, true),
     sqrtPrice,
     liquidity,
     1 /* Down */
-  ) : getDeltaAmountA(
+  ) : getAmountBFromLiquidityDelta(
     sqrtPrice,
     getNextSqrtPrice(actualInAmount, sqrtPrice, liquidity, false),
     liquidity,
@@ -7010,7 +6969,7 @@ var getEstimatedComputeUnitIxWithBuffer = (connection, instructions, feePayer, b
 
 // src/helpers/utils.ts
 import { BN as BN6 } from "@coral-xyz/anchor";
-import Decimal4 from "decimal.js";
+import Decimal2 from "decimal.js";
 var getMaxAmountWithSlippage = (amount, rate) => {
   const slippage = (100 + rate) / 100 * BASIS_POINT_MAX;
   return amount.mul(new BN6(slippage)).div(new BN6(BASIS_POINT_MAX));
@@ -7021,20 +6980,20 @@ var getMinAmountWithSlippage = (amount, rate) => {
 };
 var getPriceImpact = (actualAmount, idealAmount) => {
   const diff = idealAmount.sub(actualAmount);
-  return new Decimal4(diff.toString()).div(new Decimal4(idealAmount.toString())).mul(100).toNumber();
+  return new Decimal2(diff.toString()).div(new Decimal2(idealAmount.toString())).mul(100).toNumber();
 };
 var getPriceFromSqrtPrice = (sqrtPrice, tokenADecimal, tokenBDecimal) => {
-  const decimalSqrtPrice = new Decimal4(sqrtPrice.toString());
-  const price = decimalSqrtPrice.mul(decimalSqrtPrice).mul(new Decimal4(__pow(10, tokenADecimal - tokenBDecimal))).div(Decimal4.pow(2, 128)).toString();
+  const decimalSqrtPrice = new Decimal2(sqrtPrice.toString());
+  const price = decimalSqrtPrice.mul(decimalSqrtPrice).mul(new Decimal2(__pow(10, tokenADecimal - tokenBDecimal))).div(Decimal2.pow(2, 128)).toString();
   return price;
 };
 var getSqrtPriceFromPrice = (price, tokenADecimal, tokenBDecimal) => {
-  const decimalPrice = new Decimal4(price);
+  const decimalPrice = new Decimal2(price);
   const adjustedByDecimals = decimalPrice.div(
-    new Decimal4(__pow(10, tokenADecimal - tokenBDecimal))
+    new Decimal2(__pow(10, tokenADecimal - tokenBDecimal))
   );
-  const sqrtValue = Decimal4.sqrt(adjustedByDecimals);
-  const sqrtValueQ64 = sqrtValue.mul(Decimal4.pow(2, 64));
+  const sqrtValue = Decimal2.sqrt(adjustedByDecimals);
+  const sqrtValueQ64 = sqrtValue.mul(Decimal2.pow(2, 64));
   return new BN6(sqrtValueQ64.floor().toFixed());
 };
 var getUnClaimReward = (poolState, positionState) => {
@@ -7074,28 +7033,28 @@ var vestingByPositionFilter = (position) => {
 
 // src/helpers/priceMath.ts
 import { BN as BN7 } from "@coral-xyz/anchor";
-import Decimal5 from "decimal.js";
+import Decimal3 from "decimal.js";
 function calculateInitSqrtPrice(tokenAAmount, tokenBAmount, minSqrtPrice, maxSqrtPrice) {
   if (tokenAAmount.isZero() || tokenBAmount.isZero()) {
     throw new Error("Amount cannot be zero");
   }
-  const amountADecimal = new Decimal5(tokenAAmount.toString());
-  const amountBDecimal = new Decimal5(tokenBAmount.toString());
-  const minSqrtPriceDecimal = new Decimal5(minSqrtPrice.toString()).div(
-    Decimal5.pow(2, 64)
+  const amountADecimal = new Decimal3(tokenAAmount.toString());
+  const amountBDecimal = new Decimal3(tokenBAmount.toString());
+  const minSqrtPriceDecimal = new Decimal3(minSqrtPrice.toString()).div(
+    Decimal3.pow(2, 64)
   );
-  const maxSqrtPriceDecimal = new Decimal5(maxSqrtPrice.toString()).div(
-    Decimal5.pow(2, 64)
+  const maxSqrtPriceDecimal = new Decimal3(maxSqrtPrice.toString()).div(
+    Decimal3.pow(2, 64)
   );
-  const x = new Decimal5(1).div(maxSqrtPriceDecimal);
+  const x = new Decimal3(1).div(maxSqrtPriceDecimal);
   const y = amountBDecimal.div(amountADecimal);
   const xy = x.mul(y);
   const paMinusXY = minSqrtPriceDecimal.sub(xy);
   const xyMinusPa = xy.sub(minSqrtPriceDecimal);
-  const fourY = new Decimal5(4).mul(y);
+  const fourY = new Decimal3(4).mul(y);
   const discriminant = xyMinusPa.mul(xyMinusPa).add(fourY);
   const sqrtDiscriminant = discriminant.sqrt();
-  const result = paMinusXY.add(sqrtDiscriminant).div(new Decimal5(2)).mul(Decimal5.pow(2, 64));
+  const result = paMinusXY.add(sqrtDiscriminant).div(new Decimal3(2)).mul(Decimal3.pow(2, 64));
   return new BN7(result.floor().toFixed());
 }
 
@@ -7181,8 +7140,49 @@ function calculateTransferFeeExcludedAmount(transferFeeIncludedAmount, mint, cur
   };
 }
 
-// src/CpAmm.ts
+// src/helpers/vestings.ts
+import { BN as BN9 } from "@coral-xyz/anchor";
 import { min } from "bn.js";
+function isVestingComplete(vestingData, currentPoint) {
+  const cliffPoint = vestingData.cliffPoint;
+  const periodFrequency = vestingData.periodFrequency;
+  const numberOfPeriods = vestingData.numberOfPeriod;
+  const endPoint = cliffPoint.add(periodFrequency.muln(numberOfPeriods));
+  return currentPoint.gte(endPoint);
+}
+function getTotalLockedLiquidity(vestingData) {
+  return vestingData.cliffUnlockLiquidity.add(
+    vestingData.liquidityPerPeriod.mul(new BN9(vestingData.numberOfPeriod))
+  );
+}
+function getAvailableVestingLiquidity(vestingData, currentPoint) {
+  const {
+    cliffPoint,
+    periodFrequency,
+    cliffUnlockLiquidity,
+    liquidityPerPeriod,
+    numberOfPeriod,
+    totalReleasedLiquidity
+  } = vestingData;
+  if (currentPoint < cliffPoint) {
+    return new BN9(0);
+  }
+  if (periodFrequency.isZero()) {
+    return cliffUnlockLiquidity.sub(totalReleasedLiquidity);
+  }
+  let passedPeriod = new BN9(currentPoint).sub(cliffPoint).div(periodFrequency);
+  passedPeriod = min(passedPeriod, new BN9(numberOfPeriod));
+  const unlockedLiquidity = cliffUnlockLiquidity.add(
+    passedPeriod.mul(liquidityPerPeriod)
+  );
+  const availableReleasingLiquidity = unlockedLiquidity.sub(
+    totalReleasedLiquidity
+  );
+  return availableReleasingLiquidity;
+}
+
+// src/CpAmm.ts
+import { min as min2 } from "bn.js";
 var CpAmm = class {
   constructor(connection) {
     this._program = new Program(cp_amm_default, {
@@ -7412,6 +7412,33 @@ var CpAmm = class {
       }).instruction();
     });
   }
+  /**
+   * Builds an instruction to refresh vesting for a position
+   * @param params Parameters required for the refresh vesting instruction
+   * @returns Transaction instruction or null if no vestings to refresh
+   */
+  buildRefreshVestingInstruction(params) {
+    return __async(this, null, function* () {
+      const { owner, position, positionNftAccount, pool, vestingAccounts } = params;
+      if (vestingAccounts.length == 0) {
+        return null;
+      }
+      return yield this._program.methods.refreshVesting().accountsPartial({
+        position,
+        positionNftAccount,
+        pool,
+        owner
+      }).remainingAccounts(
+        vestingAccounts.map((pubkey) => {
+          return {
+            isSigner: false,
+            isWritable: true,
+            pubkey
+          };
+        })
+      ).instruction();
+    });
+  }
   /**
    * Fetches the Config state of the program.
    * @param config - Public key of the config account.
@@ -7559,6 +7586,44 @@ var CpAmm = class {
     );
     return totalLockedLiquidity.gtn(0);
   }
+  isPermanentLockedPosition(positionState) {
+    return positionState.permanentLockedLiquidity.gtn(0);
+  }
+  /**
+   * Checks if a position can be unlocked based on its locking state and vesting schedules.
+   *
+   * This method evaluates whether a position is eligible for operations that require
+   * unlocked liquidity, such as removing all liquidity or closing the position. It checks both
+   * permanent locks and time-based vesting schedules.
+   *
+   * @private
+   * @param {PositionState} positionState - The current state of the position
+   * @param {Array<{account: PublicKey; vestingState: VestingState}>} vestings - Array of vesting accounts and their states
+   * @param {BN} currentPoint - Current timestamp or slot number (depending on activation type of pool)
+   *
+   * @returns {Object} Result object containing unlock status and reason
+   * @returns {boolean} result.canUnlock - Whether the position can be unlocked
+   * @returns {string|undefined} result.reason - Reason why position cannot be unlocked (if applicable)
+   */
+  canUnlockPosition(positionState, vestings, currentPoint) {
+    if (vestings.length > 0) {
+      if (this.isPermanentLockedPosition(positionState)) {
+        return {
+          canUnlock: false,
+          reason: "Position is permanently locked"
+        };
+      }
+      for (const vesting of vestings) {
+        if (!isVestingComplete(vesting.vestingState, currentPoint)) {
+          return {
+            canUnlock: false,
+            reason: "Position has incomplete vesting schedule"
+          };
+        }
+      }
+    }
+    return { canUnlock: true };
+  }
   isPoolExist(pool) {
     return __async(this, null, function* () {
       const poolState = yield this._program.account.pool.fetchNullable(pool);
@@ -7631,22 +7696,25 @@ var CpAmm = class {
         aToB,
         collectFeeMode
       );
-      let actualAmoutOut = amountOut;
+      let actualAmountOut = amountOut;
       if (outputTokenInfo) {
-        actualAmoutOut = calculateTransferFeeExcludedAmount(
+        actualAmountOut = calculateTransferFeeExcludedAmount(
           amountOut,
           outputTokenInfo.mint,
           outputTokenInfo.currentEpoch
         ).amount;
       }
-      const minSwapOutAmount = getMinAmountWithSlippage(actualAmoutOut, slippage);
+      const minSwapOutAmount = getMinAmountWithSlippage(
+        actualAmountOut,
+        slippage
+      );
       return {
         swapInAmount: inAmount,
         consumedInAmount: actualAmountIn,
-        swapOutAmount: actualAmoutOut,
+        swapOutAmount: actualAmountOut,
         minSwapOutAmount,
         totalFee,
-        priceImpact: getPriceImpact(minSwapOutAmount, actualAmoutOut)
+        priceImpact: getPriceImpact(minSwapOutAmount, actualAmountOut)
       };
     });
   }
@@ -7703,7 +7771,7 @@ var CpAmm = class {
           0 /* Up */
         )
       };
-      const rawOutputAmount = new BN9(rawAmount(liquidityDelta));
+      const rawOutputAmount = new BN10(rawAmount(liquidityDelta));
       const outputAmount = outputTokenInfo ? calculateTransferFeeIncludedAmount(
         rawOutputAmount,
         outputTokenInfo.mint,
@@ -7755,15 +7823,15 @@ var CpAmm = class {
       return {
         liquidityDelta,
         outAmountA: tokenATokenInfo ? calculateTransferFeeExcludedAmount(
-          new BN9(amountA),
+          amountA,
           tokenATokenInfo.mint,
           tokenATokenInfo.currentEpoch
-        ).amount : new BN9(amountA),
+        ).amount : amountA,
         outAmountB: tokenBTokenInfo ? calculateTransferFeeExcludedAmount(
-          new BN9(amountB),
+          amountB,
           tokenBTokenInfo.mint,
           tokenBTokenInfo.currentEpoch
-        ).amount : new BN9(amountB)
+        ).amount : amountB
       };
     });
   }
@@ -7813,7 +7881,7 @@ var CpAmm = class {
       tokenAInfo,
       tokenBInfo
     } = params;
-    if (tokenAAmount.eq(new BN9(0)) && tokenBAmount.eq(new BN9(0))) {
+    if (tokenAAmount.eq(new BN10(0)) && tokenBAmount.eq(new BN10(0))) {
       throw new Error("Invalid input amount");
     }
     const actualAmountAIn = tokenAInfo ? tokenAAmount.sub(
@@ -7823,13 +7891,13 @@ var CpAmm = class {
         tokenAInfo.currentEpoch
       ).transferFee
     ) : tokenAAmount;
-    const actualAmountBIn = tokenBInfo ? tokenAAmount.sub(
+    const actualAmountBIn = tokenBInfo ? tokenBAmount.sub(
       calculateTransferFeeIncludedAmount(
         tokenBAmount,
         tokenBInfo.mint,
         tokenBInfo.currentEpoch
       ).transferFee
-    ) : tokenAAmount;
+    ) : tokenBAmount;
     const initSqrtPrice = calculateInitSqrtPrice(
       tokenAAmount,
       tokenBAmount,
@@ -7846,7 +7914,7 @@ var CpAmm = class {
       minSqrtPrice,
       initSqrtPrice
     );
-    const liquidityDelta = min(
+    const liquidityDelta = min2(
       liquidityDeltaFromAmountA,
       liquidityDeltaFromAmountB
     );
@@ -8162,7 +8230,8 @@ var CpAmm = class {
         tokenAVault,
         tokenBVault,
         tokenAProgram,
-        tokenBProgram
+        tokenBProgram,
+        vestings
       } = params;
       const {
         tokenAAta: tokenAAccount,
@@ -8182,6 +8251,16 @@ var CpAmm = class {
         const closeWrappedSOLIx = yield unwrapSOLInstruction(owner);
         closeWrappedSOLIx && postInstructions.push(closeWrappedSOLIx);
       }
+      if (vestings.length > 0) {
+        const refreshVestingInstruction = yield this.buildRefreshVestingInstruction({
+          owner,
+          position,
+          positionNftAccount,
+          pool,
+          vestingAccounts: vestings.map((item) => item.account)
+        });
+        refreshVestingInstruction && preInstructions.push(refreshVestingInstruction);
+      }
       return yield this._program.methods.removeLiquidity({
         liquidityDelta,
         tokenAAmountThreshold,
@@ -8222,7 +8301,8 @@ var CpAmm = class {
         tokenAVault,
         tokenBVault,
         tokenAProgram,
-        tokenBProgram
+        tokenBProgram,
+        vestings
       } = params;
       const {
         tokenAAta: tokenAAccount,
@@ -8242,6 +8322,16 @@ var CpAmm = class {
         const closeWrappedSOLIx = yield unwrapSOLInstruction(owner);
         closeWrappedSOLIx && postInstructions.push(closeWrappedSOLIx);
       }
+      if (vestings.length > 0) {
+        const refreshVestingInstruction = yield this.buildRefreshVestingInstruction({
+          owner,
+          position,
+          positionNftAccount,
+          pool,
+          vestingAccounts: vestings.map((item) => item.account)
+        });
+        refreshVestingInstruction && preInstructions.push(refreshVestingInstruction);
+      }
       const removeAllLiquidityInstruction = yield this.buildRemoveAllLiquidityInstruction({
         poolAuthority: this.poolAuthority,
         owner,
@@ -8399,21 +8489,8 @@ var CpAmm = class {
    */
   refreshVesting(params) {
     return __async(this, null, function* () {
-      const { owner, position, positionNftAccount, pool, vestings } = params;
-      return yield this._program.methods.refreshVesting().accountsPartial({
-        position,
-        positionNftAccount,
-        pool,
-        owner
-      }).remainingAccounts(
-        vestings.map((pubkey) => {
-          return {
-            isSigner: false,
-            isWritable: true,
-            pubkey
-          };
-        })
-      ).transaction();
+      const instruction = yield this.buildRefreshVestingInstruction(params);
+      return new Transaction().add(instruction);
     });
   }
   /**
@@ -8511,13 +8588,19 @@ var CpAmm = class {
         positionState,
         poolState,
         tokenAAmountThreshold,
-        tokenBAmountThreshold
+        tokenBAmountThreshold,
+        vestings,
+        currentPoint
       } = params;
       const { nftMint: positionNftMint, pool } = positionState;
       const { tokenAMint, tokenBMint, tokenAVault, tokenBVault } = poolState;
-      const isLockedPosition = this.isLockedPosition(positionState);
-      if (isLockedPosition) {
-        throw Error("position must be unlocked");
+      const { canUnlock, reason } = this.canUnlockPosition(
+        positionState,
+        vestings,
+        currentPoint
+      );
+      if (!canUnlock) {
+        throw new Error(`Cannot remove liquidity: ${reason}`);
       }
       const tokenAProgram = getTokenProgram(poolState.tokenAFlag);
       const tokenBProgram = getTokenProgram(poolState.tokenBFlag);
@@ -8539,6 +8622,16 @@ var CpAmm = class {
         const closeWrappedSOLIx = yield unwrapSOLInstruction(owner);
         closeWrappedSOLIx && postInstructions.push(closeWrappedSOLIx);
       }
+      if (vestings.length > 0) {
+        const refreshVestingInstruction = yield this.buildRefreshVestingInstruction({
+          owner,
+          position,
+          positionNftAccount,
+          pool,
+          vestingAccounts: vestings.map((item) => item.account)
+        });
+        refreshVestingInstruction && preInstructions.push(refreshVestingInstruction);
+      }
       const transaction = new Transaction();
       if (preInstructions.length > 0) {
         transaction.add(...preInstructions);
@@ -8617,13 +8710,19 @@ var CpAmm = class {
         tokenAAmountAddLiquidityThreshold,
         tokenBAmountAddLiquidityThreshold,
         tokenAAmountRemoveLiquidityThreshold,
-        tokenBAmountRemoveLiquidityThreshold
+        tokenBAmountRemoveLiquidityThreshold,
+        positionBVestings,
+        currentPoint
       } = params;
-      const isLockedPosition = this.isLockedPosition(positionBState);
-      if (isLockedPosition) {
-        throw Error("position must be unlocked");
+      const { canUnlock, reason } = this.canUnlockPosition(
+        positionBState,
+        positionBVestings,
+        currentPoint
+      );
+      if (!canUnlock) {
+        throw new Error(`Cannot remove liquidity: ${reason}`);
       }
-      const postionBLiquidityDelta = positionBState.unlockedLiquidity;
+      const positionBLiquidityDelta = positionBState.unlockedLiquidity;
       const pool = positionBState.pool;
       const { tokenAMint, tokenBMint, tokenAVault, tokenBVault } = poolState;
       const tokenAProgram = getTokenProgram(poolState.tokenAFlag);
@@ -8646,6 +8745,16 @@ var CpAmm = class {
         const closeWrappedSOLIx = yield unwrapSOLInstruction(owner);
         closeWrappedSOLIx && postInstructions.push(closeWrappedSOLIx);
       }
+      if (positionBVestings.length > 0) {
+        const refreshVestingInstruction = yield this.buildRefreshVestingInstruction({
+          owner,
+          position: positionB,
+          positionNftAccount: positionBNftAccount,
+          pool,
+          vestingAccounts: positionBVestings.map((item) => item.account)
+        });
+        refreshVestingInstruction && preInstructions.push(refreshVestingInstruction);
+      }
       const transaction = new Transaction();
       if (preInstructions.length > 0) {
         transaction.add(...preInstructions);
@@ -8697,7 +8806,7 @@ var CpAmm = class {
         tokenBVault,
         tokenAProgram,
         tokenBProgram,
-        liquidityDelta: postionBLiquidityDelta,
+        liquidityDelta: positionBLiquidityDelta,
         tokenAAmountThreshold: tokenAAmountAddLiquidityThreshold,
         tokenBAmountThreshold: tokenBAmountAddLiquidityThreshold
       });
@@ -8965,9 +9074,8 @@ export {
   getAllUserPositionNftAccount,
   getAmountAFromLiquidityDelta,
   getAmountBFromLiquidityDelta,
+  getAvailableVestingLiquidity,
   getBaseFeeNumerator,
-  getDeltaAmountA,
-  getDeltaAmountB,
   getDynamicFeeNumerator,
   getEstimatedComputeUnitIxWithBuffer,
   getEstimatedComputeUnitUsageWithBuffer,
@@ -8988,13 +9096,13 @@ export {
   getSwapAmount,
   getTokenDecimals,
   getTokenProgram,
+  getTotalLockedLiquidity,
   getUnClaimReward,
+  isVestingComplete,
   mulDiv,
-  mulShr,
   positionByPoolFilter,
   pow,
   q64ToDecimal,
-  shlDiv,
   unwrapSOLInstruction,
   vestingByPositionFilter,
   wrapSOLInstruction