@meteora-ag/cp-amm-sdk 1.0.1-rc.3 → 1.0.1-rc.31

package/dist/index.mjs

@@ -1,3 +1,4 @@
+var __pow = Math.pow;
 var __async = (__this, __arguments, generator) => {
   return new Promise((resolve, reject) => {
     var fulfilled = (value) => {
@@ -20,14 +21,9 @@ var __async = (__this, __arguments, generator) => {
 };
 
 // src/CpAmm.ts
-import { Program } from "@coral-xyz/anchor";
-import {
-  getAssociatedTokenAddressSync as getAssociatedTokenAddressSync2,
-  NATIVE_MINT as NATIVE_MINT2,
-  TOKEN_2022_PROGRAM_ID as TOKEN_2022_PROGRAM_ID2
-} from "@solana/spl-token";
+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";
-import Decimal3 from "decimal.js";
 
 // src/idl/cp_amm.json
 var cp_amm_default = {
@@ -1074,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: [
@@ -1165,7 +1278,7 @@ var cp_amm_default = {
     {
       name: "create_config",
       docs: [
-        "ADMIN FUNCTIONS ////"
+        "ADMIN FUNCTIONS /////"
       ],
       discriminator: [
         201,
@@ -3508,6 +3621,19 @@ var cp_amm_default = {
         5
       ]
     },
+    {
+      name: "EvtClosePosition",
+      discriminator: [
+        20,
+        145,
+        144,
+        68,
+        143,
+        142,
+        214,
+        178
+      ]
+    },
     {
       name: "EvtCreateClaimFeeOperator",
       discriminator: [
@@ -3899,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: [
@@ -4412,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"
@@ -4567,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: [
@@ -4709,6 +4872,10 @@ var cp_amm_default = {
       type: {
         kind: "struct",
         fields: [
+          {
+            name: "pool",
+            type: "pubkey"
+          },
           {
             name: "token_a_mint",
             type: "pubkey"
@@ -4773,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"
@@ -4874,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"
           }
         ]
@@ -4910,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"
           }
         ]
@@ -4950,7 +5125,7 @@ var cp_amm_default = {
             type: "u8"
           },
           {
-            name: "is_referral",
+            name: "has_referral",
             type: "bool"
           },
           {
@@ -4970,7 +5145,7 @@ var cp_amm_default = {
             }
           },
           {
-            name: "transfer_fee_excluded_amount_in",
+            name: "actual_amount_in",
             type: "u64"
           },
           {
@@ -6176,26 +6351,63 @@ var cp_amm_default = {
 
 // src/CpAmm.ts
 import {
+  Transaction,
   SystemProgram as SystemProgram2
 } from "@solana/web3.js";
 
+// 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
+import { PublicKey as PublicKey2 } from "@solana/web3.js";
+
 // src/constants.ts
 import { BN } from "@coral-xyz/anchor";
 import { PublicKey } from "@solana/web3.js";
 var CP_AMM_PROGRAM_ID = new PublicKey(
   "cpamdpZCGKUy5JxQXB4dcpGPiikHawvSWAd6mEn1sGG"
 );
+var LIQUIDITY_SCALE = 128;
 var SCALE_OFFSET = 64;
 var BASIS_POINT_MAX = 1e4;
 var MAX_FEE_NUMERATOR = 5e8;
 var FEE_DENOMINATOR = 1e9;
+var PRECISION = 1e6;
 var MIN_SQRT_PRICE = new BN("4295048016");
 var MAX_SQRT_PRICE = new BN("79226673521066979257578248091");
 var MIN_CU_BUFFER = 5e4;
 var MAX_CU_BUFFER = 2e5;
 
 // src/pda.ts
-import { PublicKey as PublicKey2 } from "@solana/web3.js";
 function getFirstKey(key1, key2) {
   const buf1 = key1.toBuffer();
   const buf2 = key2.toBuffer();
@@ -6212,19 +6424,19 @@ function getSecondKey(key1, key2) {
   }
   return buf1;
 }
-function derivePoolAuthority(programId) {
+function derivePoolAuthority() {
   return PublicKey2.findProgramAddressSync(
     [Buffer.from("pool_authority")],
-    programId
+    CP_AMM_PROGRAM_ID
   )[0];
 }
-function deriveConfigAddress(index, programId) {
+function deriveConfigAddress(index) {
   return PublicKey2.findProgramAddressSync(
     [Buffer.from("config"), index.toArrayLike(Buffer, "le", 8)],
-    programId
+    CP_AMM_PROGRAM_ID
   )[0];
 }
-function derivePoolAddress(config, tokenAMint, tokenBMint, programId) {
+function derivePoolAddress(config, tokenAMint, tokenBMint) {
   return PublicKey2.findProgramAddressSync(
     [
       Buffer.from("pool"),
@@ -6232,124 +6444,66 @@ function derivePoolAddress(config, tokenAMint, tokenBMint, programId) {
       getFirstKey(tokenAMint, tokenBMint),
       getSecondKey(tokenAMint, tokenBMint)
     ],
-    programId
+    CP_AMM_PROGRAM_ID
   )[0];
 }
-function derivePositionAddress(positionNft, programId) {
+function derivePositionAddress(positionNft) {
   return PublicKey2.findProgramAddressSync(
     [Buffer.from("position"), positionNft.toBuffer()],
-    programId
+    CP_AMM_PROGRAM_ID
   )[0];
 }
-function deriveTokenVaultAddress(tokenMint, pool, programId) {
+function deriveTokenVaultAddress(tokenMint, pool) {
   return PublicKey2.findProgramAddressSync(
     [Buffer.from("token_vault"), tokenMint.toBuffer(), pool.toBuffer()],
-    programId
+    CP_AMM_PROGRAM_ID
   )[0];
 }
-function deriveRewardVaultAddress(pool, rewardIndex, programId) {
+function deriveRewardVaultAddress(pool, rewardIndex) {
   return PublicKey2.findProgramAddressSync(
     [Buffer.from("reward_vault"), pool.toBuffer(), Buffer.from([rewardIndex])],
-    programId
+    CP_AMM_PROGRAM_ID
   )[0];
 }
-function deriveCustomizablePoolAddress(tokenAMint, tokenBMint, programId) {
+function deriveCustomizablePoolAddress(tokenAMint, tokenBMint) {
   return PublicKey2.findProgramAddressSync(
     [
       Buffer.from("cpool"),
       getFirstKey(tokenAMint, tokenBMint),
       getSecondKey(tokenAMint, tokenBMint)
     ],
-    programId
+    CP_AMM_PROGRAM_ID
   )[0];
 }
-function deriveTokenBadgeAddress(tokenMint, programId) {
+function deriveTokenBadgeAddress(tokenMint) {
   return PublicKey2.findProgramAddressSync(
     [Buffer.from("token_badge"), tokenMint.toBuffer()],
-    programId
+    CP_AMM_PROGRAM_ID
   )[0];
 }
-function deriveClaimFeeOperatorAddress(operator, programId) {
+function deriveClaimFeeOperatorAddress(operator) {
   return PublicKey2.findProgramAddressSync(
     [Buffer.from("cf_operator"), operator.toBuffer()],
-    programId
+    CP_AMM_PROGRAM_ID
   )[0];
 }
-function derivePositionNftAccount(positionNftMint, programId) {
+function derivePositionNftAccount(positionNftMint) {
   return PublicKey2.findProgramAddressSync(
     [Buffer.from("position_nft_account"), positionNftMint.toBuffer()],
-    programId
+    CP_AMM_PROGRAM_ID
   )[0];
 }
-function deriveEventAuthority(programId) {
+function deriveTokenBadge(tokenMint) {
   return PublicKey2.findProgramAddressSync(
-    [Buffer.from("__event_authority")],
-    programId
-  );
-}
-
-// src/math/index.ts
-import { BN as BN2 } from "@coral-xyz/anchor";
-import Decimal from "decimal.js";
-
-// 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__ */ ((CollectFeeMode2) => {
-  CollectFeeMode2[CollectFeeMode2["BothToken"] = 0] = "BothToken";
-  CollectFeeMode2[CollectFeeMode2["OnlyB"] = 1] = "OnlyB";
-  return CollectFeeMode2;
-})(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/index.ts
-function mulDiv(x, y, denominator, rounding) {
-  const { div, mod } = x.mul(y).divmod(denominator);
-  if (rounding == 0 /* Up */ && !mod.isZero()) {
-    return div.add(new BN2(1));
-  }
-  return div;
-}
-function divCeil(a, b) {
-  if (a.isZero()) {
-    return new BN2(0);
-  }
-  return a.add(b.sub(new BN2(1))).div(b);
-}
-function decimalToQ64(num) {
-  return new BN2(num.mul(Decimal.pow(2, 64)).floor().toFixed());
-}
-function priceToSqrtPrice(initPrice, tokenADecimal, tokenBDecimal) {
-  const sqrtPriceQ64 = decimalToQ64(
-    initPrice.mul(Decimal.pow(10, tokenBDecimal - tokenADecimal)).sqrt()
-  );
-  return sqrtPriceQ64;
+    [Buffer.from("token_badge"), tokenMint.toBuffer()],
+    CP_AMM_PROGRAM_ID
+  )[0];
 }
 
-// src/utils/token.ts
+// src/helpers/token.ts
+import { bs58 } from "@coral-xyz/anchor/dist/cjs/utils/bytes";
 import {
+  AccountLayout,
   createAssociatedTokenAccountIdempotentInstruction,
   createCloseAccountInstruction,
   getAccount,
@@ -6362,6 +6516,7 @@ import {
   TokenInvalidAccountOwnerError
 } from "@solana/spl-token";
 import {
+  PublicKey as PublicKey3,
   SystemProgram,
   TransactionInstruction
 } from "@solana/web3.js";
@@ -6435,15 +6590,59 @@ var unwrapSOLInstruction = (owner, allowOwnerOffCurve = true) => __async(void 0,
   }
   return null;
 });
-
-// src/utils/fee.ts
-import { BN as BN4 } from "@coral-xyz/anchor";
+function getNftOwner(connection, nftMint) {
+  return __async(this, null, function* () {
+    const largesTokenAccount = yield connection.getTokenLargestAccounts(nftMint);
+    const accountInfo = yield connection.getParsedAccountInfo(
+      largesTokenAccount.value[0].address
+    );
+    const owner = new PublicKey3(accountInfo.value.data.parsed.info.owner);
+    return new PublicKey3(owner);
+  });
+}
+function getAllUserPositionNftAccount(connection, user) {
+  return __async(this, null, function* () {
+    const filters = [
+      {
+        memcmp: {
+          offset: 32,
+          bytes: user.toBase58()
+        }
+      },
+      {
+        memcmp: {
+          offset: 64,
+          bytes: bs58.encode(Buffer.from([1, 0, 0, 0, 0, 0, 0, 0]))
+          // 1
+        }
+      }
+    ];
+    const tokenAccountsRaw = yield connection.getProgramAccounts(
+      TOKEN_2022_PROGRAM_ID,
+      {
+        filters
+      }
+    );
+    const userPositionNftAccount = [];
+    for (const { account, pubkey } of tokenAccountsRaw) {
+      const tokenAccountData = AccountLayout.decode(account.data);
+      userPositionNftAccount.push({
+        positionNft: tokenAccountData.mint,
+        positionNftAccount: pubkey
+      });
+    }
+    return userPositionNftAccount;
+  });
+}
+
+// src/helpers/fee.ts
+import { BN as BN5 } from "@coral-xyz/anchor";
 
 // src/math/feeMath.ts
-import { BN as BN3 } from "@coral-xyz/anchor";
-var MAX_EXPONENTIAL = new BN3(524288);
-var ONE = new BN3(1).shln(SCALE_OFFSET);
-var MAX = new BN3(2).pow(new BN3(128)).sub(new BN3(1));
+import { BN as BN2 } from "@coral-xyz/anchor";
+var MAX_EXPONENTIAL = new BN2(524288);
+var ONE = new BN2(1).shln(SCALE_OFFSET);
+var MAX = new BN2(2).pow(new BN2(128)).sub(new BN2(1));
 function pow(base, exp) {
   let invert = exp.isNeg();
   if (exp.isZero()) {
@@ -6451,7 +6650,7 @@ function pow(base, exp) {
   }
   exp = invert ? exp.abs() : exp;
   if (exp.gt(MAX_EXPONENTIAL)) {
-    return new BN3(0);
+    return new BN2(0);
   }
   let squaredBase = base;
   let result = ONE;
@@ -6459,83 +6658,83 @@ function pow(base, exp) {
     squaredBase = MAX.div(squaredBase);
     invert = !invert;
   }
-  if (!exp.and(new BN3(1)).isZero()) {
+  if (!exp.and(new BN2(1)).isZero()) {
     result = result.mul(squaredBase).shrn(SCALE_OFFSET);
   }
   squaredBase = squaredBase.mul(squaredBase).shrn(SCALE_OFFSET);
-  if (!exp.and(new BN3(2)).isZero()) {
+  if (!exp.and(new BN2(2)).isZero()) {
     result = result.mul(squaredBase).shrn(SCALE_OFFSET);
   }
   squaredBase = squaredBase.mul(squaredBase).shrn(SCALE_OFFSET);
-  if (!exp.and(new BN3(4)).isZero()) {
+  if (!exp.and(new BN2(4)).isZero()) {
     result = result.mul(squaredBase).shrn(SCALE_OFFSET);
   }
   squaredBase = squaredBase.mul(squaredBase).shrn(SCALE_OFFSET);
-  if (!exp.and(new BN3(8)).isZero()) {
+  if (!exp.and(new BN2(8)).isZero()) {
     result = result.mul(squaredBase).shrn(SCALE_OFFSET);
   }
   squaredBase = squaredBase.mul(squaredBase).shrn(SCALE_OFFSET);
-  if (!exp.and(new BN3(16)).isZero()) {
+  if (!exp.and(new BN2(16)).isZero()) {
     result = result.mul(squaredBase).shrn(SCALE_OFFSET);
   }
   squaredBase = squaredBase.mul(squaredBase).shrn(SCALE_OFFSET);
-  if (!exp.and(new BN3(32)).isZero()) {
+  if (!exp.and(new BN2(32)).isZero()) {
     result = result.mul(squaredBase).shrn(SCALE_OFFSET);
   }
   squaredBase = squaredBase.mul(squaredBase).shrn(SCALE_OFFSET);
-  if (!exp.and(new BN3(64)).isZero()) {
+  if (!exp.and(new BN2(64)).isZero()) {
     result = result.mul(squaredBase).shrn(SCALE_OFFSET);
   }
   squaredBase = squaredBase.mul(squaredBase).shrn(SCALE_OFFSET);
-  if (!exp.and(new BN3(128)).isZero()) {
+  if (!exp.and(new BN2(128)).isZero()) {
     result = result.mul(squaredBase).shrn(SCALE_OFFSET);
   }
   squaredBase = squaredBase.mul(squaredBase).shrn(SCALE_OFFSET);
-  if (!exp.and(new BN3(256)).isZero()) {
+  if (!exp.and(new BN2(256)).isZero()) {
     result = result.mul(squaredBase).shrn(SCALE_OFFSET);
   }
   squaredBase = squaredBase.mul(squaredBase).shrn(SCALE_OFFSET);
-  if (!exp.and(new BN3(512)).isZero()) {
+  if (!exp.and(new BN2(512)).isZero()) {
     result = result.mul(squaredBase).shrn(SCALE_OFFSET);
   }
   squaredBase = squaredBase.mul(squaredBase).shrn(SCALE_OFFSET);
-  if (!exp.and(new BN3(1024)).isZero()) {
+  if (!exp.and(new BN2(1024)).isZero()) {
     result = result.mul(squaredBase).shrn(SCALE_OFFSET);
   }
   squaredBase = squaredBase.mul(squaredBase).shrn(SCALE_OFFSET);
-  if (!exp.and(new BN3(2048)).isZero()) {
+  if (!exp.and(new BN2(2048)).isZero()) {
     result = result.mul(squaredBase).shrn(SCALE_OFFSET);
   }
   squaredBase = squaredBase.mul(squaredBase).shrn(SCALE_OFFSET);
-  if (!exp.and(new BN3(4096)).isZero()) {
+  if (!exp.and(new BN2(4096)).isZero()) {
     result = result.mul(squaredBase).shrn(SCALE_OFFSET);
   }
   squaredBase = squaredBase.mul(squaredBase).shrn(SCALE_OFFSET);
-  if (!exp.and(new BN3(8192)).isZero()) {
+  if (!exp.and(new BN2(8192)).isZero()) {
     result = result.mul(squaredBase).shrn(SCALE_OFFSET);
   }
   squaredBase = squaredBase.mul(squaredBase).shrn(SCALE_OFFSET);
-  if (!exp.and(new BN3(16384)).isZero()) {
+  if (!exp.and(new BN2(16384)).isZero()) {
     result = result.mul(squaredBase).shrn(SCALE_OFFSET);
   }
   squaredBase = squaredBase.mul(squaredBase).shrn(SCALE_OFFSET);
-  if (!exp.and(new BN3(32768)).isZero()) {
+  if (!exp.and(new BN2(32768)).isZero()) {
     result = result.mul(squaredBase).shrn(SCALE_OFFSET);
   }
   squaredBase = squaredBase.mul(squaredBase).shrn(SCALE_OFFSET);
-  if (!exp.and(new BN3(65536)).isZero()) {
+  if (!exp.and(new BN2(65536)).isZero()) {
     result = result.mul(squaredBase).shrn(SCALE_OFFSET);
   }
   squaredBase = squaredBase.mul(squaredBase).shrn(SCALE_OFFSET);
-  if (!exp.and(new BN3(131072)).isZero()) {
+  if (!exp.and(new BN2(131072)).isZero()) {
     result = result.mul(squaredBase).shrn(SCALE_OFFSET);
   }
   squaredBase = squaredBase.mul(squaredBase).shrn(SCALE_OFFSET);
-  if (!exp.and(new BN3(262144)).isZero()) {
+  if (!exp.and(new BN2(262144)).isZero()) {
     result = result.mul(squaredBase).shrn(SCALE_OFFSET);
   }
   if (result.isZero()) {
-    return new BN3(0);
+    return new BN2(0);
   }
   if (invert) {
     result = MAX.div(result);
@@ -6543,52 +6742,40 @@ function pow(base, exp) {
   return result;
 }
 
-// src/utils/fee.ts
-function getBaseFeeNumerator(feeSchedulerMode, cliffFeeNumerator, period, reductionFactor) {
-  let feeNumerator;
-  if (feeSchedulerMode == 0 /* Linear */) {
-    feeNumerator = cliffFeeNumerator.sub(period.mul(reductionFactor));
-  } else {
-    const bps = reductionFactor.shln(SCALE_OFFSET).div(new BN4(BASIS_POINT_MAX));
-    const base = ONE.sub(bps);
-    const result = pow(base, period);
-    feeNumerator = cliffFeeNumerator.mul(result).shrn(SCALE_OFFSET);
-  }
-  return feeNumerator;
+// src/math/mathUtils.ts
+import { BN as BN3 } from "@coral-xyz/anchor";
+import Decimal from "decimal.js";
+function mulShr(x, y, offset, rounding) {
+  const denominator = new BN3(1).shln(offset);
+  return mulDiv(x, y, denominator, rounding);
 }
-function getDynamicFeeNumerator(volatilityAccumulator, binStep, variableFeeControl) {
-  const squareVfaBin = volatilityAccumulator.mul(binStep).pow(new BN4(2));
-  const vFee = squareVfaBin.mul(variableFeeControl);
-  return vFee.addn(99999999999).divn(1e11);
+function shlDiv(x, y, offset, rounding) {
+  const scale = new BN3(1).shln(offset);
+  return mulDiv(x, scale, y, rounding);
 }
-function getFeeNumerator(currentPoint, activationPoint, numberOfPeriod, periodFrequency, feeSchedulerMode, cliffFeeNumerator, reductionFactor, dynamicFeeParams) {
-  if (Number(periodFrequency) == 0) {
-    return cliffFeeNumerator;
+function mulDiv(x, y, denominator, rounding) {
+  const { div, mod } = x.mul(y).divmod(denominator);
+  if (rounding == 0 /* Up */ && !mod.isZero()) {
+    return div.add(new BN3(1));
   }
-  const period = new BN4(currentPoint).lt(activationPoint) ? new BN4(numberOfPeriod) : BN4.min(
-    new BN4(numberOfPeriod),
-    new BN4(currentPoint).sub(activationPoint).div(periodFrequency)
-  );
-  let feeNumerator = getBaseFeeNumerator(
-    feeSchedulerMode,
-    cliffFeeNumerator,
-    period,
-    reductionFactor
-  );
-  if (dynamicFeeParams) {
-    const { volatilityAccumulator, binStep, variableFeeControl } = dynamicFeeParams;
-    const dynamicFeeNumberator = getDynamicFeeNumerator(
-      volatilityAccumulator,
-      binStep,
-      variableFeeControl
-    );
-    feeNumerator.add(dynamicFeeNumberator);
+  return div;
+}
+function divCeil(a, b) {
+  if (a.isZero()) {
+    return new BN3(0);
   }
-  return feeNumerator.gt(new BN4(MAX_FEE_NUMERATOR)) ? new BN4(MAX_FEE_NUMERATOR) : feeNumerator;
+  return a.add(b.sub(new BN3(1))).div(b);
+}
+function q64ToDecimal(num, decimalPlaces) {
+  return new Decimal(num.toString()).div(Decimal.pow(2, 64)).toDecimalPlaces(decimalPlaces);
+}
+function decimalToQ64(num) {
+  return new BN3(num.mul(Decimal.pow(2, 64)).floor().toFixed());
 }
 
-// src/utils/curve.ts
-import { BN as BN5 } from "@coral-xyz/anchor";
+// src/helpers/curve.ts
+import { BN as BN4 } from "@coral-xyz/anchor";
+import Decimal2 from "decimal.js";
 function getNextSqrtPrice(amount, sqrtPrice, liquidity, aToB) {
   let result;
   if (aToB) {
@@ -6603,119 +6790,150 @@ function getNextSqrtPrice(amount, sqrtPrice, liquidity, aToB) {
 }
 function getDeltaAmountA(lowerSqrtPrice, upperSqrtPrice, liquidity, rounding) {
   const deltaSqrtPrice = upperSqrtPrice.sub(lowerSqrtPrice);
+  const prod = liquidity.mul(deltaSqrtPrice);
   const denominator = lowerSqrtPrice.mul(upperSqrtPrice);
-  return mulDiv(liquidity, deltaSqrtPrice, denominator, rounding);
+  const result = shlDiv(prod, denominator, SCALE_OFFSET, rounding);
+  return result.shrn(SCALE_OFFSET);
 }
 function getDeltaAmountB(lowerSqrtPrice, upperSqrtPrice, liquidity, rounding) {
   const deltaSqrtPrice = upperSqrtPrice.sub(lowerSqrtPrice);
   const prod = liquidity.mul(deltaSqrtPrice);
   let result;
   if (rounding == 0 /* Up */) {
-    const denominator = new BN5(1).shln(SCALE_OFFSET * 2);
+    const denominator = new BN4(1).shln(SCALE_OFFSET * 2);
     result = divCeil(prod, denominator);
   } else {
     result = prod.shrn(SCALE_OFFSET * 2);
   }
   return result;
 }
-function calculateSwap(inAmount, sqrtPrice, liquidity, tradeFeeNumerator, aToB, collectFeeMode) {
-  let outAmount;
-  let lpFee;
-  if (collectFeeMode === 0 /* BothToken */) {
-    if (aToB) {
-      const nextSqrtPrice = getNextSqrtPrice(
-        inAmount,
-        sqrtPrice,
-        liquidity,
-        true
-      );
-      outAmount = getDeltaAmountB(
-        nextSqrtPrice,
-        sqrtPrice,
-        liquidity,
-        1 /* Down */
-      );
-      lpFee = mulDiv(
-        outAmount,
-        tradeFeeNumerator,
-        new BN5(FEE_DENOMINATOR),
-        1 /* Down */
-      );
-    } else {
-      const nextSqrtPrice = getNextSqrtPrice(
-        inAmount,
-        sqrtPrice,
-        liquidity,
-        false
-      );
-      outAmount = getDeltaAmountA(
-        sqrtPrice,
-        nextSqrtPrice,
-        liquidity,
-        1 /* Down */
-      );
-      lpFee = mulDiv(
-        outAmount,
-        tradeFeeNumerator,
-        new BN5(new BN5(FEE_DENOMINATOR)),
-        1 /* Down */
-      );
-    }
+function getLiquidityDeltaFromAmountA(maxAmountA, lowerSqrtPrice, upperSqrtPrice) {
+  const prod = new Decimal2(
+    maxAmountA.mul(upperSqrtPrice.mul(lowerSqrtPrice)).toString()
+  );
+  const delta = new Decimal2(upperSqrtPrice.sub(lowerSqrtPrice).toString());
+  return new BN4(prod.div(delta).floor().toFixed());
+}
+function getLiquidityDeltaFromAmountB(maxAmountB, lowerSqrtPrice, upperSqrtPrice) {
+  const denominator = new Decimal2(
+    upperSqrtPrice.sub(lowerSqrtPrice).toString()
+  );
+  const prod = new Decimal2(maxAmountB.toString()).mul(
+    Decimal2.pow(2, SCALE_OFFSET * 2)
+  );
+  return new BN4(prod.div(denominator).floor().toFixed());
+}
+function 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, 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();
+}
+
+// src/helpers/fee.ts
+import Decimal3 from "decimal.js";
+function getBaseFeeNumerator(feeSchedulerMode, cliffFeeNumerator, period, reductionFactor) {
+  let feeNumerator;
+  if (feeSchedulerMode == 0 /* Linear */) {
+    feeNumerator = cliffFeeNumerator.sub(period.mul(reductionFactor));
   } else {
-    const nextSqrtPrice = getNextSqrtPrice(
-      inAmount,
-      sqrtPrice,
-      liquidity,
-      true
-    );
-    outAmount = getDeltaAmountB(
-      nextSqrtPrice,
-      sqrtPrice,
-      liquidity,
-      1 /* Down */
-    );
-    lpFee = mulDiv(
-      outAmount,
-      tradeFeeNumerator,
-      new BN5(FEE_DENOMINATOR),
-      1 /* Down */
+    const bps = reductionFactor.shln(SCALE_OFFSET).div(new BN5(BASIS_POINT_MAX));
+    const base = ONE.sub(bps);
+    const result = pow(base, period);
+    feeNumerator = cliffFeeNumerator.mul(result).shrn(SCALE_OFFSET);
+  }
+  return feeNumerator;
+}
+function getDynamicFeeNumerator(volatilityAccumulator, binStep, variableFeeControl) {
+  const volatilityAccumulatorDecimal = new Decimal3(
+    volatilityAccumulator.toString()
+  ).div(Decimal3.pow(2, 64));
+  const squareVfaBin = volatilityAccumulatorDecimal.mul(new Decimal3(binStep.toString())).pow(2);
+  const vFee = squareVfaBin.mul(new Decimal3(variableFeeControl.toString()));
+  return new BN5(
+    vFee.add(99999999999).div(1e11).floor().toFixed()
+  );
+}
+function getFeeNumerator(currentPoint, activationPoint, numberOfPeriod, periodFrequency, feeSchedulerMode, cliffFeeNumerator, reductionFactor, dynamicFeeParams) {
+  if (Number(periodFrequency) == 0) {
+    return cliffFeeNumerator;
+  }
+  const period = new BN5(currentPoint).lt(activationPoint) ? new BN5(numberOfPeriod) : BN5.min(
+    new BN5(numberOfPeriod),
+    new BN5(currentPoint).sub(activationPoint).div(periodFrequency)
+  );
+  let feeNumerator = getBaseFeeNumerator(
+    feeSchedulerMode,
+    cliffFeeNumerator,
+    period,
+    reductionFactor
+  );
+  if (dynamicFeeParams) {
+    const { volatilityAccumulator, binStep, variableFeeControl } = dynamicFeeParams;
+    const dynamicFeeNumberator = getDynamicFeeNumerator(
+      volatilityAccumulator,
+      binStep,
+      variableFeeControl
     );
-    if (aToB) {
-    } else {
-      lpFee = mulDiv(
-        inAmount,
-        tradeFeeNumerator,
-        new BN5(FEE_DENOMINATOR),
-        1 /* Down */
-      );
-      const nextSqrtPrice2 = getNextSqrtPrice(
-        inAmount.sub(lpFee),
-        sqrtPrice,
-        liquidity,
-        false
-      );
-      outAmount = getDeltaAmountA(
-        sqrtPrice,
-        nextSqrtPrice2,
-        liquidity,
-        1 /* Down */
-      );
-    }
+    feeNumerator.add(dynamicFeeNumberator);
   }
-  return { amountOutExcludedlpFee: outAmount.sub(lpFee), lpFee };
+  return feeNumerator.gt(new BN5(MAX_FEE_NUMERATOR)) ? new BN5(MAX_FEE_NUMERATOR) : feeNumerator;
 }
-function getLiquidityDeltaFromAmountA(maxAmountA, lowerSqrtPrice, upperSqrtPrice) {
-  const prod = maxAmountA.mul(upperSqrtPrice.mul(lowerSqrtPrice));
-  const delta = upperSqrtPrice.sub(lowerSqrtPrice);
-  return prod.div(delta);
+function getFeeMode(collectFeeMode, btoA) {
+  const feeOnInput = btoA && collectFeeMode === 1 /* OnlyB */;
+  const feesOnTokenA = btoA && collectFeeMode === 0 /* BothToken */;
+  return {
+    feeOnInput,
+    feesOnTokenA
+  };
 }
-function getLiquidityDeltaFromAmountB(maxAmountB, lowerSqrtPrice, upperSqrtPrice) {
-  const denominator = upperSqrtPrice.sub(lowerSqrtPrice);
-  const result = maxAmountB.shln(SCALE_OFFSET * 2).div(denominator);
-  return result;
+function getTotalFeeOnAmount(amount, tradeFeeNumerator) {
+  return mulDiv(
+    amount,
+    tradeFeeNumerator,
+    new BN5(FEE_DENOMINATOR),
+    0 /* Up */
+  );
+}
+function getSwapAmount(inAmount, sqrtPrice, liquidity, tradeFeeNumerator, aToB, collectFeeMode) {
+  let feeMode = getFeeMode(collectFeeMode, !aToB);
+  let actualInAmount = inAmount;
+  let totalFee = new BN5(0);
+  if (feeMode.feeOnInput) {
+    totalFee = getTotalFeeOnAmount(inAmount, tradeFeeNumerator);
+    actualInAmount = inAmount.sub(totalFee);
+  }
+  const outAmount = aToB ? getDeltaAmountB(
+    getNextSqrtPrice(actualInAmount, sqrtPrice, liquidity, true),
+    sqrtPrice,
+    liquidity,
+    1 /* Down */
+  ) : getDeltaAmountA(
+    sqrtPrice,
+    getNextSqrtPrice(actualInAmount, sqrtPrice, liquidity, false),
+    liquidity,
+    1 /* Down */
+  );
+  const amountOut = feeMode.feeOnInput ? outAmount : (totalFee = getTotalFeeOnAmount(outAmount, tradeFeeNumerator), outAmount.sub(totalFee));
+  return { amountOut, totalFee };
 }
 
-// src/utils/computeUnits.ts
+// src/helpers/computeUnits.ts
 import {
   ComputeBudgetProgram,
   PublicKey as PublicKey4,
@@ -6790,99 +7008,580 @@ var getEstimatedComputeUnitIxWithBuffer = (connection, instructions, feePayer, b
   return ComputeBudgetProgram.setComputeUnitLimit({ units });
 });
 
-// src/utils/utils.ts
+// src/helpers/utils.ts
 import { BN as BN6 } from "@coral-xyz/anchor";
-import Decimal2 from "decimal.js";
-var getMinAmountWithSlippage = (amount, slippageRate) => {
-  const slippage = (100 - slippageRate) / 100 * BASIS_POINT_MAX;
+import Decimal4 from "decimal.js";
+var getMaxAmountWithSlippage = (amount, rate) => {
+  const slippage = (100 + rate) / 100 * BASIS_POINT_MAX;
   return amount.mul(new BN6(slippage)).div(new BN6(BASIS_POINT_MAX));
 };
-var getPriceImpact = (amount, amountWithoutSlippage) => {
-  const diff = amountWithoutSlippage.sub(amount);
-  return new Decimal2(diff.toString()).div(new Decimal2(amountWithoutSlippage.toString())).mul(100).toNumber();
+var getMinAmountWithSlippage = (amount, rate) => {
+  const slippage = (100 - rate) / 100 * BASIS_POINT_MAX;
+  return amount.mul(new BN6(slippage)).div(new BN6(BASIS_POINT_MAX));
+};
+var getPriceImpact = (actualAmount, idealAmount) => {
+  const diff = idealAmount.sub(actualAmount);
+  return new Decimal4(diff.toString()).div(new Decimal4(idealAmount.toString())).mul(100).toNumber();
+};
+var getPriceFromSqrtPrice = (sqrtPrice, tokenADecimal, tokenBDecimal) => {
+  const decimalSqrtPrice = new Decimal4(sqrtPrice.toString());
+  const price = decimalSqrtPrice.mul(decimalSqrtPrice).mul(new Decimal4(__pow(10, tokenADecimal - tokenBDecimal))).div(Decimal4.pow(2, 128)).toString();
+  return price;
+};
+var getSqrtPriceFromPrice = (price, tokenADecimal, tokenBDecimal) => {
+  const decimalPrice = new Decimal4(price);
+  const adjustedByDecimals = decimalPrice.div(
+    new Decimal4(__pow(10, tokenADecimal - tokenBDecimal))
+  );
+  const sqrtValue = Decimal4.sqrt(adjustedByDecimals);
+  const sqrtValueQ64 = sqrtValue.mul(Decimal4.pow(2, 64));
+  return new BN6(sqrtValueQ64.floor().toFixed());
+};
+var getUnClaimReward = (poolState, positionState) => {
+  const totalPositionLiquidity = positionState.unlockedLiquidity.add(positionState.vestedLiquidity).add(positionState.permanentLockedLiquidity);
+  const feeAPerTokenStored = new BN6(
+    Buffer.from(poolState.feeAPerLiquidity).reverse()
+  ).sub(new BN6(Buffer.from(positionState.feeAPerTokenCheckpoint).reverse()));
+  const feeBPerTokenStored = new BN6(
+    Buffer.from(poolState.feeBPerLiquidity).reverse()
+  ).sub(new BN6(Buffer.from(positionState.feeBPerTokenCheckpoint).reverse()));
+  const feeA = totalPositionLiquidity.mul(feeAPerTokenStored).shrn(LIQUIDITY_SCALE);
+  const feeB = totalPositionLiquidity.mul(feeBPerTokenStored).shrn(LIQUIDITY_SCALE);
+  return {
+    feeTokenA: positionState.feeAPending.add(feeA),
+    feeTokenB: positionState.feeBPending.add(feeB),
+    rewards: positionState.rewardInfos.length > 0 ? positionState.rewardInfos.map((item) => item.rewardPendings) : []
+  };
+};
+
+// src/helpers/accountFilters.ts
+var positionByPoolFilter = (pool) => {
+  return {
+    memcmp: {
+      bytes: pool.toBase58(),
+      offset: 8
+    }
+  };
+};
+var vestingByPositionFilter = (position) => {
+  return {
+    memcmp: {
+      bytes: position.toBase58(),
+      offset: 8
+    }
+  };
 };
 
+// src/helpers/priceMath.ts
+import { BN as BN7 } from "@coral-xyz/anchor";
+import Decimal5 from "decimal.js";
+function calculateInitSqrtPrice(tokenAAmount, tokenBAmount, minSqrtPrice, maxSqrtPrice) {
+  if (tokenAAmount.isZero() || tokenBAmount.isZero()) {
+    throw new Error("Amount cannot be zero");
+  }
+  const amountADecimal = new Decimal5(tokenAAmount.toString());
+  const amountBDecimal = new Decimal5(tokenBAmount.toString());
+  const minSqrtPriceDecimal = new Decimal5(minSqrtPrice.toString()).div(
+    Decimal5.pow(2, 64)
+  );
+  const maxSqrtPriceDecimal = new Decimal5(maxSqrtPrice.toString()).div(
+    Decimal5.pow(2, 64)
+  );
+  const x = new Decimal5(1).div(maxSqrtPriceDecimal);
+  const y = amountBDecimal.div(amountADecimal);
+  const xy = x.mul(y);
+  const paMinusXY = minSqrtPriceDecimal.sub(xy);
+  const xyMinusPa = xy.sub(minSqrtPriceDecimal);
+  const fourY = new Decimal5(4).mul(y);
+  const discriminant = xyMinusPa.mul(xyMinusPa).add(fourY);
+  const sqrtDiscriminant = discriminant.sqrt();
+  const result = paMinusXY.add(sqrtDiscriminant).div(new Decimal5(2)).mul(Decimal5.pow(2, 64));
+  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, {
       connection
     });
+    this.poolAuthority = derivePoolAuthority();
   }
+  /**
+   * Returns the Anchor program instance.
+   * @returns The AmmProgram instance.
+   */
   getProgram() {
     return this._program;
   }
   /**
-    Prepares token ordering, calculates the initial sqrtPrice in Q64 format,
-    @private
-    @async
-    @param {PublicKey} tokenX - One token mint address in the pair.
-    @param {PublicKey} tokenY - The other token mint address in the pair.
-    @param {Decimal} initialPrice - The initial price ratio of tokenX/tokenY (will be inverted if needed).
-    @param {Decimal} liquidity - The initial liquidity value.
-    @returns {PreparedPoolCreation} Object containing the ordered token mints and their Q64 price/liquidity values. 
-  */
-  preparePoolCreationParams(params) {
-    return __async(this, null, function* () {
-      const { tokenAAmount, tokenBAmount, tokenADecimal, tokenBDecimal } = params;
-      const initPrice = tokenBAmount.div(tokenAAmount);
-      const sqrtPriceQ64 = priceToSqrtPrice(
-        new Decimal3(initPrice.toString()),
-        tokenADecimal,
-        tokenBDecimal
-      );
-      if (sqrtPriceQ64.lt(MIN_SQRT_PRICE) || sqrtPriceQ64.gt(MAX_SQRT_PRICE)) {
-        throw new Error(`Invalid sqrt price: ${sqrtPriceQ64.toString()}`);
-      }
-      const liquidityDeltaFromAmountA = getLiquidityDeltaFromAmountA(
-        tokenAAmount,
-        sqrtPriceQ64,
-        MAX_SQRT_PRICE
-      );
-      const liquidityDeltaFromAmountB = getLiquidityDeltaFromAmountB(
-        tokenBAmount,
-        MIN_SQRT_PRICE,
-        sqrtPriceQ64
-      );
-      const liquidityQ64 = liquidityDeltaFromAmountA.gte(
-        liquidityDeltaFromAmountB
-      ) ? liquidityDeltaFromAmountB : liquidityDeltaFromAmountA;
-      return {
-        sqrtPriceQ64,
-        liquidityQ64
-      };
-    });
-  }
-  // fetcher
-  fetchConfigState(config) {
+   * 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 configState = yield this._program.account.config.fetchNullable(
-        config
-      );
-      invariant(configState, `Config account: ${config} not found`);
-      return configState;
+      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 };
     });
   }
-  fetchPoolState(pool) {
-    return __async(this, null, function* () {
-      const poolState = yield this._program.account.pool.fetchNullable(pool);
-      invariant(poolState, `Pool account: ${pool} not found`);
-      return poolState;
-    });
+  /**
+   * 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),
+        isWritable: false,
+        isSigner: false
+      },
+      {
+        pubkey: deriveTokenBadge(tokenBMint),
+        isWritable: false,
+        isSigner: false
+      }
+    ];
   }
-  fetchPositionState(position) {
+  /**
+   * 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 positionState = yield this._program.account.position.fetchNullable(
-        position
-      );
-      invariant(positionState, `Position account: ${position} not found`);
-      return positionState;
-    });
-  }
+      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: TOKEN_2022_PROGRAM_ID2
+      }).instruction();
+    });
+  }
+  /**
+   * Fetches the Config state of the program.
+   * @param config - Public key of the config account.
+   * @returns Parsed ConfigState.
+   */
+  fetchConfigState(config) {
+    return __async(this, null, function* () {
+      const configState = yield this._program.account.config.fetchNullable(
+        config
+      );
+      invariant(configState, `Config account: ${config} not found`);
+      return configState;
+    });
+  }
+  /**
+   * Fetches the Pool state.
+   * @param pool - Public key of the pool.
+   * @returns Parsed PoolState.
+   */
+  fetchPoolState(pool) {
+    return __async(this, null, function* () {
+      const poolState = yield this._program.account.pool.fetchNullable(pool);
+      invariant(poolState, `Pool account: ${pool} not found`);
+      return poolState;
+    });
+  }
+  /**
+   * Fetches the Position state.
+   * @param position - Public key of the position.
+   * @returns Parsed PositionState.
+   */
+  fetchPositionState(position) {
+    return __async(this, null, function* () {
+      const positionState = yield this._program.account.position.fetchNullable(
+        position
+      );
+      invariant(positionState, `Position account: ${position} not found`);
+      return positionState;
+    });
+  }
+  /**
+   * Retrieves all config accounts.
+   * @returns Array of config public keys and their states.
+   */
+  getAllConfigs() {
+    return __async(this, null, function* () {
+      const configAccounts = yield this._program.account.config.all();
+      return configAccounts;
+    });
+  }
+  /**
+   * Retrieves all pool accounts.
+   * @returns Array of pool public keys and their states.
+   */
+  getAllPools() {
+    return __async(this, null, function* () {
+      const poolAccounts = yield this._program.account.pool.all();
+      return poolAccounts;
+    });
+  }
+  /**
+   * Retrieves all position accounts.
+   * @returns Array of position public keys and their states.
+   */
+  getAllPositions() {
+    return __async(this, null, function* () {
+      const poolAccounts = yield this._program.account.position.all();
+      return poolAccounts;
+    });
+  }
+  /**
+   * Gets all positions a specific pool.
+   * @param pool - Public key of the pool.
+   * @returns List of user positions for the pool.
+   */
+  getAllPositionsByPool(pool) {
+    return __async(this, null, function* () {
+      return yield this._program.account.position.all([
+        positionByPoolFilter(pool)
+      ]);
+    });
+  }
+  /**
+   * Gets all positions of a user for a specific pool.
+   * @param pool - Public key of the pool.
+   * @param user - Public key of the user.
+   * @returns List of user positions for the pool.
+   */
+  getUserPositionByPool(pool, user) {
+    return __async(this, null, function* () {
+      const allUserPositions = yield this.getPositionsByUser(user);
+      return allUserPositions.filter(
+        (position) => position.positionState.pool.equals(pool)
+      );
+    });
+  }
+  /**
+   * Gets all positions of a user across all pools.
+   * @param user - Public key of the user.
+   * @returns Array of user positions already sorted by liquidity
+   */
+  getPositionsByUser(user) {
+    return __async(this, null, function* () {
+      const userPositionAccounts = yield getAllUserPositionNftAccount(
+        this._program.provider.connection,
+        user
+      );
+      if (userPositionAccounts.length === 0) {
+        return [];
+      }
+      const positionAddresses = userPositionAccounts.map(
+        (account) => derivePositionAddress(account.positionNft)
+      );
+      const positionStates = yield this._program.account.position.fetchMultiple(
+        positionAddresses
+      );
+      const positionResult = userPositionAccounts.map((account, index) => {
+        const positionState = positionStates[index];
+        if (!positionState) return null;
+        return {
+          positionNftAccount: account.positionNftAccount,
+          position: positionAddresses[index],
+          positionState
+        };
+      }).filter(Boolean);
+      positionResult.sort((a, b) => {
+        const totalLiquidityA = a.positionState.vestedLiquidity.add(a.positionState.permanentLockedLiquidity).add(a.positionState.unlockedLiquidity);
+        const totalLiquidityB = b.positionState.vestedLiquidity.add(b.positionState.permanentLockedLiquidity).add(b.positionState.unlockedLiquidity);
+        return totalLiquidityB.cmp(totalLiquidityA);
+      });
+      return positionResult;
+    });
+  }
+  getAllVestingsByPosition(position) {
+    return __async(this, null, function* () {
+      const vestings = yield this._program.account.vesting.all([
+        vestingByPositionFilter(position)
+      ]);
+      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.
+   * @returns Swap quote including expected output amount, fee, and price impact.
+   */
   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,
@@ -6899,13 +7598,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;
@@ -6921,64 +7623,245 @@ var CpAmm = class {
         reductionFactor,
         dynamicFeeParams
       );
-      const { amountOutExcludedlpFee, lpFee } = calculateSwap(
-        inAmount,
+      const { amountOut, totalFee } = getSwapAmount(
+        actualAmountIn,
         sqrtPriceQ64,
         liquidityQ64,
         tradeFeeNumerator,
         aToB,
         collectFeeMode
       );
-      const minSwapOutAmount = getMinAmountWithSlippage(
-        amountOutExcludedlpFee,
-        slippage
-      );
+      let actualAmoutOut = amountOut;
+      if (outputTokenInfo) {
+        actualAmoutOut = calculateTransferFeeExcludedAmount(
+          amountOut,
+          outputTokenInfo.mint,
+          outputTokenInfo.currentEpoch
+        ).amount;
+      }
+      const minSwapOutAmount = getMinAmountWithSlippage(actualAmoutOut, slippage);
       return {
         swapInAmount: inAmount,
-        swapOutAmount: amountOutExcludedlpFee,
+        consumedInAmount: actualAmountIn,
+        swapOutAmount: actualAmoutOut,
         minSwapOutAmount,
-        totalFee: lpFee,
-        priceImpact: getPriceImpact(minSwapOutAmount, amountOutExcludedlpFee)
+        totalFee,
+        priceImpact: getPriceImpact(minSwapOutAmount, actualAmoutOut)
       };
     });
   }
   /**
-   * 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, including:
-   *   - tokenX: The mint address of token X.
-   *   - tokenY: The mint address of token Y.
-   *   - maxAmountX: The maximum amount of token X available.
-   *   - maxAmountY: The maximum amount of token Y available.
-   *   - pool: The address of the liquidity pool.
+   * @param {GetDepositQuoteParams} params - The parameters for calculating the deposit quote.
    *
-   * @returns {Promise<BN>} - The computed liquidity delta in Q64 value.
+   * @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,
+        inAmount,
+        isTokenA,
+        inputTokenInfo,
+        outputTokenInfo,
+        minSqrtPrice,
+        maxSqrtPrice,
         sqrtPrice
       } = params;
-      const liquidityDeltaFromAmountA = getLiquidityDeltaFromAmountA(
-        maxAmountTokenA,
+      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 BN9(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,
-        sqrtMaxPrice
+        maxSqrtPrice,
+        1 /* Down */
       );
-      const liquidityDeltaFromAmountB = getLiquidityDeltaFromAmountB(
-        maxAmountTokenB,
-        sqrtMinPrice,
-        sqrtPrice
+      const amountB = getAmountBFromLiquidityDelta(
+        liquidityDelta,
+        sqrtPrice,
+        minSqrtPrice,
+        1 /* Down */
       );
-      return liquidityDeltaFromAmountA.gte(liquidityDeltaFromAmountB) ? liquidityDeltaFromAmountB : liquidityDeltaFromAmountA;
+      return {
+        liquidityDelta,
+        outAmountA: tokenATokenInfo ? calculateTransferFeeExcludedAmount(
+          new BN9(amountA),
+          tokenATokenInfo.mint,
+          tokenATokenInfo.currentEpoch
+        ).amount : new BN9(amountA),
+        outAmountB: tokenBTokenInfo ? calculateTransferFeeExcludedAmount(
+          new BN9(amountB),
+          tokenBTokenInfo.mint,
+          tokenBTokenInfo.currentEpoch
+        ).amount : new BN9(amountB)
+      };
     });
   }
+  /**
+   * Calculates liquidity and corresponding token amounts for token A single-sided pool creation
+   * Only supports initialization where initial price equals min sqrt price
+   * @param params Parameters for single-sided pool creation
+   * @returns Calculated liquidity delta
+   */
+  preparePoolCreationSingleSide(params) {
+    const {
+      tokenAAmount,
+      initSqrtPrice,
+      minSqrtPrice,
+      maxSqrtPrice,
+      tokenAInfo
+    } = params;
+    if (!initSqrtPrice.eq(minSqrtPrice)) {
+      throw new Error("Only support single side for base token.");
+    }
+    const actualAmountIn = tokenAInfo ? tokenAAmount.sub(
+      calculateTransferFeeIncludedAmount(
+        tokenAAmount,
+        tokenAInfo.mint,
+        tokenAInfo.currentEpoch
+      ).transferFee
+    ) : tokenAAmount;
+    const liquidityDelta = getLiquidityDeltaFromAmountA(
+      actualAmountIn,
+      initSqrtPrice,
+      maxSqrtPrice
+    );
+    return liquidityDelta;
+  }
+  /**
+   * Prepares parameters required for pool creation, including initial sqrt price and liquidity.
+   * @private
+   * @param {PreparePoolCreationParams} params - Initial token amounts for pool creation.
+   * @returns init sqrt price and liquidity in Q64 format.
+   */
+  preparePoolCreationParams(params) {
+    const {
+      tokenAAmount,
+      tokenBAmount,
+      minSqrtPrice,
+      maxSqrtPrice,
+      tokenAInfo,
+      tokenBInfo
+    } = params;
+    if (tokenAAmount.eq(new BN9(0)) && tokenBAmount.eq(new BN9(0))) {
+      throw new Error("Invalid input amount");
+    }
+    const actualAmountAIn = tokenAInfo ? tokenAAmount.sub(
+      calculateTransferFeeIncludedAmount(
+        tokenAAmount,
+        tokenAInfo.mint,
+        tokenAInfo.currentEpoch
+      ).transferFee
+    ) : tokenAAmount;
+    const actualAmountBIn = tokenBInfo ? tokenAAmount.sub(
+      calculateTransferFeeIncludedAmount(
+        tokenBAmount,
+        tokenBInfo.mint,
+        tokenBInfo.currentEpoch
+      ).transferFee
+    ) : tokenAAmount;
+    const initSqrtPrice = calculateInitSqrtPrice(
+      tokenAAmount,
+      tokenBAmount,
+      minSqrtPrice,
+      maxSqrtPrice
+    );
+    const liquidityDeltaFromAmountA = getLiquidityDeltaFromAmountA(
+      actualAmountAIn,
+      initSqrtPrice,
+      maxSqrtPrice
+    );
+    const liquidityDeltaFromAmountB = getLiquidityDeltaFromAmountB(
+      actualAmountBIn,
+      minSqrtPrice,
+      initSqrtPrice
+    );
+    const liquidityDelta = min(
+      liquidityDeltaFromAmountA,
+      liquidityDeltaFromAmountB
+    );
+    return {
+      initSqrtPrice,
+      liquidityDelta
+    };
+  }
+  /**
+   * Builds a transaction to create a permissionless pool.
+   * @param params - Parameters for pool creation.
+   * @returns Transaction builder.
+   */
   createPool(params) {
     return __async(this, null, function* () {
-      var _a, _b, _c, _d;
       const {
         payer,
         creator,
@@ -6986,70 +7869,61 @@ var CpAmm = class {
         positionNft,
         tokenAMint,
         tokenBMint,
+        initSqrtPrice,
+        liquidityDelta,
         activationPoint,
         tokenAAmount,
         tokenBAmount,
-        tokenADecimal,
-        tokenBDecimal
+        tokenAProgram,
+        tokenBProgram
       } = params;
-      const { sqrtPriceQ64, liquidityQ64 } = yield this.preparePoolCreationParams(
-        {
-          tokenAAmount,
-          tokenBAmount,
-          tokenADecimal,
-          tokenBDecimal
-        }
-      );
-      const poolAuthority = derivePoolAuthority(this._program.programId);
-      const pool = derivePoolAddress(
-        config,
-        tokenAMint,
-        tokenBMint,
-        this._program.programId
-      );
-      const position = derivePositionAddress(
-        positionNft,
-        this._program.programId
-      );
-      const positionNftAccount = derivePositionNftAccount(
-        positionNft,
-        this._program.programId
-      );
-      const tokenAProgram = (_b = (_a = yield this._program.provider.connection.getParsedAccountInfo(tokenAMint)) == null ? void 0 : _a.value) == null ? void 0 : _b.owner;
-      const tokenBProgram = (_d = (_c = yield this._program.provider.connection.getParsedAccountInfo(tokenBMint)) == null ? void 0 : _c.value) == null ? void 0 : _d.owner;
-      const payerTokenA = getAssociatedTokenAddressSync2(
-        tokenAMint,
+      const pool = derivePoolAddress(config, tokenAMint, tokenBMint);
+      const position = derivePositionAddress(positionNft);
+      const positionNftAccount = derivePositionNftAccount(positionNft);
+      const tokenAVault = deriveTokenVaultAddress(tokenAMint, pool);
+      const tokenBVault = deriveTokenVaultAddress(tokenBMint, pool);
+      const {
+        tokenAAta: payerTokenA,
+        tokenBAta: payerTokenB,
+        instructions: preInstructions
+      } = yield this.prepareTokenAccounts(
         payer,
-        true,
-        tokenAProgram
-      );
-      const payerTokenB = getAssociatedTokenAddressSync2(
+        tokenAMint,
         tokenBMint,
-        payer,
-        true,
+        tokenAProgram,
         tokenBProgram
       );
-      const tokenAVault = deriveTokenVaultAddress(
+      if (tokenAMint.equals(NATIVE_MINT2)) {
+        const wrapSOLIx = wrapSOLInstruction(
+          payer,
+          payerTokenA,
+          BigInt(tokenAAmount.toString())
+        );
+        preInstructions.push(...wrapSOLIx);
+      }
+      if (tokenBMint.equals(NATIVE_MINT2)) {
+        const wrapSOLIx = wrapSOLInstruction(
+          payer,
+          payerTokenB,
+          BigInt(tokenBAmount.toString())
+        );
+        preInstructions.push(...wrapSOLIx);
+      }
+      const tokenBadgeAccounts = this.getTokenBadgeAccounts(
         tokenAMint,
-        pool,
-        this._program.programId
-      );
-      const tokenBVault = deriveTokenVaultAddress(
-        tokenBMint,
-        pool,
-        this._program.programId
+        tokenBMint
       );
       const tx = yield this._program.methods.initializePool({
-        liquidity: liquidityQ64,
-        sqrtPrice: sqrtPriceQ64,
+        liquidity: liquidityDelta,
+        sqrtPrice: initSqrtPrice,
         activationPoint
-      }).accountsStrict({
+      }).accountsPartial({
         creator,
         positionNftAccount,
         positionNftMint: positionNft,
         payer,
         config,
-        poolAuthority,
+        poolAuthority: this.poolAuthority,
         pool,
         position,
         tokenAMint,
@@ -7061,13 +7935,16 @@ var CpAmm = class {
         token2022Program: TOKEN_2022_PROGRAM_ID2,
         tokenAProgram,
         tokenBProgram,
-        systemProgram: SystemProgram2.programId,
-        eventAuthority: deriveEventAuthority(this._program.programId)[0],
-        program: this._program.programId
-      }).transaction();
+        systemProgram: SystemProgram2.programId
+      }).preInstructions(preInstructions).remainingAccounts(tokenBadgeAccounts).transaction();
       return tx;
     });
   }
+  /**
+   * Builds a transaction to create a customizable pool.
+   * @param params - Parameters for customizable pool creation.
+   * @returns Transaction and related addresses.
+   */
   createCustomPool(params) {
     return __async(this, null, function* () {
       const {
@@ -7075,8 +7952,10 @@ var CpAmm = class {
         tokenBMint,
         tokenAAmount,
         tokenBAmount,
-        tokenADecimal,
-        tokenBDecimal,
+        sqrtMinPrice,
+        sqrtMaxPrice,
+        liquidityDelta,
+        initSqrtPrice,
         payer,
         creator,
         positionNft,
@@ -7088,62 +7967,22 @@ var CpAmm = class {
         tokenAProgram,
         tokenBProgram
       } = params;
-      const { sqrtPriceQ64, liquidityQ64 } = yield this.preparePoolCreationParams(
-        {
-          tokenAAmount,
-          tokenBAmount,
-          tokenADecimal,
-          tokenBDecimal
-        }
-      );
-      const poolAuthority = derivePoolAuthority(this._program.programId);
-      const pool = deriveCustomizablePoolAddress(
-        tokenAMint,
-        tokenBMint,
-        this._program.programId
-      );
-      const position = derivePositionAddress(
-        positionNft,
-        this._program.programId
-      );
-      const positionNftAccount = derivePositionNftAccount(
-        positionNft,
-        this._program.programId
-      );
-      const tokenAVault = deriveTokenVaultAddress(
+      const pool = deriveCustomizablePoolAddress(tokenAMint, tokenBMint);
+      const position = derivePositionAddress(positionNft);
+      const positionNftAccount = derivePositionNftAccount(positionNft);
+      const tokenAVault = deriveTokenVaultAddress(tokenAMint, pool);
+      const tokenBVault = deriveTokenVaultAddress(tokenBMint, pool);
+      const {
+        tokenAAta: payerTokenA,
+        tokenBAta: payerTokenB,
+        instructions: preInstructions
+      } = yield this.prepareTokenAccounts(
+        payer,
         tokenAMint,
-        pool,
-        this._program.programId
-      );
-      const tokenBVault = deriveTokenVaultAddress(
         tokenBMint,
-        pool,
-        this._program.programId
+        tokenAProgram,
+        tokenBProgram
       );
-      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);
       if (tokenAMint.equals(NATIVE_MINT2)) {
         const wrapSOLIx = wrapSOLInstruction(
           payer,
@@ -7160,22 +7999,26 @@ var CpAmm = class {
         );
         preInstructions.push(...wrapSOLIx);
       }
+      const tokenBadgeAccounts = this.getTokenBadgeAccounts(
+        tokenAMint,
+        tokenBMint
+      );
       const transaction = yield this._program.methods.initializeCustomizablePool({
         poolFees,
-        sqrtMinPrice: MIN_SQRT_PRICE,
-        sqrtMaxPrice: MAX_SQRT_PRICE,
+        sqrtMinPrice,
+        sqrtMaxPrice,
         hasAlphaVault,
-        liquidity: liquidityQ64,
-        sqrtPrice: sqrtPriceQ64,
+        liquidity: liquidityDelta,
+        sqrtPrice: initSqrtPrice,
         activationType,
         collectFeeMode,
         activationPoint
-      }).accountsStrict({
+      }).accountsPartial({
         creator,
         positionNftAccount,
         positionNftMint: positionNft,
         payer,
-        poolAuthority,
+        poolAuthority: this.poolAuthority,
         pool,
         position,
         tokenAMint,
@@ -7185,50 +8028,49 @@ var CpAmm = class {
         payerTokenA,
         payerTokenB,
         token2022Program: TOKEN_2022_PROGRAM_ID2,
-        tokenAProgram: tokenAProgram != null ? tokenAProgram : (yield this._program.provider.connection.getAccountInfo(tokenAMint)).owner,
-        tokenBProgram: tokenBProgram != null ? tokenBProgram : (yield this._program.provider.connection.getAccountInfo(tokenBMint)).owner,
-        systemProgram: SystemProgram2.programId,
-        eventAuthority: deriveEventAuthority(this._program.programId)[0],
-        program: this._program.programId
-      }).preInstructions(preInstructions).transaction();
+        tokenAProgram,
+        tokenBProgram,
+        systemProgram: SystemProgram2.programId
+      }).preInstructions(preInstructions).remainingAccounts(tokenBadgeAccounts).transaction();
       return { tx: transaction, pool, position };
     });
   }
+  /**
+   * Builds a transaction to create a position.
+   * @param {CreatePositionParams} params - Parameters for position creation.
+   * @returns Transaction builder.
+   */
   createPosition(params) {
     return __async(this, null, function* () {
       const { owner, payer, pool, positionNft } = params;
-      const poolAuthority = derivePoolAuthority(this._program.programId);
-      const position = derivePositionAddress(
-        positionNft,
-        this._program.programId
-      );
-      const positionNftAccount = derivePositionNftAccount(
-        positionNft,
-        this._program.programId
-      );
-      return yield this._program.methods.createPosition().accountsStrict({
+      const position = derivePositionAddress(positionNft);
+      const positionNftAccount = derivePositionNftAccount(positionNft);
+      return yield this._program.methods.createPosition().accountsPartial({
         owner,
         positionNftMint: positionNft,
-        poolAuthority,
+        poolAuthority: this.poolAuthority,
         positionNftAccount,
         payer,
         pool,
         position,
         tokenProgram: TOKEN_2022_PROGRAM_ID2,
-        systemProgram: SystemProgram2.programId,
-        eventAuthority: deriveEventAuthority(this._program.programId)[0],
-        program: this._program.programId
+        systemProgram: SystemProgram2.programId
       }).transaction();
     });
   }
+  /**
+   * Builds a transaction to add liquidity to an existing position.
+   * @param {AddLiquidityParams} params - Parameters for adding liquidity.
+   * @returns Transaction builder.
+   */
   addLiquidity(params) {
     return __async(this, null, function* () {
       const {
         owner,
         pool,
         position,
-        positionNftMint,
-        liquidityDeltaQ64,
+        positionNftAccount,
+        liquidityDelta,
         maxAmountTokenA,
         maxAmountTokenB,
         tokenAAmountThreshold,
@@ -7240,34 +8082,17 @@ var CpAmm = class {
         tokenAProgram,
         tokenBProgram
       } = params;
-      const positionNftAccount = derivePositionNftAccount(
-        positionNftMint,
-        this._program.programId
+      const {
+        tokenAAta: tokenAAccount,
+        tokenBAta: tokenBAccount,
+        instructions: preInstructions
+      } = yield this.prepareTokenAccounts(
+        owner,
+        tokenAMint,
+        tokenBMint,
+        tokenAProgram,
+        tokenBProgram
       );
-      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);
       if (tokenAMint.equals(NATIVE_MINT2)) {
         const wrapSOLIx = wrapSOLInstruction(
           owner,
@@ -7291,11 +8116,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,
@@ -7308,19 +8129,32 @@ var CpAmm = class {
         tokenBVault,
         tokenAProgram,
         tokenBProgram,
-        eventAuthority: deriveEventAuthority(this._program.programId)[0],
-        program: this._program.programId
-      }).preInstructions(preInstructions).postInstructions(postInstructions).transaction();
+        liquidityDelta,
+        tokenAAmountThreshold,
+        tokenBAmountThreshold
+      });
+      const transaction = new Transaction();
+      transaction.add(
+        ...preInstructions.length > 0 ? preInstructions : [],
+        addLiquidityInstruction,
+        ...postInstructions.length > 0 ? postInstructions : []
+      );
+      return transaction;
     });
   }
+  /**
+   * Builds a transaction to remove liquidity from a position.
+   * @param {RemoveLiquidityParams} params - Parameters for removing liquidity.
+   * @returns Transaction builder.
+   */
   removeLiquidity(params) {
     return __async(this, null, function* () {
       const {
         owner,
         pool,
         position,
-        positionNftMint,
-        liquidityDeltaQ64,
+        positionNftAccount,
+        liquidityDelta,
         tokenAAmountThreshold,
         tokenBAmountThreshold,
         tokenAMint,
@@ -7330,35 +8164,17 @@ var CpAmm = class {
         tokenAProgram,
         tokenBProgram
       } = params;
-      const positionNftAccount = derivePositionNftAccount(
-        positionNftMint,
-        this._program.programId
+      const {
+        tokenAAta: tokenAAccount,
+        tokenBAta: tokenBAccount,
+        instructions: preInstructions
+      } = yield this.prepareTokenAccounts(
+        owner,
+        tokenAMint,
+        tokenBMint,
+        tokenAProgram,
+        tokenBProgram
       );
-      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()
@@ -7367,11 +8183,11 @@ var CpAmm = class {
         closeWrappedSOLIx && postInstructions.push(closeWrappedSOLIx);
       }
       return yield this._program.methods.removeLiquidity({
-        liquidityDelta: liquidityDeltaQ64,
+        liquidityDelta,
         tokenAAmountThreshold,
         tokenBAmountThreshold
-      }).accountsStrict({
-        poolAuthority,
+      }).accountsPartial({
+        poolAuthority: this.poolAuthority,
         pool,
         position,
         positionNftAccount,
@@ -7383,12 +8199,80 @@ var CpAmm = class {
         tokenAVault,
         tokenBVault,
         tokenAProgram,
-        tokenBProgram,
-        eventAuthority: deriveEventAuthority(this._program.programId)[0],
-        program: this._program.programId
+        tokenBProgram
       }).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,
+        positionNftAccount,
+        tokenAAmountThreshold,
+        tokenBAmountThreshold,
+        tokenAMint,
+        tokenBMint,
+        tokenAVault,
+        tokenBVault,
+        tokenAProgram,
+        tokenBProgram
+      } = params;
+      const {
+        tokenAAta: tokenAAccount,
+        tokenBAta: tokenBAccount,
+        instructions: preInstructions
+      } = yield this.prepareTokenAccounts(
+        owner,
+        tokenAMint,
+        tokenBMint,
+        tokenAProgram,
+        tokenBProgram
+      );
+      const postInstructions = [];
+      if ([tokenAMint.toBase58(), tokenBMint.toBase58()].includes(
+        NATIVE_MINT2.toBase58()
+      )) {
+        const closeWrappedSOLIx = yield unwrapSOLInstruction(owner);
+        closeWrappedSOLIx && postInstructions.push(closeWrappedSOLIx);
+      }
+      const removeAllLiquidityInstruction = yield this.buildRemoveAllLiquidityInstruction({
+        poolAuthority: this.poolAuthority,
+        owner,
+        pool,
+        position,
+        positionNftAccount,
+        tokenAAccount,
+        tokenBAccount,
+        tokenAAmountThreshold,
+        tokenBAmountThreshold,
+        tokenAMint,
+        tokenBMint,
+        tokenAVault,
+        tokenBVault,
+        tokenAProgram,
+        tokenBProgram
+      });
+      const transaction = new Transaction();
+      transaction.add(
+        ...preInstructions.length > 0 ? preInstructions : [],
+        removeAllLiquidityInstruction,
+        ...postInstructions.length > 0 ? postInstructions : []
+      );
+      return transaction;
+    });
+  }
+  /**
+   * Builds a transaction to perform a swap in the pool.
+   * @param {SwapParams} params - Parameters for swapping tokens.
+   * @returns Transaction builder.
+   */
   swap(params) {
     return __async(this, null, function* () {
       const {
@@ -7406,31 +8290,20 @@ var CpAmm = class {
         tokenBProgram,
         referralTokenAccount
       } = params;
-      const poolAuthority = derivePoolAuthority(this._program.programId);
-      const preInstructions = [];
-      const [
-        { ataPubkey: inputTokenAccount, ix: createInputTokenAccountIx },
-        { ataPubkey: outputTokenAccount, ix: createOutputTokenAccountIx }
-      ] = yield Promise.all([
-        getOrCreateATAInstruction(
-          this._program.provider.connection,
-          inputTokenMint,
-          payer,
-          payer,
-          true,
-          tokenAProgram
-        ),
-        getOrCreateATAInstruction(
-          this._program.provider.connection,
-          outputTokenMint,
-          payer,
-          payer,
-          true,
-          tokenBProgram
-        )
-      ]);
-      createInputTokenAccountIx && preInstructions.push(createInputTokenAccountIx);
-      createOutputTokenAccountIx && preInstructions.push(createOutputTokenAccountIx);
+      const [inputTokenProgram, outputTokenProgram] = inputTokenMint.equals(
+        tokenAMint
+      ) ? [tokenAProgram, tokenBProgram] : [tokenBProgram, tokenAProgram];
+      const {
+        tokenAAta: inputTokenAccount,
+        tokenBAta: outputTokenAccount,
+        instructions: preInstructions
+      } = yield this.prepareTokenAccounts(
+        payer,
+        inputTokenMint,
+        outputTokenMint,
+        inputTokenProgram,
+        outputTokenProgram
+      );
       if (inputTokenMint.equals(NATIVE_MINT2)) {
         const wrapSOLIx = wrapSOLInstruction(
           payer,
@@ -7449,8 +8322,8 @@ var CpAmm = class {
       return yield this._program.methods.swap({
         amountIn,
         minimumAmountOut
-      }).accountsStrict({
-        poolAuthority,
+      }).accountsPartial({
+        poolAuthority: this.poolAuthority,
         pool,
         payer,
         inputTokenAccount,
@@ -7461,12 +8334,15 @@ var CpAmm = class {
         tokenBMint,
         tokenAProgram,
         tokenBProgram,
-        referralTokenAccount,
-        eventAuthority: deriveEventAuthority(this._program.programId)[0],
-        program: this._program.programId
+        referralTokenAccount
       }).preInstructions(preInstructions).postInstructions(postInstructions).transaction();
     });
   }
+  /**
+   * Builds a transaction to lock a position with vesting schedule.
+   * @param {LockPositionParams} params - Locking parameters.
+   * @returns Transaction builder.
+   */
   lockPosition(params) {
     return __async(this, null, function* () {
       const {
@@ -7475,64 +8351,56 @@ var CpAmm = class {
         payer,
         vestingAccount,
         position,
-        positionNftMint,
+        positionNftAccount,
         cliffPoint,
         periodFrequency,
         cliffUnlockLiquidity,
         liquidityPerPeriod,
-        numberOfPeriod,
-        vestings
+        numberOfPeriod
       } = params;
-      const positionNftAccount = derivePositionNftAccount(
-        positionNftMint,
-        this._program.programId
-      );
       const lockPositionParams = {
         cliffPoint,
         periodFrequency,
         cliffUnlockLiquidity,
         liquidityPerPeriod,
-        numberOfPeriod,
-        index: vestings.length
+        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: SystemProgram2.programId,
-        eventAuthority: deriveEventAuthority(this._program.programId)[0],
-        program: this._program.programId
+        systemProgram: SystemProgram2.programId
       }).transaction();
     });
   }
+  /**
+   * Builds a transaction to permanently lock a position.
+   * @param {PermanentLockParams} params - Parameters for permanent locking.
+   * @returns Transaction builder.
+   */
   permanentLockPosition(params) {
     return __async(this, null, function* () {
-      const { owner, position, positionNftMint, pool, unlockedLiquidity } = params;
-      const positionNftAccount = derivePositionNftAccount(
-        positionNftMint,
-        this._program.programId
-      );
-      return yield this._program.methods.permanentLockPosition(unlockedLiquidity).accountsStrict({
+      const { owner, position, positionNftAccount, pool, unlockedLiquidity } = params;
+      return yield this._program.methods.permanentLockPosition(unlockedLiquidity).accountsPartial({
         position,
         positionNftAccount,
         pool,
-        owner,
-        eventAuthority: deriveEventAuthority(this._program.programId)[0],
-        program: this._program.programId
+        owner
       }).transaction();
     });
   }
+  /**
+   * Builds a transaction to refresh vesting status of a position.
+   * @param {RefreshVestingParams} params - Refresh vesting parameters.
+   * @returns Transaction builder.
+   */
   refreshVesting(params) {
     return __async(this, null, function* () {
-      const { owner, position, positionNftMint, pool, vestings } = params;
-      const positionNftAccount = derivePositionNftAccount(
-        positionNftMint,
-        this._program.programId
-      );
-      return yield this._program.methods.refreshVesting().accountsStrict({
+      const { owner, position, positionNftAccount, pool, vestings } = params;
+      return yield this._program.methods.refreshVesting().accountsPartial({
         position,
         positionNftAccount,
         pool,
@@ -7548,13 +8416,18 @@ var CpAmm = class {
       ).transaction();
     });
   }
+  /**
+   * Builds a transaction to claim position fee rewards.
+   * @param {ClaimPositionFeeParams} params - Parameters for claiming position fee.
+   * @returns Transaction builder.
+   */
   claimPositionFee(params) {
     return __async(this, null, function* () {
       const {
         owner,
         pool,
         position,
-        nftPositionMint,
+        positionNftAccount,
         tokenAVault,
         tokenBVault,
         tokenAMint,
@@ -7562,35 +8435,17 @@ var CpAmm = class {
         tokenAProgram,
         tokenBProgram
       } = params;
-      const positionNftAccount = derivePositionNftAccount(
-        nftPositionMint,
-        this._program.programId
+      const {
+        tokenAAta: tokenAAccount,
+        tokenBAta: tokenBAccount,
+        instructions: preInstructions
+      } = yield this.prepareTokenAccounts(
+        owner,
+        tokenAMint,
+        tokenBMint,
+        tokenAProgram,
+        tokenBProgram
       );
-      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()
@@ -7598,47 +8453,303 @@ 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: this.poolAuthority,
+        pool,
+        position,
+        positionNftAccount,
+        tokenAAccount,
+        tokenBAccount,
+        tokenAVault,
+        tokenBVault,
+        tokenAMint,
+        tokenBMint,
+        tokenAProgram,
+        tokenBProgram
+      });
+      const transaction = new Transaction();
+      transaction.add(
+        ...preInstructions.length > 0 ? preInstructions : [],
+        claimPositionFeeInstruction,
+        ...postInstructions.length > 0 ? postInstructions : []
+      );
+      return transaction;
+    });
+  }
+  closePosition(params) {
+    return __async(this, null, function* () {
+      const { owner, pool, position, positionNftMint, positionNftAccount } = params;
+      const instruction = yield this.buildClosePositionInstruction({
+        owner,
+        poolAuthority: this.poolAuthority,
+        pool,
+        position,
+        positionNftMint,
+        positionNftAccount
+      });
+      return new 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,
+        positionNftAccount,
+        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 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(
+        NATIVE_MINT2.toBase58()
+      )) {
+        const closeWrappedSOLIx = yield unwrapSOLInstruction(owner);
+        closeWrappedSOLIx && postInstructions.push(closeWrappedSOLIx);
+      }
+      const transaction = new Transaction();
+      if (preInstructions.length > 0) {
+        transaction.add(...preInstructions);
+      }
+      const claimPositionFeeInstruction = yield this.buildClaimPositionFeeInstruction({
+        owner,
+        poolAuthority: this.poolAuthority,
+        pool,
+        position,
+        positionNftAccount,
+        tokenAAccount,
+        tokenBAccount,
+        tokenAVault,
+        tokenBVault,
+        tokenAMint,
+        tokenBMint,
+        tokenAProgram,
+        tokenBProgram
+      });
+      transaction.add(claimPositionFeeInstruction);
+      const removeAllLiquidityInstruction = yield this.buildRemoveAllLiquidityInstruction({
+        poolAuthority: this.poolAuthority,
         owner,
         pool,
         position,
         positionNftAccount,
         tokenAAccount,
         tokenBAccount,
+        tokenAAmountThreshold,
+        tokenBAmountThreshold,
+        tokenAMint,
+        tokenBMint,
+        tokenAVault,
+        tokenBVault,
+        tokenAProgram,
+        tokenBProgram
+      });
+      transaction.add(removeAllLiquidityInstruction);
+      const closePositionInstruction = yield this.buildClosePositionInstruction({
+        owner,
+        poolAuthority: this.poolAuthority,
+        pool,
+        position,
+        positionNftMint,
+        positionNftAccount
+      });
+      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,
+        poolState,
+        positionBNftAccount,
+        positionANftAccount,
+        tokenAAmountAddLiquidityThreshold,
+        tokenBAmountAddLiquidityThreshold,
+        tokenAAmountRemoveLiquidityThreshold,
+        tokenBAmountRemoveLiquidityThreshold
+      } = 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 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(
+        NATIVE_MINT2.toBase58()
+      )) {
+        const closeWrappedSOLIx = yield unwrapSOLInstruction(owner);
+        closeWrappedSOLIx && postInstructions.push(closeWrappedSOLIx);
+      }
+      const transaction = new Transaction();
+      if (preInstructions.length > 0) {
+        transaction.add(...preInstructions);
+      }
+      const claimPositionFeeInstruction = yield this.buildClaimPositionFeeInstruction({
+        owner,
+        poolAuthority: this.poolAuthority,
+        pool,
+        position: positionB,
+        positionNftAccount: positionBNftAccount,
+        tokenAAccount,
+        tokenBAccount,
+        tokenAVault,
+        tokenBVault,
+        tokenAMint,
+        tokenBMint,
+        tokenAProgram,
+        tokenBProgram
+      });
+      transaction.add(claimPositionFeeInstruction);
+      const removeAllLiquidityInstruction = yield this.buildRemoveAllLiquidityInstruction({
+        poolAuthority: this.poolAuthority,
+        owner,
+        pool,
+        position: positionB,
+        positionNftAccount: positionBNftAccount,
+        tokenAAccount,
+        tokenBAccount,
+        tokenAAmountThreshold: tokenAAmountRemoveLiquidityThreshold,
+        tokenBAmountThreshold: tokenBAmountRemoveLiquidityThreshold,
+        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,
-        eventAuthority: deriveEventAuthority(this._program.programId)[0],
-        program: this._program.programId
-      }).preInstructions(preInstructions).postInstructions(postInstructions).transaction();
+        liquidityDelta: postionBLiquidityDelta,
+        tokenAAmountThreshold: tokenAAmountAddLiquidityThreshold,
+        tokenBAmountThreshold: tokenBAmountAddLiquidityThreshold
+      });
+      transaction.add(addLiquidityInstruction);
+      const closePositionInstruction = yield this.buildClosePositionInstruction({
+        owner,
+        poolAuthority: this.poolAuthority,
+        pool: positionBState.pool,
+        position: positionB,
+        positionNftMint: positionBState.nftMint,
+        positionNftAccount: positionBNftAccount
+      });
+      transaction.add(closePositionInstruction);
+      if (postInstructions.length > 0) {
+        transaction.add(...postInstructions);
+      }
+      return transaction;
     });
   }
+  /**
+   * Builds a transaction to update reward duration.
+   * @param {UpdateRewardDurationParams} params - Parameters including pool and new duration.
+   * @returns Transaction builder.
+   */
   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();
     });
   }
+  /**
+   * Builds a transaction to update reward funder address.
+   * @param {UpdateRewardFunderParams} params - Parameters including pool and new funder address.
+   * @returns Transaction builder.
+   */
   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();
     });
   }
+  /**
+   * Builds a transaction to fund rewards in a pool.
+   * @param {FundRewardParams} params - Funding parameters.
+   * @returns Transaction builder.
+   */
   fundReward(params) {
     return __async(this, null, function* () {
       const { rewardIndex, carryForward, pool, funder, amount } = params;
@@ -7664,22 +8775,24 @@ 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();
     });
   }
+  /**
+   * Builds a transaction to withdraw ineligible rewards from a pool.
+   * @param {WithdrawIneligibleRewardParams} params - Parameters for withdrawal.
+   * @returns Transaction builder.
+   */
   withdrawIneligibleReward(params) {
     return __async(this, null, function* () {
       const { rewardIndex, pool, funder } = params;
-      const poolAuthority = derivePoolAuthority(this._program.programId);
       const poolState = yield this.fetchPoolState(pool);
       const rewardInfo = poolState.rewardInfos[rewardIndex];
       const { mint, vault, rewardTokenFlag } = rewardInfo;
@@ -7699,19 +8812,22 @@ 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,
+        poolAuthority: this.poolAuthority,
         funderTokenAccount,
         funder,
-        tokenProgram,
-        eventAuthority: deriveEventAuthority(this._program.programId)[0],
-        program: this._program.programId
+        tokenProgram
       }).preInstructions(preInstructions).postInstructions(postInstructions).transaction();
     });
   }
+  /**
+   * Builds a transaction to claim partner fee rewards.
+   * @param {ClaimPartnerFeeParams} params - Claim parameters including amounts and partner address.
+   * @returns Transaction builder.
+   */
   claimPartnerFee(params) {
     return __async(this, null, function* () {
       const { partner, pool, maxAmountA, maxAmountB } = params;
@@ -7724,33 +8840,19 @@ var CpAmm = class {
         tokenAFlag,
         tokenBFlag
       } = poolState;
-      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(),
@@ -7759,8 +8861,8 @@ var CpAmm = class {
         const closeWrappedSOLIx = yield unwrapSOLInstruction(partner);
         closeWrappedSOLIx && postInstructions.push(closeWrappedSOLIx);
       }
-      return yield this._program.methods.claimPartnerFee(maxAmountA, maxAmountB).accountsStrict({
-        poolAuthority,
+      return yield this._program.methods.claimPartnerFee(maxAmountA, maxAmountB).accountsPartial({
+        poolAuthority: this.poolAuthority,
         pool,
         tokenAAccount,
         tokenBAccount,
@@ -7770,22 +8872,25 @@ var CpAmm = class {
         tokenBMint,
         partner,
         tokenAProgram,
-        tokenBProgram,
-        eventAuthority: deriveEventAuthority(this._program.programId)[0],
-        program: this._program.programId
+        tokenBProgram
       }).preInstructions(preInstructions).postInstructions(postInstructions).transaction();
     });
   }
+  /**
+   * Builds a transaction to claim reward from a position.
+   * @param {ClaimRewardParams} params - Parameters for claiming reward.
+   * @returns Transaction builder.
+   */
   claimReward(params) {
     return __async(this, null, function* () {
-      const { user, position, rewardIndex } = params;
-      const poolAuthority = derivePoolAuthority(this._program.programId);
-      const positionState = yield this.fetchPositionState(position);
-      const poolState = yield this.fetchPoolState(positionState.pool);
-      const positionNftAccount = derivePositionNftAccount(
-        positionState.nftMint,
-        this._program.programId
-      );
+      const {
+        user,
+        position,
+        positionNftAccount,
+        rewardIndex,
+        poolState,
+        positionState
+      } = params;
       const rewardInfo = poolState.rewardInfos[rewardIndex];
       const tokenProgram = getTokenProgram(rewardInfo.rewardTokenFlag);
       const preInstructions = [];
@@ -7803,18 +8908,16 @@ 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,
         rewardMint: rewardInfo.mint,
-        poolAuthority,
+        poolAuthority: this.poolAuthority,
         position,
         userTokenAccount,
         owner: user,
-        tokenProgram,
-        eventAuthority: deriveEventAuthority(this._program.programId)[0],
-        program: this._program.programId
+        tokenProgram
       }).preInstructions(preInstructions).postInstructions(postInstructions).transaction();
     });
   }
@@ -7831,27 +8934,37 @@ export {
   CpAmm,
   FEE_DENOMINATOR,
   FeeSchedulerMode,
+  LIQUIDITY_SCALE,
   MAX_CU_BUFFER,
   MAX_FEE_NUMERATOR,
   MAX_SQRT_PRICE,
   MIN_CU_BUFFER,
   MIN_SQRT_PRICE,
+  ONE,
+  PRECISION,
   Rounding,
   SCALE_OFFSET,
   TradeDirection,
-  calculateSwap,
+  calculateInitSqrtPrice,
+  calculateTransferFeeExcludedAmount,
+  calculateTransferFeeIncludedAmount,
+  decimalToQ64,
   index_default as default,
   deriveClaimFeeOperatorAddress,
   deriveConfigAddress,
   deriveCustomizablePoolAddress,
-  deriveEventAuthority,
   derivePoolAddress,
   derivePoolAuthority,
   derivePositionAddress,
   derivePositionNftAccount,
   deriveRewardVaultAddress,
+  deriveTokenBadge,
   deriveTokenBadgeAddress,
   deriveTokenVaultAddress,
+  divCeil,
+  getAllUserPositionNftAccount,
+  getAmountAFromLiquidityDelta,
+  getAmountBFromLiquidityDelta,
   getBaseFeeNumerator,
   getDeltaAmountA,
   getDeltaAmountB,
@@ -7862,13 +8975,28 @@ export {
   getFirstKey,
   getLiquidityDeltaFromAmountA,
   getLiquidityDeltaFromAmountB,
+  getMaxAmountWithSlippage,
+  getMinAmountWithSlippage,
   getNextSqrtPrice,
+  getNftOwner,
   getOrCreateATAInstruction,
+  getPriceFromSqrtPrice,
+  getPriceImpact,
   getSecondKey,
   getSimulationComputeUnits,
+  getSqrtPriceFromPrice,
+  getSwapAmount,
   getTokenDecimals,
   getTokenProgram,
+  getUnClaimReward,
+  mulDiv,
+  mulShr,
+  positionByPoolFilter,
+  pow,
+  q64ToDecimal,
+  shlDiv,
   unwrapSOLInstruction,
+  vestingByPositionFilter,
   wrapSOLInstruction
 };
 //# sourceMappingURL=index.mjs.map