@meteora-ag/cp-amm-sdk 1.0.1-rc.25 → 1.0.1-rc.27

package/dist/index.js

@@ -6352,6 +6352,7 @@ var cp_amm_default = {
 // src/CpAmm.ts
 
 
+
 var _web3js = require('@solana/web3.js');
 
 // src/constants.ts
@@ -6371,6 +6372,38 @@ var MAX_SQRT_PRICE = new (0, _anchor.BN)("79226673521066979257578248091");
 var MIN_CU_BUFFER = 5e4;
 var MAX_CU_BUFFER = 2e5;
 
+// src/types.ts
+var Rounding = /* @__PURE__ */ ((Rounding2) => {
+  Rounding2[Rounding2["Up"] = 0] = "Up";
+  Rounding2[Rounding2["Down"] = 1] = "Down";
+  return Rounding2;
+})(Rounding || {});
+var ActivationPoint = /* @__PURE__ */ ((ActivationPoint2) => {
+  ActivationPoint2[ActivationPoint2["Timestamp"] = 0] = "Timestamp";
+  ActivationPoint2[ActivationPoint2["Slot"] = 1] = "Slot";
+  return ActivationPoint2;
+})(ActivationPoint || {});
+var FeeSchedulerMode = /* @__PURE__ */ ((FeeSchedulerMode2) => {
+  FeeSchedulerMode2[FeeSchedulerMode2["Linear"] = 0] = "Linear";
+  FeeSchedulerMode2[FeeSchedulerMode2["Exponential"] = 1] = "Exponential";
+  return FeeSchedulerMode2;
+})(FeeSchedulerMode || {});
+var CollectFeeMode = /* @__PURE__ */ ((CollectFeeMode3) => {
+  CollectFeeMode3[CollectFeeMode3["BothToken"] = 0] = "BothToken";
+  CollectFeeMode3[CollectFeeMode3["OnlyB"] = 1] = "OnlyB";
+  return CollectFeeMode3;
+})(CollectFeeMode || {});
+var TradeDirection = /* @__PURE__ */ ((TradeDirection2) => {
+  TradeDirection2[TradeDirection2["AtoB"] = 0] = "AtoB";
+  TradeDirection2[TradeDirection2["BtoA"] = 1] = "BtoA";
+  return TradeDirection2;
+})(TradeDirection || {});
+var ActivationType = /* @__PURE__ */ ((ActivationType2) => {
+  ActivationType2[ActivationType2["Slot"] = 0] = "Slot";
+  ActivationType2[ActivationType2["Timestamp"] = 1] = "Timestamp";
+  return ActivationType2;
+})(ActivationType || {});
+
 // src/pda.ts
 
 function getFirstKey(key1, key2) {
@@ -6589,38 +6622,6 @@ function getAllNftByUser(_0, _1) {
 // src/helpers/fee.ts
 
 
-// src/types.ts
-var Rounding = /* @__PURE__ */ ((Rounding2) => {
-  Rounding2[Rounding2["Up"] = 0] = "Up";
-  Rounding2[Rounding2["Down"] = 1] = "Down";
-  return Rounding2;
-})(Rounding || {});
-var ActivationPoint = /* @__PURE__ */ ((ActivationPoint2) => {
-  ActivationPoint2[ActivationPoint2["Timestamp"] = 0] = "Timestamp";
-  ActivationPoint2[ActivationPoint2["Slot"] = 1] = "Slot";
-  return ActivationPoint2;
-})(ActivationPoint || {});
-var FeeSchedulerMode = /* @__PURE__ */ ((FeeSchedulerMode2) => {
-  FeeSchedulerMode2[FeeSchedulerMode2["Linear"] = 0] = "Linear";
-  FeeSchedulerMode2[FeeSchedulerMode2["Exponential"] = 1] = "Exponential";
-  return FeeSchedulerMode2;
-})(FeeSchedulerMode || {});
-var CollectFeeMode = /* @__PURE__ */ ((CollectFeeMode3) => {
-  CollectFeeMode3[CollectFeeMode3["BothToken"] = 0] = "BothToken";
-  CollectFeeMode3[CollectFeeMode3["OnlyB"] = 1] = "OnlyB";
-  return CollectFeeMode3;
-})(CollectFeeMode || {});
-var TradeDirection = /* @__PURE__ */ ((TradeDirection2) => {
-  TradeDirection2[TradeDirection2["AtoB"] = 0] = "AtoB";
-  TradeDirection2[TradeDirection2["BtoA"] = 1] = "BtoA";
-  return TradeDirection2;
-})(TradeDirection || {});
-var ActivationType = /* @__PURE__ */ ((ActivationType2) => {
-  ActivationType2[ActivationType2["Slot"] = 0] = "Slot";
-  ActivationType2[ActivationType2["Timestamp"] = 1] = "Timestamp";
-  return ActivationType2;
-})(ActivationType || {});
-
 // src/math/feeMath.ts
 
 var MAX_EXPONENTIAL = new (0, _anchor.BN)(524288);
@@ -7210,6 +7211,46 @@ var CpAmm = class {
       };
     });
   }
+  /**
+   * Prepares token accounts for a transaction by retrieving or creating associated token accounts.
+   * @private
+   * @param {PublicKey} owner - The owner of the token accounts
+   * @param {PublicKey} tokenAMint - Mint address of token A
+   * @param {PublicKey} tokenBMint - Mint address of token B
+   * @param {PublicKey} tokenAProgram - Program ID for token A (Token or Token2022)
+   * @param {PublicKey} tokenBProgram - Program ID for token B (Token or Token2022)
+   * @returns {Promise<{tokenAAta: PublicKey, tokenBAta: PublicKey, instructions: TransactionInstruction[]}>}
+   *          The token account addresses and any instructions needed to create them
+   */
+  prepareTokenAccounts(owner, tokenAMint, tokenBMint, tokenAProgram, tokenBProgram) {
+    return __async(this, null, function* () {
+      const instructions = [];
+      const [
+        { ataPubkey: tokenAAta, ix: createInputTokenAccountIx },
+        { ataPubkey: tokenBAta, ix: createOutputTokenAccountIx }
+      ] = yield Promise.all([
+        getOrCreateATAInstruction(
+          this._program.provider.connection,
+          tokenAMint,
+          owner,
+          owner,
+          true,
+          tokenAProgram
+        ),
+        getOrCreateATAInstruction(
+          this._program.provider.connection,
+          tokenBMint,
+          owner,
+          owner,
+          true,
+          tokenBProgram
+        )
+      ]);
+      createInputTokenAccountIx && instructions.push(createInputTokenAccountIx);
+      createOutputTokenAccountIx && instructions.push(createOutputTokenAccountIx);
+      return { tokenAAta, tokenBAta, instructions };
+    });
+  }
   /**
    * Derives token badge account metadata
    * @param tokenAMint - Public key of token A mint
@@ -7230,6 +7271,161 @@ var CpAmm = class {
       }
     ];
   }
+  /**
+   * Builds an instruction to add liquidity to a position.
+   * @private
+   * @param {BuildAddLiquidityParams} params - Parameters for adding liquidity
+   * @returns {Promise<TransactionInstruction>} Instruction to add liquidity
+   */
+  buildAddLiquidityInstruction(params) {
+    return __async(this, null, function* () {
+      const {
+        pool,
+        position,
+        positionNftAccount,
+        owner,
+        tokenAAccount,
+        tokenBAccount,
+        tokenAMint,
+        tokenBMint,
+        tokenAVault,
+        tokenBVault,
+        tokenAProgram,
+        tokenBProgram,
+        liquidityDelta,
+        tokenAAmountThreshold,
+        tokenBAmountThreshold
+      } = params;
+      return yield this._program.methods.addLiquidity({
+        liquidityDelta,
+        tokenAAmountThreshold,
+        tokenBAmountThreshold
+      }).accountsPartial({
+        pool,
+        position,
+        positionNftAccount,
+        owner,
+        tokenAAccount,
+        tokenBAccount,
+        tokenAMint,
+        tokenBMint,
+        tokenAVault,
+        tokenBVault,
+        tokenAProgram,
+        tokenBProgram
+      }).instruction();
+    });
+  }
+  /**
+   * Builds an instruction to remove all liquidity from a position.
+   * @private
+   * @param {BuildRemoveAllLiquidityInstructionParams} params - Parameters for removing all liquidity
+   * @returns {Promise<TransactionInstruction>} Instruction to remove all liquidity
+   */
+  buildRemoveAllLiquidityInstruction(params) {
+    return __async(this, null, function* () {
+      const {
+        poolAuthority,
+        owner,
+        pool,
+        position,
+        positionNftAccount,
+        tokenAAccount,
+        tokenBAccount,
+        tokenAAmountThreshold,
+        tokenBAmountThreshold,
+        tokenAMint,
+        tokenBMint,
+        tokenAVault,
+        tokenBVault,
+        tokenAProgram,
+        tokenBProgram
+      } = params;
+      return yield this._program.methods.removeAllLiquidity(tokenAAmountThreshold, tokenBAmountThreshold).accountsPartial({
+        poolAuthority,
+        pool,
+        position,
+        positionNftAccount,
+        owner,
+        tokenAAccount,
+        tokenBAccount,
+        tokenAMint,
+        tokenBMint,
+        tokenAVault,
+        tokenBVault,
+        tokenAProgram,
+        tokenBProgram
+      }).instruction();
+    });
+  }
+  /**
+   * Builds an instruction to claim fees accumulated by a position.
+   * @private
+   * @param {ClaimPositionFeeInstructionParams} params - Parameters for claiming position fees
+   * @returns {Promise<TransactionInstruction>} Instruction to claim position fees
+   */
+  buildClaimPositionFeeInstruction(params) {
+    return __async(this, null, function* () {
+      const {
+        owner,
+        poolAuthority,
+        pool,
+        position,
+        positionNftAccount,
+        tokenAAccount,
+        tokenBAccount,
+        tokenAVault,
+        tokenBVault,
+        tokenAMint,
+        tokenBMint,
+        tokenAProgram,
+        tokenBProgram
+      } = params;
+      return yield this._program.methods.claimPositionFee().accountsPartial({
+        poolAuthority,
+        owner,
+        pool,
+        position,
+        positionNftAccount,
+        tokenAAccount,
+        tokenBAccount,
+        tokenAVault,
+        tokenBVault,
+        tokenAMint,
+        tokenBMint,
+        tokenAProgram,
+        tokenBProgram
+      }).instruction();
+    });
+  }
+  /**
+   * Builds an instruction to close a position.
+   * @private
+   * @param {ClosePositionInstructionParams} params - Parameters for closing a position
+   * @returns {Promise<TransactionInstruction>} Instruction to close the position
+   */
+  buildClosePositionInstruction(params) {
+    return __async(this, null, function* () {
+      const {
+        owner,
+        poolAuthority,
+        pool,
+        position,
+        positionNftAccount,
+        positionNftMint
+      } = params;
+      return yield this._program.methods.closePosition().accountsPartial({
+        positionNftMint,
+        positionNftAccount,
+        pool,
+        position,
+        poolAuthority,
+        rentReceiver: owner,
+        owner,
+        tokenProgram: _spltoken.TOKEN_2022_PROGRAM_ID
+      }).instruction();
+    });
+  }
   /**
    * Fetches the Config state of the program.
    * @param config - Public key of the config account.
@@ -7359,6 +7555,18 @@ var CpAmm = class {
       return vestings;
     });
   }
+  isLockedPosition(position) {
+    const totalLockedLiquidity = position.vestedLiquidity.add(
+      position.permanentLockedLiquidity
+    );
+    return totalLockedLiquidity.gtn(0);
+  }
+  isPoolExist(pool) {
+    return __async(this, null, function* () {
+      const poolState = yield this._program.account.pool.fetchNullable(pool);
+      return poolState !== null;
+    });
+  }
   /**
    * Calculates swap quote based on input amount and pool state.
    * @param params - Swap parameters including input amount, pool state, slippage, etc.
@@ -7445,34 +7653,151 @@ var CpAmm = class {
     });
   }
   /**
-   * Computes the liquidity delta based on the provided token amounts and pool state.
+   * Calculates the deposit quote for liquidity pool.
    *
-   * @param {LiquidityDeltaParams} params - The parameters for liquidity calculation
-   * @returns {Promise<BN>} - The computed liquidity delta in Q64 value.
+   * @param {GetDepositQuoteParams} params - The parameters for calculating the deposit quote.
+   *
+   * @returns {Promise<Object>} Deposit quote results
+   * @returns {BN} returns.actualInputAmount - The actual amount used as input (after deducting transfer fees).
+   * @returns {BN} returns.outputAmount - The calculated corresponding amount of the other token.
+   * @returns {BN} returns.liquidityDelta - The amount of liquidity that will be added to the pool.
    */
-  getLiquidityDelta(params) {
+  getDepositQuote(params) {
     return __async(this, null, function* () {
       const {
-        maxAmountTokenA,
-        maxAmountTokenB,
-        sqrtMaxPrice,
-        sqrtMinPrice,
-        sqrtPrice,
-        tokenAInfo,
-        tokenBInfo
+        inAmount,
+        isTokenA,
+        inputTokenInfo,
+        outputTokenInfo,
+        minSqrtPrice,
+        maxSqrtPrice,
+        sqrtPrice
       } = params;
-      let actualMaxAmountTokenA = maxAmountTokenA;
-      let actualMaxAmountTokenB = maxAmountTokenB;
-      if (tokenAInfo) {
-        actualMaxAmountTokenA = calculateTransferFeeExcludedAmount(
-          maxAmountTokenA,
-          tokenAInfo.mint,
-          tokenAInfo.currentEpoch
-        ).amount;
-      }
-      if (tokenBInfo) {
-        actualMaxAmountTokenB = calculateTransferFeeExcludedAmount(
-          maxAmountTokenB,
+      const actualAmountIn = inputTokenInfo ? inAmount.sub(
+        calculateTransferFeeIncludedAmount(
+          inAmount,
+          inputTokenInfo.mint,
+          inputTokenInfo.currentEpoch
+        ).transferFee
+      ) : inAmount;
+      const { liquidityDelta, rawAmount } = isTokenA ? {
+        liquidityDelta: getLiquidityDeltaFromAmountA(
+          actualAmountIn,
+          sqrtPrice,
+          maxSqrtPrice
+        ),
+        rawAmount: (delta) => getAmountBFromLiquidityDelta(
+          delta,
+          sqrtPrice,
+          minSqrtPrice,
+          0 /* Up */
+        )
+      } : {
+        liquidityDelta: getLiquidityDeltaFromAmountB(
+          actualAmountIn,
+          minSqrtPrice,
+          sqrtPrice
+        ),
+        rawAmount: (delta) => getAmountAFromLiquidityDelta(
+          delta,
+          sqrtPrice,
+          maxSqrtPrice,
+          0 /* Up */
+        )
+      };
+      const rawOutputAmount = new (0, _anchor.BN)(rawAmount(liquidityDelta));
+      const outputAmount = outputTokenInfo ? calculateTransferFeeIncludedAmount(
+        rawOutputAmount,
+        outputTokenInfo.mint,
+        outputTokenInfo.currentEpoch
+      ).amount : rawOutputAmount;
+      return {
+        actualInputAmount: actualAmountIn,
+        consumedInputAmount: inAmount,
+        liquidityDelta,
+        outputAmount
+      };
+    });
+  }
+  /**
+   * Calculates the withdrawal quote for removing liquidity from a concentrated liquidity pool.
+   *
+   * @param {GetWithdrawQuoteParams} params - The parameters for calculating the withdraw quote
+   *
+   * @param {Object|null} params.tokenATokenInfo - must provide if token a is token2022
+   * @param {Object|null} params.tokenBTokenInfo - must provide if token b is token2022
+   *
+   * @returns {Promise<Object>} Withdrawal quote results
+   * @returns {BN} returns.liquidityDelta - The amount of liquidity that will be removed from the pool
+   * @returns {BN} returns.outAmountA - The calculated amount of token A to be received (after deducting transfer fees)
+   * @returns {BN} returns.outAmountB - The calculated amount of token B to be received (after deducting transfer fees)
+   */
+  getWithdrawQuote(params) {
+    return __async(this, null, function* () {
+      const {
+        liquidityDelta,
+        sqrtPrice,
+        maxSqrtPrice,
+        minSqrtPrice,
+        tokenATokenInfo,
+        tokenBTokenInfo
+      } = params;
+      const amountA = getAmountAFromLiquidityDelta(
+        liquidityDelta,
+        sqrtPrice,
+        maxSqrtPrice,
+        1 /* Down */
+      );
+      const amountB = getAmountBFromLiquidityDelta(
+        liquidityDelta,
+        sqrtPrice,
+        minSqrtPrice,
+        1 /* Down */
+      );
+      return {
+        liquidityDelta,
+        outAmountA: tokenATokenInfo ? calculateTransferFeeExcludedAmount(
+          new (0, _anchor.BN)(amountA),
+          tokenATokenInfo.mint,
+          tokenATokenInfo.currentEpoch
+        ).amount : new (0, _anchor.BN)(amountA),
+        outAmountB: tokenBTokenInfo ? calculateTransferFeeExcludedAmount(
+          new (0, _anchor.BN)(amountB),
+          tokenBTokenInfo.mint,
+          tokenBTokenInfo.currentEpoch
+        ).amount : new (0, _anchor.BN)(amountB)
+      };
+    });
+  }
+  /**
+   * Computes the liquidity delta based on the provided token amounts and pool state.
+   *
+   * @param {LiquidityDeltaParams} params - The parameters for liquidity calculation
+   * @returns {Promise<BN>} - The computed liquidity delta in Q64 value.
+   */
+  getLiquidityDelta(params) {
+    return __async(this, null, function* () {
+      const {
+        maxAmountTokenA,
+        maxAmountTokenB,
+        sqrtMaxPrice,
+        sqrtMinPrice,
+        sqrtPrice,
+        tokenAInfo,
+        tokenBInfo
+      } = params;
+      let actualMaxAmountTokenA = maxAmountTokenA;
+      let actualMaxAmountTokenB = maxAmountTokenB;
+      if (tokenAInfo) {
+        actualMaxAmountTokenA = calculateTransferFeeExcludedAmount(
+          maxAmountTokenA,
+          tokenAInfo.mint,
+          tokenAInfo.currentEpoch
+        ).amount;
+      }
+      if (tokenBInfo) {
+        actualMaxAmountTokenB = calculateTransferFeeExcludedAmount(
+          maxAmountTokenB,
           tokenBInfo.mint,
           tokenBInfo.currentEpoch
         ).amount;
@@ -7549,30 +7874,17 @@ var CpAmm = class {
         pool,
         this._program.programId
       );
-      const preInstructions = [];
-      const [
-        { ataPubkey: payerTokenA, ix: createTokenATokenAccountIx },
-        { ataPubkey: payerTokenB, ix: createTokenBTokenAccountIx }
-      ] = yield Promise.all([
-        getOrCreateATAInstruction(
-          this._program.provider.connection,
-          tokenAMint,
-          payer,
-          payer,
-          true,
-          tokenAProgram
-        ),
-        getOrCreateATAInstruction(
-          this._program.provider.connection,
-          tokenBMint,
-          payer,
-          payer,
-          true,
-          tokenBProgram
-        )
-      ]);
-      createTokenATokenAccountIx && preInstructions.push(createTokenATokenAccountIx);
-      createTokenBTokenAccountIx && preInstructions.push(createTokenBTokenAccountIx);
+      const {
+        tokenAAta: payerTokenA,
+        tokenBAta: payerTokenB,
+        instructions: preInstructions
+      } = yield this.prepareTokenAccounts(
+        payer,
+        tokenAMint,
+        tokenBMint,
+        tokenAProgram,
+        tokenBProgram
+      );
       if (tokenAMint.equals(_spltoken.NATIVE_MINT)) {
         const wrapSOLIx = wrapSOLInstruction(
           payer,
@@ -7681,30 +7993,17 @@ var CpAmm = class {
         pool,
         this._program.programId
       );
-      const preInstructions = [];
-      const [
-        { ataPubkey: payerTokenA, ix: createTokenATokenAccountIx },
-        { ataPubkey: payerTokenB, ix: createTokenBTokenAccountIx }
-      ] = yield Promise.all([
-        getOrCreateATAInstruction(
-          this._program.provider.connection,
-          tokenAMint,
-          payer,
-          payer,
-          true,
-          tokenAProgram
-        ),
-        getOrCreateATAInstruction(
-          this._program.provider.connection,
-          tokenBMint,
-          payer,
-          payer,
-          true,
-          tokenBProgram
-        )
-      ]);
-      createTokenATokenAccountIx && preInstructions.push(createTokenATokenAccountIx);
-      createTokenBTokenAccountIx && preInstructions.push(createTokenBTokenAccountIx);
+      const {
+        tokenAAta: payerTokenA,
+        tokenBAta: payerTokenB,
+        instructions: preInstructions
+      } = yield this.prepareTokenAccounts(
+        payer,
+        tokenAMint,
+        tokenBMint,
+        tokenAProgram,
+        tokenBProgram
+      );
       if (tokenAMint.equals(_spltoken.NATIVE_MINT)) {
         const wrapSOLIx = wrapSOLInstruction(
           payer,
@@ -7774,7 +8073,7 @@ var CpAmm = class {
         positionNft,
         this._program.programId
       );
-      return yield this._program.methods.createPosition().accountsStrict({
+      return yield this._program.methods.createPosition().accountsPartial({
         owner,
         positionNftMint: positionNft,
         poolAuthority,
@@ -7783,9 +8082,7 @@ var CpAmm = class {
         pool,
         position,
         tokenProgram: _spltoken.TOKEN_2022_PROGRAM_ID,
-        systemProgram: _web3js.SystemProgram.programId,
-        eventAuthority: deriveEventAuthority(this._program.programId)[0],
-        program: this._program.programId
+        systemProgram: _web3js.SystemProgram.programId
       }).transaction();
     });
   }
@@ -7817,30 +8114,17 @@ var CpAmm = class {
         positionNftMint,
         this._program.programId
       );
-      const preInstructions = [];
-      const [
-        { ataPubkey: tokenAAccount, ix: createTokenATokenAccountIx },
-        { ataPubkey: tokenBAccount, ix: createTokenBTokenAccountIx }
-      ] = yield Promise.all([
-        getOrCreateATAInstruction(
-          this._program.provider.connection,
-          tokenAMint,
-          owner,
-          owner,
-          true,
-          tokenAProgram
-        ),
-        getOrCreateATAInstruction(
-          this._program.provider.connection,
-          tokenBMint,
-          owner,
-          owner,
-          true,
-          tokenBProgram
-        )
-      ]);
-      createTokenATokenAccountIx && preInstructions.push(createTokenATokenAccountIx);
-      createTokenBTokenAccountIx && preInstructions.push(createTokenBTokenAccountIx);
+      const {
+        tokenAAta: tokenAAccount,
+        tokenBAta: tokenBAccount,
+        instructions: preInstructions
+      } = yield this.prepareTokenAccounts(
+        owner,
+        tokenAMint,
+        tokenBMint,
+        tokenAProgram,
+        tokenBProgram
+      );
       if (tokenAMint.equals(_spltoken.NATIVE_MINT)) {
         const wrapSOLIx = wrapSOLInstruction(
           owner,
@@ -7864,11 +8148,7 @@ var CpAmm = class {
         const closeWrappedSOLIx = yield unwrapSOLInstruction(owner);
         closeWrappedSOLIx && postInstructions.push(closeWrappedSOLIx);
       }
-      return yield this._program.methods.addLiquidity({
-        liquidityDelta: liquidityDeltaQ64,
-        tokenAAmountThreshold,
-        tokenBAmountThreshold
-      }).accountsStrict({
+      const addLiquidityInstruction = yield this.buildAddLiquidityInstruction({
         pool,
         position,
         positionNftAccount,
@@ -7881,9 +8161,17 @@ var CpAmm = class {
         tokenBVault,
         tokenAProgram,
         tokenBProgram,
-        eventAuthority: deriveEventAuthority(this._program.programId)[0],
-        program: this._program.programId
-      }).preInstructions(preInstructions).postInstructions(postInstructions).transaction();
+        liquidityDelta: liquidityDeltaQ64,
+        tokenAAmountThreshold,
+        tokenBAmountThreshold
+      });
+      const transaction = new (0, _web3js.Transaction)();
+      transaction.add(
+        ...preInstructions.length > 0 ? preInstructions : [],
+        addLiquidityInstruction,
+        ...postInstructions.length > 0 ? postInstructions : []
+      );
+      return transaction;
     });
   }
   /**
@@ -7913,30 +8201,17 @@ var CpAmm = class {
         this._program.programId
       );
       const poolAuthority = derivePoolAuthority(this._program.programId);
-      const preInstructions = [];
-      const [
-        { ataPubkey: tokenAAccount, ix: createTokenAAccountIx },
-        { ataPubkey: tokenBAccount, ix: createTokenBAccountIx }
-      ] = yield Promise.all([
-        getOrCreateATAInstruction(
-          this._program.provider.connection,
-          tokenAMint,
-          owner,
-          owner,
-          true,
-          tokenAProgram
-        ),
-        getOrCreateATAInstruction(
-          this._program.provider.connection,
-          tokenBMint,
-          owner,
-          owner,
-          true,
-          tokenBProgram
-        )
-      ]);
-      createTokenAAccountIx && preInstructions.push(createTokenAAccountIx);
-      createTokenBAccountIx && preInstructions.push(createTokenBAccountIx);
+      const {
+        tokenAAta: tokenAAccount,
+        tokenBAta: tokenBAccount,
+        instructions: preInstructions
+      } = yield this.prepareTokenAccounts(
+        owner,
+        tokenAMint,
+        tokenBMint,
+        tokenAProgram,
+        tokenBProgram
+      );
       const postInstructions = [];
       if ([tokenAMint.toBase58(), tokenBMint.toBase58()].includes(
         _spltoken.NATIVE_MINT.toBase58()
@@ -7948,7 +8223,7 @@ var CpAmm = class {
         liquidityDelta: liquidityDeltaQ64,
         tokenAAmountThreshold,
         tokenBAmountThreshold
-      }).accountsStrict({
+      }).accountsPartial({
         poolAuthority,
         pool,
         position,
@@ -7961,9 +8236,7 @@ var CpAmm = class {
         tokenAVault,
         tokenBVault,
         tokenAProgram,
-        tokenBProgram,
-        eventAuthority: deriveEventAuthority(this._program.programId)[0],
-        program: this._program.programId
+        tokenBProgram
       }).preInstructions(preInstructions).postInstructions(postInstructions).transaction();
     });
   }
@@ -7993,30 +8266,17 @@ var CpAmm = class {
         this._program.programId
       );
       const poolAuthority = derivePoolAuthority(this._program.programId);
-      const preInstructions = [];
-      const [
-        { ataPubkey: tokenAAccount, ix: createTokenAAccountIx },
-        { ataPubkey: tokenBAccount, ix: createTokenBAccountIx }
-      ] = yield Promise.all([
-        getOrCreateATAInstruction(
-          this._program.provider.connection,
-          tokenAMint,
-          owner,
-          owner,
-          true,
-          tokenAProgram
-        ),
-        getOrCreateATAInstruction(
-          this._program.provider.connection,
-          tokenBMint,
-          owner,
-          owner,
-          true,
-          tokenBProgram
-        )
-      ]);
-      createTokenAAccountIx && preInstructions.push(createTokenAAccountIx);
-      createTokenBAccountIx && preInstructions.push(createTokenBAccountIx);
+      const {
+        tokenAAta: tokenAAccount,
+        tokenBAta: tokenBAccount,
+        instructions: preInstructions
+      } = yield this.prepareTokenAccounts(
+        owner,
+        tokenAMint,
+        tokenBMint,
+        tokenAProgram,
+        tokenBProgram
+      );
       const postInstructions = [];
       if ([tokenAMint.toBase58(), tokenBMint.toBase58()].includes(
         _spltoken.NATIVE_MINT.toBase58()
@@ -8024,21 +8284,30 @@ var CpAmm = class {
         const closeWrappedSOLIx = yield unwrapSOLInstruction(owner);
         closeWrappedSOLIx && postInstructions.push(closeWrappedSOLIx);
       }
-      return yield this._program.methods.removeAllLiquidity(tokenAAmountThreshold, tokenBAmountThreshold).accountsPartial({
+      const removeAllLiquidityInstruction = yield this.buildRemoveAllLiquidityInstruction({
         poolAuthority,
+        owner,
         pool,
         position,
         positionNftAccount,
-        owner,
         tokenAAccount,
         tokenBAccount,
+        tokenAAmountThreshold,
+        tokenBAmountThreshold,
         tokenAMint,
         tokenBMint,
         tokenAVault,
         tokenBVault,
         tokenAProgram,
         tokenBProgram
-      }).preInstructions(preInstructions).postInstructions(postInstructions).transaction();
+      });
+      const transaction = new (0, _web3js.Transaction)();
+      transaction.add(
+        ...preInstructions.length > 0 ? preInstructions : [],
+        removeAllLiquidityInstruction,
+        ...postInstructions.length > 0 ? postInstructions : []
+      );
+      return transaction;
     });
   }
   /**
@@ -8067,30 +8336,17 @@ var CpAmm = class {
       const [inputTokenProgram, outputTokenProgram] = inputTokenMint.equals(
         tokenAMint
       ) ? [tokenAProgram, tokenBProgram] : [tokenBProgram, tokenAProgram];
-      const preInstructions = [];
-      const [
-        { ataPubkey: inputTokenAccount, ix: createInputTokenAccountIx },
-        { ataPubkey: outputTokenAccount, ix: createOutputTokenAccountIx }
-      ] = yield Promise.all([
-        getOrCreateATAInstruction(
-          this._program.provider.connection,
-          inputTokenMint,
-          payer,
-          payer,
-          true,
-          inputTokenProgram
-        ),
-        getOrCreateATAInstruction(
-          this._program.provider.connection,
-          outputTokenMint,
-          payer,
-          payer,
-          true,
-          outputTokenProgram
-        )
-      ]);
-      createInputTokenAccountIx && preInstructions.push(createInputTokenAccountIx);
-      createOutputTokenAccountIx && preInstructions.push(createOutputTokenAccountIx);
+      const {
+        tokenAAta: inputTokenAccount,
+        tokenBAta: outputTokenAccount,
+        instructions: preInstructions
+      } = yield this.prepareTokenAccounts(
+        payer,
+        inputTokenMint,
+        outputTokenMint,
+        inputTokenProgram,
+        outputTokenProgram
+      );
       if (inputTokenMint.equals(_spltoken.NATIVE_MINT)) {
         const wrapSOLIx = wrapSOLInstruction(
           payer,
@@ -8109,7 +8365,7 @@ var CpAmm = class {
       return yield this._program.methods.swap({
         amountIn,
         minimumAmountOut
-      }).accountsStrict({
+      }).accountsPartial({
         poolAuthority,
         pool,
         payer,
@@ -8121,9 +8377,7 @@ var CpAmm = class {
         tokenBMint,
         tokenAProgram,
         tokenBProgram,
-        referralTokenAccount,
-        eventAuthority: deriveEventAuthority(this._program.programId)[0],
-        program: this._program.programId
+        referralTokenAccount
       }).preInstructions(preInstructions).postInstructions(postInstructions).transaction();
     });
   }
@@ -8158,16 +8412,14 @@ var CpAmm = class {
         liquidityPerPeriod,
         numberOfPeriod
       };
-      return yield this._program.methods.lockPosition(lockPositionParams).accountsStrict({
+      return yield this._program.methods.lockPosition(lockPositionParams).accountsPartial({
         position,
         positionNftAccount,
         vesting: vestingAccount,
         pool,
         owner,
         payer,
-        systemProgram: _web3js.SystemProgram.programId,
-        eventAuthority: deriveEventAuthority(this._program.programId)[0],
-        program: this._program.programId
+        systemProgram: _web3js.SystemProgram.programId
       }).transaction();
     });
   }
@@ -8183,13 +8435,11 @@ var CpAmm = class {
         positionNftMint,
         this._program.programId
       );
-      return yield this._program.methods.permanentLockPosition(unlockedLiquidity).accountsStrict({
+      return yield this._program.methods.permanentLockPosition(unlockedLiquidity).accountsPartial({
         position,
         positionNftAccount,
         pool,
-        owner,
-        eventAuthority: deriveEventAuthority(this._program.programId)[0],
-        program: this._program.programId
+        owner
       }).transaction();
     });
   }
@@ -8205,7 +8455,7 @@ var CpAmm = class {
         positionNftMint,
         this._program.programId
       );
-      return yield this._program.methods.refreshVesting().accountsStrict({
+      return yield this._program.methods.refreshVesting().accountsPartial({
         position,
         positionNftAccount,
         pool,
@@ -8245,30 +8495,17 @@ var CpAmm = class {
         this._program.programId
       );
       const poolAuthority = derivePoolAuthority(this._program.programId);
-      const preInstructions = [];
-      const [
-        { ataPubkey: tokenAAccount, ix: createTokenAAccountIx },
-        { ataPubkey: tokenBAccount, ix: createTokenBAccountIx }
-      ] = yield Promise.all([
-        getOrCreateATAInstruction(
-          this._program.provider.connection,
-          tokenAMint,
-          owner,
-          owner,
-          true,
-          tokenAProgram
-        ),
-        getOrCreateATAInstruction(
-          this._program.provider.connection,
-          tokenBMint,
-          owner,
-          owner,
-          true,
-          tokenBProgram
-        )
-      ]);
-      createTokenAAccountIx && preInstructions.push(createTokenAAccountIx);
-      createTokenBAccountIx && preInstructions.push(createTokenBAccountIx);
+      const {
+        tokenAAta: tokenAAccount,
+        tokenBAta: tokenBAccount,
+        instructions: preInstructions
+      } = yield this.prepareTokenAccounts(
+        owner,
+        tokenAMint,
+        tokenBMint,
+        tokenAProgram,
+        tokenBProgram
+      );
       const postInstructions = [];
       if ([tokenAMint.toBase58(), tokenBMint.toBase58()].includes(
         _spltoken.NATIVE_MINT.toBase58()
@@ -8276,9 +8513,9 @@ var CpAmm = class {
         const closeWrappedSOLIx = yield unwrapSOLInstruction(owner);
         closeWrappedSOLIx && postInstructions.push(closeWrappedSOLIx);
       }
-      return yield this._program.methods.claimPositionFee().accountsStrict({
-        poolAuthority,
+      const claimPositionFeeInstruction = yield this.buildClaimPositionFeeInstruction({
         owner,
+        poolAuthority,
         pool,
         position,
         positionNftAccount,
@@ -8289,10 +8526,15 @@ var CpAmm = class {
         tokenAMint,
         tokenBMint,
         tokenAProgram,
-        tokenBProgram,
-        eventAuthority: deriveEventAuthority(this._program.programId)[0],
-        program: this._program.programId
-      }).preInstructions(preInstructions).postInstructions(postInstructions).transaction();
+        tokenBProgram
+      });
+      const transaction = new (0, _web3js.Transaction)();
+      transaction.add(
+        ...preInstructions.length > 0 ? preInstructions : [],
+        claimPositionFeeInstruction,
+        ...postInstructions.length > 0 ? postInstructions : []
+      );
+      return transaction;
     });
   }
   closePosition(params) {
@@ -8303,16 +8545,251 @@ var CpAmm = class {
         positionNftMint,
         this._program.programId
       );
-      return yield this._program.methods.closePosition().accountsPartial({
+      const instruction = yield this.buildClosePositionInstruction({
+        owner,
+        poolAuthority,
+        pool,
+        position,
+        positionNftMint,
+        positionNftAccount
+      });
+      return new (0, _web3js.Transaction)().add(instruction);
+    });
+  }
+  /**
+   * Builds a transaction to remove all liquidity from a position and close it.
+   * This combines several operations in a single transaction:
+   * 1. Claims any accumulated fees
+   * 2. Removes all liquidity
+   * 3. Closes the position
+   *
+   * @param {RemoveAllLiquidityAndClosePositionParams} params - Combined parameters
+   * @returns {TxBuilder} Transaction builder with all required instructions
+   * @throws {Error} If the position is locked or cannot be closed
+   */
+  removeAllLiquidityAndClosePosition(params) {
+    return __async(this, null, function* () {
+      const {
+        owner,
+        position,
+        positionState,
+        poolState,
+        tokenAAmountThreshold,
+        tokenBAmountThreshold
+      } = 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 positionNftAccount = derivePositionNftAccount(
         positionNftMint,
+        this._program.programId
+      );
+      const poolAuthority = derivePoolAuthority(this._program.programId);
+      const tokenAProgram = getTokenProgram(poolState.tokenAFlag);
+      const tokenBProgram = getTokenProgram(poolState.tokenBFlag);
+      const {
+        tokenAAta: tokenAAccount,
+        tokenBAta: tokenBAccount,
+        instructions: preInstructions
+      } = yield this.prepareTokenAccounts(
+        owner,
+        tokenAMint,
+        tokenBMint,
+        tokenAProgram,
+        tokenBProgram
+      );
+      const postInstructions = [];
+      if ([tokenAMint.toBase58(), tokenBMint.toBase58()].includes(
+        _spltoken.NATIVE_MINT.toBase58()
+      )) {
+        const closeWrappedSOLIx = yield unwrapSOLInstruction(owner);
+        closeWrappedSOLIx && postInstructions.push(closeWrappedSOLIx);
+      }
+      const transaction = new (0, _web3js.Transaction)();
+      if (preInstructions.length > 0) {
+        transaction.add(...preInstructions);
+      }
+      const claimPositionFeeInstruction = yield this.buildClaimPositionFeeInstruction({
+        owner,
+        poolAuthority,
+        pool,
+        position,
         positionNftAccount,
+        tokenAAccount,
+        tokenBAccount,
+        tokenAVault,
+        tokenBVault,
+        tokenAMint,
+        tokenBMint,
+        tokenAProgram,
+        tokenBProgram
+      });
+      transaction.add(claimPositionFeeInstruction);
+      const removeAllLiquidityInstruction = yield this.buildRemoveAllLiquidityInstruction({
+        poolAuthority,
+        owner,
+        pool,
+        position,
+        positionNftAccount,
+        tokenAAccount,
+        tokenBAccount,
+        tokenAAmountThreshold,
+        tokenBAmountThreshold,
+        tokenAMint,
+        tokenBMint,
+        tokenAVault,
+        tokenBVault,
+        tokenAProgram,
+        tokenBProgram
+      });
+      transaction.add(removeAllLiquidityInstruction);
+      const closePositionInstruction = yield this.buildClosePositionInstruction({
+        owner,
+        poolAuthority,
         pool,
         position,
+        positionNftMint,
+        positionNftAccount
+      });
+      transaction.add(closePositionInstruction);
+      if (postInstructions.length > 0) {
+        transaction.add(...postInstructions);
+      }
+      return transaction;
+    });
+  }
+  /**
+   * Builds a transaction to merge liquidity from one position into another.
+   * This process:
+   * 1. Claims fees from the source position
+   * 2. Removes all liquidity from the source position
+   * 3. Adds that liquidity to the target position
+   * 4. Closes the source position
+   *
+   * @param {MergePositionParams} params - Parameters for merging positions
+   * @returns {TxBuilder} Transaction builder with all required instructions
+   * @throws {Error} If either position is locked or incompatible
+   */
+  mergePosition(params) {
+    return __async(this, null, function* () {
+      const {
+        owner,
+        positionA,
+        positionB,
+        positionBState,
+        positionAState,
+        poolState,
+        tokenAAmountThreshold,
+        tokenBAmountThreshold
+      } = params;
+      const isLockedPosition = this.isLockedPosition(positionBState);
+      if (isLockedPosition) {
+        throw Error("position must be unlocked");
+      }
+      const postionBLiquidityDelta = positionBState.unlockedLiquidity;
+      const pool = positionBState.pool;
+      const { tokenAMint, tokenBMint, tokenAVault, tokenBVault } = poolState;
+      const positionBNftAccount = derivePositionNftAccount(
+        positionBState.nftMint,
+        this._program.programId
+      );
+      const positionANftAccount = derivePositionNftAccount(
+        positionAState.nftMint,
+        this._program.programId
+      );
+      const poolAuthority = derivePoolAuthority(this._program.programId);
+      const tokenAProgram = getTokenProgram(poolState.tokenAFlag);
+      const tokenBProgram = getTokenProgram(poolState.tokenBFlag);
+      const {
+        tokenAAta: tokenAAccount,
+        tokenBAta: tokenBAccount,
+        instructions: preInstructions
+      } = yield this.prepareTokenAccounts(
+        owner,
+        tokenAMint,
+        tokenBMint,
+        tokenAProgram,
+        tokenBProgram
+      );
+      const postInstructions = [];
+      if ([tokenAMint.toBase58(), tokenBMint.toBase58()].includes(
+        _spltoken.NATIVE_MINT.toBase58()
+      )) {
+        const closeWrappedSOLIx = yield unwrapSOLInstruction(owner);
+        closeWrappedSOLIx && postInstructions.push(closeWrappedSOLIx);
+      }
+      const transaction = new (0, _web3js.Transaction)();
+      if (preInstructions.length > 0) {
+        transaction.add(...preInstructions);
+      }
+      const claimPositionFeeInstruction = yield this.buildClaimPositionFeeInstruction({
+        owner,
+        poolAuthority,
+        pool,
+        position: positionB,
+        positionNftAccount: positionBNftAccount,
+        tokenAAccount,
+        tokenBAccount,
+        tokenAVault,
+        tokenBVault,
+        tokenAMint,
+        tokenBMint,
+        tokenAProgram,
+        tokenBProgram
+      });
+      transaction.add(claimPositionFeeInstruction);
+      const removeAllLiquidityInstruction = yield this.buildRemoveAllLiquidityInstruction({
         poolAuthority,
-        rentReceiver: owner,
         owner,
-        tokenProgram: _spltoken.TOKEN_2022_PROGRAM_ID
-      }).transaction();
+        pool,
+        position: positionB,
+        positionNftAccount: positionBNftAccount,
+        tokenAAccount,
+        tokenBAccount,
+        tokenAAmountThreshold,
+        tokenBAmountThreshold,
+        tokenAMint,
+        tokenBMint,
+        tokenAVault,
+        tokenBVault,
+        tokenAProgram,
+        tokenBProgram
+      });
+      transaction.add(removeAllLiquidityInstruction);
+      const addLiquidityInstruction = yield this.buildAddLiquidityInstruction({
+        pool,
+        position: positionA,
+        positionNftAccount: positionANftAccount,
+        owner,
+        tokenAAccount,
+        tokenBAccount,
+        tokenAMint,
+        tokenBMint,
+        tokenAVault,
+        tokenBVault,
+        tokenAProgram,
+        tokenBProgram,
+        liquidityDelta: postionBLiquidityDelta,
+        tokenAAmountThreshold,
+        tokenBAmountThreshold
+      });
+      transaction.add(addLiquidityInstruction);
+      const closePositionInstruction = yield this.buildClosePositionInstruction({
+        owner,
+        poolAuthority,
+        pool: positionBState.pool,
+        position: positionB,
+        positionNftMint: positionBState.nftMint,
+        positionNftAccount: positionBNftAccount
+      });
+      transaction.add(closePositionInstruction);
+      if (postInstructions.length > 0) {
+        transaction.add(...postInstructions);
+      }
+      return transaction;
     });
   }
   /**
@@ -8323,11 +8800,9 @@ var CpAmm = class {
   updateRewardDuration(params) {
     return __async(this, null, function* () {
       const { pool, admin, rewardIndex, newDuration } = params;
-      return yield this._program.methods.updateRewardDuration(rewardIndex, newDuration).accountsStrict({
+      return yield this._program.methods.updateRewardDuration(rewardIndex, newDuration).accountsPartial({
         pool,
-        admin,
-        eventAuthority: deriveEventAuthority(this._program.programId)[0],
-        program: this._program.programId
+        admin
       }).transaction();
     });
   }
@@ -8339,11 +8814,9 @@ var CpAmm = class {
   updateRewardFunder(params) {
     return __async(this, null, function* () {
       const { pool, admin, rewardIndex, newFunder } = params;
-      return yield this._program.methods.updateRewardFunder(rewardIndex, newFunder).accountsStrict({
+      return yield this._program.methods.updateRewardFunder(rewardIndex, newFunder).accountsPartial({
         pool,
-        admin,
-        eventAuthority: deriveEventAuthority(this._program.programId)[0],
-        program: this._program.programId
+        admin
       }).transaction();
     });
   }
@@ -8377,15 +8850,13 @@ var CpAmm = class {
         );
         preInstructions.push(...wrapSOLIx);
       }
-      return yield this._program.methods.fundReward(rewardIndex, amount, carryForward).accountsStrict({
+      return yield this._program.methods.fundReward(rewardIndex, amount, carryForward).accountsPartial({
         pool,
         rewardVault: vault,
         rewardMint: mint,
         funderTokenAccount,
         funder,
-        tokenProgram,
-        eventAuthority: deriveEventAuthority(this._program.programId)[0],
-        program: this._program.programId
+        tokenProgram
       }).transaction();
     });
   }
@@ -8417,16 +8888,14 @@ var CpAmm = class {
         const closeWrappedSOLIx = yield unwrapSOLInstruction(funder);
         closeWrappedSOLIx && postInstructions.push(closeWrappedSOLIx);
       }
-      return yield this._program.methods.withdrawIneligibleReward(rewardIndex).accountsStrict({
+      return yield this._program.methods.withdrawIneligibleReward(rewardIndex).accountsPartial({
         pool,
         rewardVault: vault,
         rewardMint: mint,
         poolAuthority,
         funderTokenAccount,
         funder,
-        tokenProgram,
-        eventAuthority: deriveEventAuthority(this._program.programId)[0],
-        program: this._program.programId
+        tokenProgram
       }).preInstructions(preInstructions).postInstructions(postInstructions).transaction();
     });
   }
@@ -8450,30 +8919,17 @@ var CpAmm = class {
       const poolAuthority = derivePoolAuthority(this._program.programId);
       const tokenAProgram = getTokenProgram(tokenAFlag);
       const tokenBProgram = getTokenProgram(tokenBFlag);
-      const preInstructions = [];
-      const [
-        { ataPubkey: tokenAAccount, ix: createTokenAAccountIx },
-        { ataPubkey: tokenBAccount, ix: createTokenBAccountIx }
-      ] = yield Promise.all([
-        getOrCreateATAInstruction(
-          this._program.provider.connection,
-          poolState.tokenAMint,
-          partner,
-          partner,
-          true,
-          tokenAProgram
-        ),
-        getOrCreateATAInstruction(
-          this._program.provider.connection,
-          poolState.tokenBMint,
-          partner,
-          partner,
-          true,
-          tokenBProgram
-        )
-      ]);
-      createTokenAAccountIx && preInstructions.push(createTokenAAccountIx);
-      createTokenBAccountIx && preInstructions.push(createTokenBAccountIx);
+      const {
+        tokenAAta: tokenAAccount,
+        tokenBAta: tokenBAccount,
+        instructions: preInstructions
+      } = yield this.prepareTokenAccounts(
+        partner,
+        tokenAMint,
+        tokenBMint,
+        tokenAProgram,
+        tokenBProgram
+      );
       const postInstructions = [];
       if ([
         poolState.tokenAMint.toBase58(),
@@ -8482,7 +8938,7 @@ var CpAmm = class {
         const closeWrappedSOLIx = yield unwrapSOLInstruction(partner);
         closeWrappedSOLIx && postInstructions.push(closeWrappedSOLIx);
       }
-      return yield this._program.methods.claimPartnerFee(maxAmountA, maxAmountB).accountsStrict({
+      return yield this._program.methods.claimPartnerFee(maxAmountA, maxAmountB).accountsPartial({
         poolAuthority,
         pool,
         tokenAAccount,
@@ -8493,9 +8949,7 @@ var CpAmm = class {
         tokenBMint,
         partner,
         tokenAProgram,
-        tokenBProgram,
-        eventAuthority: deriveEventAuthority(this._program.programId)[0],
-        program: this._program.programId
+        tokenBProgram
       }).preInstructions(preInstructions).postInstructions(postInstructions).transaction();
     });
   }
@@ -8531,7 +8985,7 @@ var CpAmm = class {
         const closeWrappedSOLIx = yield unwrapSOLInstruction(user);
         closeWrappedSOLIx && postInstructions.push(closeWrappedSOLIx);
       }
-      return yield this._program.methods.claimReward(rewardIndex).accountsStrict({
+      return yield this._program.methods.claimReward(rewardIndex).accountsPartial({
         pool: positionState.pool,
         positionNftAccount,
         rewardVault: rewardInfo.vault,
@@ -8540,9 +8994,7 @@ var CpAmm = class {
         position,
         userTokenAccount,
         owner: user,
-        tokenProgram,
-        eventAuthority: deriveEventAuthority(this._program.programId)[0],
-        program: this._program.programId
+        tokenProgram
       }).preInstructions(preInstructions).postInstructions(postInstructions).transaction();
     });
   }