@meteora-ag/cp-amm-sdk 1.0.2 → 1.0.3

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: {
@@ -6570,7 +7027,7 @@ var wrapSOLInstruction = (from, to, amount) => {
     })
   ];
 };
-var unwrapSOLInstruction = (owner, allowOwnerOffCurve = true) => __async(void 0, null, function* () {
+var unwrapSOLInstruction = (_0, ..._1) => __async(void 0, [_0, ..._1], function* (owner, receiver = owner, allowOwnerOffCurve = true) {
   const wSolATAAccount = getAssociatedTokenAddressSync(
     NATIVE_MINT,
     owner,
@@ -6579,7 +7036,7 @@ var unwrapSOLInstruction = (owner, allowOwnerOffCurve = true) => __async(void 0,
   if (wSolATAAccount) {
     const closedWrappedSolInstruction = createCloseAccountInstruction(
       wSolATAAccount,
-      owner,
+      receiver,
       owner,
       [],
       TOKEN_PROGRAM_ID
@@ -7270,7 +7727,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, {
@@ -7278,6 +7735,7 @@ var CpAmm = class {
     });
     this.poolAuthority = derivePoolAuthority();
   }
+  //// ANCHOR: PRIVATE FUNCTIONS //////
   /**
    * Prepares token accounts for a transaction by retrieving or creating associated token accounts.
    * @private
@@ -7289,8 +7747,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 },
@@ -7299,16 +7766,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
         )
@@ -7618,6 +8085,127 @@ 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,
+        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;
+      const tokenAOwner = tempWSolAccount && tokenAIsSOL ? tempWSolAccount : receiver;
+      const tokenBOwner = tempWSolAccount && 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 : receiver,
+          receiver
+        );
+        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.
@@ -7941,13 +8529,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,
@@ -8122,6 +8708,7 @@ var CpAmm = class {
       liquidityDelta
     };
   }
+  //// ANCHOR: MAIN ENDPOINT //////
   /**
    * Builds a transaction to create a permissionless pool.
    * @param params - Parameters for pool creation.
@@ -8142,44 +8729,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);
+      });
+      const postInstruction = [];
+      if (isLockLiquidity) {
+        const permanentLockIx = yield this._program.methods.permanentLockPosition(liquidityDelta).accountsPartial({
+          position,
+          positionNftAccount,
+          pool,
+          owner: creator
+        }).instruction();
+        postInstruction.push(permanentLockIx);
       }
-      if (tokenBMint.equals(NATIVE_MINT2)) {
-        const wrapSOLIx = wrapSOLInstruction(
-          payer,
-          payerTokenB,
-          BigInt(tokenBAmount.toString())
-        );
-        preInstructions.push(...wrapSOLIx);
-      }
-      const tokenBadgeAccounts = this.getTokenBadgeAccounts(
-        tokenAMint,
-        tokenBMint
-      );
       const tx = yield this._program.methods.initializePool({
         liquidity: liquidityDelta,
         sqrtPrice: initSqrtPrice,
@@ -8203,7 +8786,7 @@ var CpAmm = class {
         tokenAProgram,
         tokenBProgram,
         systemProgram: SystemProgram2.programId
-      }).preInstructions(preInstructions).remainingAccounts(tokenBadgeAccounts).transaction();
+      }).preInstructions(preInstructions).postInstructions(postInstruction).remainingAccounts(tokenBadgeAccounts).transaction();
       return tx;
     });
   }
@@ -8232,45 +8815,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,
@@ -8299,7 +8877,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 };
     });
   }
@@ -8342,13 +9010,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,
@@ -8429,13 +9099,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,
@@ -8523,13 +9195,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()
@@ -8594,13 +9268,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()
@@ -8673,13 +9349,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,
@@ -8779,67 +9457,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;
@@ -8894,13 +9511,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()
@@ -8985,13 +9604,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(
@@ -9191,7 +9812,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,
@@ -9203,25 +9832,16 @@ var CpAmm = class {
       } = poolState;
       const tokenAProgram = getTokenProgram(tokenAFlag);
       const tokenBProgram = getTokenProgram(tokenBFlag);
-      const {
-        tokenAAta: tokenAAccount,
-        tokenBAta: tokenBAccount,
-        instructions: preInstructions
-      } = yield this.prepareTokenAccounts(
-        partner,
+      const payer = feePayer != null ? feePayer : partner;
+      const { tokenAAccount, tokenBAccount, preInstructions, postInstructions } = yield this.setupFeeClaimAccounts({
+        payer,
         tokenAMint,
         tokenBMint,
         tokenAProgram,
-        tokenBProgram
-      );
-      const postInstructions = [];
-      if ([
-        poolState.tokenAMint.toBase58(),
-        poolState.tokenBMint.toBase58()
-      ].includes(NATIVE_MINT2.toBase58())) {
-        const closeWrappedSOLIx = yield unwrapSOLInstruction(partner);
-        closeWrappedSOLIx && postInstructions.push(closeWrappedSOLIx);
-      }
+        tokenBProgram,
+        receiver,
+        tempWSolAccount
+      });
       return yield this._program.methods.claimPartnerFee(maxAmountA, maxAmountB).accountsPartial({
         poolAuthority: this.poolAuthority,
         pool,
@@ -9237,6 +9857,62 @@ var CpAmm = class {
       }).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,
+        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 reward from a position.
    * @param {ClaimRewardParams} params - Parameters for claiming reward.
@@ -9245,6 +9921,7 @@ var CpAmm = class {
   claimReward(params) {
     return __async(this, null, function* () {
       const {
+        feePayer,
         user,
         position,
         positionNftAccount,
@@ -9260,7 +9937,7 @@ var CpAmm = class {
         this._program.provider.connection,
         rewardInfo.mint,
         user,
-        user,
+        feePayer != null ? feePayer : user,
         true,
         tokenProgram
       );