@meteora-ag/cp-amm-sdk 1.0.1-rc.23 → 1.0.1-rc.24

package/dist/index.mjs

@@ -21,7 +21,7 @@ var __async = (__this, __arguments, generator) => {
 };
 
 // src/CpAmm.ts
-import { Program, BN as BN8 } from "@coral-xyz/anchor";
+import { Program, BN as BN9 } 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";
 
@@ -1070,6 +1070,123 @@ var cp_amm_default = {
       ],
       args: []
     },
+    {
+      name: "close_position",
+      discriminator: [
+        123,
+        134,
+        81,
+        0,
+        49,
+        68,
+        98,
+        98
+      ],
+      accounts: [
+        {
+          name: "position_nft_mint",
+          docs: [
+            "position_nft_mint"
+          ],
+          writable: true
+        },
+        {
+          name: "position_nft_account",
+          docs: [
+            "The token account for nft"
+          ],
+          writable: true
+        },
+        {
+          name: "pool",
+          writable: true,
+          relations: [
+            "position"
+          ]
+        },
+        {
+          name: "position",
+          writable: true
+        },
+        {
+          name: "pool_authority",
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  112,
+                  111,
+                  111,
+                  108,
+                  95,
+                  97,
+                  117,
+                  116,
+                  104,
+                  111,
+                  114,
+                  105,
+                  116,
+                  121
+                ]
+              }
+            ]
+          }
+        },
+        {
+          name: "rent_receiver",
+          writable: true
+        },
+        {
+          name: "owner",
+          docs: [
+            "Owner of position"
+          ],
+          signer: true
+        },
+        {
+          name: "token_program",
+          docs: [
+            "Program to create NFT mint/token account and transfer for token22 account"
+          ],
+          address: "TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb"
+        },
+        {
+          name: "event_authority",
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  95,
+                  95,
+                  101,
+                  118,
+                  101,
+                  110,
+                  116,
+                  95,
+                  97,
+                  117,
+                  116,
+                  104,
+                  111,
+                  114,
+                  105,
+                  116,
+                  121
+                ]
+              }
+            ]
+          }
+        },
+        {
+          name: "program"
+        }
+      ],
+      args: []
+    },
     {
       name: "create_claim_fee_operator",
       discriminator: [
@@ -1161,7 +1278,7 @@ var cp_amm_default = {
     {
       name: "create_config",
       docs: [
-        "ADMIN FUNCTIONS ////"
+        "ADMIN FUNCTIONS /////"
       ],
       discriminator: [
         201,
@@ -3504,6 +3621,19 @@ var cp_amm_default = {
         5
       ]
     },
+    {
+      name: "EvtClosePosition",
+      discriminator: [
+        20,
+        145,
+        144,
+        68,
+        143,
+        142,
+        214,
+        178
+      ]
+    },
     {
       name: "EvtCreateClaimFeeOperator",
       discriminator: [
@@ -3895,6 +4025,11 @@ var cp_amm_default = {
       code: 6038,
       name: "FeeInverseIsIncorrect",
       msg: "Fee inverse is incorrect"
+    },
+    {
+      code: 6039,
+      name: "PositionIsNotEmpty",
+      msg: "Position is not empty"
     }
   ],
   types: [
@@ -4408,6 +4543,14 @@ var cp_amm_default = {
               }
             }
           },
+          {
+            name: "token_a_amount",
+            type: "u64"
+          },
+          {
+            name: "token_b_amount",
+            type: "u64"
+          },
           {
             name: "total_amount_a",
             type: "u64"
@@ -4563,6 +4706,30 @@ var cp_amm_default = {
         ]
       }
     },
+    {
+      name: "EvtClosePosition",
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "pool",
+            type: "pubkey"
+          },
+          {
+            name: "owner",
+            type: "pubkey"
+          },
+          {
+            name: "position",
+            type: "pubkey"
+          },
+          {
+            name: "position_nft_mint",
+            type: "pubkey"
+          }
+        ]
+      }
+    },
     {
       name: "EvtCreateClaimFeeOperator",
       docs: [
@@ -4705,6 +4872,10 @@ var cp_amm_default = {
       type: {
         kind: "struct",
         fields: [
+          {
+            name: "pool",
+            type: "pubkey"
+          },
           {
             name: "token_a_mint",
             type: "pubkey"
@@ -4769,6 +4940,14 @@ var cp_amm_default = {
             name: "token_b_flag",
             type: "u8"
           },
+          {
+            name: "token_a_amount",
+            type: "u64"
+          },
+          {
+            name: "token_b_amount",
+            type: "u64"
+          },
           {
             name: "total_amount_a",
             type: "u64"
@@ -4870,11 +5049,11 @@ var cp_amm_default = {
             type: "pubkey"
           },
           {
-            name: "liquidity",
+            name: "lock_liquidity_amount",
             type: "u128"
           },
           {
-            name: "pool_new_permanent_locked_liquidity",
+            name: "total_permanent_locked_liquidity",
             type: "u128"
           }
         ]
@@ -4906,11 +5085,11 @@ var cp_amm_default = {
             }
           },
           {
-            name: "amount_a",
+            name: "token_a_amount",
             type: "u64"
           },
           {
-            name: "amount_b",
+            name: "token_b_amount",
             type: "u64"
           }
         ]
@@ -4946,7 +5125,7 @@ var cp_amm_default = {
             type: "u8"
           },
           {
-            name: "is_referral",
+            name: "has_referral",
             type: "bool"
           },
           {
@@ -4966,7 +5145,7 @@ var cp_amm_default = {
             }
           },
           {
-            name: "transfer_fee_excluded_amount_in",
+            name: "actual_amount_in",
             type: "u64"
           },
           {
@@ -6285,9 +6464,16 @@ function deriveEventAuthority(programId) {
     programId
   );
 }
+function deriveTokenBadge(tokenMint, programId) {
+  return PublicKey2.findProgramAddressSync(
+    [Buffer.from("token_badge"), tokenMint.toBuffer()],
+    programId
+  )[0];
+}
 
 // src/helpers/token.ts
 import {
+  AccountLayout,
   createAssociatedTokenAccountIdempotentInstruction,
   createCloseAccountInstruction,
   getAccount,
@@ -6384,6 +6570,21 @@ function getNftOwner(connection, nftMint) {
     return new PublicKey3(owner);
   });
 }
+function getAllNftByUser(_0, _1) {
+  return __async(this, arguments, function* (connection, user, tokenProgram = TOKEN_2022_PROGRAM_ID) {
+    const allUserTokenAccounts = yield connection.getTokenAccountsByOwner(user, {
+      programId: tokenProgram
+    });
+    const userNfts = [];
+    for (const { account } of allUserTokenAccounts.value) {
+      const tokenAccountData = AccountLayout.decode(account.data);
+      if (tokenAccountData.amount.toString() === "1") {
+        userNfts.push(tokenAccountData.mint.toString());
+      }
+    }
+    return userNfts;
+  });
+}
 
 // src/helpers/fee.ts
 import { BN as BN5 } from "@coral-xyz/anchor";
@@ -6605,19 +6806,25 @@ function getLiquidityDeltaFromAmountB(maxAmountB, lowerSqrtPrice, upperSqrtPrice
   );
   return new BN4(prod.div(denominator).floor().toFixed());
 }
-function getAmountAFromLiquidityDelta(liquidity, currentSqrtPrice, maxSqrtPrice) {
+function getAmountAFromLiquidityDelta(liquidity, currentSqrtPrice, maxSqrtPrice, rounding) {
   const prod = new Decimal2(liquidity.toString()).mul(
     new Decimal2(maxSqrtPrice.sub(currentSqrtPrice).toString())
   );
   const denominator = currentSqrtPrice.mul(maxSqrtPrice);
   const result = prod.mul(Decimal2.pow(2, 64)).div(new Decimal2(denominator.toString()));
+  if (rounding == 0 /* Up */) {
+    return result.div(Decimal2.pow(2, 64)).ceil().toFixed();
+  }
   return result.div(Decimal2.pow(2, 64)).floor().toFixed();
 }
-function getAmountBFromLiquidityDelta(liquidity, currentSqrtPrice, minSqrtPrice) {
+function getAmountBFromLiquidityDelta(liquidity, currentSqrtPrice, minSqrtPrice, rounding) {
   const delta = currentSqrtPrice.sub(minSqrtPrice);
   const prod = new Decimal2(liquidity.toString()).mul(
     new Decimal2(delta.toString())
   );
+  if (rounding == 0 /* Up */) {
+    return prod.div(Decimal2.pow(2, 128)).ceil().toFixed();
+  }
   return prod.div(Decimal2.pow(2, 128)).floor().toFixed();
 }
 
@@ -6705,8 +6912,8 @@ function getSwapAmount(inAmount, sqrtPrice, liquidity, tradeFeeNumerator, aToB,
     liquidity,
     1 /* Down */
   );
-  const actualOutAmount = feeMode.feeOnInput ? outAmount : (totalFee = getTotalFeeOnAmount(outAmount, tradeFeeNumerator), outAmount.sub(totalFee));
-  return { actualOutAmount, totalFee };
+  const amountOut = feeMode.feeOnInput ? outAmount : (totalFee = getTotalFeeOnAmount(outAmount, tradeFeeNumerator), outAmount.sub(totalFee));
+  return { amountOut, totalFee };
 }
 
 // src/helpers/computeUnits.ts
@@ -6866,7 +7073,90 @@ function calculateInitSqrtPrice(tokenAAmount, tokenBAmount, minSqrtPrice, maxSqr
   return new BN7(result.floor().toFixed());
 }
 
+// src/helpers/token2022.ts
+import { BN as BN8 } from "@coral-xyz/anchor";
+import {
+  calculateFee,
+  getEpochFee,
+  getTransferFeeConfig,
+  MAX_FEE_BASIS_POINTS
+} from "@solana/spl-token";
+function calculatePreFeeAmount(transferFee, postFeeAmount) {
+  if (postFeeAmount.isZero()) {
+    return new BN8(0);
+  }
+  if (transferFee.transferFeeBasisPoints === 0) {
+    return postFeeAmount;
+  }
+  const maximumFee = new BN8(transferFee.maximumFee.toString());
+  if (transferFee.transferFeeBasisPoints === MAX_FEE_BASIS_POINTS) {
+    return postFeeAmount.add(maximumFee);
+  }
+  const ONE_IN_BASIS_POINTS = new BN8(MAX_FEE_BASIS_POINTS);
+  const numerator = postFeeAmount.mul(ONE_IN_BASIS_POINTS);
+  const denominator = ONE_IN_BASIS_POINTS.sub(
+    new BN8(transferFee.transferFeeBasisPoints)
+  );
+  const rawPreFeeAmount = numerator.add(denominator).sub(new BN8(1)).div(denominator);
+  if (rawPreFeeAmount.sub(postFeeAmount).gte(maximumFee)) {
+    return postFeeAmount.add(maximumFee);
+  }
+  return rawPreFeeAmount;
+}
+function calculateInverseFee(transferFee, postFeeAmount) {
+  const preFeeAmount = calculatePreFeeAmount(transferFee, postFeeAmount);
+  return new BN8(
+    calculateFee(transferFee, BigInt(preFeeAmount.toString())).toString()
+  );
+}
+function calculateTransferFeeIncludedAmount(transferFeeExcludedAmount, mint, currentEpoch) {
+  if (transferFeeExcludedAmount.isZero()) {
+    return {
+      amount: new BN8(0),
+      transferFee: new BN8(0)
+    };
+  }
+  const transferFeeConfig = getTransferFeeConfig(mint);
+  if (transferFeeConfig === null) {
+    return {
+      amount: transferFeeExcludedAmount,
+      transferFee: new BN8(0)
+    };
+  }
+  const epochFee = getEpochFee(transferFeeConfig, BigInt(currentEpoch));
+  const transferFee = epochFee.transferFeeBasisPoints == MAX_FEE_BASIS_POINTS ? new BN8(epochFee.maximumFee.toString()) : calculateInverseFee(epochFee, transferFeeExcludedAmount);
+  const transferFeeIncludedAmount = transferFeeExcludedAmount.add(transferFee);
+  return {
+    amount: transferFeeIncludedAmount,
+    transferFee
+  };
+}
+function calculateTransferFeeExcludedAmount(transferFeeIncludedAmount, mint, currentEpoch) {
+  const transferFeeConfig = getTransferFeeConfig(mint);
+  if (transferFeeConfig === null) {
+    return {
+      amount: transferFeeIncludedAmount,
+      transferFee: new BN8(0)
+    };
+  }
+  const transferFeeIncludedAmountN = BigInt(
+    transferFeeIncludedAmount.toString()
+  );
+  const transferFee = calculateFee(
+    getEpochFee(transferFeeConfig, BigInt(currentEpoch)),
+    transferFeeIncludedAmountN
+  );
+  const transferFeeExcludedAmount = new BN8(
+    (transferFeeIncludedAmountN - transferFee).toString()
+  );
+  return {
+    amount: transferFeeExcludedAmount,
+    transferFee: new BN8(transferFee.toString())
+  };
+}
+
 // src/CpAmm.ts
+import { min } from "bn.js";
 var CpAmm = class {
   constructor(connection) {
     this._program = new Program(cp_amm_default, {
@@ -6889,7 +7179,7 @@ var CpAmm = class {
   preparePoolCreationParams(params) {
     return __async(this, null, function* () {
       const { tokenAAmount, tokenBAmount, minSqrtPrice, maxSqrtPrice } = params;
-      if (tokenAAmount.eq(new BN8(0)) && tokenBAmount.eq(new BN8(0))) {
+      if (tokenAAmount.eq(new BN9(0)) && tokenBAmount.eq(new BN9(0))) {
         throw new Error("Invalid input amount");
       }
       if (minSqrtPrice.gt(maxSqrtPrice)) {
@@ -6920,6 +7210,26 @@ var CpAmm = class {
       };
     });
   }
+  /**
+   * Derives token badge account metadata
+   * @param tokenAMint - Public key of token A mint
+   * @param tokenBMint - Public key of token B mint
+   * @returns Array of account metadata for token badges
+   */
+  getTokenBadgeAccounts(tokenAMint, tokenBMint) {
+    return [
+      {
+        pubkey: deriveTokenBadge(tokenAMint, this._program.programId),
+        isWritable: false,
+        isSigner: false
+      },
+      {
+        pubkey: deriveTokenBadge(tokenBMint, this._program.programId),
+        isWritable: false,
+        isSigner: false
+      }
+    ];
+  }
   /**
    * Fetches the Config state of the program.
    * @param config - Public key of the config account.
@@ -7013,16 +7323,13 @@ var CpAmm = class {
       const positions = yield this._program.account.position.all([
         positionByPoolFilter(pool)
       ]);
-      const result = [];
-      for (const position of positions) {
-        const owner = yield getNftOwner(
-          this._program.provider.connection,
-          position.account.nftMint
-        );
-        if (owner.equals(user)) {
-          result.push(position);
-        }
-      }
+      const userNfts = yield getAllNftByUser(
+        this._program.provider.connection,
+        user
+      );
+      const result = positions.filter(
+        (item) => userNfts.includes(item.account.nftMint.toString())
+      );
       return result;
     });
   }
@@ -7033,17 +7340,14 @@ var CpAmm = class {
    */
   getPositionsByUser(user) {
     return __async(this, null, function* () {
+      const userNfts = yield getAllNftByUser(
+        this._program.provider.connection,
+        user
+      );
       const positions = yield this._program.account.position.all();
-      const result = [];
-      for (const position of positions) {
-        const owner = yield getNftOwner(
-          this._program.provider.connection,
-          position.account.nftMint
-        );
-        if (owner.equals(user)) {
-          result.push(position);
-        }
-      }
+      const result = positions.filter(
+        (item) => userNfts.includes(item.account.nftMint.toString())
+      );
       return result;
     });
   }
@@ -7062,8 +7366,16 @@ var CpAmm = class {
    */
   getQuote(params) {
     return __async(this, null, function* () {
-      var _a;
-      const { inAmount, inputTokenMint, slippage, poolState } = params;
+      const {
+        inAmount,
+        inputTokenMint,
+        slippage,
+        poolState,
+        currentTime,
+        currentSlot,
+        inputTokenInfo,
+        outputTokenInfo
+      } = params;
       const {
         sqrtPrice: sqrtPriceQ64,
         liquidity: liquidityQ64,
@@ -7080,13 +7392,16 @@ var CpAmm = class {
         periodFrequency
       } = poolFees.baseFee;
       const dynamicFee = poolFees.dynamicFee;
+      let actualAmountIn = inAmount;
+      if (inputTokenInfo) {
+        actualAmountIn = calculateTransferFeeExcludedAmount(
+          inAmount,
+          inputTokenInfo.mint,
+          inputTokenInfo.currentEpoch
+        ).amount;
+      }
       const aToB = poolState.tokenAMint.equals(inputTokenMint);
-      const slot = yield this._program.provider.connection.getSlot();
-      const blockInfo = yield this._program.provider.connection.getBlock(slot, {
-        maxSupportedTransactionVersion: 0
-      });
-      const currentTime = (_a = blockInfo == null ? void 0 : blockInfo.blockTime) != null ? _a : Math.floor(Date.now() / 1e3);
-      const currentPoint = activationType ? currentTime : slot;
+      const currentPoint = activationType ? currentTime : currentSlot;
       let dynamicFeeParams;
       if (dynamicFee.initialized) {
         const { volatilityAccumulator, binStep, variableFeeControl } = dynamicFee;
@@ -7102,24 +7417,30 @@ var CpAmm = class {
         reductionFactor,
         dynamicFeeParams
       );
-      const { actualOutAmount, totalFee } = getSwapAmount(
-        inAmount,
+      const { amountOut, totalFee } = getSwapAmount(
+        actualAmountIn,
         sqrtPriceQ64,
         liquidityQ64,
         tradeFeeNumerator,
         aToB,
         collectFeeMode
       );
-      const minSwapOutAmount = getMinAmountWithSlippage(
-        actualOutAmount,
-        slippage
-      );
+      let actualAmoutOut = amountOut;
+      if (outputTokenInfo) {
+        actualAmoutOut = calculateTransferFeeExcludedAmount(
+          amountOut,
+          outputTokenInfo.mint,
+          outputTokenInfo.currentEpoch
+        ).amount;
+      }
+      const minSwapOutAmount = getMinAmountWithSlippage(actualAmoutOut, slippage);
       return {
         swapInAmount: inAmount,
-        swapOutAmount: actualOutAmount,
+        consumedInAmount: actualAmountIn,
+        swapOutAmount: actualAmoutOut,
         minSwapOutAmount,
         totalFee,
-        priceImpact: getPriceImpact(minSwapOutAmount, actualOutAmount)
+        priceImpact: getPriceImpact(minSwapOutAmount, actualAmoutOut)
       };
     });
   }
@@ -7136,19 +7457,37 @@ var CpAmm = class {
         maxAmountTokenB,
         sqrtMaxPrice,
         sqrtMinPrice,
-        sqrtPrice
+        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;
+      }
       const liquidityDeltaFromAmountA = getLiquidityDeltaFromAmountA(
-        maxAmountTokenA,
+        actualMaxAmountTokenA,
         sqrtPrice,
         sqrtMaxPrice
       );
       const liquidityDeltaFromAmountB = getLiquidityDeltaFromAmountB(
-        maxAmountTokenB,
+        actualMaxAmountTokenB,
         sqrtMinPrice,
         sqrtPrice
       );
-      return liquidityDeltaFromAmountA.gte(liquidityDeltaFromAmountB) ? liquidityDeltaFromAmountB : liquidityDeltaFromAmountA;
+      return min(liquidityDeltaFromAmountA, liquidityDeltaFromAmountB);
     });
   }
   /**
@@ -7250,11 +7589,15 @@ var CpAmm = class {
         );
         preInstructions.push(...wrapSOLIx);
       }
+      const tokenBadgeAccounts = this.getTokenBadgeAccounts(
+        tokenAMint,
+        tokenBMint
+      );
       const tx = yield this._program.methods.initializePool({
         liquidity: liquidityQ64,
         sqrtPrice: sqrtPriceQ64,
         activationPoint
-      }).accountsStrict({
+      }).accountsPartial({
         creator,
         positionNftAccount,
         positionNftMint: positionNft,
@@ -7272,10 +7615,8 @@ var CpAmm = class {
         token2022Program: TOKEN_2022_PROGRAM_ID2,
         tokenAProgram,
         tokenBProgram,
-        systemProgram: SystemProgram2.programId,
-        eventAuthority: deriveEventAuthority(this._program.programId)[0],
-        program: this._program.programId
-      }).preInstructions(preInstructions).transaction();
+        systemProgram: SystemProgram2.programId
+      }).preInstructions(preInstructions).remainingAccounts(tokenBadgeAccounts).transaction();
       return tx;
     });
   }
@@ -7380,6 +7721,10 @@ var CpAmm = class {
         );
         preInstructions.push(...wrapSOLIx);
       }
+      const tokenBadgeAccounts = this.getTokenBadgeAccounts(
+        tokenAMint,
+        tokenBMint
+      );
       const transaction = yield this._program.methods.initializeCustomizablePool({
         poolFees,
         sqrtMinPrice: MIN_SQRT_PRICE,
@@ -7390,7 +7735,7 @@ var CpAmm = class {
         activationType,
         collectFeeMode,
         activationPoint
-      }).accountsStrict({
+      }).accountsPartial({
         creator,
         positionNftAccount,
         positionNftMint: positionNft,
@@ -7407,10 +7752,8 @@ var CpAmm = class {
         token2022Program: TOKEN_2022_PROGRAM_ID2,
         tokenAProgram,
         tokenBProgram,
-        systemProgram: SystemProgram2.programId,
-        eventAuthority: deriveEventAuthority(this._program.programId)[0],
-        program: this._program.programId
-      }).preInstructions(preInstructions).transaction();
+        systemProgram: SystemProgram2.programId
+      }).preInstructions(preInstructions).remainingAccounts(tokenBadgeAccounts).transaction();
       return { tx: transaction, pool, position };
     });
   }
@@ -7624,6 +7967,80 @@ var CpAmm = class {
       }).preInstructions(preInstructions).postInstructions(postInstructions).transaction();
     });
   }
+  /**
+   * Builds a transaction to remove liquidity from a position.
+   * @param {RemoveLiquidityParams} params - Parameters for removing liquidity.
+   * @returns Transaction builder.
+   */
+  removeAllLiquidity(params) {
+    return __async(this, null, function* () {
+      const {
+        owner,
+        pool,
+        position,
+        positionNftMint,
+        tokenAAmountThreshold,
+        tokenBAmountThreshold,
+        tokenAMint,
+        tokenBMint,
+        tokenAVault,
+        tokenBVault,
+        tokenAProgram,
+        tokenBProgram
+      } = params;
+      const positionNftAccount = derivePositionNftAccount(
+        positionNftMint,
+        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 postInstructions = [];
+      if ([tokenAMint.toBase58(), tokenBMint.toBase58()].includes(
+        NATIVE_MINT2.toBase58()
+      )) {
+        const closeWrappedSOLIx = yield unwrapSOLInstruction(owner);
+        closeWrappedSOLIx && postInstructions.push(closeWrappedSOLIx);
+      }
+      return yield this._program.methods.removeAllLiquidity(tokenAAmountThreshold, tokenBAmountThreshold).accountsPartial({
+        poolAuthority,
+        pool,
+        position,
+        positionNftAccount,
+        owner,
+        tokenAAccount,
+        tokenBAccount,
+        tokenAMint,
+        tokenBMint,
+        tokenAVault,
+        tokenBVault,
+        tokenAProgram,
+        tokenBProgram
+      }).preInstructions(preInstructions).postInstructions(postInstructions).transaction();
+    });
+  }
   /**
    * Builds a transaction to perform a swap in the pool.
    * @param {SwapParams} params - Parameters for swapping tokens.
@@ -7875,6 +8292,26 @@ var CpAmm = class {
       }).preInstructions(preInstructions).postInstructions(postInstructions).transaction();
     });
   }
+  closePosition(params) {
+    return __async(this, null, function* () {
+      const { owner, pool, position, positionNftMint } = params;
+      const poolAuthority = derivePoolAuthority(this._program.programId);
+      const positionNftAccount = derivePositionNftAccount(
+        positionNftMint,
+        this._program.programId
+      );
+      return yield this._program.methods.closePosition().accountsPartial({
+        positionNftMint,
+        positionNftAccount,
+        pool,
+        position,
+        poolAuthority,
+        rentReceiver: owner,
+        owner,
+        tokenProgram: TOKEN_2022_PROGRAM_ID2
+      }).transaction();
+    });
+  }
   /**
    * Builds a transaction to update reward duration.
    * @param {UpdateRewardDurationParams} params - Parameters including pool and new duration.
@@ -8131,6 +8568,8 @@ export {
   SCALE_OFFSET,
   TradeDirection,
   calculateInitSqrtPrice,
+  calculateTransferFeeExcludedAmount,
+  calculateTransferFeeIncludedAmount,
   decimalToQ64,
   index_default as default,
   deriveClaimFeeOperatorAddress,
@@ -8142,9 +8581,11 @@ export {
   derivePositionAddress,
   derivePositionNftAccount,
   deriveRewardVaultAddress,
+  deriveTokenBadge,
   deriveTokenBadgeAddress,
   deriveTokenVaultAddress,
   divCeil,
+  getAllNftByUser,
   getAmountAFromLiquidityDelta,
   getAmountBFromLiquidityDelta,
   getBaseFeeNumerator,