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

package/dist/index.js

@@ -6352,6 +6352,7 @@ var cp_amm_default = {
 // src/CpAmm.ts
 
 
+
 var _web3js = require('@solana/web3.js');
 
 // src/constants.ts
@@ -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.
@@ -7549,30 +7757,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 +7876,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 +7956,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 +7965,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 +7997,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 +8031,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 +8044,15 @@ 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);
+      transaction.add(addLiquidityInstruction);
+      transaction.add(...postInstructions);
+      return transaction;
     });
   }
   /**
@@ -7913,30 +8082,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 +8104,7 @@ var CpAmm = class {
         liquidityDelta: liquidityDeltaQ64,
         tokenAAmountThreshold,
         tokenBAmountThreshold
-      }).accountsStrict({
+      }).accountsPartial({
         poolAuthority,
         pool,
         position,
@@ -7961,9 +8117,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 +8147,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 +8165,28 @@ 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);
+      transaction.add(removeAllLiquidityInstruction);
+      transaction.add(...postInstructions);
+      return transaction;
     });
   }
   /**
@@ -8067,30 +8215,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 +8244,7 @@ var CpAmm = class {
       return yield this._program.methods.swap({
         amountIn,
         minimumAmountOut
-      }).accountsStrict({
+      }).accountsPartial({
         poolAuthority,
         pool,
         payer,
@@ -8121,9 +8256,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 +8291,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 +8314,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 +8334,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 +8374,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 +8392,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 +8405,13 @@ 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);
+      transaction.add(claimPositionFeeInstruction);
+      transaction.add(...postInstructions);
+      return transaction;
     });
   }
   closePosition(params) {
@@ -8303,16 +8422,241 @@ 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)();
+      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,
-        rentReceiver: owner,
+        pool,
+        position,
+        positionNftMint,
+        positionNftAccount
+      });
+      transaction.add(closePositionInstruction);
+      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,
-        tokenProgram: _spltoken.TOKEN_2022_PROGRAM_ID
-      }).transaction();
+        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)();
+      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,
+        owner,
+        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);
+      return transaction;
     });
   }
   /**
@@ -8323,11 +8667,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 +8681,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 +8717,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 +8755,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 +8786,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 +8805,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 +8816,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 +8852,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 +8861,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();
     });
   }