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

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 BN10 } from "@coral-xyz/anchor";
+import { NATIVE_MINT as NATIVE_MINT2, TOKEN_2022_PROGRAM_ID as TOKEN_2022_PROGRAM_ID2 } from "@solana/spl-token";
 import invariant from "invariant";
-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,16 +6351,52 @@ var cp_amm_default = {
 
 // src/CpAmm.ts
 import {
-  PublicKey as PublicKey5,
+  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__ */ ((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/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;
@@ -6194,9 +6405,14 @@ var MIN_SQRT_PRICE = new BN("4295048016");
 var MAX_SQRT_PRICE = new BN("79226673521066979257578248091");
 var MIN_CU_BUFFER = 5e4;
 var MAX_CU_BUFFER = 2e5;
+var DYNAMIC_FEE_FILTER_PERIOD_DEFAULT = 10;
+var DYNAMIC_FEE_DECAY_PERIOD_DEFAULT = 120;
+var DYNAMIC_FEE_REDUCTION_FACTOR_DEFAULT = 5e3;
+var BIN_STEP_BPS_DEFAULT = 1;
+var BIN_STEP_BPS_U128_DEFAULT = new BN("1844674407370955");
+var MAX_PRICE_CHANGE_BPS_DEFAULT = 1500;
 
 // src/pda.ts
-import { PublicKey as PublicKey2 } from "@solana/web3.js";
 function getFirstKey(key1, key2) {
   const buf1 = key1.toBuffer();
   const buf2 = key2.toBuffer();
@@ -6213,19 +6429,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"),
@@ -6233,124 +6449,60 @@ 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) {
-  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;
-}
-
-// src/utils/token.ts
+// src/helpers/token.ts
+import { bs58 } from "@coral-xyz/anchor/dist/cjs/utils/bytes";
 import {
+  AccountLayout,
   createAssociatedTokenAccountIdempotentInstruction,
   createCloseAccountInstruction,
   getAccount,
@@ -6436,15 +6588,67 @@ var unwrapSOLInstruction = (owner, allowOwnerOffCurve = true) => __async(void 0,
   }
   return null;
 });
+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;
+  });
+}
+function getAllPositionNftAccountByOwner(connection, user) {
+  return __async(this, null, function* () {
+    const tokenAccounts = yield connection.getTokenAccountsByOwner(user, {
+      programId: TOKEN_2022_PROGRAM_ID
+    });
+    const userPositionNftAccount = [];
+    for (const { account, pubkey } of tokenAccounts.value) {
+      const tokenAccountData = AccountLayout.decode(account.data);
+      if (tokenAccountData.amount.toString() === "1") {
+        userPositionNftAccount.push({
+          positionNft: tokenAccountData.mint,
+          positionNftAccount: pubkey
+        });
+      }
+    }
+    return userPositionNftAccount;
+  });
+}
 
-// src/utils/fee.ts
-import { BN as BN4 } from "@coral-xyz/anchor";
+// 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()) {
@@ -6452,7 +6656,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;
@@ -6460,83 +6664,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);
@@ -6544,13 +6748,74 @@ function pow(base, exp) {
   return result;
 }
 
-// src/utils/fee.ts
+// src/math/mathUtils.ts
+import { BN as BN3 } from "@coral-xyz/anchor";
+import Decimal from "decimal.js";
+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));
+  }
+  return div;
+}
+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/helpers/curve.ts
+import { BN as BN4 } from "@coral-xyz/anchor";
+function getNextSqrtPrice(amount, sqrtPrice, liquidity, aToB) {
+  let result;
+  if (aToB) {
+    const product = amount.mul(sqrtPrice);
+    const denominator = liquidity.add(product);
+    const numerator = liquidity.mul(sqrtPrice);
+    result = numerator.add(denominator.sub(new BN4(1))).div(denominator);
+  } else {
+    const quotient = amount.shln(SCALE_OFFSET * 2).div(liquidity);
+    result = sqrtPrice.add(quotient);
+  }
+  return result;
+}
+function getLiquidityDeltaFromAmountA(amountA, lowerSqrtPrice, upperSqrtPrice) {
+  const product = amountA.mul(lowerSqrtPrice).mul(upperSqrtPrice);
+  const denominator = upperSqrtPrice.sub(lowerSqrtPrice);
+  return product.div(denominator);
+}
+function getLiquidityDeltaFromAmountB(amountB, lowerSqrtPrice, upperSqrtPrice) {
+  const denominator = upperSqrtPrice.sub(lowerSqrtPrice);
+  const product = amountB.shln(128);
+  return product.div(denominator);
+}
+function getAmountAFromLiquidityDelta(liquidity, currentSqrtPrice, maxSqrtPrice, rounding) {
+  const product = liquidity.mul(maxSqrtPrice.sub(currentSqrtPrice));
+  const denominator = currentSqrtPrice.mul(maxSqrtPrice);
+  if (rounding == 0 /* Up */) {
+    return product.add(denominator.sub(new BN4(1))).div(denominator);
+  }
+  return product.div(denominator);
+}
+function getAmountBFromLiquidityDelta(liquidity, currentSqrtPrice, minSqrtPrice, rounding) {
+  const one = new BN4(1).shln(128);
+  const deltaPrice = currentSqrtPrice.sub(minSqrtPrice);
+  const result = liquidity.mul(deltaPrice);
+  if (rounding == 0 /* Up */) {
+    return result.add(one.sub(new BN4(1))).div(one);
+  }
+  return result.shrn(128);
+}
+
+// src/helpers/fee.ts
+import Decimal2 from "decimal.js";
 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 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);
@@ -6558,17 +6823,20 @@ function getBaseFeeNumerator(feeSchedulerMode, cliffFeeNumerator, period, reduct
   return feeNumerator;
 }
 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);
+  if (variableFeeControl.isZero()) {
+    return new BN5(0);
+  }
+  const squareVfaBin = volatilityAccumulator.mul(new BN5(binStep)).pow(new BN5(2));
+  const vFee = variableFeeControl.mul(squareVfaBin);
+  return vFee.add(new BN5(99999999999)).div(new BN5(1e11));
 }
 function getFeeNumerator(currentPoint, activationPoint, numberOfPeriod, periodFrequency, feeSchedulerMode, cliffFeeNumerator, reductionFactor, dynamicFeeParams) {
   if (Number(periodFrequency) == 0) {
     return cliffFeeNumerator;
   }
-  const period = new BN4(currentPoint).lt(activationPoint) ? new BN4(numberOfPeriod) : BN4.min(
-    new BN4(numberOfPeriod),
-    new BN4(currentPoint).sub(activationPoint).div(periodFrequency)
+  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,
@@ -6580,143 +6848,139 @@ function getFeeNumerator(currentPoint, activationPoint, numberOfPeriod, periodFr
     const { volatilityAccumulator, binStep, variableFeeControl } = dynamicFeeParams;
     const dynamicFeeNumberator = getDynamicFeeNumerator(
       volatilityAccumulator,
-      binStep,
-      variableFeeControl
+      new BN5(binStep),
+      new BN5(variableFeeControl)
     );
-    feeNumerator.add(dynamicFeeNumberator);
+    feeNumerator = feeNumerator.add(dynamicFeeNumberator);
   }
-  return feeNumerator.gt(new BN4(MAX_FEE_NUMERATOR)) ? new BN4(MAX_FEE_NUMERATOR) : feeNumerator;
+  return feeNumerator.gt(new BN5(MAX_FEE_NUMERATOR)) ? new BN5(MAX_FEE_NUMERATOR) : feeNumerator;
 }
-
-// src/utils/curve.ts
-import { BN as BN5 } from "@coral-xyz/anchor";
-function getNextSqrtPrice(amount, sqrtPrice, liquidity, aToB) {
-  let result;
-  if (aToB) {
-    const product = amount.mul(sqrtPrice);
-    const denominator = liquidity.add(product);
-    result = mulDiv(liquidity, sqrtPrice, denominator, 0 /* Up */);
-  } else {
-    const quotient = amount.shln(SCALE_OFFSET * 2).div(liquidity);
-    result = sqrtPrice.add(quotient);
-  }
-  return result;
+function getFeeMode(collectFeeMode, btoA) {
+  const feeOnInput = btoA && collectFeeMode === 1 /* OnlyB */;
+  const feesOnTokenA = btoA && collectFeeMode === 0 /* BothToken */;
+  return {
+    feeOnInput,
+    feesOnTokenA
+  };
 }
-function getDeltaAmountA(lowerSqrtPrice, upperSqrtPrice, liquidity, rounding) {
-  const deltaSqrtPrice = upperSqrtPrice.sub(lowerSqrtPrice);
-  const denominator = lowerSqrtPrice.mul(upperSqrtPrice);
-  return mulDiv(liquidity, deltaSqrtPrice, denominator, rounding);
+function getTotalFeeOnAmount(amount, tradeFeeNumerator) {
+  return mulDiv(
+    amount,
+    tradeFeeNumerator,
+    new BN5(FEE_DENOMINATOR),
+    0 /* Up */
+  );
 }
-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);
-    result = divCeil(prod, denominator);
-  } else {
-    result = prod.shrn(SCALE_OFFSET * 2);
+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);
   }
-  return result;
+  const outAmount = aToB ? getAmountBFromLiquidityDelta(
+    liquidity,
+    sqrtPrice,
+    getNextSqrtPrice(actualInAmount, sqrtPrice, liquidity, true),
+    1 /* Down */
+  ) : getAmountAFromLiquidityDelta(
+    liquidity,
+    sqrtPrice,
+    getNextSqrtPrice(actualInAmount, sqrtPrice, liquidity, false),
+    1 /* Down */
+  );
+  const amountOut = feeMode.feeOnInput ? outAmount : (totalFee = getTotalFeeOnAmount(outAmount, tradeFeeNumerator), outAmount.sub(totalFee));
+  return { amountOut, totalFee };
 }
-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 bpsToFeeNumerator(bps) {
+  return new BN5(bps * FEE_DENOMINATOR).divn(BASIS_POINT_MAX);
+}
+function feeNumeratorToBps(feeNumerator) {
+  return feeNumerator.muln(BASIS_POINT_MAX).div(new BN5(FEE_DENOMINATOR)).toNumber();
+}
+function getBaseFeeParams(maxBaseFeeBps, minBaseFeeBps, feeSchedulerMode, numberOfPeriod, totalDuration) {
+  if (maxBaseFeeBps == minBaseFeeBps) {
+    if (numberOfPeriod != 0 || totalDuration != 0) {
+      throw new Error("numberOfPeriod and totalDuration must both be zero");
     }
-  } else {
-    const nextSqrtPrice = getNextSqrtPrice(
-      inAmount,
-      sqrtPrice,
-      liquidity,
-      true
+    return {
+      cliffFeeNumerator: bpsToFeeNumerator(maxBaseFeeBps),
+      numberOfPeriod: 0,
+      periodFrequency: new BN5(0),
+      reductionFactor: new BN5(0),
+      feeSchedulerMode: 0
+    };
+  }
+  if (numberOfPeriod <= 0) {
+    throw new Error("Total periods must be greater than zero");
+  }
+  if (maxBaseFeeBps > feeNumeratorToBps(new BN5(MAX_FEE_NUMERATOR))) {
+    throw new Error(
+      `maxBaseFeeBps (${maxBaseFeeBps} bps) exceeds maximum allowed value of ${feeNumeratorToBps(
+        new BN5(MAX_FEE_NUMERATOR)
+      )} bps`
     );
-    outAmount = getDeltaAmountB(
-      nextSqrtPrice,
-      sqrtPrice,
-      liquidity,
-      1 /* Down */
+  }
+  if (minBaseFeeBps > maxBaseFeeBps) {
+    throw new Error(
+      "minBaseFee bps must be less than or equal to maxBaseFee bps"
     );
-    lpFee = mulDiv(
-      outAmount,
-      tradeFeeNumerator,
-      new BN5(FEE_DENOMINATOR),
-      1 /* Down */
+  }
+  if (numberOfPeriod == 0 || totalDuration == 0) {
+    throw new Error(
+      "numberOfPeriod and totalDuration must both greater than zero"
     );
-    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 */
-      );
-    }
   }
-  return { amountOutExcludedlpFee: outAmount.sub(lpFee), lpFee };
-}
-function getLiquidityDeltaFromAmountA(maxAmountA, lowerSqrtPrice, upperSqrtPrice) {
-  const prod = maxAmountA.mul(upperSqrtPrice.mul(lowerSqrtPrice));
-  const delta = upperSqrtPrice.sub(lowerSqrtPrice);
-  return prod.div(delta);
+  const maxBaseFeeNumerator = bpsToFeeNumerator(maxBaseFeeBps);
+  const minBaseFeeNumerator = bpsToFeeNumerator(minBaseFeeBps);
+  const periodFrequency = new BN5(totalDuration / numberOfPeriod);
+  let reductionFactor;
+  if (feeSchedulerMode == 0 /* Linear */) {
+    const totalReduction = maxBaseFeeNumerator.sub(minBaseFeeNumerator);
+    reductionFactor = totalReduction.divn(numberOfPeriod);
+  } else {
+    const ratio = minBaseFeeNumerator.toNumber() / maxBaseFeeNumerator.toNumber();
+    const decayBase = Math.pow(ratio, 1 / numberOfPeriod);
+    reductionFactor = new BN5(BASIS_POINT_MAX * (1 - decayBase));
+  }
+  return {
+    cliffFeeNumerator: maxBaseFeeNumerator,
+    numberOfPeriod,
+    periodFrequency,
+    reductionFactor,
+    feeSchedulerMode
+  };
 }
-function getLiquidityDeltaFromAmountB(maxAmountB, lowerSqrtPrice, upperSqrtPrice) {
-  const denominator = upperSqrtPrice.sub(lowerSqrtPrice);
-  const result = maxAmountB.shln(SCALE_OFFSET * 2).div(denominator);
-  return result;
+function getDynamicFeeParams(baseFeeBps, maxPriceChangeBps = MAX_PRICE_CHANGE_BPS_DEFAULT) {
+  if (maxPriceChangeBps > MAX_PRICE_CHANGE_BPS_DEFAULT) {
+    throw new Error(
+      `maxPriceChangeBps (${maxPriceChangeBps} bps) must be less than or equal to ${MAX_PRICE_CHANGE_BPS_DEFAULT}`
+    );
+  }
+  const priceRatio = maxPriceChangeBps / BASIS_POINT_MAX + 1;
+  const sqrtPriceRatioQ64 = new BN5(
+    Decimal2.sqrt(priceRatio.toString()).mul(Decimal2.pow(2, 64)).floor().toFixed()
+  );
+  const deltaBinId = sqrtPriceRatioQ64.sub(ONE).div(BIN_STEP_BPS_U128_DEFAULT).muln(2);
+  const maxVolatilityAccumulator = new BN5(deltaBinId.muln(BASIS_POINT_MAX));
+  const squareVfaBin = maxVolatilityAccumulator.mul(new BN5(BIN_STEP_BPS_DEFAULT)).pow(new BN5(2));
+  const baseFeeNumerator = new BN5(bpsToFeeNumerator(baseFeeBps));
+  const maxDynamicFeeNumerator = baseFeeNumerator.muln(20).divn(100);
+  const vFee = maxDynamicFeeNumerator.mul(new BN5(1e11)).sub(new BN5(99999999999));
+  const variableFeeControl = vFee.div(squareVfaBin);
+  return {
+    binStep: BIN_STEP_BPS_DEFAULT,
+    binStepU128: BIN_STEP_BPS_U128_DEFAULT,
+    filterPeriod: DYNAMIC_FEE_FILTER_PERIOD_DEFAULT,
+    decayPeriod: DYNAMIC_FEE_DECAY_PERIOD_DEFAULT,
+    reductionFactor: DYNAMIC_FEE_REDUCTION_FACTOR_DEFAULT,
+    maxVolatilityAccumulator: maxVolatilityAccumulator.toNumber(),
+    variableFeeControl: variableFeeControl.toNumber()
+  };
 }
 
-// src/utils/computeUnits.ts
+// src/helpers/computeUnits.ts
 import {
   ComputeBudgetProgram,
   PublicKey as PublicKey4,
@@ -6791,19 +7055,53 @@ 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 Decimal3 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 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 = (amount, amountWithoutSlippage) => {
-  const diff = amountWithoutSlippage.sub(amount);
-  return new Decimal2(diff.toString()).div(new Decimal2(amountWithoutSlippage.toString())).mul(100).toNumber();
+var getPriceImpact = (actualAmount, idealAmount) => {
+  const diff = idealAmount.sub(actualAmount);
+  return new Decimal3(diff.toString()).div(new Decimal3(idealAmount.toString())).mul(100).toNumber();
+};
+var getPriceFromSqrtPrice = (sqrtPrice, tokenADecimal, tokenBDecimal) => {
+  const decimalSqrtPrice = new Decimal3(sqrtPrice.toString());
+  const price = decimalSqrtPrice.mul(decimalSqrtPrice).mul(new Decimal3(__pow(10, tokenADecimal - tokenBDecimal))).div(Decimal3.pow(2, 128)).toString();
+  return price;
+};
+var getSqrtPriceFromPrice = (price, tokenADecimal, tokenBDecimal) => {
+  const decimalPrice = new Decimal3(price);
+  const adjustedByDecimals = decimalPrice.div(
+    new Decimal3(__pow(10, tokenADecimal - tokenBDecimal))
+  );
+  const sqrtValue = Decimal3.sqrt(adjustedByDecimals);
+  const sqrtValueQ64 = sqrtValue.mul(Decimal3.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/utils/accountFilters.ts
+// src/helpers/accountFilters.ts
 var positionByPoolFilter = (pool) => {
   return {
     memcmp: {
@@ -6812,243 +7110,1025 @@ var positionByPoolFilter = (pool) => {
     }
   };
 };
+var vestingByPositionFilter = (position) => {
+  return {
+    memcmp: {
+      bytes: position.toBase58(),
+      offset: 8
+    }
+  };
+};
+
+// src/helpers/priceMath.ts
+import { BN as BN7 } from "@coral-xyz/anchor";
+import Decimal4 from "decimal.js";
+function calculateInitSqrtPrice(tokenAAmount, tokenBAmount, minSqrtPrice, maxSqrtPrice) {
+  if (tokenAAmount.isZero() || tokenBAmount.isZero()) {
+    throw new Error("Amount cannot be zero");
+  }
+  const amountADecimal = new Decimal4(tokenAAmount.toString());
+  const amountBDecimal = new Decimal4(tokenBAmount.toString());
+  const minSqrtPriceDecimal = new Decimal4(minSqrtPrice.toString()).div(
+    Decimal4.pow(2, 64)
+  );
+  const maxSqrtPriceDecimal = new Decimal4(maxSqrtPrice.toString()).div(
+    Decimal4.pow(2, 64)
+  );
+  const x = new Decimal4(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 Decimal4(4).mul(y);
+  const discriminant = xyMinusPa.mul(xyMinusPa).add(fourY);
+  const sqrtDiscriminant = discriminant.sqrt();
+  const result = paMinusXY.add(sqrtDiscriminant).div(new Decimal4(2)).mul(Decimal4.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/helpers/vestings.ts
+import { BN as BN9 } from "@coral-xyz/anchor";
+import { min } from "bn.js";
+function isVestingComplete(vestingData, currentPoint) {
+  const cliffPoint = vestingData.cliffPoint;
+  const periodFrequency = vestingData.periodFrequency;
+  const numberOfPeriods = vestingData.numberOfPeriod;
+  const endPoint = cliffPoint.add(periodFrequency.muln(numberOfPeriods));
+  return currentPoint.gte(endPoint);
+}
+function getTotalLockedLiquidity(vestingData) {
+  return vestingData.cliffUnlockLiquidity.add(
+    vestingData.liquidityPerPeriod.mul(new BN9(vestingData.numberOfPeriod))
+  );
+}
+function getAvailableVestingLiquidity(vestingData, currentPoint) {
+  const {
+    cliffPoint,
+    periodFrequency,
+    cliffUnlockLiquidity,
+    liquidityPerPeriod,
+    numberOfPeriod,
+    totalReleasedLiquidity
+  } = vestingData;
+  if (currentPoint.lt(cliffPoint)) {
+    return new BN9(0);
+  }
+  if (periodFrequency.isZero()) {
+    return cliffUnlockLiquidity;
+  }
+  let passedPeriod = new BN9(currentPoint).sub(cliffPoint).div(periodFrequency);
+  passedPeriod = min(passedPeriod, new BN9(numberOfPeriod));
+  const unlockedLiquidity = cliffUnlockLiquidity.add(
+    passedPeriod.mul(liquidityPerPeriod)
+  );
+  const availableReleasingLiquidity = unlockedLiquidity.sub(
+    totalReleasedLiquidity
+  );
+  return availableReleasingLiquidity;
+}
 
 // src/CpAmm.ts
+import { min as min2 } from "bn.js";
 var CpAmm = class {
   constructor(connection) {
     this._program = new Program(cp_amm_default, {
       connection
     });
-  }
-  getProgram() {
-    return this._program;
+    this.poolAuthority = derivePoolAuthority();
   }
   /**
-    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: deriveTokenBadgeAddress(tokenAMint),
+        isWritable: false,
+        isSigner: false
+      },
+      {
+        pubkey: deriveTokenBadgeAddress(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;
-    });
-  }
-  getAllConfigs() {
+      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();
+    });
+  }
+  /**
+   * Builds an instruction to refresh vesting for a position
+   * @param params Parameters required for the refresh vesting instruction
+   * @returns Transaction instruction or null if no vestings to refresh
+   */
+  buildRefreshVestingInstruction(params) {
+    return __async(this, null, function* () {
+      const { owner, position, positionNftAccount, pool, vestingAccounts } = params;
+      if (vestingAccounts.length == 0) {
+        return null;
+      }
+      return yield this._program.methods.refreshVesting().accountsPartial({
+        position,
+        positionNftAccount,
+        pool,
+        owner
+      }).remainingAccounts(
+        vestingAccounts.map((pubkey) => {
+          return {
+            isSigner: false,
+            isWritable: true,
+            pubkey
+          };
+        })
+      ).instruction();
+    });
+  }
+  /**
+   * Helper function that builds instructions to claim fees, remove liquidity, and close a position
+   * @param {BuildLiquidatePositionInstructionParams} params - Parameters for liquidating a position
+   * @returns {Promise<TransactionInstruction[]>} Array of instructions
+   * @private
+   */
+  buildLiquidatePositionInstruction(params) {
+    return __async(this, null, function* () {
+      const {
+        owner,
+        position,
+        positionNftAccount,
+        positionState,
+        poolState,
+        tokenAAccount,
+        tokenBAccount,
+        tokenAAmountThreshold,
+        tokenBAmountThreshold
+      } = params;
+      const { nftMint: positionNftMint, pool } = positionState;
+      const { tokenAMint, tokenBMint, tokenAVault, tokenBVault } = poolState;
+      const tokenAProgram = getTokenProgram(poolState.tokenAFlag);
+      const tokenBProgram = getTokenProgram(poolState.tokenBFlag);
+      const instructions = [];
+      const claimPositionFeeInstruction = yield this.buildClaimPositionFeeInstruction({
+        owner,
+        poolAuthority: this.poolAuthority,
+        pool,
+        position,
+        positionNftAccount,
+        tokenAAccount,
+        tokenBAccount,
+        tokenAVault,
+        tokenBVault,
+        tokenAMint,
+        tokenBMint,
+        tokenAProgram,
+        tokenBProgram
+      });
+      instructions.push(claimPositionFeeInstruction);
+      const removeAllLiquidityInstruction = yield this.buildRemoveAllLiquidityInstruction({
+        poolAuthority: this.poolAuthority,
+        owner,
+        pool,
+        position,
+        positionNftAccount,
+        tokenAAccount,
+        tokenBAccount,
+        tokenAAmountThreshold,
+        tokenBAmountThreshold,
+        tokenAMint,
+        tokenBMint,
+        tokenAVault,
+        tokenBVault,
+        tokenAProgram,
+        tokenBProgram
+      });
+      instructions.push(removeAllLiquidityInstruction);
+      const closePositionInstruction = yield this.buildClosePositionInstruction({
+        owner,
+        poolAuthority: this.poolAuthority,
+        pool,
+        position,
+        positionNftMint,
+        positionNftAccount
+      });
+      instructions.push(closePositionInstruction);
+      return instructions;
+    });
+  }
+  /**
+   * Builds a instruction to create a position.
+   * @param {CreatePositionParams} params - Parameters for position creation.
+   * @returns Transaction instruction.
+   */
+  buildCreatePositionInstruction(params) {
+    return __async(this, null, function* () {
+      const { owner, payer, pool, positionNft } = params;
+      const position = derivePositionAddress(positionNft);
+      const positionNftAccount = derivePositionNftAccount(positionNft);
+      const ix = yield this._program.methods.createPosition().accountsPartial({
+        owner,
+        positionNftMint: positionNft,
+        poolAuthority: this.poolAuthority,
+        positionNftAccount,
+        payer,
+        pool,
+        position,
+        tokenProgram: TOKEN_2022_PROGRAM_ID2,
+        systemProgram: SystemProgram2.programId
+      }).instruction();
+      return {
+        ix,
+        position,
+        positionNftAccount
+      };
+    });
+  }
+  /**
+   * 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;
     });
   }
-  getUserPositionByPool(pool, user) {
+  /**
+   * 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* () {
-      const positions = yield this._program.account.position.all([
+      return yield this._program.account.position.all([
         positionByPoolFilter(pool)
       ]);
-      const result = [];
-      for (const position of positions) {
-        const largesTokenAccount = yield this._program.provider.connection.getTokenLargestAccounts(
-          position.account.nftMint
-        );
-        const accountInfo = yield this._program.provider.connection.getParsedAccountInfo(
-          largesTokenAccount.value[0].address
-        );
-        const owner = new PublicKey5(accountInfo.value.data.parsed.info.owner);
-        if (owner.equals(user)) {
-          result.push(position);
-        }
-      }
-      return result;
     });
   }
-  getPositionsByUser(user) {
+  /**
+   * 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 positions = yield this._program.account.position.all();
-      const positionNftMints = positions.map((item) => item.account.nftMint);
-      const result = [];
-      for (const position of positions) {
-        const largesTokenAccount = yield this._program.provider.connection.getTokenLargestAccounts(
-          positionNftMints[0]
-        );
-        const accountInfo = yield this._program.provider.connection.getParsedAccountInfo(
-          largesTokenAccount.value[0].address
-        );
-        const owner = new PublicKey5(accountInfo.value.data.parsed.info.owner);
-        if (owner.equals(user)) {
-          result.push(position);
-        }
-      }
-      return result;
+      const allUserPositions = yield this.getPositionsByUser(user);
+      return allUserPositions.filter(
+        (position) => position.positionState.pool.equals(pool)
+      );
     });
   }
-  getQuote(params) {
+  /**
+   * 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* () {
-      var _a;
-      const { inAmount, inputTokenMint, slippage, poolState } = params;
-      const {
-        sqrtPrice: sqrtPriceQ64,
-        liquidity: liquidityQ64,
-        activationType,
-        activationPoint,
-        collectFeeMode,
-        poolFees
-      } = poolState;
-      const {
-        feeSchedulerMode,
-        cliffFeeNumerator,
-        numberOfPeriod,
-        reductionFactor,
-        periodFrequency
-      } = poolFees.baseFee;
-      const dynamicFee = poolFees.dynamicFee;
-      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;
-      let dynamicFeeParams;
-      if (dynamicFee.initialized) {
-        const { volatilityAccumulator, binStep, variableFeeControl } = dynamicFee;
-        dynamicFeeParams = { volatilityAccumulator, binStep, variableFeeControl };
-      }
-      const tradeFeeNumerator = getFeeNumerator(
-        currentPoint,
-        activationPoint,
-        numberOfPeriod,
-        periodFrequency,
-        feeSchedulerMode,
-        cliffFeeNumerator,
-        reductionFactor,
-        dynamicFeeParams
+      const userPositionAccounts = yield getAllPositionNftAccountByOwner(
+        this._program.provider.connection,
+        user
       );
-      const { amountOutExcludedlpFee, lpFee } = calculateSwap(
-        inAmount,
-        sqrtPriceQ64,
-        liquidityQ64,
-        tradeFeeNumerator,
-        aToB,
-        collectFeeMode
+      if (userPositionAccounts.length === 0) {
+        return [];
+      }
+      const positionAddresses = userPositionAccounts.map(
+        (account) => derivePositionAddress(account.positionNft)
       );
-      const minSwapOutAmount = getMinAmountWithSlippage(
-        amountOutExcludedlpFee,
-        slippage
+      const positionStates = yield this._program.account.position.fetchMultiple(
+        positionAddresses
       );
-      return {
-        swapInAmount: inAmount,
-        swapOutAmount: amountOutExcludedlpFee,
-        minSwapOutAmount,
-        totalFee: lpFee,
-        priceImpact: getPriceImpact(minSwapOutAmount, amountOutExcludedlpFee)
-      };
+      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);
+  }
+  isPermanentLockedPosition(positionState) {
+    return positionState.permanentLockedLiquidity.gtn(0);
+  }
   /**
-   * Computes the liquidity delta based on the provided token amounts and pool state.
+   * Checks if a position can be unlocked based on its locking state and vesting schedules.
    *
-   * @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.
+   * This method evaluates whether a position is eligible for operations that require
+   * unlocked liquidity, such as removing all liquidity or closing the position. It checks both
+   * permanent locks and time-based vesting schedules.
    *
+   * @private
+   * @param {PositionState} positionState - The current state of the position
+   * @param {Array<{account: PublicKey; vestingState: VestingState}>} vestings - Array of vesting accounts and their states
+   * @param {BN} currentPoint - Current timestamp or slot number (depending on activation type of pool)
+   *
+   * @returns {Object} Result object containing unlock status and reason
+   * @returns {boolean} result.canUnlock - Whether the position can be unlocked
+   * @returns {string|undefined} result.reason - Reason why position cannot be unlocked (if applicable)
+   */
+  canUnlockPosition(positionState, vestings, currentPoint) {
+    if (vestings.length > 0) {
+      if (this.isPermanentLockedPosition(positionState)) {
+        return {
+          canUnlock: false,
+          reason: "Position is permanently locked"
+        };
+      }
+      for (const vesting of vestings) {
+        if (!isVestingComplete(vesting.vestingState, currentPoint)) {
+          return {
+            canUnlock: false,
+            reason: "Position has incomplete vesting schedule"
+          };
+        }
+      }
+    }
+    return { canUnlock: true };
+  }
+  isPoolExist(pool) {
+    return __async(this, null, function* () {
+      const poolState = yield this._program.account.pool.fetchNullable(pool);
+      return poolState !== null;
+    });
+  }
+  /**
+   * Computes the liquidity delta based on the provided token amounts and sqrt price
+   *
+   * @param {LiquidityDeltaParams} params - The parameters for liquidity calculation
    * @returns {Promise<BN>} - The computed liquidity delta in Q64 value.
    */
   getLiquidityDelta(params) {
-    return __async(this, null, function* () {
-      const {
-        maxAmountTokenA,
-        maxAmountTokenB,
-        sqrtMaxPrice,
-        sqrtMinPrice,
-        sqrtPrice
-      } = params;
-      const liquidityDeltaFromAmountA = getLiquidityDeltaFromAmountA(
-        maxAmountTokenA,
+    const {
+      maxAmountTokenA,
+      maxAmountTokenB,
+      sqrtMaxPrice,
+      sqrtMinPrice,
+      sqrtPrice
+    } = params;
+    const liquidityDeltaFromAmountA = getLiquidityDeltaFromAmountA(
+      maxAmountTokenA,
+      sqrtPrice,
+      sqrtMaxPrice
+    );
+    const liquidityDeltaFromAmountB = getLiquidityDeltaFromAmountB(
+      maxAmountTokenB,
+      sqrtMinPrice,
+      sqrtPrice
+    );
+    return min2(liquidityDeltaFromAmountA, liquidityDeltaFromAmountB);
+  }
+  /**
+   * 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) {
+    const {
+      inAmount,
+      inputTokenMint,
+      slippage,
+      poolState,
+      currentTime,
+      currentSlot,
+      inputTokenInfo,
+      outputTokenInfo
+    } = params;
+    const {
+      sqrtPrice: sqrtPriceQ64,
+      liquidity: liquidityQ64,
+      activationType,
+      activationPoint,
+      collectFeeMode,
+      poolFees
+    } = poolState;
+    const {
+      feeSchedulerMode,
+      cliffFeeNumerator,
+      numberOfPeriod,
+      reductionFactor,
+      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 currentPoint = activationType ? currentTime : currentSlot;
+    let dynamicFeeParams;
+    if (dynamicFee.initialized) {
+      const { volatilityAccumulator, binStep, variableFeeControl } = dynamicFee;
+      dynamicFeeParams = { volatilityAccumulator, binStep, variableFeeControl };
+    }
+    const tradeFeeNumerator = getFeeNumerator(
+      currentPoint,
+      activationPoint,
+      numberOfPeriod,
+      periodFrequency,
+      feeSchedulerMode,
+      cliffFeeNumerator,
+      reductionFactor,
+      dynamicFeeParams
+    );
+    const { amountOut, totalFee } = getSwapAmount(
+      actualAmountIn,
+      sqrtPriceQ64,
+      liquidityQ64,
+      tradeFeeNumerator,
+      aToB,
+      collectFeeMode
+    );
+    let actualAmountOut = amountOut;
+    if (outputTokenInfo) {
+      actualAmountOut = calculateTransferFeeExcludedAmount(
+        amountOut,
+        outputTokenInfo.mint,
+        outputTokenInfo.currentEpoch
+      ).amount;
+    }
+    const minSwapOutAmount = getMinAmountWithSlippage(
+      actualAmountOut,
+      slippage
+    );
+    return {
+      swapInAmount: inAmount,
+      consumedInAmount: actualAmountIn,
+      swapOutAmount: actualAmountOut,
+      minSwapOutAmount,
+      totalFee,
+      priceImpact: getPriceImpact(minSwapOutAmount, actualAmountOut)
+    };
+  }
+  /**
+   * Calculates the deposit quote for liquidity pool.
+   *
+   * @param {GetDepositQuoteParams} params - The parameters for calculating the deposit quote.
+   *
+   * @returns {Promise<Object>} Deposit quote results
+   * @returns {BN} returns.actualInputAmount - The actual amount used as input (after deducting transfer fees).
+   * @returns {BN} returns.outputAmount - The calculated corresponding amount of the other token.
+   * @returns {BN} returns.liquidityDelta - The amount of liquidity that will be added to the pool.
+   */
+  getDepositQuote(params) {
+    const {
+      inAmount,
+      isTokenA,
+      inputTokenInfo,
+      outputTokenInfo,
+      minSqrtPrice,
+      maxSqrtPrice,
+      sqrtPrice
+    } = params;
+    const actualAmountIn = inputTokenInfo ? inAmount.sub(
+      calculateTransferFeeIncludedAmount(
+        inAmount,
+        inputTokenInfo.mint,
+        inputTokenInfo.currentEpoch
+      ).transferFee
+    ) : inAmount;
+    const { liquidityDelta, rawAmount } = isTokenA ? {
+      liquidityDelta: getLiquidityDeltaFromAmountA(
+        actualAmountIn,
         sqrtPrice,
-        sqrtMaxPrice
-      );
-      const liquidityDeltaFromAmountB = getLiquidityDeltaFromAmountB(
-        maxAmountTokenB,
-        sqrtMinPrice,
+        maxSqrtPrice
+      ),
+      rawAmount: (delta) => getAmountBFromLiquidityDelta(
+        delta,
+        sqrtPrice,
+        minSqrtPrice,
+        0 /* Up */
+      )
+    } : {
+      liquidityDelta: getLiquidityDeltaFromAmountB(
+        actualAmountIn,
+        minSqrtPrice,
         sqrtPrice
-      );
-      return liquidityDeltaFromAmountA.gte(liquidityDeltaFromAmountB) ? liquidityDeltaFromAmountB : liquidityDeltaFromAmountA;
-    });
+      ),
+      rawAmount: (delta) => getAmountAFromLiquidityDelta(
+        delta,
+        sqrtPrice,
+        maxSqrtPrice,
+        0 /* Up */
+      )
+    };
+    const rawOutputAmount = new BN10(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) {
+    const {
+      liquidityDelta,
+      sqrtPrice,
+      maxSqrtPrice,
+      minSqrtPrice,
+      tokenATokenInfo,
+      tokenBTokenInfo
+    } = params;
+    const amountA = getAmountAFromLiquidityDelta(
+      liquidityDelta,
+      sqrtPrice,
+      maxSqrtPrice,
+      1 /* Down */
+    );
+    const amountB = getAmountBFromLiquidityDelta(
+      liquidityDelta,
+      sqrtPrice,
+      minSqrtPrice,
+      1 /* Down */
+    );
+    return {
+      liquidityDelta,
+      outAmountA: tokenATokenInfo ? calculateTransferFeeExcludedAmount(
+        amountA,
+        tokenATokenInfo.mint,
+        tokenATokenInfo.currentEpoch
+      ).amount : amountA,
+      outAmountB: tokenBTokenInfo ? calculateTransferFeeExcludedAmount(
+        amountB,
+        tokenBTokenInfo.mint,
+        tokenBTokenInfo.currentEpoch
+      ).amount : 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 BN10(0)) && tokenBAmount.eq(new BN10(0))) {
+      throw new Error("Invalid input amount");
+    }
+    const actualAmountAIn = tokenAInfo ? tokenAAmount.sub(
+      calculateTransferFeeIncludedAmount(
+        tokenAAmount,
+        tokenAInfo.mint,
+        tokenAInfo.currentEpoch
+      ).transferFee
+    ) : tokenAAmount;
+    const actualAmountBIn = tokenBInfo ? tokenBAmount.sub(
+      calculateTransferFeeIncludedAmount(
+        tokenBAmount,
+        tokenBInfo.mint,
+        tokenBInfo.currentEpoch
+      ).transferFee
+    ) : tokenBAmount;
+    const initSqrtPrice = calculateInitSqrtPrice(
+      tokenAAmount,
+      tokenBAmount,
+      minSqrtPrice,
+      maxSqrtPrice
+    );
+    const liquidityDeltaFromAmountA = getLiquidityDeltaFromAmountA(
+      actualAmountAIn,
+      initSqrtPrice,
+      maxSqrtPrice
+    );
+    const liquidityDeltaFromAmountB = getLiquidityDeltaFromAmountB(
+      actualAmountBIn,
+      minSqrtPrice,
+      initSqrtPrice
+    );
+    const liquidityDelta = min2(
+      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,
@@ -7056,70 +8136,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,
@@ -7131,13 +8202,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 {
@@ -7145,8 +8219,10 @@ var CpAmm = class {
         tokenBMint,
         tokenAAmount,
         tokenBAmount,
-        tokenADecimal,
-        tokenBDecimal,
+        sqrtMinPrice,
+        sqrtMaxPrice,
+        liquidityDelta,
+        initSqrtPrice,
         payer,
         creator,
         positionNft,
@@ -7158,62 +8234,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,
@@ -7223,29 +8259,34 @@ var CpAmm = class {
         preInstructions.push(...wrapSOLIx);
       }
       if (tokenBMint.equals(NATIVE_MINT2)) {
+        const lamports = tokenBAmount.eq(new BN10(0)) ? new BN10(1) : tokenBAmount;
         const wrapSOLIx = wrapSOLInstruction(
           payer,
           payerTokenB,
-          BigInt(tokenBAmount.toString())
+          BigInt(lamports.toString())
         );
         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,
@@ -7255,50 +8296,37 @@ 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({
-        owner,
-        positionNftMint: positionNft,
-        poolAuthority,
-        positionNftAccount,
-        payer,
-        pool,
-        position,
-        tokenProgram: TOKEN_2022_PROGRAM_ID2,
-        systemProgram: SystemProgram2.programId,
-        eventAuthority: deriveEventAuthority(this._program.programId)[0],
-        program: this._program.programId
-      }).transaction();
+      const { ix } = yield this.buildCreatePositionInstruction(params);
+      return new Transaction().add(ix);
     });
   }
+  /**
+   * 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,
@@ -7310,34 +8338,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,
@@ -7361,11 +8372,104 @@ var CpAmm = class {
         const closeWrappedSOLIx = yield unwrapSOLInstruction(owner);
         closeWrappedSOLIx && postInstructions.push(closeWrappedSOLIx);
       }
-      return yield this._program.methods.addLiquidity({
-        liquidityDelta: liquidityDeltaQ64,
+      const addLiquidityInstruction = yield this.buildAddLiquidityInstruction({
+        pool,
+        position,
+        positionNftAccount,
+        owner,
+        tokenAAccount,
+        tokenBAccount,
+        tokenAMint,
+        tokenBMint,
+        tokenAVault,
+        tokenBVault,
+        tokenAProgram,
+        tokenBProgram,
+        liquidityDelta,
         tokenAAmountThreshold,
         tokenBAmountThreshold
-      }).accountsStrict({
+      });
+      const transaction = new Transaction();
+      transaction.add(
+        ...preInstructions.length > 0 ? preInstructions : [],
+        addLiquidityInstruction,
+        ...postInstructions.length > 0 ? postInstructions : []
+      );
+      return transaction;
+    });
+  }
+  /**
+   * Creates a new position and add liquidity to position it in a single transaction.
+   * Handles both native SOL and other tokens, automatically wrapping/unwrapping SOL as needed.
+   *
+   * @param {CreatePositionAndAddLiquidity} params - Parameters for creating position and adding liquidity
+   *
+   * @returns {Transaction} A transaction that creates a position and adds liquidity
+   *
+   **/
+  createPositionAndAddLiquidity(params) {
+    return __async(this, null, function* () {
+      const {
+        owner,
+        pool,
+        positionNft,
+        liquidityDelta,
+        maxAmountTokenA,
+        maxAmountTokenB,
+        tokenAAmountThreshold,
+        tokenBAmountThreshold,
+        tokenAMint,
+        tokenBMint,
+        tokenAVault,
+        tokenBVault,
+        tokenAProgram,
+        tokenBProgram
+      } = params;
+      const {
+        tokenAAta: tokenAAccount,
+        tokenBAta: tokenBAccount,
+        instructions: preInstructions
+      } = yield this.prepareTokenAccounts(
+        owner,
+        tokenAMint,
+        tokenBMint,
+        tokenAProgram,
+        tokenBProgram
+      );
+      if (tokenAMint.equals(NATIVE_MINT2)) {
+        const wrapSOLIx = wrapSOLInstruction(
+          owner,
+          tokenAAccount,
+          BigInt(maxAmountTokenA.toString())
+        );
+        preInstructions.push(...wrapSOLIx);
+      }
+      if (tokenBMint.equals(NATIVE_MINT2)) {
+        const wrapSOLIx = wrapSOLInstruction(
+          owner,
+          tokenBAccount,
+          BigInt(maxAmountTokenB.toString())
+        );
+        preInstructions.push(...wrapSOLIx);
+      }
+      const postInstructions = [];
+      if ([tokenAMint.toBase58(), tokenBMint.toBase58()].includes(
+        NATIVE_MINT2.toBase58()
+      )) {
+        const closeWrappedSOLIx = yield unwrapSOLInstruction(owner);
+        closeWrappedSOLIx && postInstructions.push(closeWrappedSOLIx);
+      }
+      const {
+        ix: createPositionIx,
+        position,
+        positionNftAccount
+      } = yield this.buildCreatePositionInstruction({
+        owner,
+        payer: owner,
+        pool,
+        positionNft
+      });
+      const addLiquidityInstruction = yield this.buildAddLiquidityInstruction({
         pool,
         position,
         positionNftAccount,
@@ -7378,19 +8482,33 @@ 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(createPositionIx);
+      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,
@@ -7398,37 +8516,91 @@ var CpAmm = class {
         tokenAVault,
         tokenBVault,
         tokenAProgram,
-        tokenBProgram
+        tokenBProgram,
+        vestings
       } = 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,
+      const postInstructions = [];
+      if ([tokenAMint.toBase58(), tokenBMint.toBase58()].includes(
+        NATIVE_MINT2.toBase58()
+      )) {
+        const closeWrappedSOLIx = yield unwrapSOLInstruction(owner);
+        closeWrappedSOLIx && postInstructions.push(closeWrappedSOLIx);
+      }
+      if (vestings.length > 0) {
+        const refreshVestingInstruction = yield this.buildRefreshVestingInstruction({
           owner,
-          true,
-          tokenBProgram
-        )
-      ]);
-      createTokenAAccountIx && preInstructions.push(createTokenAAccountIx);
-      createTokenBAccountIx && preInstructions.push(createTokenBAccountIx);
+          position,
+          positionNftAccount,
+          pool,
+          vestingAccounts: vestings.map((item) => item.account)
+        });
+        refreshVestingInstruction && preInstructions.push(refreshVestingInstruction);
+      }
+      return yield this._program.methods.removeLiquidity({
+        liquidityDelta,
+        tokenAAmountThreshold,
+        tokenBAmountThreshold
+      }).accountsPartial({
+        poolAuthority: this.poolAuthority,
+        pool,
+        position,
+        positionNftAccount,
+        owner,
+        tokenAAccount,
+        tokenBAccount,
+        tokenAMint,
+        tokenBMint,
+        tokenAVault,
+        tokenBVault,
+        tokenAProgram,
+        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,
+        vestings
+      } = 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()
@@ -7436,29 +8608,47 @@ var CpAmm = class {
         const closeWrappedSOLIx = yield unwrapSOLInstruction(owner);
         closeWrappedSOLIx && postInstructions.push(closeWrappedSOLIx);
       }
-      return yield this._program.methods.removeLiquidity({
-        liquidityDelta: liquidityDeltaQ64,
-        tokenAAmountThreshold,
-        tokenBAmountThreshold
-      }).accountsStrict({
-        poolAuthority,
+      if (vestings.length > 0) {
+        const refreshVestingInstruction = yield this.buildRefreshVestingInstruction({
+          owner,
+          position,
+          positionNftAccount,
+          pool,
+          vestingAccounts: vestings.map((item) => item.account)
+        });
+        refreshVestingInstruction && preInstructions.push(refreshVestingInstruction);
+      }
+      const removeAllLiquidityInstruction = yield this.buildRemoveAllLiquidityInstruction({
+        poolAuthority: this.poolAuthority,
+        owner,
         pool,
         position,
         positionNftAccount,
-        owner,
         tokenAAccount,
         tokenBAccount,
+        tokenAAmountThreshold,
+        tokenBAmountThreshold,
         tokenAMint,
         tokenBMint,
         tokenAVault,
         tokenBVault,
         tokenAProgram,
-        tokenBProgram,
-        eventAuthority: deriveEventAuthority(this._program.programId)[0],
-        program: this._program.programId
-      }).preInstructions(preInstructions).postInstructions(postInstructions).transaction();
+        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 {
@@ -7476,31 +8666,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,
@@ -7519,8 +8698,8 @@ var CpAmm = class {
       return yield this._program.methods.swap({
         amountIn,
         minimumAmountOut
-      }).accountsStrict({
-        poolAuthority,
+      }).accountsPartial({
+        poolAuthority: this.poolAuthority,
         pool,
         payer,
         inputTokenAccount,
@@ -7531,12 +8710,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 {
@@ -7545,86 +8727,70 @@ 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({
-        position,
-        positionNftAccount,
-        pool,
-        owner
-      }).remainingAccounts(
-        vestings.map((pubkey) => {
-          return {
-            isSigner: false,
-            isWritable: true,
-            pubkey
-          };
-        })
-      ).transaction();
+      const instruction = yield this.buildRefreshVestingInstruction(params);
+      return new Transaction().add(instruction);
     });
   }
+  /**
+   * 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,
@@ -7632,35 +8798,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()
@@ -7668,9 +8816,9 @@ var CpAmm = class {
         const closeWrappedSOLIx = yield unwrapSOLInstruction(owner);
         closeWrappedSOLIx && postInstructions.push(closeWrappedSOLIx);
       }
-      return yield this._program.methods.claimPositionFee().accountsStrict({
-        poolAuthority,
+      const claimPositionFeeInstruction = yield this.buildClaimPositionFeeInstruction({
         owner,
+        poolAuthority: this.poolAuthority,
         pool,
         position,
         positionNftAccount,
@@ -7681,34 +8829,288 @@ var CpAmm = class {
         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,
+        vestings,
+        currentPoint
+      } = params;
+      const { pool } = positionState;
+      const { tokenAMint, tokenBMint } = poolState;
+      const { canUnlock, reason } = this.canUnlockPosition(
+        positionState,
+        vestings,
+        currentPoint
+      );
+      if (!canUnlock) {
+        throw new Error(`Cannot remove liquidity: ${reason}`);
+      }
+      const tokenAProgram = getTokenProgram(poolState.tokenAFlag);
+      const tokenBProgram = getTokenProgram(poolState.tokenBFlag);
+      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);
+      }
+      if (vestings.length > 0) {
+        const refreshVestingInstruction = yield this.buildRefreshVestingInstruction({
+          owner,
+          position,
+          positionNftAccount,
+          pool,
+          vestingAccounts: vestings.map((item) => item.account)
+        });
+        refreshVestingInstruction && preInstructions.push(refreshVestingInstruction);
+      }
+      const transaction = new Transaction();
+      if (preInstructions.length > 0) {
+        transaction.add(...preInstructions);
+      }
+      const liquidatePositionInstructions = yield this.buildLiquidatePositionInstruction({
+        owner,
+        position,
+        positionNftAccount,
+        positionState,
+        poolState,
+        tokenAAccount,
+        tokenBAccount,
+        tokenAAmountThreshold,
+        tokenBAmountThreshold
+      });
+      transaction.add(...liquidatePositionInstructions);
+      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,
+        positionBVestings,
+        currentPoint
+      } = params;
+      const { canUnlock, reason } = this.canUnlockPosition(
+        positionBState,
+        positionBVestings,
+        currentPoint
+      );
+      if (!canUnlock) {
+        throw new Error(`Cannot remove liquidity: ${reason}`);
+      }
+      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
+      );
+      let positionBLiquidityDelta = positionBState.unlockedLiquidity;
+      if (positionBVestings.length > 0) {
+        const totalAvailableVestingLiquidity = positionBVestings.reduce(
+          (total, position) => {
+            const available = getAvailableVestingLiquidity(
+              position.vestingState,
+              currentPoint
+            );
+            return total.add(available);
+          },
+          new BN10(0)
+        );
+        positionBLiquidityDelta = positionBLiquidityDelta.add(
+          totalAvailableVestingLiquidity
+        );
+        const refreshVestingInstruction = yield this.buildRefreshVestingInstruction({
+          owner,
+          position: positionB,
+          positionNftAccount: positionBNftAccount,
+          pool,
+          vestingAccounts: positionBVestings.map((item) => item.account)
+        });
+        refreshVestingInstruction && preInstructions.push(refreshVestingInstruction);
+      }
+      const tokenAWithdrawAmount = getAmountAFromLiquidityDelta(
+        positionBLiquidityDelta,
+        poolState.sqrtPrice,
+        poolState.sqrtMaxPrice,
+        1 /* Down */
+      );
+      const tokenBWithdrawAmount = getAmountBFromLiquidityDelta(
+        positionBLiquidityDelta,
+        poolState.sqrtPrice,
+        poolState.sqrtMinPrice,
+        1 /* Down */
+      );
+      const newLiquidityDelta = this.getLiquidityDelta({
+        maxAmountTokenA: tokenAWithdrawAmount,
+        maxAmountTokenB: tokenBWithdrawAmount,
+        sqrtMaxPrice: poolState.sqrtMaxPrice,
+        sqrtMinPrice: poolState.sqrtMinPrice,
+        sqrtPrice: poolState.sqrtPrice
+      });
+      const transaction = new Transaction();
+      if (preInstructions.length > 0) {
+        transaction.add(...preInstructions);
+      }
+      const liquidatePositionInstructions = yield this.buildLiquidatePositionInstruction({
+        owner,
+        position: positionB,
+        positionNftAccount: positionBNftAccount,
+        positionState: positionBState,
+        poolState,
+        tokenAAccount,
+        tokenBAccount,
+        tokenAAmountThreshold: tokenAAmountRemoveLiquidityThreshold,
+        tokenBAmountThreshold: tokenBAmountRemoveLiquidityThreshold
+      });
+      transaction.add(...liquidatePositionInstructions);
+      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: newLiquidityDelta,
+        tokenAAmountThreshold: tokenAAmountAddLiquidityThreshold,
+        tokenBAmountThreshold: tokenBAmountAddLiquidityThreshold
+      });
+      transaction.add(addLiquidityInstruction);
+      if ([tokenAMint.toBase58(), tokenBMint.toBase58()].includes(
+        NATIVE_MINT2.toBase58()
+      )) {
+        const closeWrappedSOLIx = yield unwrapSOLInstruction(owner);
+        closeWrappedSOLIx && transaction.add(closeWrappedSOLIx);
+      }
+      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;
@@ -7734,22 +9136,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;
@@ -7769,19 +9173,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;
@@ -7794,33 +9201,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(),
@@ -7829,8 +9222,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,
@@ -7840,22 +9233,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 = [];
@@ -7873,18 +9269,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();
     });
   }
@@ -7896,25 +9290,36 @@ export {
   ActivationPoint,
   ActivationType,
   BASIS_POINT_MAX,
+  BIN_STEP_BPS_DEFAULT,
+  BIN_STEP_BPS_U128_DEFAULT,
   CP_AMM_PROGRAM_ID,
   CollectFeeMode,
   CpAmm,
+  DYNAMIC_FEE_DECAY_PERIOD_DEFAULT,
+  DYNAMIC_FEE_FILTER_PERIOD_DEFAULT,
+  DYNAMIC_FEE_REDUCTION_FACTOR_DEFAULT,
   FEE_DENOMINATOR,
   FeeSchedulerMode,
+  LIQUIDITY_SCALE,
   MAX_CU_BUFFER,
   MAX_FEE_NUMERATOR,
+  MAX_PRICE_CHANGE_BPS_DEFAULT,
   MAX_SQRT_PRICE,
   MIN_CU_BUFFER,
   MIN_SQRT_PRICE,
+  ONE,
   Rounding,
   SCALE_OFFSET,
   TradeDirection,
-  calculateSwap,
+  bpsToFeeNumerator,
+  calculateInitSqrtPrice,
+  calculateTransferFeeExcludedAmount,
+  calculateTransferFeeIncludedAmount,
+  decimalToQ64,
   index_default as default,
   deriveClaimFeeOperatorAddress,
   deriveConfigAddress,
   deriveCustomizablePoolAddress,
-  deriveEventAuthority,
   derivePoolAddress,
   derivePoolAuthority,
   derivePositionAddress,
@@ -7922,23 +9327,43 @@ export {
   deriveRewardVaultAddress,
   deriveTokenBadgeAddress,
   deriveTokenVaultAddress,
+  feeNumeratorToBps,
+  getAllPositionNftAccountByOwner,
+  getAllUserPositionNftAccount,
+  getAmountAFromLiquidityDelta,
+  getAmountBFromLiquidityDelta,
+  getAvailableVestingLiquidity,
   getBaseFeeNumerator,
-  getDeltaAmountA,
-  getDeltaAmountB,
+  getBaseFeeParams,
   getDynamicFeeNumerator,
+  getDynamicFeeParams,
   getEstimatedComputeUnitIxWithBuffer,
   getEstimatedComputeUnitUsageWithBuffer,
   getFeeNumerator,
   getFirstKey,
   getLiquidityDeltaFromAmountA,
   getLiquidityDeltaFromAmountB,
+  getMaxAmountWithSlippage,
+  getMinAmountWithSlippage,
   getNextSqrtPrice,
   getOrCreateATAInstruction,
+  getPriceFromSqrtPrice,
+  getPriceImpact,
   getSecondKey,
   getSimulationComputeUnits,
+  getSqrtPriceFromPrice,
+  getSwapAmount,
   getTokenDecimals,
   getTokenProgram,
+  getTotalLockedLiquidity,
+  getUnClaimReward,
+  isVestingComplete,
+  mulDiv,
+  positionByPoolFilter,
+  pow,
+  q64ToDecimal,
   unwrapSOLInstruction,
+  vestingByPositionFilter,
   wrapSOLInstruction
 };
 //# sourceMappingURL=index.mjs.map