@meteora-ag/cp-amm-sdk 1.0.0 → 1.0.1-1.rc-0

package/dist/index.mjs

@@ -30,7 +30,7 @@ var cp_amm_default = {
   address: "cpamdpZCGKUy5JxQXB4dcpGPiikHawvSWAd6mEn1sGG",
   metadata: {
     name: "cp_amm",
-    version: "0.1.0",
+    version: "0.1.1",
     spec: "0.1.0",
     description: "Created with Anchor"
   },
@@ -591,38 +591,38 @@ var cp_amm_default = {
               {
                 kind: "const",
                 value: [
-                  153,
-                  10,
-                  107,
-                  154,
-                  255,
-                  249,
-                  210,
+                  48,
+                  9,
+                  89,
+                  123,
+                  106,
+                  114,
+                  131,
+                  251,
+                  50,
                   173,
-                  176,
-                  67,
-                  220,
-                  214,
-                  152,
-                  71,
-                  46,
-                  146,
-                  161,
-                  33,
+                  254,
+                  250,
+                  10,
+                  80,
+                  160,
+                  84,
+                  143,
+                  100,
                   81,
-                  148,
+                  249,
+                  134,
+                  112,
+                  30,
+                  213,
+                  50,
                   166,
-                  119,
-                  5,
-                  189,
-                  142,
-                  11,
-                  57,
-                  68,
-                  162,
-                  70,
-                  126,
-                  100
+                  239,
+                  78,
+                  53,
+                  175,
+                  188,
+                  85
                 ]
               },
               {
@@ -684,38 +684,38 @@ var cp_amm_default = {
               {
                 kind: "const",
                 value: [
-                  153,
-                  10,
-                  107,
-                  154,
-                  255,
-                  249,
-                  210,
+                  48,
+                  9,
+                  89,
+                  123,
+                  106,
+                  114,
+                  131,
+                  251,
+                  50,
                   173,
-                  176,
-                  67,
-                  220,
-                  214,
-                  152,
-                  71,
-                  46,
-                  146,
-                  161,
-                  33,
+                  254,
+                  250,
+                  10,
+                  80,
+                  160,
+                  84,
+                  143,
+                  100,
                   81,
-                  148,
+                  249,
+                  134,
+                  112,
+                  30,
+                  213,
+                  50,
                   166,
-                  119,
-                  5,
-                  189,
-                  142,
-                  11,
-                  57,
-                  68,
-                  162,
-                  70,
-                  126,
-                  100
+                  239,
+                  78,
+                  53,
+                  175,
+                  188,
+                  85
                 ]
               },
               {
@@ -1309,7 +1309,100 @@ var cp_amm_default = {
               },
               {
                 kind: "arg",
-                path: "config_parameters.index"
+                path: "index"
+              }
+            ]
+          }
+        },
+        {
+          name: "admin",
+          writable: true,
+          signer: true
+        },
+        {
+          name: "system_program",
+          address: "11111111111111111111111111111111"
+        },
+        {
+          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: "index",
+          type: "u64"
+        },
+        {
+          name: "config_parameters",
+          type: {
+            defined: {
+              name: "StaticConfigParameters"
+            }
+          }
+        }
+      ]
+    },
+    {
+      name: "create_dynamic_config",
+      discriminator: [
+        81,
+        251,
+        122,
+        78,
+        66,
+        57,
+        208,
+        82
+      ],
+      accounts: [
+        {
+          name: "config",
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  99,
+                  111,
+                  110,
+                  102,
+                  105,
+                  103
+                ]
+              },
+              {
+                kind: "arg",
+                path: "index"
               }
             ]
           }
@@ -1357,11 +1450,15 @@ var cp_amm_default = {
         }
       ],
       args: [
+        {
+          name: "index",
+          type: "u64"
+        },
         {
           name: "config_parameters",
           type: {
             defined: {
-              name: "ConfigParameters"
+              name: "DynamicConfigParameters"
             }
           }
         }
@@ -2307,18 +2404,90 @@ var cp_amm_default = {
       ]
     },
     {
-      name: "initialize_reward",
+      name: "initialize_pool_with_dynamic_config",
       discriminator: [
-        95,
-        135,
-        192,
-        196,
-        242,
-        129,
-        230,
-        68
+        149,
+        82,
+        72,
+        197,
+        253,
+        252,
+        68,
+        15
       ],
       accounts: [
+        {
+          name: "creator"
+        },
+        {
+          name: "position_nft_mint",
+          docs: [
+            "position_nft_mint"
+          ],
+          writable: true,
+          signer: true
+        },
+        {
+          name: "position_nft_account",
+          docs: [
+            "position nft account"
+          ],
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  112,
+                  111,
+                  115,
+                  105,
+                  116,
+                  105,
+                  111,
+                  110,
+                  95,
+                  110,
+                  102,
+                  116,
+                  95,
+                  97,
+                  99,
+                  99,
+                  111,
+                  117,
+                  110,
+                  116
+                ]
+              },
+              {
+                kind: "account",
+                path: "position_nft_mint"
+              }
+            ]
+          }
+        },
+        {
+          name: "payer",
+          docs: [
+            "Address paying to create the pool. Can be anyone"
+          ],
+          writable: true,
+          signer: true
+        },
+        {
+          name: "pool_creator_authority",
+          signer: true,
+          relations: [
+            "config"
+          ]
+        },
+        {
+          name: "config",
+          docs: [
+            "Which config the pool belongs to."
+          ]
+        },
         {
           name: "pool_authority",
           pda: {
@@ -2347,67 +2516,301 @@ var cp_amm_default = {
         },
         {
           name: "pool",
+          docs: [
+            "Initialize an account to store the pool state"
+          ],
           writable: true
         },
         {
-          name: "reward_vault",
+          name: "position",
           writable: true,
           pda: {
             seeds: [
               {
                 kind: "const",
                 value: [
-                  114,
-                  101,
-                  119,
-                  97,
-                  114,
-                  100,
-                  95,
-                  118,
-                  97,
-                  117,
-                  108,
-                  116
+                  112,
+                  111,
+                  115,
+                  105,
+                  116,
+                  105,
+                  111,
+                  110
                 ]
               },
               {
                 kind: "account",
-                path: "pool"
-              },
-              {
-                kind: "arg",
-                path: "reward_index"
+                path: "position_nft_mint"
               }
             ]
           }
         },
         {
-          name: "reward_mint"
-        },
-        {
-          name: "admin",
-          writable: true,
-          signer: true
-        },
-        {
-          name: "token_program"
+          name: "token_a_mint",
+          docs: [
+            "Token a mint"
+          ]
         },
         {
-          name: "system_program",
-          address: "11111111111111111111111111111111"
+          name: "token_b_mint",
+          docs: [
+            "Token b mint"
+          ]
         },
         {
-          name: "event_authority",
+          name: "token_a_vault",
+          docs: [
+            "Token a vault for the pool"
+          ],
+          writable: true,
           pda: {
             seeds: [
               {
                 kind: "const",
                 value: [
-                  95,
-                  95,
-                  101,
-                  118,
+                  116,
+                  111,
+                  107,
+                  101,
+                  110,
+                  95,
+                  118,
+                  97,
+                  117,
+                  108,
+                  116
+                ]
+              },
+              {
+                kind: "account",
+                path: "token_a_mint"
+              },
+              {
+                kind: "account",
+                path: "pool"
+              }
+            ]
+          }
+        },
+        {
+          name: "token_b_vault",
+          docs: [
+            "Token b vault for the pool"
+          ],
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  116,
+                  111,
+                  107,
+                  101,
+                  110,
+                  95,
+                  118,
+                  97,
+                  117,
+                  108,
+                  116
+                ]
+              },
+              {
+                kind: "account",
+                path: "token_b_mint"
+              },
+              {
+                kind: "account",
+                path: "pool"
+              }
+            ]
+          }
+        },
+        {
+          name: "payer_token_a",
+          docs: [
+            "payer token a account"
+          ],
+          writable: true
+        },
+        {
+          name: "payer_token_b",
+          docs: [
+            "creator token b account"
+          ],
+          writable: true
+        },
+        {
+          name: "token_a_program",
+          docs: [
+            "Program to create mint account and mint tokens"
+          ]
+        },
+        {
+          name: "token_b_program",
+          docs: [
+            "Program to create mint account and mint tokens"
+          ]
+        },
+        {
+          name: "token_2022_program",
+          docs: [
+            "Program to create NFT mint/token account and transfer for token22 account"
+          ],
+          address: "TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb"
+        },
+        {
+          name: "system_program",
+          address: "11111111111111111111111111111111"
+        },
+        {
+          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: "params",
+          type: {
+            defined: {
+              name: "InitializeCustomizablePoolParameters"
+            }
+          }
+        }
+      ]
+    },
+    {
+      name: "initialize_reward",
+      discriminator: [
+        95,
+        135,
+        192,
+        196,
+        242,
+        129,
+        230,
+        68
+      ],
+      accounts: [
+        {
+          name: "pool_authority",
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  112,
+                  111,
+                  111,
+                  108,
+                  95,
+                  97,
+                  117,
+                  116,
+                  104,
+                  111,
+                  114,
+                  105,
+                  116,
+                  121
+                ]
+              }
+            ]
+          }
+        },
+        {
+          name: "pool",
+          writable: true
+        },
+        {
+          name: "reward_vault",
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  114,
+                  101,
+                  119,
+                  97,
+                  114,
+                  100,
+                  95,
+                  118,
+                  97,
+                  117,
+                  108,
+                  116
+                ]
+              },
+              {
+                kind: "account",
+                path: "pool"
+              },
+              {
+                kind: "arg",
+                path: "reward_index"
+              }
+            ]
+          }
+        },
+        {
+          name: "reward_mint"
+        },
+        {
+          name: "admin",
+          writable: true,
+          signer: true
+        },
+        {
+          name: "token_program"
+        },
+        {
+          name: "system_program",
+          address: "11111111111111111111111111111111"
+        },
+        {
+          name: "event_authority",
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  95,
+                  95,
+                  101,
+                  118,
                   101,
                   110,
                   116,
@@ -3660,6 +4063,19 @@ var cp_amm_default = {
         54
       ]
     },
+    {
+      name: "EvtCreateDynamicConfig",
+      discriminator: [
+        231,
+        197,
+        13,
+        164,
+        248,
+        213,
+        133,
+        152
+      ]
+    },
     {
       name: "EvtCreatePosition",
       discriminator: [
@@ -4030,6 +4446,16 @@ var cp_amm_default = {
       code: 6039,
       name: "PositionIsNotEmpty",
       msg: "Position is not empty"
+    },
+    {
+      code: 6040,
+      name: "InvalidPoolCreatorAuthority",
+      msg: "Invalid pool creator authority"
+    },
+    {
+      code: 6041,
+      name: "InvalidConfigType",
+      msg: "Invalid config type"
     }
   ],
   types: [
@@ -4259,14 +4685,21 @@ var cp_amm_default = {
             type: "u8"
           },
           {
-            name: "_padding_0",
+            name: "config_type",
             docs: [
-              "padding 0"
+              "Config type mode, 0 for static, 1 for dynamic"
             ],
-            type: {
+            type: "u8"
+          },
+          {
+            name: "_padding_0",
+            docs: [
+              "padding 0"
+            ],
+            type: {
               array: [
                 "u8",
-                6
+                5
               ]
             }
           },
@@ -4308,45 +4741,13 @@ var cp_amm_default = {
       }
     },
     {
-      name: "ConfigParameters",
+      name: "DynamicConfigParameters",
       type: {
         kind: "struct",
         fields: [
-          {
-            name: "pool_fees",
-            type: {
-              defined: {
-                name: "PoolFeeParameters"
-              }
-            }
-          },
-          {
-            name: "sqrt_min_price",
-            type: "u128"
-          },
-          {
-            name: "sqrt_max_price",
-            type: "u128"
-          },
-          {
-            name: "vault_config_key",
-            type: "pubkey"
-          },
           {
             name: "pool_creator_authority",
             type: "pubkey"
-          },
-          {
-            name: "activation_type",
-            type: "u8"
-          },
-          {
-            name: "collect_fee_mode",
-            type: "u8"
-          },
-          {
-            name: "index",
-            type: "u64"
           }
         ]
       }
@@ -4748,7 +5149,7 @@ var cp_amm_default = {
     {
       name: "EvtCreateConfig",
       docs: [
-        "Create config"
+        "Create static config"
       ],
       type: {
         kind: "struct",
@@ -4796,6 +5197,29 @@ var cp_amm_default = {
         ]
       }
     },
+    {
+      name: "EvtCreateDynamicConfig",
+      docs: [
+        "Create dynamic config"
+      ],
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "config",
+            type: "pubkey"
+          },
+          {
+            name: "pool_creator_authority",
+            type: "pubkey"
+          },
+          {
+            name: "index",
+            type: "u64"
+          }
+        ]
+      }
+    },
     {
       name: "EvtCreatePosition",
       type: {
@@ -5401,18 +5825,11 @@ var cp_amm_default = {
             type: "u128"
           },
           {
-            name: "token_a_reserve",
-            docs: [
-              "token a reserve"
-            ],
-            type: "u64"
-          },
-          {
-            name: "token_b_reserve",
+            name: "_padding",
             docs: [
-              "token b reserve"
+              "padding, previous reserve amount, be careful to use that field"
             ],
-            type: "u64"
+            type: "u128"
           },
           {
             name: "protocol_a_fee",
@@ -6135,6 +6552,46 @@ var cp_amm_default = {
         ]
       }
     },
+    {
+      name: "StaticConfigParameters",
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "pool_fees",
+            type: {
+              defined: {
+                name: "PoolFeeParameters"
+              }
+            }
+          },
+          {
+            name: "sqrt_min_price",
+            type: "u128"
+          },
+          {
+            name: "sqrt_max_price",
+            type: "u128"
+          },
+          {
+            name: "vault_config_key",
+            type: "pubkey"
+          },
+          {
+            name: "pool_creator_authority",
+            type: "pubkey"
+          },
+          {
+            name: "activation_type",
+            type: "u8"
+          },
+          {
+            name: "collect_fee_mode",
+            type: "u8"
+          }
+        ]
+      }
+    },
     {
       name: "SwapParameters",
       type: {
@@ -6405,6 +6862,12 @@ 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
 function getFirstKey(key1, key2) {
@@ -6515,10 +6978,10 @@ import {
 function getTokenProgram(flag) {
   return flag == 0 ? TOKEN_PROGRAM_ID : TOKEN_2022_PROGRAM_ID;
 }
-var getTokenDecimals = (connection, mint) => __async(void 0, null, function* () {
+var getTokenDecimals = (connection, mint) => __async(null, null, function* () {
   return (yield getMint(connection, mint)).decimals;
 });
-var getOrCreateATAInstruction = (_0, _1, _2, ..._3) => __async(void 0, [_0, _1, _2, ..._3], function* (connection, tokenMint, owner, payer = owner, allowOwnerOffCurve = true, tokenProgram) {
+var getOrCreateATAInstruction = (_0, _1, _2, ..._3) => __async(null, [_0, _1, _2, ..._3], function* (connection, tokenMint, owner, payer = owner, allowOwnerOffCurve = true, tokenProgram) {
   const toAccount = getAssociatedTokenAddressSync(
     tokenMint,
     owner,
@@ -6564,7 +7027,7 @@ var wrapSOLInstruction = (from, to, amount) => {
     })
   ];
 };
-var unwrapSOLInstruction = (owner, allowOwnerOffCurve = true) => __async(void 0, null, function* () {
+var unwrapSOLInstruction = (_0, ..._1) => __async(null, [_0, ..._1], function* (owner, receiver = owner, allowOwnerOffCurve = true) {
   const wSolATAAccount = getAssociatedTokenAddressSync(
     NATIVE_MINT,
     owner,
@@ -6573,7 +7036,7 @@ var unwrapSOLInstruction = (owner, allowOwnerOffCurve = true) => __async(void 0,
   if (wSolATAAccount) {
     const closedWrappedSolInstruction = createCloseAccountInstruction(
       wSolATAAccount,
-      owner,
+      receiver,
       owner,
       [],
       TOKEN_PROGRAM_ID
@@ -6803,6 +7266,7 @@ function getAmountBFromLiquidityDelta(liquidity, currentSqrtPrice, minSqrtPrice,
 }
 
 // src/helpers/fee.ts
+import Decimal2 from "decimal.js";
 function getBaseFeeNumerator(feeSchedulerMode, cliffFeeNumerator, period, reductionFactor) {
   let feeNumerator;
   if (feeSchedulerMode == 0 /* Linear */) {
@@ -6824,10 +7288,10 @@ function getDynamicFeeNumerator(volatilityAccumulator, binStep, variableFeeContr
   return vFee.add(new BN5(99999999999)).div(new BN5(1e11));
 }
 function getFeeNumerator(currentPoint, activationPoint, numberOfPeriod, periodFrequency, feeSchedulerMode, cliffFeeNumerator, reductionFactor, dynamicFeeParams) {
-  if (Number(periodFrequency) == 0) {
+  if (Number(periodFrequency) == 0 || new BN5(currentPoint).lt(activationPoint)) {
     return cliffFeeNumerator;
   }
-  const period = new BN5(currentPoint).lt(activationPoint) ? new BN5(numberOfPeriod) : BN5.min(
+  const period = BN5.min(
     new BN5(numberOfPeriod),
     new BN5(currentPoint).sub(activationPoint).div(periodFrequency)
   );
@@ -6872,19 +7336,111 @@ function getSwapAmount(inAmount, sqrtPrice, liquidity, tradeFeeNumerator, aToB,
     totalFee = getTotalFeeOnAmount(inAmount, tradeFeeNumerator);
     actualInAmount = inAmount.sub(totalFee);
   }
+  const nextSqrtPrice = getNextSqrtPrice(
+    actualInAmount,
+    sqrtPrice,
+    liquidity,
+    aToB
+  );
   const outAmount = aToB ? getAmountBFromLiquidityDelta(
     liquidity,
     sqrtPrice,
-    getNextSqrtPrice(actualInAmount, sqrtPrice, liquidity, true),
+    nextSqrtPrice,
     1 /* Down */
   ) : getAmountAFromLiquidityDelta(
     liquidity,
     sqrtPrice,
-    getNextSqrtPrice(actualInAmount, sqrtPrice, liquidity, false),
+    nextSqrtPrice,
     1 /* Down */
   );
   const amountOut = feeMode.feeOnInput ? outAmount : (totalFee = getTotalFeeOnAmount(outAmount, tradeFeeNumerator), outAmount.sub(totalFee));
-  return { amountOut, totalFee };
+  return { amountOut, totalFee, nextSqrtPrice };
+}
+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");
+    }
+    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`
+    );
+  }
+  if (minBaseFeeBps > maxBaseFeeBps) {
+    throw new Error(
+      "minBaseFee bps must be less than or equal to maxBaseFee bps"
+    );
+  }
+  if (numberOfPeriod == 0 || totalDuration == 0) {
+    throw new Error(
+      "numberOfPeriod and totalDuration must both greater than zero"
+    );
+  }
+  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 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/helpers/computeUnits.ts
@@ -6894,7 +7450,7 @@ import {
   TransactionMessage,
   VersionedTransaction
 } from "@solana/web3.js";
-var getSimulationComputeUnits = (connection, instructions, payer, lookupTables, commitment = "confirmed") => __async(void 0, null, function* () {
+var getSimulationComputeUnits = (connection, instructions, payer, lookupTables, commitment = "confirmed") => __async(null, null, function* () {
   var _a, _b, _c;
   const testInstructions = [
     // Set an arbitrarily high number in simulation
@@ -6926,7 +7482,7 @@ var getSimulationComputeUnits = (connection, instructions, payer, lookupTables,
   }
   return rpcResponse.value.unitsConsumed || null;
 });
-var getEstimatedComputeUnitUsageWithBuffer = (connection, instructions, feePayer, buffer) => __async(void 0, null, function* () {
+var getEstimatedComputeUnitUsageWithBuffer = (connection, instructions, feePayer, buffer) => __async(null, null, function* () {
   if (!buffer) {
     buffer = 0.1;
   }
@@ -6949,7 +7505,7 @@ var getEstimatedComputeUnitUsageWithBuffer = (connection, instructions, feePayer
   }
   return estimatedComputeUnitUsage + extraComputeUnitBuffer;
 });
-var getEstimatedComputeUnitIxWithBuffer = (connection, instructions, feePayer, buffer) => __async(void 0, null, function* () {
+var getEstimatedComputeUnitIxWithBuffer = (connection, instructions, feePayer, buffer) => __async(null, null, function* () {
   const units = yield getEstimatedComputeUnitUsageWithBuffer(
     connection,
     instructions,
@@ -6964,7 +7520,7 @@ var getEstimatedComputeUnitIxWithBuffer = (connection, instructions, feePayer, b
 
 // src/helpers/utils.ts
 import { BN as BN6 } from "@coral-xyz/anchor";
-import Decimal2 from "decimal.js";
+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));
@@ -6973,22 +7529,22 @@ var getMinAmountWithSlippage = (amount, rate) => {
   const slippage = (100 - rate) / 100 * BASIS_POINT_MAX;
   return amount.mul(new BN6(slippage)).div(new BN6(BASIS_POINT_MAX));
 };
-var getPriceImpact = (actualAmount, idealAmount) => {
-  const diff = idealAmount.sub(actualAmount);
-  return new Decimal2(diff.toString()).div(new Decimal2(idealAmount.toString())).mul(100).toNumber();
+var getPriceImpact = (nextSqrtPrice, currentSqrtPrice) => {
+  const diff = nextSqrtPrice.pow(new BN6(2)).sub(currentSqrtPrice.pow(new BN6(2))).abs();
+  return new Decimal3(diff.toString()).div(new Decimal3(currentSqrtPrice.pow(new BN6(2)).toString())).mul(100).toNumber();
 };
 var getPriceFromSqrtPrice = (sqrtPrice, tokenADecimal, tokenBDecimal) => {
-  const decimalSqrtPrice = new Decimal2(sqrtPrice.toString());
-  const price = decimalSqrtPrice.mul(decimalSqrtPrice).mul(new Decimal2(__pow(10, tokenADecimal - tokenBDecimal))).div(Decimal2.pow(2, 128)).toString();
+  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 Decimal2(price);
+  const decimalPrice = new Decimal3(price);
   const adjustedByDecimals = decimalPrice.div(
-    new Decimal2(__pow(10, tokenADecimal - tokenBDecimal))
+    new Decimal3(__pow(10, tokenADecimal - tokenBDecimal))
   );
-  const sqrtValue = Decimal2.sqrt(adjustedByDecimals);
-  const sqrtValueQ64 = sqrtValue.mul(Decimal2.pow(2, 64));
+  const sqrtValue = Decimal3.sqrt(adjustedByDecimals);
+  const sqrtValueQ64 = sqrtValue.mul(Decimal3.pow(2, 64));
   return new BN6(sqrtValueQ64.floor().toFixed());
 };
 var getUnClaimReward = (poolState, positionState) => {
@@ -7028,28 +7584,28 @@ var vestingByPositionFilter = (position) => {
 
 // src/helpers/priceMath.ts
 import { BN as BN7 } from "@coral-xyz/anchor";
-import Decimal3 from "decimal.js";
+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 Decimal3(tokenAAmount.toString());
-  const amountBDecimal = new Decimal3(tokenBAmount.toString());
-  const minSqrtPriceDecimal = new Decimal3(minSqrtPrice.toString()).div(
-    Decimal3.pow(2, 64)
+  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 Decimal3(maxSqrtPrice.toString()).div(
-    Decimal3.pow(2, 64)
+  const maxSqrtPriceDecimal = new Decimal4(maxSqrtPrice.toString()).div(
+    Decimal4.pow(2, 64)
   );
-  const x = new Decimal3(1).div(maxSqrtPriceDecimal);
+  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 Decimal3(4).mul(y);
+  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 Decimal3(2)).mul(Decimal3.pow(2, 64));
+  const result = paMinusXY.add(sqrtDiscriminant).div(new Decimal4(2)).mul(Decimal4.pow(2, 64));
   return new BN7(result.floor().toFixed());
 }
 
@@ -7177,7 +7733,7 @@ function getAvailableVestingLiquidity(vestingData, currentPoint) {
 }
 
 // src/CpAmm.ts
-import { min as min2 } from "bn.js";
+import { min as min2, max } from "bn.js";
 var CpAmm = class {
   constructor(connection) {
     this._program = new Program(cp_amm_default, {
@@ -7185,13 +7741,7 @@ var CpAmm = class {
     });
     this.poolAuthority = derivePoolAuthority();
   }
-  /**
-   * Returns the Anchor program instance.
-   * @returns The AmmProgram instance.
-   */
-  getProgram() {
-    return this._program;
-  }
+  //// ANCHOR: PRIVATE FUNCTIONS //////
   /**
    * Prepares token accounts for a transaction by retrieving or creating associated token accounts.
    * @private
@@ -7203,8 +7753,17 @@ var CpAmm = class {
    * @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) {
+  prepareTokenAccounts(params) {
     return __async(this, null, function* () {
+      const {
+        payer,
+        tokenAOwner,
+        tokenBOwner,
+        tokenAMint,
+        tokenBMint,
+        tokenAProgram,
+        tokenBProgram
+      } = params;
       const instructions = [];
       const [
         { ataPubkey: tokenAAta, ix: createInputTokenAccountIx },
@@ -7213,16 +7772,16 @@ var CpAmm = class {
         getOrCreateATAInstruction(
           this._program.provider.connection,
           tokenAMint,
-          owner,
-          owner,
+          tokenAOwner,
+          payer,
           true,
           tokenAProgram
         ),
         getOrCreateATAInstruction(
           this._program.provider.connection,
           tokenBMint,
-          owner,
-          owner,
+          tokenBOwner,
+          payer,
           true,
           tokenBProgram
         )
@@ -7532,6 +8091,132 @@ var CpAmm = class {
       };
     });
   }
+  /**
+   * Private helper method to prepare common customizable pool creation logic
+   * @param {PrepareCustomizablePoolParams} params - Common parameters for pool creation
+   * @returns Prepared transaction data including instructions and accounts
+   */
+  prepareCreatePoolParams(params) {
+    return __async(this, null, function* () {
+      const {
+        pool,
+        tokenAMint,
+        tokenBMint,
+        tokenAAmount,
+        tokenBAmount,
+        payer,
+        positionNft,
+        tokenAProgram,
+        tokenBProgram
+      } = params;
+      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,
+        tokenAOwner: payer,
+        tokenBOwner: payer,
+        tokenAMint,
+        tokenBMint,
+        tokenAProgram,
+        tokenBProgram
+      });
+      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,
+        tokenBMint
+      );
+      return {
+        position,
+        positionNftAccount,
+        tokenAVault,
+        tokenBVault,
+        payerTokenA,
+        payerTokenB,
+        preInstructions,
+        tokenBadgeAccounts
+      };
+    });
+  }
+  /**
+   * Sets up token accounts and instructions for fee claim operations.
+   * @private
+   * @param {SetupFeeClaimAccountsParams} params - Parameters for setting up fee claim accounts.
+   * @returns Token accounts and instructions for fee claiming.
+   */
+  setupFeeClaimAccounts(params) {
+    return __async(this, null, function* () {
+      const {
+        payer,
+        owner,
+        tokenAMint,
+        tokenBMint,
+        tokenAProgram,
+        tokenBProgram,
+        receiver,
+        tempWSolAccount
+      } = params;
+      const tokenAIsSOL = tokenAMint.equals(NATIVE_MINT2);
+      const tokenBIsSOL = tokenBMint.equals(NATIVE_MINT2);
+      const hasSolToken = tokenAIsSOL || tokenBIsSOL;
+      const preInstructions = [];
+      const postInstructions = [];
+      let tokenAAccount;
+      let tokenBAccount;
+      let tokenAOwner = owner;
+      let tokenBOwner = owner;
+      if (receiver) {
+        tokenAOwner = tokenAIsSOL ? tempWSolAccount : receiver;
+        tokenBOwner = tokenBIsSOL ? tempWSolAccount : receiver;
+      }
+      const { tokenAAta, tokenBAta, instructions } = yield this.prepareTokenAccounts({
+        payer,
+        tokenAOwner,
+        tokenBOwner,
+        tokenAMint,
+        tokenBMint,
+        tokenAProgram,
+        tokenBProgram
+      });
+      tokenAAccount = tokenAAta;
+      tokenBAccount = tokenBAta;
+      preInstructions.push(...instructions);
+      if (hasSolToken) {
+        const closeWrappedSOLIx = yield unwrapSOLInstruction(
+          tempWSolAccount != null ? tempWSolAccount : owner,
+          receiver != null ? receiver : owner
+        );
+        closeWrappedSOLIx && postInstructions.push(closeWrappedSOLIx);
+      }
+      return {
+        tokenAAccount,
+        tokenBAccount,
+        preInstructions,
+        postInstructions
+      };
+    });
+  }
+  //// ANCHOR: GETTER/FETCHER FUNCTIONS //////
   /**
    * Fetches the Config state of the program.
    * @param config - Public key of the config account.
@@ -7806,7 +8491,7 @@ var CpAmm = class {
       reductionFactor,
       dynamicFeeParams
     );
-    const { amountOut, totalFee } = getSwapAmount(
+    const { amountOut, totalFee, nextSqrtPrice } = getSwapAmount(
       actualAmountIn,
       sqrtPriceQ64,
       liquidityQ64,
@@ -7832,7 +8517,7 @@ var CpAmm = class {
       swapOutAmount: actualAmountOut,
       minSwapOutAmount,
       totalFee,
-      priceImpact: getPriceImpact(minSwapOutAmount, actualAmountOut)
+      priceImpact: getPriceImpact(nextSqrtPrice, sqrtPriceQ64)
     };
   }
   /**
@@ -7855,13 +8540,11 @@ var CpAmm = class {
       maxSqrtPrice,
       sqrtPrice
     } = params;
-    const actualAmountIn = inputTokenInfo ? inAmount.sub(
-      calculateTransferFeeIncludedAmount(
-        inAmount,
-        inputTokenInfo.mint,
-        inputTokenInfo.currentEpoch
-      ).transferFee
-    ) : inAmount;
+    const actualAmountIn = inputTokenInfo ? calculateTransferFeeExcludedAmount(
+      inAmount,
+      inputTokenInfo.mint,
+      inputTokenInfo.currentEpoch
+    ).amount : inAmount;
     const { liquidityDelta, rawAmount } = isTokenA ? {
       liquidityDelta: getLiquidityDeltaFromAmountA(
         actualAmountIn,
@@ -8036,6 +8719,7 @@ var CpAmm = class {
       liquidityDelta
     };
   }
+  //// ANCHOR: MAIN ENDPOINT //////
   /**
    * Builds a transaction to create a permissionless pool.
    * @param params - Parameters for pool creation.
@@ -8056,44 +8740,40 @@ var CpAmm = class {
         tokenAAmount,
         tokenBAmount,
         tokenAProgram,
-        tokenBProgram
+        tokenBProgram,
+        isLockLiquidity
       } = params;
       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,
+        position,
+        positionNftAccount,
+        tokenAVault,
+        tokenBVault,
+        payerTokenA,
+        payerTokenB,
+        preInstructions,
+        tokenBadgeAccounts
+      } = yield this.prepareCreatePoolParams({
+        pool,
         tokenAMint,
         tokenBMint,
+        tokenAAmount,
+        tokenBAmount,
+        payer,
+        positionNft,
         tokenAProgram,
         tokenBProgram
-      );
-      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 postInstruction = [];
+      if (isLockLiquidity) {
+        const permanentLockIx = yield this._program.methods.permanentLockPosition(liquidityDelta).accountsPartial({
+          position,
+          positionNftAccount,
+          pool,
+          owner: creator
+        }).instruction();
+        postInstruction.push(permanentLockIx);
       }
-      const tokenBadgeAccounts = this.getTokenBadgeAccounts(
-        tokenAMint,
-        tokenBMint
-      );
       const tx = yield this._program.methods.initializePool({
         liquidity: liquidityDelta,
         sqrtPrice: initSqrtPrice,
@@ -8117,7 +8797,7 @@ var CpAmm = class {
         tokenAProgram,
         tokenBProgram,
         systemProgram: SystemProgram2.programId
-      }).preInstructions(preInstructions).remainingAccounts(tokenBadgeAccounts).transaction();
+      }).preInstructions(preInstructions).postInstructions(postInstruction).remainingAccounts(tokenBadgeAccounts).transaction();
       return tx;
     });
   }
@@ -8146,45 +8826,40 @@ var CpAmm = class {
         activationPoint,
         activationType,
         tokenAProgram,
-        tokenBProgram
+        tokenBProgram,
+        isLockLiquidity
       } = params;
       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,
+        position,
+        positionNftAccount,
+        tokenAVault,
+        tokenBVault,
+        payerTokenA,
+        payerTokenB,
+        preInstructions,
+        tokenBadgeAccounts
+      } = yield this.prepareCreatePoolParams({
+        pool,
         tokenAMint,
         tokenBMint,
+        tokenAAmount,
+        tokenBAmount: tokenBMint.equals(NATIVE_MINT2) ? max(tokenBAmount, new BN10(1)) : tokenBAmount,
+        payer,
+        positionNft,
         tokenAProgram,
         tokenBProgram
-      );
-      if (tokenAMint.equals(NATIVE_MINT2)) {
-        const wrapSOLIx = wrapSOLInstruction(
-          payer,
-          payerTokenA,
-          BigInt(tokenAAmount.toString())
-        );
-        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(lamports.toString())
-        );
-        preInstructions.push(...wrapSOLIx);
+      });
+      const postInstruction = [];
+      if (isLockLiquidity) {
+        const permanentLockIx = yield this._program.methods.permanentLockPosition(liquidityDelta).accountsPartial({
+          position,
+          positionNftAccount,
+          pool,
+          owner: creator
+        }).instruction();
+        postInstruction.push(permanentLockIx);
       }
-      const tokenBadgeAccounts = this.getTokenBadgeAccounts(
-        tokenAMint,
-        tokenBMint
-      );
       const transaction = yield this._program.methods.initializeCustomizablePool({
         poolFees,
         sqrtMinPrice,
@@ -8213,7 +8888,97 @@ var CpAmm = class {
         tokenAProgram,
         tokenBProgram,
         systemProgram: SystemProgram2.programId
-      }).preInstructions(preInstructions).remainingAccounts(tokenBadgeAccounts).transaction();
+      }).preInstructions(preInstructions).postInstructions(postInstruction).remainingAccounts(tokenBadgeAccounts).transaction();
+      return { tx: transaction, pool, position };
+    });
+  }
+  createCustomPoolWithDynamicConfig(params) {
+    return __async(this, null, function* () {
+      const {
+        tokenAMint,
+        tokenBMint,
+        tokenAAmount,
+        tokenBAmount,
+        sqrtMinPrice,
+        sqrtMaxPrice,
+        liquidityDelta,
+        initSqrtPrice,
+        payer,
+        config,
+        poolCreatorAuthority,
+        creator,
+        positionNft,
+        poolFees,
+        hasAlphaVault,
+        collectFeeMode,
+        activationPoint,
+        activationType,
+        tokenAProgram,
+        tokenBProgram,
+        isLockLiquidity
+      } = params;
+      const pool = derivePoolAddress(config, tokenAMint, tokenBMint);
+      const {
+        position,
+        positionNftAccount,
+        tokenAVault,
+        tokenBVault,
+        payerTokenA,
+        payerTokenB,
+        preInstructions,
+        tokenBadgeAccounts
+      } = yield this.prepareCreatePoolParams({
+        pool,
+        tokenAMint,
+        tokenBMint,
+        tokenAAmount,
+        tokenBAmount,
+        payer,
+        positionNft,
+        tokenAProgram,
+        tokenBProgram
+      });
+      const postInstruction = [];
+      if (isLockLiquidity) {
+        const permanentLockIx = yield this._program.methods.permanentLockPosition(liquidityDelta).accountsPartial({
+          position,
+          positionNftAccount,
+          pool,
+          owner: creator
+        }).instruction();
+        postInstruction.push(permanentLockIx);
+      }
+      const transaction = yield this._program.methods.initializePoolWithDynamicConfig({
+        poolFees,
+        sqrtMinPrice,
+        sqrtMaxPrice,
+        hasAlphaVault,
+        liquidity: liquidityDelta,
+        sqrtPrice: initSqrtPrice,
+        activationType,
+        collectFeeMode,
+        activationPoint
+      }).accountsPartial({
+        creator,
+        positionNftAccount,
+        positionNftMint: positionNft,
+        payer,
+        poolAuthority: this.poolAuthority,
+        pool,
+        position,
+        poolCreatorAuthority,
+        config,
+        tokenAMint,
+        tokenBMint,
+        tokenAVault,
+        tokenBVault,
+        payerTokenA,
+        payerTokenB,
+        token2022Program: TOKEN_2022_PROGRAM_ID2,
+        tokenAProgram,
+        tokenBProgram,
+        systemProgram: SystemProgram2.programId
+      }).preInstructions(preInstructions).postInstructions(postInstruction).remainingAccounts(tokenBadgeAccounts).transaction();
       return { tx: transaction, pool, position };
     });
   }
@@ -8256,13 +9021,15 @@ var CpAmm = class {
         tokenAAta: tokenAAccount,
         tokenBAta: tokenBAccount,
         instructions: preInstructions
-      } = yield this.prepareTokenAccounts(
-        owner,
+      } = yield this.prepareTokenAccounts({
+        payer: owner,
+        tokenAOwner: owner,
+        tokenBOwner: owner,
         tokenAMint,
         tokenBMint,
         tokenAProgram,
         tokenBProgram
-      );
+      });
       if (tokenAMint.equals(NATIVE_MINT2)) {
         const wrapSOLIx = wrapSOLInstruction(
           owner,
@@ -8334,8 +9101,6 @@ var CpAmm = class {
         tokenBAmountThreshold,
         tokenAMint,
         tokenBMint,
-        tokenAVault,
-        tokenBVault,
         tokenAProgram,
         tokenBProgram
       } = params;
@@ -8343,13 +9108,17 @@ var CpAmm = class {
         tokenAAta: tokenAAccount,
         tokenBAta: tokenBAccount,
         instructions: preInstructions
-      } = yield this.prepareTokenAccounts(
-        owner,
+      } = yield this.prepareTokenAccounts({
+        payer: owner,
+        tokenAOwner: owner,
+        tokenBOwner: owner,
         tokenAMint,
         tokenBMint,
         tokenAProgram,
         tokenBProgram
-      );
+      });
+      const tokenAVault = deriveTokenVaultAddress(tokenAMint, pool);
+      const tokenBVault = deriveTokenVaultAddress(tokenBMint, pool);
       if (tokenAMint.equals(NATIVE_MINT2)) {
         const wrapSOLIx = wrapSOLInstruction(
           owner,
@@ -8437,13 +9206,15 @@ var CpAmm = class {
         tokenAAta: tokenAAccount,
         tokenBAta: tokenBAccount,
         instructions: preInstructions
-      } = yield this.prepareTokenAccounts(
-        owner,
+      } = yield this.prepareTokenAccounts({
+        payer: owner,
+        tokenAOwner: owner,
+        tokenBOwner: owner,
         tokenAMint,
         tokenBMint,
         tokenAProgram,
         tokenBProgram
-      );
+      });
       const postInstructions = [];
       if ([tokenAMint.toBase58(), tokenBMint.toBase58()].includes(
         NATIVE_MINT2.toBase58()
@@ -8508,13 +9279,15 @@ var CpAmm = class {
         tokenAAta: tokenAAccount,
         tokenBAta: tokenBAccount,
         instructions: preInstructions
-      } = yield this.prepareTokenAccounts(
-        owner,
+      } = yield this.prepareTokenAccounts({
+        payer: owner,
+        tokenAOwner: owner,
+        tokenBOwner: owner,
         tokenAMint,
         tokenBMint,
         tokenAProgram,
         tokenBProgram
-      );
+      });
       const postInstructions = [];
       if ([tokenAMint.toBase58(), tokenBMint.toBase58()].includes(
         NATIVE_MINT2.toBase58()
@@ -8587,13 +9360,15 @@ var CpAmm = class {
         tokenAAta: inputTokenAccount,
         tokenBAta: outputTokenAccount,
         instructions: preInstructions
-      } = yield this.prepareTokenAccounts(
+      } = yield this.prepareTokenAccounts({
         payer,
-        inputTokenMint,
-        outputTokenMint,
-        inputTokenProgram,
-        outputTokenProgram
-      );
+        tokenAOwner: payer,
+        tokenBOwner: payer,
+        tokenAMint: inputTokenMint,
+        tokenBMint: outputTokenMint,
+        tokenAProgram: inputTokenProgram,
+        tokenBProgram: outputTokenProgram
+      });
       if (inputTokenMint.equals(NATIVE_MINT2)) {
         const wrapSOLIx = wrapSOLInstruction(
           payer,
@@ -8693,67 +9468,6 @@ var CpAmm = class {
       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,
-        positionNftAccount,
-        tokenAVault,
-        tokenBVault,
-        tokenAMint,
-        tokenBMint,
-        tokenAProgram,
-        tokenBProgram
-      } = params;
-      const {
-        tokenAAta: tokenAAccount,
-        tokenBAta: tokenBAccount,
-        instructions: preInstructions
-      } = yield this.prepareTokenAccounts(
-        owner,
-        tokenAMint,
-        tokenBMint,
-        tokenAProgram,
-        tokenBProgram
-      );
-      const postInstructions = [];
-      if ([tokenAMint.toBase58(), tokenBMint.toBase58()].includes(
-        NATIVE_MINT2.toBase58()
-      )) {
-        const closeWrappedSOLIx = yield unwrapSOLInstruction(owner);
-        closeWrappedSOLIx && postInstructions.push(closeWrappedSOLIx);
-      }
-      const claimPositionFeeInstruction = yield this.buildClaimPositionFeeInstruction({
-        owner,
-        poolAuthority: this.poolAuthority,
-        pool,
-        position,
-        positionNftAccount,
-        tokenAAccount,
-        tokenBAccount,
-        tokenAVault,
-        tokenBVault,
-        tokenAMint,
-        tokenBMint,
-        tokenAProgram,
-        tokenBProgram
-      });
-      const transaction = new Transaction();
-      transaction.add(
-        ...preInstructions.length > 0 ? preInstructions : [],
-        claimPositionFeeInstruction,
-        ...postInstructions.length > 0 ? postInstructions : []
-      );
-      return transaction;
-    });
-  }
   closePosition(params) {
     return __async(this, null, function* () {
       const { owner, pool, position, positionNftMint, positionNftAccount } = params;
@@ -8808,13 +9522,15 @@ var CpAmm = class {
         tokenAAta: tokenAAccount,
         tokenBAta: tokenBAccount,
         instructions: preInstructions
-      } = yield this.prepareTokenAccounts(
-        owner,
+      } = yield this.prepareTokenAccounts({
+        payer: owner,
+        tokenAOwner: owner,
+        tokenBOwner: owner,
         tokenAMint,
         tokenBMint,
         tokenAProgram,
         tokenBProgram
-      );
+      });
       const postInstructions = [];
       if ([tokenAMint.toBase58(), tokenBMint.toBase58()].includes(
         NATIVE_MINT2.toBase58()
@@ -8899,13 +9615,15 @@ var CpAmm = class {
         tokenAAta: tokenAAccount,
         tokenBAta: tokenBAccount,
         instructions: preInstructions
-      } = yield this.prepareTokenAccounts(
-        owner,
+      } = yield this.prepareTokenAccounts({
+        payer: owner,
+        tokenAOwner: owner,
+        tokenBOwner: owner,
         tokenAMint,
         tokenBMint,
         tokenAProgram,
         tokenBProgram
-      );
+      });
       let positionBLiquidityDelta = positionBState.unlockedLiquidity;
       if (positionBVestings.length > 0) {
         const totalAvailableVestingLiquidity = positionBVestings.reduce(
@@ -8930,15 +9648,26 @@ var CpAmm = class {
         });
         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 (poolState.tokenAMint.equals(NATIVE_MINT2)) {
-        const wrapSOLIx = wrapSOLInstruction(owner, tokenAAccount, BigInt(1));
-        preInstructions.push(...wrapSOLIx);
-      }
-      if (poolState.tokenBMint.equals(NATIVE_MINT2)) {
-        const wrapSOLIx = wrapSOLInstruction(owner, tokenBAccount, BigInt(1));
-        preInstructions.push(...wrapSOLIx);
-      }
       if (preInstructions.length > 0) {
         transaction.add(...preInstructions);
       }
@@ -8967,7 +9696,7 @@ var CpAmm = class {
         tokenBVault,
         tokenAProgram,
         tokenBProgram,
-        liquidityDelta: positionBLiquidityDelta,
+        liquidityDelta: newLiquidityDelta,
         tokenAAmountThreshold: tokenAAmountAddLiquidityThreshold,
         tokenBAmountThreshold: tokenBAmountAddLiquidityThreshold
       });
@@ -9094,7 +9823,15 @@ var CpAmm = class {
    */
   claimPartnerFee(params) {
     return __async(this, null, function* () {
-      const { partner, pool, maxAmountA, maxAmountB } = params;
+      const {
+        feePayer,
+        receiver,
+        tempWSolAccount,
+        partner,
+        pool,
+        maxAmountA,
+        maxAmountB
+      } = params;
       const poolState = yield this.fetchPoolState(pool);
       const {
         tokenAVault,
@@ -9106,38 +9843,159 @@ var CpAmm = class {
       } = poolState;
       const tokenAProgram = getTokenProgram(tokenAFlag);
       const tokenBProgram = getTokenProgram(tokenBFlag);
+      const payer = feePayer != null ? feePayer : partner;
+      const { tokenAAccount, tokenBAccount, preInstructions, postInstructions } = yield this.setupFeeClaimAccounts({
+        payer,
+        owner: partner,
+        tokenAMint,
+        tokenBMint,
+        tokenAProgram,
+        tokenBProgram,
+        receiver,
+        tempWSolAccount
+      });
+      return yield this._program.methods.claimPartnerFee(maxAmountA, maxAmountB).accountsPartial({
+        poolAuthority: this.poolAuthority,
+        pool,
+        tokenAAccount,
+        tokenBAccount,
+        tokenAVault,
+        tokenBVault,
+        tokenAMint,
+        tokenBMint,
+        partner,
+        tokenAProgram,
+        tokenBProgram
+      }).preInstructions(preInstructions).postInstructions(postInstructions).transaction();
+    });
+  }
+  /**
+   * Builds a transaction to claim position fee rewards.
+   * @param {ClaimPositionFeeParams} params - Parameters for claiming position fee.
+   * @returns Transaction builder.
+   */
+  claimPositionFee(params) {
+    return __async(this, null, function* () {
+      const {
+        receiver,
+        tempWSolAccount,
+        feePayer,
+        owner,
+        pool,
+        position,
+        positionNftAccount,
+        tokenAVault,
+        tokenBVault,
+        tokenAMint,
+        tokenBMint,
+        tokenAProgram,
+        tokenBProgram
+      } = params;
+      const payer = feePayer != null ? feePayer : owner;
+      const { tokenAAccount, tokenBAccount, preInstructions, postInstructions } = yield this.setupFeeClaimAccounts({
+        payer,
+        owner,
+        tokenAMint,
+        tokenBMint,
+        tokenAProgram,
+        tokenBProgram,
+        receiver,
+        tempWSolAccount
+      });
+      const claimPositionFeeInstruction = yield this.buildClaimPositionFeeInstruction({
+        owner,
+        poolAuthority: this.poolAuthority,
+        pool,
+        position,
+        positionNftAccount,
+        tokenAAccount,
+        tokenBAccount,
+        tokenAVault,
+        tokenBVault,
+        tokenAMint,
+        tokenBMint,
+        tokenAProgram,
+        tokenBProgram
+      });
+      const transaction = new Transaction();
+      transaction.add(
+        ...preInstructions.length > 0 ? preInstructions : [],
+        claimPositionFeeInstruction,
+        ...postInstructions.length > 0 ? postInstructions : []
+      );
+      return transaction;
+    });
+  }
+  /**
+   * Builds a transaction to claim position fee rewards.
+   * @param {ClaimPositionFeeParams2} params - Parameters for claiming position fee.
+   * @returns Transaction builder.
+   */
+  claimPositionFee2(params) {
+    return __async(this, null, function* () {
+      const {
+        receiver,
+        feePayer,
+        owner,
+        pool,
+        position,
+        positionNftAccount,
+        tokenAVault,
+        tokenBVault,
+        tokenAMint,
+        tokenBMint,
+        tokenAProgram,
+        tokenBProgram
+      } = params;
+      const payer = feePayer != null ? feePayer : owner;
+      let tokenAOwner = receiver;
+      let tokenBOwner = receiver;
+      if (tokenAMint.equals(NATIVE_MINT2)) {
+        tokenAOwner = owner;
+      }
+      if (tokenBMint.equals(NATIVE_MINT2)) {
+        tokenBOwner = owner;
+      }
       const {
         tokenAAta: tokenAAccount,
         tokenBAta: tokenBAccount,
-        instructions: preInstructions
-      } = yield this.prepareTokenAccounts(
-        partner,
+        instructions: preInstruction
+      } = yield this.prepareTokenAccounts({
+        payer,
+        tokenAOwner,
+        tokenBOwner,
         tokenAMint,
         tokenBMint,
         tokenAProgram,
         tokenBProgram
-      );
+      });
       const postInstructions = [];
-      if ([
-        poolState.tokenAMint.toBase58(),
-        poolState.tokenBMint.toBase58()
-      ].includes(NATIVE_MINT2.toBase58())) {
-        const closeWrappedSOLIx = yield unwrapSOLInstruction(partner);
+      if (tokenAMint.equals(NATIVE_MINT2) || tokenBMint.equals(NATIVE_MINT2)) {
+        const closeWrappedSOLIx = yield unwrapSOLInstruction(owner, receiver);
         closeWrappedSOLIx && postInstructions.push(closeWrappedSOLIx);
       }
-      return yield this._program.methods.claimPartnerFee(maxAmountA, maxAmountB).accountsPartial({
+      const claimPositionFeeInstruction = yield this.buildClaimPositionFeeInstruction({
+        owner,
         poolAuthority: this.poolAuthority,
         pool,
+        position,
+        positionNftAccount,
         tokenAAccount,
         tokenBAccount,
         tokenAVault,
         tokenBVault,
         tokenAMint,
         tokenBMint,
-        partner,
         tokenAProgram,
         tokenBProgram
-      }).preInstructions(preInstructions).postInstructions(postInstructions).transaction();
+      });
+      const transaction = new Transaction();
+      transaction.add(
+        ...preInstruction.length > 0 ? preInstruction : [],
+        claimPositionFeeInstruction,
+        ...postInstructions.length > 0 ? postInstructions : []
+      );
+      return transaction;
     });
   }
   /**
@@ -9148,6 +10006,7 @@ var CpAmm = class {
   claimReward(params) {
     return __async(this, null, function* () {
       const {
+        feePayer,
         user,
         position,
         positionNftAccount,
@@ -9163,7 +10022,7 @@ var CpAmm = class {
         this._program.provider.connection,
         rewardInfo.mint,
         user,
-        user,
+        feePayer != null ? feePayer : user,
         true,
         tokenProgram
       );
@@ -9193,14 +10052,20 @@ 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,
@@ -9208,6 +10073,7 @@ export {
   Rounding,
   SCALE_OFFSET,
   TradeDirection,
+  bpsToFeeNumerator,
   calculateInitSqrtPrice,
   calculateTransferFeeExcludedAmount,
   calculateTransferFeeIncludedAmount,
@@ -9223,13 +10089,16 @@ export {
   deriveRewardVaultAddress,
   deriveTokenBadgeAddress,
   deriveTokenVaultAddress,
+  feeNumeratorToBps,
   getAllPositionNftAccountByOwner,
   getAllUserPositionNftAccount,
   getAmountAFromLiquidityDelta,
   getAmountBFromLiquidityDelta,
   getAvailableVestingLiquidity,
   getBaseFeeNumerator,
+  getBaseFeeParams,
   getDynamicFeeNumerator,
+  getDynamicFeeParams,
   getEstimatedComputeUnitIxWithBuffer,
   getEstimatedComputeUnitUsageWithBuffer,
   getFeeNumerator,