@meteora-ag/cp-amm-sdk 1.0.1-rc.33 → 1.0.1-rc.35

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";
 
@@ -7140,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, {
@@ -7371,6 +7412,103 @@ 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();
+    });
+  }
+  /**
+   * Helper function that builds instructions to claim fees, remove liquidity, and close a position
+   * @param {BuildLiquidatePositionInstructionParams} params - Parameters for liquidating a position
+   * @returns {Promise<TransactionInstruction[]>} Array of instructions
+   * @private
+   */
+  buildLiquidatePositionInstruction(params) {
+    return __async(this, null, function* () {
+      const {
+        owner,
+        position,
+        positionNftAccount,
+        positionState,
+        poolState,
+        tokenAAccount,
+        tokenBAccount,
+        tokenAAmountThreshold,
+        tokenBAmountThreshold
+      } = params;
+      const { nftMint: positionNftMint, pool } = positionState;
+      const { tokenAMint, tokenBMint, tokenAVault, tokenBVault } = poolState;
+      const tokenAProgram = getTokenProgram(poolState.tokenAFlag);
+      const tokenBProgram = getTokenProgram(poolState.tokenBFlag);
+      const instructions = [];
+      const claimPositionFeeInstruction = yield this.buildClaimPositionFeeInstruction({
+        owner,
+        poolAuthority: this.poolAuthority,
+        pool,
+        position,
+        positionNftAccount,
+        tokenAAccount,
+        tokenBAccount,
+        tokenAVault,
+        tokenBVault,
+        tokenAMint,
+        tokenBMint,
+        tokenAProgram,
+        tokenBProgram
+      });
+      instructions.push(claimPositionFeeInstruction);
+      const removeAllLiquidityInstruction = yield this.buildRemoveAllLiquidityInstruction({
+        poolAuthority: this.poolAuthority,
+        owner,
+        pool,
+        position,
+        positionNftAccount,
+        tokenAAccount,
+        tokenBAccount,
+        tokenAAmountThreshold,
+        tokenBAmountThreshold,
+        tokenAMint,
+        tokenBMint,
+        tokenAVault,
+        tokenBVault,
+        tokenAProgram,
+        tokenBProgram
+      });
+      instructions.push(removeAllLiquidityInstruction);
+      const closePositionInstruction = yield this.buildClosePositionInstruction({
+        owner,
+        poolAuthority: this.poolAuthority,
+        pool,
+        position,
+        positionNftMint,
+        positionNftAccount
+      });
+      instructions.push(closePositionInstruction);
+      return instructions;
+    });
+  }
   /**
    * Fetches the Config state of the program.
    * @param config - Public key of the config account.
@@ -7518,6 +7656,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);
@@ -7590,22 +7766,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)
       };
     });
   }
@@ -7662,7 +7841,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,
@@ -7772,7 +7951,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(
@@ -7782,13 +7961,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,
@@ -7805,7 +7984,7 @@ var CpAmm = class {
       minSqrtPrice,
       initSqrtPrice
     );
-    const liquidityDelta = min(
+    const liquidityDelta = min2(
       liquidityDeltaFromAmountA,
       liquidityDeltaFromAmountB
     );
@@ -8121,7 +8300,8 @@ var CpAmm = class {
         tokenAVault,
         tokenBVault,
         tokenAProgram,
-        tokenBProgram
+        tokenBProgram,
+        vestings
       } = params;
       const {
         tokenAAta: tokenAAccount,
@@ -8141,6 +8321,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,
@@ -8181,7 +8371,8 @@ var CpAmm = class {
         tokenAVault,
         tokenBVault,
         tokenAProgram,
-        tokenBProgram
+        tokenBProgram,
+        vestings
       } = params;
       const {
         tokenAAta: tokenAAccount,
@@ -8201,6 +8392,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,
@@ -8358,21 +8559,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);
     });
   }
   /**
@@ -8470,13 +8658,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 { pool } = positionState;
+      const { tokenAMint, tokenBMint } = poolState;
+      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);
@@ -8498,53 +8692,32 @@ 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);
       }
-      const claimPositionFeeInstruction = yield this.buildClaimPositionFeeInstruction({
-        owner,
-        poolAuthority: this.poolAuthority,
-        pool,
-        position,
-        positionNftAccount,
-        tokenAAccount,
-        tokenBAccount,
-        tokenAVault,
-        tokenBVault,
-        tokenAMint,
-        tokenBMint,
-        tokenAProgram,
-        tokenBProgram
-      });
-      transaction.add(claimPositionFeeInstruction);
-      const removeAllLiquidityInstruction = yield this.buildRemoveAllLiquidityInstruction({
-        poolAuthority: this.poolAuthority,
+      const liquidatePositionInstructions = yield this.buildLiquidatePositionInstruction({
         owner,
-        pool,
         position,
         positionNftAccount,
+        positionState,
+        poolState,
         tokenAAccount,
         tokenBAccount,
         tokenAAmountThreshold,
-        tokenBAmountThreshold,
-        tokenAMint,
-        tokenBMint,
-        tokenAVault,
-        tokenBVault,
-        tokenAProgram,
-        tokenBProgram
-      });
-      transaction.add(removeAllLiquidityInstruction);
-      const closePositionInstruction = yield this.buildClosePositionInstruction({
-        owner,
-        poolAuthority: this.poolAuthority,
-        pool,
-        position,
-        positionNftMint,
-        positionNftAccount
+        tokenBAmountThreshold
       });
-      transaction.add(closePositionInstruction);
+      transaction.add(...liquidatePositionInstructions);
       if (postInstructions.length > 0) {
         transaction.add(...postInstructions);
       }
@@ -8576,13 +8749,18 @@ 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 pool = positionBState.pool;
       const { tokenAMint, tokenBMint, tokenAVault, tokenBVault } = poolState;
       const tokenAProgram = getTokenProgram(poolState.tokenAFlag);
@@ -8605,44 +8783,46 @@ var CpAmm = class {
         const closeWrappedSOLIx = yield unwrapSOLInstruction(owner);
         closeWrappedSOLIx && postInstructions.push(closeWrappedSOLIx);
       }
+      let positionBLiquidityDelta = positionBState.unlockedLiquidity;
+      if (positionBVestings.length > 0) {
+        const totalAvailableVestingLiquidity = positionBVestings.reduce(
+          (total, position) => {
+            const available = getAvailableVestingLiquidity(
+              position.vestingState,
+              currentPoint
+            );
+            return total.add(available);
+          },
+          new BN10(0)
+        );
+        positionBLiquidityDelta = positionBLiquidityDelta.add(
+          totalAvailableVestingLiquidity
+        );
+        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);
       }
-      const claimPositionFeeInstruction = yield this.buildClaimPositionFeeInstruction({
-        owner,
-        poolAuthority: this.poolAuthority,
-        pool,
-        position: positionB,
-        positionNftAccount: positionBNftAccount,
-        tokenAAccount,
-        tokenBAccount,
-        tokenAVault,
-        tokenBVault,
-        tokenAMint,
-        tokenBMint,
-        tokenAProgram,
-        tokenBProgram
-      });
-      transaction.add(claimPositionFeeInstruction);
-      const removeAllLiquidityInstruction = yield this.buildRemoveAllLiquidityInstruction({
-        poolAuthority: this.poolAuthority,
+      const liquidatePositionInstructions = yield this.buildLiquidatePositionInstruction({
         owner,
-        pool,
         position: positionB,
         positionNftAccount: positionBNftAccount,
+        positionState: positionBState,
+        poolState,
         tokenAAccount,
         tokenBAccount,
         tokenAAmountThreshold: tokenAAmountRemoveLiquidityThreshold,
-        tokenBAmountThreshold: tokenBAmountRemoveLiquidityThreshold,
-        tokenAMint,
-        tokenBMint,
-        tokenAVault,
-        tokenBVault,
-        tokenAProgram,
-        tokenBProgram
+        tokenBAmountThreshold: tokenBAmountRemoveLiquidityThreshold
       });
-      transaction.add(removeAllLiquidityInstruction);
+      transaction.add(...liquidatePositionInstructions);
       const addLiquidityInstruction = yield this.buildAddLiquidityInstruction({
         pool,
         position: positionA,
@@ -8656,20 +8836,11 @@ var CpAmm = class {
         tokenBVault,
         tokenAProgram,
         tokenBProgram,
-        liquidityDelta: postionBLiquidityDelta,
+        liquidityDelta: positionBLiquidityDelta,
         tokenAAmountThreshold: tokenAAmountAddLiquidityThreshold,
         tokenBAmountThreshold: tokenBAmountAddLiquidityThreshold
       });
       transaction.add(addLiquidityInstruction);
-      const closePositionInstruction = yield this.buildClosePositionInstruction({
-        owner,
-        poolAuthority: this.poolAuthority,
-        pool: positionBState.pool,
-        position: positionB,
-        positionNftMint: positionBState.nftMint,
-        positionNftAccount: positionBNftAccount
-      });
-      transaction.add(closePositionInstruction);
       if (postInstructions.length > 0) {
         transaction.add(...postInstructions);
       }
@@ -8924,6 +9095,7 @@ export {
   getAllUserPositionNftAccount,
   getAmountAFromLiquidityDelta,
   getAmountBFromLiquidityDelta,
+  getAvailableVestingLiquidity,
   getBaseFeeNumerator,
   getDynamicFeeNumerator,
   getEstimatedComputeUnitIxWithBuffer,
@@ -8945,7 +9117,9 @@ export {
   getSwapAmount,
   getTokenDecimals,
   getTokenProgram,
+  getTotalLockedLiquidity,
   getUnClaimReward,
+  isVestingComplete,
   mulDiv,
   positionByPoolFilter,
   pow,