@meteora-ag/cp-amm-sdk 1.1.4 → 1.1.5-rc.0

package/dist/index.d.mts

@@ -1,7 +1,8 @@
-import { Program, IdlAccounts, BN, IdlTypes } from '@coral-xyz/anchor';
 import { PublicKey, Transaction, Connection, TransactionInstruction, AddressLookupTableAccount, Commitment, GetProgramAccountsFilter } from '@solana/web3.js';
+import { Program, IdlAccounts, BN, IdlTypes } from '@coral-xyz/anchor';
 import { Mint } from '@solana/spl-token';
 import Decimal from 'decimal.js';
+import BN$1 from 'bn.js';
 
 /**
  * Program IDL in camelCase format in order to be used in JS/TS.
@@ -13,7 +14,7 @@ type CpAmm$1 = {
     address: "cpamdpZCGKUy5JxQXB4dcpGPiikHawvSWAd6mEn1sGG";
     metadata: {
         name: "cpAmm";
-        version: "0.1.3";
+        version: "0.1.5";
         spec: "0.1.0";
         description: "Created with Anchor";
     };
@@ -2668,6 +2669,83 @@ type CpAmm$1 = {
                 }
             ];
         },
+        {
+            name: "splitPosition2";
+            discriminator: [221, 147, 228, 207, 140, 212, 17, 119];
+            accounts: [
+                {
+                    name: "pool";
+                    writable: true;
+                    relations: ["firstPosition", "secondPosition"];
+                },
+                {
+                    name: "firstPosition";
+                    docs: ["The first position"];
+                    writable: true;
+                },
+                {
+                    name: "firstPositionNftAccount";
+                    docs: ["The token account for position nft"];
+                },
+                {
+                    name: "secondPosition";
+                    docs: ["The second position"];
+                    writable: true;
+                },
+                {
+                    name: "secondPositionNftAccount";
+                    docs: ["The token account for position nft"];
+                },
+                {
+                    name: "firstOwner";
+                    docs: ["Owner of first position"];
+                    signer: true;
+                },
+                {
+                    name: "secondOwner";
+                    docs: ["Owner of second position"];
+                    signer: true;
+                },
+                {
+                    name: "eventAuthority";
+                    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: "numerator";
+                    type: "u32";
+                }
+            ];
+        },
         {
             name: "swap";
             discriminator: [248, 198, 158, 145, 225, 117, 135, 200];
@@ -2774,6 +2852,112 @@ type CpAmm$1 = {
                 }
             ];
         },
+        {
+            name: "swap2";
+            discriminator: [65, 75, 63, 76, 235, 91, 91, 136];
+            accounts: [
+                {
+                    name: "poolAuthority";
+                    address: "HLnpSz9h2S4hiLQ43rnSD9XkcUThA7B8hQMKmDaiTLcC";
+                },
+                {
+                    name: "pool";
+                    docs: ["Pool account"];
+                    writable: true;
+                },
+                {
+                    name: "inputTokenAccount";
+                    docs: ["The user token account for input token"];
+                    writable: true;
+                },
+                {
+                    name: "outputTokenAccount";
+                    docs: ["The user token account for output token"];
+                    writable: true;
+                },
+                {
+                    name: "tokenAVault";
+                    docs: ["The vault token account for input token"];
+                    writable: true;
+                    relations: ["pool"];
+                },
+                {
+                    name: "tokenBVault";
+                    docs: ["The vault token account for output token"];
+                    writable: true;
+                    relations: ["pool"];
+                },
+                {
+                    name: "tokenAMint";
+                    docs: ["The mint of token a"];
+                },
+                {
+                    name: "tokenBMint";
+                    docs: ["The mint of token b"];
+                },
+                {
+                    name: "payer";
+                    docs: ["The user performing the swap"];
+                    signer: true;
+                },
+                {
+                    name: "tokenAProgram";
+                    docs: ["Token a program"];
+                },
+                {
+                    name: "tokenBProgram";
+                    docs: ["Token b program"];
+                },
+                {
+                    name: "referralTokenAccount";
+                    docs: ["referral token account"];
+                    writable: true;
+                    optional: true;
+                },
+                {
+                    name: "eventAuthority";
+                    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: "swapParameters2";
+                        };
+                    };
+                }
+            ];
+        },
         {
             name: "updateRewardDuration";
             discriminator: [138, 174, 196, 169, 213, 235, 254, 107];
@@ -3048,6 +3232,10 @@ type CpAmm$1 = {
             name: "evtInitializeReward";
             discriminator: [129, 91, 188, 3, 246, 52, 185, 249];
         },
+        {
+            name: "evtLiquidityChange";
+            discriminator: [197, 171, 78, 127, 224, 211, 87, 13];
+        },
         {
             name: "evtLockPosition";
             discriminator: [168, 63, 108, 83, 219, 82, 2, 200];
@@ -3065,13 +3253,17 @@ type CpAmm$1 = {
             discriminator: [100, 213, 74, 3, 95, 91, 228, 146];
         },
         {
-            name: "evtSplitPosition";
-            discriminator: [182, 138, 42, 254, 27, 94, 82, 221];
+            name: "evtSplitPosition2";
+            discriminator: [165, 32, 203, 174, 72, 100, 233, 103];
         },
         {
             name: "evtSwap";
             discriminator: [27, 60, 21, 213, 138, 170, 187, 147];
         },
+        {
+            name: "evtSwap2";
+            discriminator: [189, 66, 51, 168, 38, 80, 117, 153];
+        },
         {
             name: "evtUpdateRewardDuration";
             discriminator: [149, 135, 65, 231, 129, 153, 65, 57];
@@ -3320,6 +3512,36 @@ type CpAmm$1 = {
             code: 6046;
             name: "samePosition";
             msg: "Same position";
+        },
+        {
+            code: 6047;
+            name: "invalidBaseFeeMode";
+            msg: "Invalid base fee mode";
+        },
+        {
+            code: 6048;
+            name: "invalidFeeRateLimiter";
+            msg: "Invalid fee rate limiter";
+        },
+        {
+            code: 6049;
+            name: "failToValidateSingleSwapInstruction";
+            msg: "Fail to validate single swap instruction in rate limiter";
+        },
+        {
+            code: 6050;
+            name: "invalidFeeScheduler";
+            msg: "Invalid fee scheduler";
+        },
+        {
+            code: 6051;
+            name: "undeterminedError";
+            msg: "Undetermined error";
+        },
+        {
+            code: 6052;
+            name: "invalidPoolVersion";
+            msg: "Invalid pool version";
         }
     ];
     types: [
@@ -3360,7 +3582,7 @@ type CpAmm$1 = {
                         type: "u64";
                     },
                     {
-                        name: "feeSchedulerMode";
+                        name: "baseFeeMode";
                         type: "u8";
                     },
                     {
@@ -3370,15 +3592,17 @@ type CpAmm$1 = {
                         };
                     },
                     {
-                        name: "numberOfPeriod";
+                        name: "firstFactor";
                         type: "u16";
                     },
                     {
-                        name: "periodFrequency";
-                        type: "u64";
+                        name: "secondFactor";
+                        type: {
+                            array: ["u8", 8];
+                        };
                     },
                     {
-                        name: "reductionFactor";
+                        name: "thirdFactor";
                         type: "u64";
                     }
                 ];
@@ -3394,19 +3618,21 @@ type CpAmm$1 = {
                         type: "u64";
                     },
                     {
-                        name: "numberOfPeriod";
+                        name: "firstFactor";
                         type: "u16";
                     },
                     {
-                        name: "periodFrequency";
-                        type: "u64";
+                        name: "secondFactor";
+                        type: {
+                            array: ["u8", 8];
+                        };
                     },
                     {
-                        name: "reductionFactor";
+                        name: "thirdFactor";
                         type: "u64";
                     },
                     {
-                        name: "feeSchedulerMode";
+                        name: "baseFeeMode";
                         type: "u8";
                     }
                 ];
@@ -3426,7 +3652,7 @@ type CpAmm$1 = {
                         type: "u64";
                     },
                     {
-                        name: "feeSchedulerMode";
+                        name: "baseFeeMode";
                         type: "u8";
                     },
                     {
@@ -3436,15 +3662,17 @@ type CpAmm$1 = {
                         };
                     },
                     {
-                        name: "numberOfPeriod";
+                        name: "firstFactor";
                         type: "u16";
                     },
                     {
-                        name: "periodFrequency";
-                        type: "u64";
+                        name: "secondFactor";
+                        type: {
+                            array: ["u8", 8];
+                        };
                     },
                     {
-                        name: "reductionFactor";
+                        name: "thirdFactor";
                         type: "u64";
                     },
                     {
@@ -4223,7 +4451,7 @@ type CpAmm$1 = {
             };
         },
         {
-            name: "evtLockPosition";
+            name: "evtLiquidityChange";
             type: {
                 kind: "struct";
                 fields: [
@@ -4240,34 +4468,50 @@ type CpAmm$1 = {
                         type: "pubkey";
                     },
                     {
-                        name: "vesting";
-                        type: "pubkey";
+                        name: "tokenAAmount";
+                        type: "u64";
                     },
                     {
-                        name: "cliffPoint";
+                        name: "tokenBAmount";
                         type: "u64";
                     },
                     {
-                        name: "periodFrequency";
+                        name: "transferFeeIncludedTokenAAmount";
                         type: "u64";
                     },
                     {
-                        name: "cliffUnlockLiquidity";
-                        type: "u128";
+                        name: "transferFeeIncludedTokenBAmount";
+                        type: "u64";
                     },
                     {
-                        name: "liquidityPerPeriod";
+                        name: "reserveAAmount";
+                        type: "u64";
+                    },
+                    {
+                        name: "reserveBAmount";
+                        type: "u64";
+                    },
+                    {
+                        name: "liquidityDelta";
                         type: "u128";
                     },
                     {
-                        name: "numberOfPeriod";
-                        type: "u16";
+                        name: "tokenAAmountThreshold";
+                        type: "u64";
+                    },
+                    {
+                        name: "tokenBAmountThreshold";
+                        type: "u64";
+                    },
+                    {
+                        name: "changeType";
+                        type: "u8";
                     }
                 ];
             };
         },
         {
-            name: "evtPermanentLockPosition";
+            name: "evtLockPosition";
             type: {
                 kind: "struct";
                 fields: [
@@ -4280,15 +4524,59 @@ type CpAmm$1 = {
                         type: "pubkey";
                     },
                     {
-                        name: "lockLiquidityAmount";
-                        type: "u128";
+                        name: "owner";
+                        type: "pubkey";
                     },
                     {
-                        name: "totalPermanentLockedLiquidity";
-                        type: "u128";
-                    }
-                ];
-            };
+                        name: "vesting";
+                        type: "pubkey";
+                    },
+                    {
+                        name: "cliffPoint";
+                        type: "u64";
+                    },
+                    {
+                        name: "periodFrequency";
+                        type: "u64";
+                    },
+                    {
+                        name: "cliffUnlockLiquidity";
+                        type: "u128";
+                    },
+                    {
+                        name: "liquidityPerPeriod";
+                        type: "u128";
+                    },
+                    {
+                        name: "numberOfPeriod";
+                        type: "u16";
+                    }
+                ];
+            };
+        },
+        {
+            name: "evtPermanentLockPosition";
+            type: {
+                kind: "struct";
+                fields: [
+                    {
+                        name: "pool";
+                        type: "pubkey";
+                    },
+                    {
+                        name: "position";
+                        type: "pubkey";
+                    },
+                    {
+                        name: "lockLiquidityAmount";
+                        type: "u128";
+                    },
+                    {
+                        name: "totalPermanentLockedLiquidity";
+                        type: "u128";
+                    }
+                ];
+            };
         },
         {
             name: "evtRemoveLiquidity";
@@ -4343,7 +4631,7 @@ type CpAmm$1 = {
             };
         },
         {
-            name: "evtSplitPosition";
+            name: "evtSplitPosition2";
             type: {
                 kind: "struct";
                 fields: [
@@ -4399,7 +4687,7 @@ type CpAmm$1 = {
                         name: "splitPositionParameters";
                         type: {
                             defined: {
-                                name: "splitPositionParameters";
+                                name: "splitPositionParameters2";
                             };
                         };
                     }
@@ -4450,6 +4738,70 @@ type CpAmm$1 = {
                 ];
             };
         },
+        {
+            name: "evtSwap2";
+            type: {
+                kind: "struct";
+                fields: [
+                    {
+                        name: "pool";
+                        type: "pubkey";
+                    },
+                    {
+                        name: "tradeDirection";
+                        type: "u8";
+                    },
+                    {
+                        name: "collectFeeMode";
+                        type: "u8";
+                    },
+                    {
+                        name: "hasReferral";
+                        type: "bool";
+                    },
+                    {
+                        name: "params";
+                        type: {
+                            defined: {
+                                name: "swapParameters2";
+                            };
+                        };
+                    },
+                    {
+                        name: "swapResult";
+                        type: {
+                            defined: {
+                                name: "swapResult2";
+                            };
+                        };
+                    },
+                    {
+                        name: "includedTransferFeeAmountIn";
+                        type: "u64";
+                    },
+                    {
+                        name: "includedTransferFeeAmountOut";
+                        type: "u64";
+                    },
+                    {
+                        name: "excludedTransferFeeAmountOut";
+                        type: "u64";
+                    },
+                    {
+                        name: "currentTimestamp";
+                        type: "u64";
+                    },
+                    {
+                        name: "reserveAAmount";
+                        type: "u64";
+                    },
+                    {
+                        name: "reserveBAmount";
+                        type: "u64";
+                    }
+                ];
+            };
+        },
         {
             name: "evtUpdateRewardDuration";
             type: {
@@ -4740,12 +5092,17 @@ type CpAmm$1 = {
                         docs: ["pool type"];
                         type: "u8";
                     },
+                    {
+                        name: "version";
+                        docs: [
+                            "pool version, 0: max_fee is still capped at 50%, 1: max_fee is capped at 99%"
+                        ];
+                        type: "u8";
+                    },
                     {
                         name: "padding0";
                         docs: ["padding"];
-                        type: {
-                            array: ["u8", 2];
-                        };
+                        type: "u8";
                     },
                     {
                         name: "feeAPerLiquidity";
@@ -5347,6 +5704,38 @@ type CpAmm$1 = {
                 ];
             };
         },
+        {
+            name: "splitPositionParameters2";
+            type: {
+                kind: "struct";
+                fields: [
+                    {
+                        name: "unlockedLiquidityNumerator";
+                        type: "u32";
+                    },
+                    {
+                        name: "permanentLockedLiquidityNumerator";
+                        type: "u32";
+                    },
+                    {
+                        name: "feeANumerator";
+                        type: "u32";
+                    },
+                    {
+                        name: "feeBNumerator";
+                        type: "u32";
+                    },
+                    {
+                        name: "reward0Numerator";
+                        type: "u32";
+                    },
+                    {
+                        name: "reward1Numerator";
+                        type: "u32";
+                    }
+                ];
+            };
+        },
         {
             name: "staticConfigParameters";
             type: {
@@ -5403,6 +5792,33 @@ type CpAmm$1 = {
                 ];
             };
         },
+        {
+            name: "swapParameters2";
+            type: {
+                kind: "struct";
+                fields: [
+                    {
+                        name: "amount0";
+                        docs: [
+                            "When it's exact in, partial fill, this will be amount_in. When it's exact out, this will be amount_out"
+                        ];
+                        type: "u64";
+                    },
+                    {
+                        name: "amount1";
+                        docs: [
+                            "When it's exact in, partial fill, this will be minimum_amount_out. When it's exact out, this will be maximum_amount_in"
+                        ];
+                        type: "u64";
+                    },
+                    {
+                        name: "swapMode";
+                        docs: ["Swap mode, refer [SwapMode]"];
+                        type: "u8";
+                    }
+                ];
+            };
+        },
         {
             name: "swapResult";
             docs: ["Encodes all results of swapping"];
@@ -5436,6 +5852,50 @@ type CpAmm$1 = {
                 ];
             };
         },
+        {
+            name: "swapResult2";
+            type: {
+                kind: "struct";
+                fields: [
+                    {
+                        name: "includedFeeInputAmount";
+                        type: "u64";
+                    },
+                    {
+                        name: "excludedFeeInputAmount";
+                        type: "u64";
+                    },
+                    {
+                        name: "amountLeft";
+                        type: "u64";
+                    },
+                    {
+                        name: "outputAmount";
+                        type: "u64";
+                    },
+                    {
+                        name: "nextSqrtPrice";
+                        type: "u128";
+                    },
+                    {
+                        name: "tradingFee";
+                        type: "u64";
+                    },
+                    {
+                        name: "protocolFee";
+                        type: "u64";
+                    },
+                    {
+                        name: "partnerFee";
+                        type: "u64";
+                    },
+                    {
+                        name: "referralFee";
+                        type: "u64";
+                    }
+                ];
+            };
+        },
         {
             name: "tokenBadge";
             docs: ["Parameter that set by the protocol"];
@@ -5585,9 +6045,10 @@ declare enum ActivationPoint {
     Timestamp = 0,
     Slot = 1
 }
-declare enum FeeSchedulerMode {
-    Linear = 0,
-    Exponential = 1
+declare enum BaseFeeMode {
+    FeeSchedulerLinear = 0,
+    FeeSchedulerExponential = 1,
+    RateLimiter = 2
 }
 declare enum CollectFeeMode {
     BothToken = 0,
@@ -5601,32 +6062,68 @@ declare enum ActivationType {
     Slot = 0,
     Timestamp = 1
 }
+declare enum PoolVersion {
+    V0 = 0,
+    V1 = 1
+}
 type FeeMode = {
-    feeOnInput: boolean;
+    feesOnInput: boolean;
     feesOnTokenA: boolean;
+    hasReferral: boolean;
 };
+declare enum PoolStatus {
+    Enable = 0,
+    Disable = 1
+}
+declare enum SwapMode {
+    ExactIn = 0,
+    PartialFill = 1,
+    ExactOut = 2
+}
 type PoolState = IdlAccounts<CpAmm$1>["pool"];
 type PositionState = IdlAccounts<CpAmm$1>["position"];
 type VestingState = IdlAccounts<CpAmm$1>["vesting"];
 type ConfigState = IdlAccounts<CpAmm$1>["config"];
 type TokenBadgeState = IdlAccounts<CpAmm$1>["tokenBadge"];
 type RewardInfo = IdlTypes<CpAmm$1>["rewardInfo"];
-type DynamicFee = {
-    binStep: number;
-    binStepU128: BN;
-    filterPeriod: number;
-    decayPeriod: number;
-    reductionFactor: number;
-    maxVolatilityAccumulator: number;
-    variableFeeControl: number;
-};
-type BaseFee = {
-    cliffFeeNumerator: BN;
-    numberOfPeriod: number;
-    periodFrequency: BN;
-    reductionFactor: BN;
-    feeSchedulerMode: number;
-};
+/**
+ * Dynamic fee parameters
+ * @param binStep
+ * @param binStepU128
+ * @param filterPeriod
+ * @param decayPeriod
+ * @param reductionFactor
+ * @param maxVolatilityAccumulator
+ * @param variableFeeControl
+ */
+type DynamicFee = IdlTypes<CpAmm$1>["dynamicFeeParameters"];
+/**
+ * Dynamic fee struct
+ * @param initialized
+ * @param padding
+ * @param maxVolatilityAccumulator
+ * @param variableFeeControl
+ * @param binStep
+ * @param filterPeriod
+ * @param decayPeriod
+ * @param reductionFactor
+ * @param lastUpdateTimestamp
+ * @param binStepU128
+ * @param sqrtPriceReference
+ * @param volatilityAccumulator
+ * @param volatilityReference
+ */
+type DynamicFeeStruct = IdlTypes<CpAmm$1>["dynamicFeeStruct"];
+/**
+ * Base fee parameters
+ * @param cliffFeeNumerator
+ * @param firstFactor // feeScheduler: numberOfPeriod, rateLimiter: feeIncrementBps
+ * @param secondFactor // feeScheduler: periodFrequency, rateLimiter: maxLimiterDuration
+ * @param thirdFactor // feeScheduler: reductionFactor, rateLimiter: referenceAmount
+ * @param baseFeeMode
+ */
+type BaseFee = IdlTypes<CpAmm$1>["baseFeeParameters"];
+type PoolFeesStruct = IdlTypes<CpAmm$1>["poolFeesStruct"];
 type PoolFeesParams = {
     baseFee: BaseFee;
     padding: number[];
@@ -5895,18 +6392,13 @@ type GetQuoteParams = {
     };
     tokenADecimal: number;
     tokenBDecimal: number;
+    hasReferral?: boolean;
 };
-type SwapAmount = {
-    outputAmount: BN;
-    nextSqrtPrice: BN;
-};
-type GetQuoteExactOutParams = {
-    outAmount: BN;
-    outputTokenMint: PublicKey;
+type GetQuote2Params = {
+    inputTokenMint: PublicKey;
     slippage: number;
+    currentPoint: BN;
     poolState: PoolState;
-    currentTime: number;
-    currentSlot: number;
     inputTokenInfo?: {
         mint: Mint;
         currentEpoch: number;
@@ -5917,26 +6409,28 @@ type GetQuoteExactOutParams = {
     };
     tokenADecimal: number;
     tokenBDecimal: number;
-};
-type SwapResult = {
+    hasReferral: boolean;
+} & ({
+    swapMode: SwapMode.ExactIn;
+    amountIn: BN;
+} | {
+    swapMode: SwapMode.PartialFill;
+    amountIn: BN;
+} | {
+    swapMode: SwapMode.ExactOut;
+    amountOut: BN;
+});
+type SwapAmount = {
     outputAmount: BN;
     nextSqrtPrice: BN;
-    lpFee: BN;
-    protocolFee: BN;
-    referralFee: BN;
-    partnerFee: BN;
-};
-type QuoteExactOutResult = {
-    swapResult: SwapResult;
-    inputAmount: BN;
-    maxInputAmount: BN;
-    priceImpact: number;
-};
-type SwapQuotes = {
-    totalFee: BN;
-    minOutAmount: BN;
-    actualAmount: BN;
 };
+type SwapResult = IdlTypes<CpAmm$1>["swapResult"];
+type SwapResult2 = IdlTypes<CpAmm$1>["swapResult2"];
+interface Quote2Result extends SwapResult2 {
+    priceImpact: Decimal;
+    minimumAmountOut?: BN;
+    maximumAmountIn?: BN;
+}
 type SwapParams = {
     payer: PublicKey;
     pool: PublicKey;
@@ -5952,6 +6446,31 @@ type SwapParams = {
     tokenBProgram: PublicKey;
     referralTokenAccount: PublicKey | null;
 };
+type Swap2Params = {
+    payer: PublicKey;
+    pool: PublicKey;
+    inputTokenMint: PublicKey;
+    outputTokenMint: PublicKey;
+    tokenAMint: PublicKey;
+    tokenBMint: PublicKey;
+    tokenAVault: PublicKey;
+    tokenBVault: PublicKey;
+    tokenAProgram: PublicKey;
+    tokenBProgram: PublicKey;
+    referralTokenAccount: PublicKey | null;
+} & ({
+    swapMode: SwapMode.ExactIn;
+    amountIn: BN;
+    minimumAmountOut: BN;
+} | {
+    swapMode: SwapMode.PartialFill;
+    amountIn: BN;
+    minimumAmountOut: BN;
+} | {
+    swapMode: SwapMode.ExactOut;
+    amountOut: BN;
+    maximumAmountIn: BN;
+});
 type LockPositionParams = {
     owner: PublicKey;
     payer: PublicKey;
@@ -6151,13 +6670,41 @@ type SplitPositionParams = {
     reward0Percentage: number;
     reward1Percentage: number;
 };
-
-/**
- * CpAmm SDK class to interact with the DAMM-V2
- */
-declare class CpAmm {
-    _program: AmmProgram;
-    private poolAuthority;
+type SplitPosition2Params = {
+    firstPositionOwner: PublicKey;
+    secondPositionOwner: PublicKey;
+    pool: PublicKey;
+    firstPosition: PublicKey;
+    firstPositionNftAccount: PublicKey;
+    secondPosition: PublicKey;
+    secondPositionNftAccount: PublicKey;
+    numerator: number;
+};
+interface BaseFeeHandler {
+    validate(collectFeeMode: CollectFeeMode, activationType: ActivationType, poolVersion: PoolVersion): boolean;
+    getBaseFeeNumeratorFromIncludedFeeAmount(currentPoint: BN, activationPoint: BN, tradeDirection: TradeDirection, includedFeeAmount: BN): BN;
+    getBaseFeeNumeratorFromExcludedFeeAmount(currentPoint: BN, activationPoint: BN, tradeDirection: TradeDirection, excludedFeeAmount: BN): BN;
+}
+interface FeeOnAmountResult {
+    amount: BN;
+    tradingFee: BN;
+    protocolFee: BN;
+    partnerFee: BN;
+    referralFee: BN;
+}
+interface SplitFees {
+    tradingFee: BN;
+    protocolFee: BN;
+    referralFee: BN;
+    partnerFee: BN;
+}
+
+/**
+ * CpAmm SDK class to interact with the DAMM-V2
+ */
+declare class CpAmm {
+    _program: AmmProgram;
+    private poolAuthority;
     constructor(connection: Connection);
     /**
      * Prepares token accounts for a transaction by retrieving or creating associated token accounts.
@@ -6335,7 +6882,7 @@ declare class CpAmm {
     canUnlockPosition(positionState: PositionState, vestings: Array<{
         account: PublicKey;
         vestingState: VestingState;
-    }>, currentPoint: BN): {
+    }>, currentPoint: BN$1): {
         canUnlock: boolean;
         reason?: string;
     };
@@ -6346,26 +6893,21 @@ declare class CpAmm {
      * @param {LiquidityDeltaParams} params - The parameters for liquidity calculation
      * @returns {Promise<BN>} - The computed liquidity delta in Q64 value.
      */
-    getLiquidityDelta(params: LiquidityDeltaParams): BN;
+    getLiquidityDelta(params: LiquidityDeltaParams): BN$1;
     /**
      * Calculates swap quote based on input amount and pool state.
      * @param params - Swap parameters including input amount, pool state, slippage, etc.
      * @returns Swap quote including expected output amount, fee, and price impact.
      */
     getQuote(params: GetQuoteParams): {
-        swapInAmount: BN;
-        consumedInAmount: BN;
-        swapOutAmount: BN;
-        minSwapOutAmount: BN;
-        totalFee: BN;
+        swapInAmount: BN$1;
+        consumedInAmount: BN$1;
+        swapOutAmount: BN$1;
+        minSwapOutAmount: BN$1;
+        totalFee: BN$1;
         priceImpact: Decimal;
     };
-    /**
-     * Calculates swap quote based on desired output amount and pool state.
-     * @param params - Swap parameters including output amount, pool state, slippage, etc.
-     * @returns Swap quote including required input amount, fees, and price impact.
-     */
-    getQuoteExactOut(params: GetQuoteExactOutParams): QuoteExactOutResult;
+    getQuote2(params: GetQuote2Params): Quote2Result;
     /**
      * Calculates the deposit quote for liquidity pool.
      *
@@ -6397,7 +6939,7 @@ declare class CpAmm {
      * @param params Parameters for single-sided pool creation
      * @returns Calculated liquidity delta
      */
-    preparePoolCreationSingleSide(params: PreparePoolCreationSingleSide): BN;
+    preparePoolCreationSingleSide(params: PreparePoolCreationSingleSide): BN$1;
     /**
      * Prepares parameters required for pool creation, including initial sqrt price and liquidity.
      * @private
@@ -6466,6 +7008,7 @@ declare class CpAmm {
      * @returns Transaction builder.
      */
     swap(params: SwapParams): TxBuilder;
+    swap2(params: Swap2Params): TxBuilder;
     /**
      * Builds a transaction to lock a position with vesting schedule.
      * @param {LockPositionParams} params - Locking parameters.
@@ -6559,6 +7102,7 @@ declare class CpAmm {
      */
     claimReward(params: ClaimRewardParams): TxBuilder;
     splitPosition(params: SplitPositionParams): TxBuilder;
+    splitPosition2(params: SplitPosition2Params): TxBuilder;
 }
 
 declare function getFirstKey(key1: PublicKey, key2: PublicKey): Buffer<ArrayBufferLike>;
@@ -6578,172 +7122,109 @@ declare const CP_AMM_PROGRAM_ID: PublicKey;
 declare const LIQUIDITY_SCALE = 128;
 declare const SCALE_OFFSET = 64;
 declare const BASIS_POINT_MAX = 10000;
-declare const MAX_FEE_NUMERATOR = 500000000;
 declare const FEE_DENOMINATOR = 1000000000;
-declare const MIN_SQRT_PRICE: BN;
-declare const MAX_SQRT_PRICE: BN;
+declare const ONE_Q64: BN$1;
+declare const MAX_EXPONENTIAL: BN$1;
+declare const MAX: BN$1;
+declare const MIN_FEE_BPS = 1;
+declare const MIN_FEE_NUMERATOR = 100000;
+declare const MAX_FEE_BPS_V0 = 5000;
+declare const MAX_FEE_NUMERATOR_V0 = 500000000;
+declare const MAX_FEE_BPS_V1 = 9900;
+declare const MAX_FEE_NUMERATOR_V1 = 990000000;
+declare const MIN_SQRT_PRICE: BN$1;
+declare const MAX_SQRT_PRICE: BN$1;
 declare const MIN_CU_BUFFER = 50000;
 declare const MAX_CU_BUFFER = 200000;
+declare const DYNAMIC_FEE_SCALING_FACTOR: BN$1;
+declare const DYNAMIC_FEE_ROUNDING_OFFSET: BN$1;
 declare const DYNAMIC_FEE_FILTER_PERIOD_DEFAULT = 10;
 declare const DYNAMIC_FEE_DECAY_PERIOD_DEFAULT = 120;
 declare const DYNAMIC_FEE_REDUCTION_FACTOR_DEFAULT = 5000;
 declare const BIN_STEP_BPS_DEFAULT = 1;
-declare const BIN_STEP_BPS_U128_DEFAULT: BN;
+declare const BIN_STEP_BPS_U128_DEFAULT: BN$1;
 declare const MAX_PRICE_CHANGE_BPS_DEFAULT = 1500;
+declare const U128_MAX: BN$1;
+declare const U64_MAX: BN$1;
+declare const U16_MAX = 65535;
+declare const MAX_RATE_LIMITER_DURATION_IN_SECONDS = 43200;
+declare const MAX_RATE_LIMITER_DURATION_IN_SLOTS = 108000;
+declare const SPLIT_POSITION_DENOMINATOR = 1000000000;
+declare const CURRENT_POOL_VERSION = PoolVersion.V0;
 
+/**
+ * Gets the token program
+ * @param flag - The flag
+ * @returns The token program
+ */
 declare function getTokenProgram(flag: number): PublicKey;
+/**
+ * Gets the token decimals
+ * @param connection - The connection
+ * @param mint - The mint
+ * @returns The token decimals
+ */
 declare const getTokenDecimals: (connection: Connection, mint: PublicKey) => Promise<number>;
+/**
+ * Gets the or creates the ATA instruction
+ * @param connection - The connection
+ * @param tokenMint - The token mint
+ * @param owner - The owner
+ * @param payer - The payer
+ * @param allowOwnerOffCurve - The allow owner off curve
+ * @param tokenProgram - The token program
+ * @returns The ATA instruction
+ */
 declare const getOrCreateATAInstruction: (connection: Connection, tokenMint: PublicKey, owner: PublicKey, payer: PublicKey, allowOwnerOffCurve: boolean, tokenProgram: PublicKey) => Promise<{
     ataPubkey: PublicKey;
     ix?: TransactionInstruction;
 }>;
+/**
+ * Gets the wrap SOL instruction
+ * @param from - The from
+ * @param to - The to
+ * @param amount - The amount
+ * @returns The wrap SOL instruction
+ */
 declare const wrapSOLInstruction: (from: PublicKey, to: PublicKey, amount: bigint) => TransactionInstruction[];
+/**
+ * Gets the unwrap SOL instruction
+ * @param owner - The owner
+ * @param receiver - The receiver
+ * @param allowOwnerOffCurve - The allow owner off curve
+ * @returns The unwrap SOL instruction
+ */
 declare const unwrapSOLInstruction: (owner: PublicKey, receiver?: PublicKey, allowOwnerOffCurve?: boolean) => Promise<TransactionInstruction>;
+/**
+ * Gets all the user position NFT accounts
+ * @param connection - The connection
+ * @param user - The user
+ * @returns The user position NFT accounts
+ */
 declare function getAllUserPositionNftAccount(connection: Connection, user: PublicKey): Promise<Array<{
     positionNft: PublicKey;
     positionNftAccount: PublicKey;
 }>>;
+/**
+ * Gets all the position NFT accounts by owner
+ * @param connection - The connection
+ * @param user - The user
+ * @returns The position NFT accounts by owner
+ */
 declare function getAllPositionNftAccountByOwner(connection: Connection, user: PublicKey): Promise<Array<{
     positionNft: PublicKey;
     positionNftAccount: PublicKey;
 }>>;
 
-declare function getBaseFeeNumerator(feeSchedulerMode: FeeSchedulerMode, cliffFeeNumerator: BN, period: BN, reductionFactor: BN): BN;
-/**
- * Calculates the dynamic fee numerator based on market volatility metrics
- *
- * @param volatilityAccumulator - A measure of accumulated market volatility (BN)
- * @param binStep - The size of price bins in the liquidity distribution (BN)
- * @param variableFeeControl - Parameter controlling the impact of volatility on fees (BN)
- * @returns The calculated dynamic fee numerator (BN)
- */
-declare function getDynamicFeeNumerator(volatilityAccumulator: BN, binStep: BN, variableFeeControl: BN): BN;
-/**
- * Calculates the fee numerator based on current market conditions and fee schedule configuration
- *
- * @param currentPoint - The current price point in the liquidity curve
- * @param activationPoint - The price point at which the fee schedule is activated (BN)
- * @param numberOfPeriod - The total number of periods in the fee schedule
- * @param periodFrequency - The frequency at which periods change (BN)
- * @param feeSchedulerMode - The mode determining how fees are calculated (0 = constant, 1 = linear, etc.)
- * @param cliffFeeNumerator - The initial fee numerator at the cliff point (BN)
- * @param reductionFactor - The factor by which fees are reduced in each period (BN)
- * @param dynamicFeeParams - Optional parameters for dynamic fee calculation
- * @param dynamicFeeParams.volatilityAccumulator - Measure of accumulated market volatility (BN)
- * @param dynamicFeeParams.binStep - Size of price bins in the liquidity distribution (BN)
- * @param dynamicFeeParams.variableFeeControl - Parameter controlling the impact of volatility (BN)
- * @returns The calculated fee numerator (BN), capped at MAX_FEE_NUMERATOR
- */
-declare function getFeeNumerator(currentPoint: number, activationPoint: BN, numberOfPeriod: number, periodFrequency: BN, feeSchedulerMode: number, cliffFeeNumerator: BN, reductionFactor: BN, dynamicFeeParams?: {
-    volatilityAccumulator: BN;
-    binStep: number;
-    variableFeeControl: number;
-}): BN;
-/**
- * Determines the fee mode based on the swap direction and fee collection configuration
- *
- * @param collectFeeMode - The fee collection mode (e.g., OnlyB, BothToken)
- * @param btoA - Boolean indicating if the swap is from token B to token A
- * @returns { feeOnInput, feesOnTokenA }
- */
-declare function getFeeMode(collectFeeMode: CollectFeeMode, btoA: boolean): FeeMode;
-/**
- *
- * Calculates the output amount and fees for a swap operation in a concentrated liquidity pool.
- *
- * @param inAmount - The input amount of tokens the user is swapping
- * @param sqrtPrice - The current square root price of the pool
- * @param liquidity - The current liquidity available in the pool
- * @param tradeFeeNumerator - The fee numerator used to calculate trading fees
- * @param aToB - Direction of the swap: true for token A to token B, false for token B to token A
- * @param collectFeeMode - Determines how fees are collected (0: both tokens, 1: only token B)
- * @returns Object containing the actual output amount after fees and the total fee amount
- */
-declare function getSwapAmount(inAmount: BN, sqrtPrice: BN, liquidity: BN, tradeFeeNumerator: BN, aToB: boolean, collectFeeMode: number): {
-    amountOut: BN;
-    totalFee: BN;
-    nextSqrtPrice: BN;
-};
-/**
- * Converts basis points (bps) to a fee numerator
- * 1 bps = 0.01% = 0.0001 in decimal
- *
- * @param bps - The value in basis points [1-10_000]
- * @returns The equivalent fee numerator
- */
-declare function bpsToFeeNumerator(bps: number): BN;
-/**
- * Converts a fee numerator back to basis points (bps)
- *
- * @param feeNumerator - The fee numerator to convert
- * @returns The equivalent value in basis points [1-10_000]
- */
-declare function feeNumeratorToBps(feeNumerator: BN): number;
-/**
- * Calculates base fee parameters for a fee scheduler system.
- * @param {number} maxBaseFeeBps - Maximum fee in basis points
- * @param {number} minBaseFeeBps - Minimum fee in basis points
- * @param {FeeSchedulerMode} feeSchedulerMode - Mode for fee reduction (Linear or Exponential)
- * @param {number} numberOfPeriod - Number of periods over which to schedule fee reduction
- * @param {BN} periodFrequency - Time interval between fee reductions
- *
- * @returns {BaseFee}
- */
-declare function getBaseFeeParams(maxBaseFeeBps: number, minBaseFeeBps: number, feeSchedulerMode: FeeSchedulerMode, numberOfPeriod: number, totalDuration: number): BaseFee;
-/**
- * Calculate dynamic fee parameters
- * @param {number} baseFeeBps - Base fee in basis points
- * @param {number} [maxPriceChangeBps=1500] - Maximum price change to consider for fee calculation (in basis points)
- *
- * @returns {DynamicFee}
- */
-declare function getDynamicFeeParams(baseFeeBps: number, maxPriceChangeBps?: number): DynamicFee;
 /**
- * Calculates the excluded fee amount and trading fee from an included fee amount
- * @param tradeFeeNumerator - The fee numerator
- * @param includedFeeAmount - The amount that includes the fee
- * @returns Tuple of [excluded_fee_amount, trading_fee]
+ * Gets the estimated compute unit usage for a transaction.
+ * @param connection - The connection to the Solana cluster
+ * @param instructions - The instructions to simulate
+ * @param payer - The public key of the fee payer
+ * @param lookupTables - The lookup tables to simulate
+ * @param commitment - The commitment level to simulate
+ * @returns The estimated compute unit usage
  */
-declare function getExcludedFeeAmount(tradeFeeNumerator: BN, includedFeeAmount: BN): {
-    excludedFeeAmount: BN;
-    tradingFee: BN;
-};
-/**
- * Calculates the included fee amount from an excluded fee amount
- * @param tradeFeeNumerator - The fee numerator
- * @param excludedFeeAmount - The amount that excludes the fee
- * @returns The amount including the fee
- */
-declare function getIncludedFeeAmount(tradeFeeNumerator: BN, excludedFeeAmount: BN): BN;
-/**
- * Calculates the swap result from a given output amount
- * @param pool - The pool state
- * @param outAmount - The desired output amount
- * @param feeMode - The fee mode configuration
- * @param tradeDirection - The direction of the trade
- * @param currentPoint - The current time/slot point
- * @returns Tuple of [SwapResult, input_amount]
- */
-declare function getSwapResultFromOutAmount(pool: PoolState, outAmount: BN, feeMode: FeeMode & {
-    hasReferral?: boolean;
-}, tradeDirection: TradeDirection, currentPoint: number): {
-    swapResult: SwapResult;
-    inputAmount: BN;
-};
-
-declare function getNextSqrtPrice(amount: BN, sqrtPrice: BN, liquidity: BN, aToB: boolean): BN;
-declare function getLiquidityDeltaFromAmountA(amountA: BN, lowerSqrtPrice: BN, // current sqrt price
-upperSqrtPrice: BN): BN;
-declare function getLiquidityDeltaFromAmountB(amountB: BN, lowerSqrtPrice: BN, // min sqrt price
-upperSqrtPrice: BN): BN;
-declare function getAmountAFromLiquidityDelta(liquidity: BN, currentSqrtPrice: BN, // current sqrt price
-maxSqrtPrice: BN, rounding: Rounding): BN;
-declare function getAmountBFromLiquidityDelta(liquidity: BN, currentSqrtPrice: BN, // current sqrt price,
-minSqrtPrice: BN, rounding: Rounding): BN;
-declare function getNextSqrtPriceFromAmountBRoundingUp(sqrtPrice: BN, liquidity: BN, amount: BN): BN;
-declare function getNextSqrtPriceFromAmountARoundingDown(sqrtPrice: BN, liquidity: BN, amount: BN): BN;
-declare function getNextSqrtPriceFromOutput(sqrtPrice: BN, liquidity: BN, outAmount: BN, isB: boolean): BN;
-
 declare const getSimulationComputeUnits: (connection: Connection, instructions: Array<TransactionInstruction>, payer: PublicKey, lookupTables: Array<AddressLookupTableAccount> | [], commitment?: Commitment) => Promise<number | null>;
 /**
  * Gets the estimated compute unit usage with a buffer.
@@ -6775,13 +7256,16 @@ declare const getEstimatedComputeUnitIxWithBuffer: (connection: Connection, inst
  */
 declare const getMaxAmountWithSlippage: (amount: BN, rate: number) => BN;
 /**
- * It takes an amount and a slippage rate, and returns the minimum amount that will be received after
- * slippage
- * @param {BN} amount - The amount of tokens you want to sell.
- * @param {number} rate - The percentage of slippage you're willing to accept. (Max to 2 decimal place)
- * @returns The minimum amount that can be received after slippage is applied.
+ * Calculates minimum amount out or maximum amount in based on slippage and swap mode.
+ * For ExactIn/PartialFill: returns minimum amount out.
+ * For ExactOut: returns maximum amount in.
+ *
+ * @param {BN} amount - The base amount (outputAmount for ExactIn/PartialFill, includedFeeInputAmount for ExactOut)
+ * @param {number} slippageBps - Slippage in basis points (1% = 100)
+ * @param {SwapMode} swapMode - Swap mode (ExactIn, PartialFill, ExactOut)
+ * @returns {BN} - Minimum amount out (for ExactIn/PartialFill) or maximum amount in (for ExactOut)
  */
-declare const getMinAmountWithSlippage: (amount: BN, rate: number) => BN;
+declare const getAmountWithSlippage: (amount: BN, slippageBps: number, swapMode: SwapMode) => BN;
 /**
  * Calculate price impact as a percentage
  * Price impact measures how much worse the user's execution was compared to the current market price
@@ -6802,28 +7286,74 @@ declare const getPriceImpact: (amountIn: BN, amountOut: BN, currentSqrtPrice: BN
  * @returns Price change as a percentage (e.g., 1.5 means 1.5% change)
  */
 declare const getPriceChange: (nextSqrtPrice: BN, currentSqrtPrice: BN) => number;
+/**
+ * Converts a sqrt price to a price
+ * (sqrtPrice)^2 * 10 ** (base_decimal - quote_decimal) / 2^128
+ * @param sqrtPrice - The sqrt price
+ * @param tokenADecimal - The token A decimal
+ * @param tokenBDecimal - The token B decimal
+ * @returns The price
+ */
 declare const getPriceFromSqrtPrice: (sqrtPrice: BN, tokenADecimal: number, tokenBDecimal: number) => Decimal;
+/**
+ * Converts a price to a sqrt price
+ * sqrt(price / 10^(tokenADecimal - tokenBDecimal)) * 2^64
+ * @param price - The price
+ * @param tokenADecimal - The token A decimal
+ * @param tokenBDecimal - The token B decimal
+ * @returns The sqrt price
+ */
 declare const getSqrtPriceFromPrice: (price: string, tokenADecimal: number, tokenBDecimal: number) => BN;
+/**
+ * Gets the unclaimed reward
+ * fee = totalLiquidity * feePerTokenStore
+ * precision: (totalLiquidity * feePerTokenStore) >> 128
+ * @param poolState - The pool state
+ * @param positionState - The position state
+ * @returns The unclaimed reward
+ */
 declare const getUnClaimReward: (poolState: PoolState, positionState: PositionState) => {
     feeTokenA: BN;
     feeTokenB: BN;
     rewards: BN[];
 };
 
+/**
+ * Filters for the position by pool
+ * @param pool - The pool address
+ * @returns The filter for the position by pool
+ */
 declare const positionByPoolFilter: (pool: PublicKey) => GetProgramAccountsFilter;
+/**
+ * Filters for the vesting by position
+ * @param position - The position address
+ * @returns The filter for the vesting by position
+ */
 declare const vestingByPositionFilter: (position: PublicKey) => GetProgramAccountsFilter;
 
-declare function calculateInitSqrtPrice(tokenAAmount: BN, tokenBAmount: BN, minSqrtPrice: BN, maxSqrtPrice: BN): BN;
-
 interface TransferFeeIncludedAmount {
     amount: BN;
     transferFee: BN;
 }
+/**
+ * Calculates the transfer fee included amount
+ * @param transferFeeExcludedAmount - The transfer fee excluded amount
+ * @param mint - The mint
+ * @param currentEpoch - The current epoch
+ * @returns The transfer fee included amount
+ */
 declare function calculateTransferFeeIncludedAmount(transferFeeExcludedAmount: BN, mint: Mint, currentEpoch: number): TransferFeeIncludedAmount;
 interface TransferFeeExcludedAmount {
     amount: BN;
     transferFee: BN;
 }
+/**
+ * Calculates the transfer fee excluded amount
+ * @param transferFeeIncludedAmount - The transfer fee included amount
+ * @param mint - The mint
+ * @param currentEpoch - The current epoch
+ * @returns The transfer fee excluded amount
+ */
 declare function calculateTransferFeeExcludedAmount(transferFeeIncludedAmount: BN, mint: Mint, currentEpoch: number): TransferFeeExcludedAmount;
 
 /**
@@ -6848,17 +7378,774 @@ declare function getTotalLockedLiquidity(vestingData: VestingState): BN;
  */
 declare function getAvailableVestingLiquidity(vestingData: VestingState, currentPoint: BN): BN;
 
-declare const ONE: BN;
-declare function pow(base: BN, exp: BN): BN;
+/**
+ * Validate fee scheduler parameters
+ * @param numberOfPeriod Number of periods
+ * @param periodFrequency Period frequency
+ * @param reductionFactor Reduction factor
+ * @param cliffFeeNumerator Cliff fee numerator
+ * @returns Validation result
+ */
+declare function validateFeeScheduler(numberOfPeriod: number, periodFrequency: BN$1, reductionFactor: BN$1, cliffFeeNumerator: BN$1, baseFeeMode: BaseFeeMode, poolVersion: PoolVersion): boolean;
+/**
+ * Validate rate limiter parameters
+ * @param cliffFeeNumerator - Cliff fee numerator
+ * @param feeIncrementBps - Fee increment bps
+ * @param maxLimiterDuration - Max limiter duration
+ * @param referenceAmount - Reference amount
+ * @param collectFeeMode - Collect fee mode
+ * @param activationType - Activation type (slot or timestamp)
+ * @returns Validation result
+ */
+declare function validateFeeRateLimiter(cliffFeeNumerator: BN$1, feeIncrementBps: number, maxFeeBps: number, maxLimiterDuration: number, referenceAmount: BN$1, collectFeeMode: CollectFeeMode, activationType: ActivationType, poolVersion: PoolVersion): boolean;
+/**
+ * Validates that the fee fraction is valid (numerator < denominator, denominator != 0)
+ * @param numerator - The numerator of the fee fraction
+ * @param denominator - The denominator of the fee fraction
+ * @throws Error if the fee fraction is invalid
+ */
+declare function validateFeeFraction(numerator: BN$1, denominator: BN$1): void;
+
+/**
+ * Checks if the partner is valid
+ * @param partner - The partner address
+ * @returns True if the partner is valid, false otherwise
+ */
+declare function hasPartner(partner: PublicKey): boolean;
+/**
+ * Gets the current point
+ * @param connection - The connection to the Solana cluster
+ * @param activationType - The activation type
+ * @returns The current point
+ */
+declare function getCurrentPoint(connection: Connection, activationType: ActivationType): Promise<BN$1>;
+/**
+ * Checks if the swap is enabled
+ * @param pool - The pool
+ * @param currentPoint - The current point
+ * @returns True if the swap is enabled, false otherwise
+ */
+declare function isSwapEnabled(pool: {
+    poolStatus: PoolStatus;
+    activationPoint: BN$1;
+}, currentPoint: BN$1): boolean;
+/**
+ * Converts the value to a fee scheduler second factor
+ * @param value - The value to convert
+ * @returns The fee scheduler second factor
+ */
+declare function convertToFeeSchedulerSecondFactor(value: BN$1): number[];
+/**
+ * Parses the fee scheduler second factor
+ * @param secondFactor - The fee scheduler second factor
+ * @returns The fee scheduler second factor
+ */
+declare function parseFeeSchedulerSecondFactor(secondFactor: number[]): BN$1;
+/**
+ * Converts the value to a rate limiter second factor
+ * @param maxLimiterDuration - The max limiter duration
+ * @param maxFeeBps - The max fee in basis points
+ * @returns The rate limiter second factor
+ */
+declare function convertToRateLimiterSecondFactor(maxLimiterDuration: BN$1, maxFeeBps: BN$1): number[];
+/**
+ * Parses the rate limiter second factor
+ * @param secondFactor - The rate limiter second factor
+ * @returns The rate limiter second factor
+ */
+declare function parseRateLimiterSecondFactor(secondFactor: number[]): {
+    maxLimiterDuration: number;
+    maxFeeBps: number;
+};
+/**
+ * Converts basis points (bps) to a fee numerator
+ * 1 bps = 0.01% = 0.0001 in decimal
+ *
+ * @param bps - The value in basis points [1-10_000]
+ * @returns The equivalent fee numerator
+ */
+declare function bpsToFeeNumerator(bps: number): BN$1;
+/**
+ * Converts a fee numerator back to basis points (bps)
+ *
+ * @param feeNumerator - The fee numerator to convert
+ * @returns The equivalent value in basis points [1-10_000]
+ */
+declare function feeNumeratorToBps(feeNumerator: BN$1): number;
+/**
+ * Converts the amount to lamports
+ * @param amount - The amount to convert
+ * @param tokenDecimal - The token decimal
+ * @returns The amount in lamports
+ */
+declare function convertToLamports(amount: number | string, tokenDecimal: number): BN$1;
+/**
+ * Converts the value to a BN
+ * @param value - The value to convert
+ * @returns The value in BN
+ */
+declare function fromDecimalToBN(value: Decimal): BN$1;
+/**
+ * Gets the fee scheduler parameters
+ * @param startingBaseFeeBps - The starting base fee in basis points
+ * @param endingBaseFeeBps - The ending base fee in basis points
+ * @param baseFeeMode - The base fee mode
+ * @param numberOfPeriod - The number of periods
+ * @param totalDuration - The total duration
+ * @param poolVersion - The pool version
+ * @returns The fee scheduler parameters
+ */
+declare function getFeeSchedulerParams(startingBaseFeeBps: number, endingBaseFeeBps: number, baseFeeMode: BaseFeeMode, numberOfPeriod: number, totalDuration: number): BaseFee;
+/**
+ * Gets the rate limiter parameters
+ * @param baseFeeBps - The base fee in basis points
+ * @param feeIncrementBps - The fee increment in basis points
+ * @param referenceAmount - The reference amount
+ * @param maxLimiterDuration - The max limiter duration
+ * @param maxFeeBps - The max fee in basis points
+ * @param tokenBDecimal - The token B decimal
+ * @param activationType - The activation type
+ * @param poolVersion - The pool version
+ * @returns The rate limiter parameters
+ */
+declare function getRateLimiterParams(baseFeeBps: number, feeIncrementBps: number, referenceAmount: number, maxLimiterDuration: number, maxFeeBps: number, tokenBDecimal: number, activationType: ActivationType): BaseFee;
+/**
+ * Gets the base fee parameters
+ * @param baseFeeParams - The base fee parameters
+ * @param tokenBDecimal - The token B decimal
+ * @param activationType - The activation type
+ * @param poolVersion - The pool version
+ * @returns The base fee parameters
+ */
+declare function getBaseFeeParams(baseFeeParams: {
+    baseFeeMode: BaseFeeMode;
+    rateLimiterParam?: {
+        baseFeeBps: number;
+        feeIncrementBps: number;
+        referenceAmount: number;
+        maxLimiterDuration: number;
+        maxFeeBps: number;
+    };
+    feeSchedulerParam?: {
+        startingFeeBps: number;
+        endingFeeBps: number;
+        numberOfPeriod: number;
+        totalDuration: number;
+    };
+}, tokenBDecimal: number, activationType: ActivationType): BaseFee;
+/**
+ * Gets the dynamic fee parameters
+ * @param baseFeeBps - The base fee in basis points
+ * @param maxPriceChangeBps - The max price change in basis points
+ * @returns The dynamic fee parameters
+ */
+declare function getDynamicFeeParams(baseFeeBps: number, maxPriceChangeBps?: number): DynamicFee;
+
+/**
+ * Converts basis points to a numerator
+ * @param bps - The basis points
+ * @param feeDenominator - The fee denominator
+ * @returns The numerator
+ */
+declare function toNumerator(bps: BN, feeDenominator: BN): BN;
+/**
+ * Gets the fee in a period
+ * @param cliffFeeNumerator - The cliff fee numerator
+ * @param reductionFactor - The reduction factor
+ * @param passedPeriod - The passed period
+ * @returns The fee in a period
+ */
+declare function getFeeInPeriod(cliffFeeNumerator: BN, reductionFactor: BN, passedPeriod: number): BN;
+/**
+ * Gets the fee mode
+ * @param collectFeeMode - The collect fee mode
+ * @param tradeDirection - The trade direction
+ * @param hasReferral - The has referral
+ * @returns The fee mode
+ */
+declare function getFeeMode(collectFeeMode: CollectFeeMode, tradeDirection: TradeDirection, hasReferral: boolean): FeeMode;
+/**
+ * Gets the total fee numerator
+ * @param poolFees - The pool fees
+ * @param baseFeeNumerator - The base fee numerator
+ * @param maxFeeNumerator - The max fee numerator
+ * @returns The total fee numerator
+ */
+declare function getTotalFeeNumerator(poolFees: PoolFeesStruct, baseFeeNumerator: BN, maxFeeNumerator: BN): BN;
+/**
+ * Gets the total trading fee from included fee amount
+ * @param poolFees - The pool fees
+ * @param currentPoint - The current point
+ * @param activationPoint - The activation point
+ * @param includedFeeAmount - The included fee amount
+ * @param tradeDirection - The trade direction
+ * @param maxFeeNumerator - The max fee numerator
+ * @returns The total trading fee from included fee amount
+ */
+declare function getTotalTradingFeeFromIncludedFeeAmount(poolFees: PoolFeesStruct, currentPoint: BN, activationPoint: BN, includedFeeAmount: BN, tradeDirection: TradeDirection, maxFeeNumerator: BN): BN;
+/**
+ * Gets the total trading fee from excluded fee amount
+ * @param poolFees - The pool fees
+ * @param currentPoint - The current point
+ * @param activationPoint - The activation point
+ * @param excludedFeeAmount - The excluded fee amount
+ * @param tradeDirection - The trade direction
+ * @param maxFeeNumerator - The max fee numerator
+ * @returns The total trading fee from excluded fee amount
+ */
+declare function getTotalTradingFeeFromExcludedFeeAmount(poolFees: PoolFeesStruct, currentPoint: BN, activationPoint: BN, excludedFeeAmount: BN, tradeDirection: TradeDirection, maxFeeNumerator: BN): BN;
+/**
+ * Splits the fees
+ * @param poolFees - The pool fees
+ * @param feeAmount - The fee amount
+ * @param hasReferral - The has referral
+ * @param hasPartner - The has partner
+ * @returns The split fees
+ */
+declare function splitFees(poolFees: PoolFeesStruct, feeAmount: BN, hasReferral: boolean, hasPartner: boolean): SplitFees;
+/**
+ * Gets the fee on amount
+ * @param poolFees - The pool fees
+ * @param amount - The amount
+ * @param tradeFeeNumerator - The trade fee numerator
+ * @param hasReferral - The has referral
+ * @param hasPartner - The has partner
+ * @returns The fee on amount result
+ */
+declare function getFeeOnAmount(poolFees: PoolFeesStruct, amount: BN, tradeFeeNumerator: BN, hasReferral: boolean, hasPartner: boolean): FeeOnAmountResult;
+/**
+ * Calculates the excluded fee amount and trading fee from an included fee amount
+ * @param tradeFeeNumerator - The fee numerator
+ * @param includedFeeAmount - The amount that includes the fee
+ * @returns Tuple of [excluded_fee_amount, trading_fee]
+ */
+declare function getExcludedFeeAmount(tradeFeeNumerator: BN, includedFeeAmount: BN): {
+    excludedFeeAmount: BN;
+    tradingFee: BN;
+};
+/**
+ * Calculates the included fee amount and fee amount from an excluded fee amount
+ * @param tradeFeeNumerator - The fee numerator
+ * @param excludedFeeAmount - The amount that excludes the fee
+ * @returns Tuple of [included_fee_amount, fee_amount]
+ */
+declare function getIncludedFeeAmount(tradeFeeNumerator: BN, excludedFeeAmount: BN): {
+    includedFeeAmount: BN;
+    feeAmount: BN;
+};
+/**
+ * Gets the max fee numerator
+ * @param poolVersion - The pool version
+ * @returns The max fee numerator
+ */
+declare function getMaxFeeNumerator(poolVersion: PoolVersion): BN;
+/**
+ * Gets the max fee bps
+ * @param poolVersion - The pool version
+ * @returns The max fee bps
+ */
+declare function getMaxFeeBps(poolVersion: PoolVersion): number;
+
+/**
+ * Multiplies two numbers and divides by a denominator, rounding up or down
+ * @param x - The first number
+ * @param y - The second number
+ * @param denominator - The denominator
+ * @param rounding - The rounding mode
+ * @returns The result of the multiplication and division
+ */
+declare function mulDiv(x: BN$1, y: BN$1, denominator: BN$1, rounding: Rounding): BN$1;
+/**
+ * Converts a Q64 number to a Decimal
+ * @param num - The Q64 number
+ * @param decimalPlaces - The number of decimal places
+ * @returns The Decimal number
+ */
+declare function q64ToDecimal(num: BN$1, decimalPlaces?: number): Decimal;
+/**
+ * Converts a Decimal number to a Q64 number
+ * @param num - The Decimal number
+ * @returns The Q64 number
+ */
+declare function decimalToQ64(num: Decimal): BN$1;
+/**
+ * Calculates the square root of a number
+ * @param value - The number
+ * @returns The square root of the number
+ */
+declare function sqrt(value: BN$1): BN$1;
+/**
+ * Calculates the power of a number
+ * @param base - The base
+ * @param exp - The exponent
+ * @returns The power of the number
+ */
+declare function pow(base: BN$1, exp: BN$1): BN$1;
 
-declare function mulDiv(x: BN, y: BN, denominator: BN, rounding: Rounding): BN;
-declare function q64ToDecimal(num: BN, decimalPlaces?: number): Decimal;
-declare function decimalToQ64(num: Decimal): BN;
+/**
+ * Fee Rate Limiter class
+ */
+declare class FeeRateLimiter implements BaseFeeHandler {
+    cliffFeeNumerator: BN$1;
+    feeIncrementBps: number;
+    maxFeeBps: number;
+    maxLimiterDuration: number;
+    referenceAmount: BN$1;
+    constructor(cliffFeeNumerator: BN$1, feeIncrementBps: number, maxFeeBps: number, maxLimiterDuration: number, referenceAmount: BN$1);
+    validate(collectFeeMode: CollectFeeMode, activationType: ActivationType, poolVersion: PoolVersion): boolean;
+    getBaseFeeNumeratorFromIncludedFeeAmount(currentPoint: BN$1, activationPoint: BN$1, tradeDirection: TradeDirection, includedFeeAmount: BN$1): BN$1;
+    getBaseFeeNumeratorFromExcludedFeeAmount(currentPoint: BN$1, activationPoint: BN$1, tradeDirection: TradeDirection, excludedFeeAmount: BN$1): BN$1;
+}
+/**
+ * Fee Scheduler implementation
+ */
+declare class FeeScheduler implements BaseFeeHandler {
+    cliffFeeNumerator: BN$1;
+    numberOfPeriod: number;
+    periodFrequency: BN$1;
+    reductionFactor: BN$1;
+    feeSchedulerMode: BaseFeeMode;
+    constructor(cliffFeeNumerator: BN$1, numberOfPeriod: number, periodFrequency: BN$1, reductionFactor: BN$1, feeSchedulerMode: BaseFeeMode);
+    validate(collectFeeMode: CollectFeeMode, activationType: ActivationType, poolVersion: PoolVersion): boolean;
+    getBaseFeeNumeratorFromIncludedFeeAmount(currentPoint: BN$1, activationPoint: BN$1): BN$1;
+    getBaseFeeNumeratorFromExcludedFeeAmount(currentPoint: BN$1, activationPoint: BN$1): BN$1;
+}
+/**
+ * Get base fee handler based on base fee mode
+ * @param cliffFeeNumerator Cliff fee numerator
+ * @param firstFactor First factor (feeScheduler: numberOfPeriod, rateLimiter: feeIncrementBps)
+ * @param secondFactor Second factor (feeScheduler: periodFrequency, rateLimiter: maxLimiterDuration)
+ * @param thirdFactor Third factor (feeScheduler: reductionFactor, rateLimiter: referenceAmount)
+ * @param baseFeeMode Base fee mode
+ * @returns Base fee handler instance
+ */
+declare function getBaseFeeHandler(cliffFeeNumerator: BN$1, firstFactor: number, secondFactor: number[], thirdFactor: BN$1, baseFeeMode: BaseFeeMode): BaseFeeHandler;
+
+/**
+ * Check if dynamic fee is enabled
+ * @param dynamicFee Dynamic fee parameters
+ * @returns True if dynamic fee is enabled
+ */
+declare function isDynamicFeeEnabled(dynamicFee: DynamicFeeStruct): boolean;
+/**
+ * Calculates the dynamic fee numerator based on market volatility metrics
+ *
+ * @param volatilityAccumulator - A measure of accumulated market volatility (BN)
+ * @param binStep - The size of price bins in the liquidity distribution (BN)
+ * @param variableFeeControl - Parameter controlling the impact of volatility on fees (BN)
+ * @returns The calculated dynamic fee numerator (BN)
+ */
+declare function getDynamicFeeNumerator(volatilityAccumulator: BN$1, binStep: BN$1, variableFeeControl: BN$1): BN$1;
+
+/**
+ * Gets the max base fee numerator.
+ * @param cliffFeeNumerator - The cliff fee numerator.
+ * @returns The max base fee numerator.
+ */
+declare function getMaxBaseFeeNumerator(cliffFeeNumerator: BN$1): BN$1;
+/**
+ * Gets the min base fee numerator.
+ * @param cliffFeeNumerator - The cliff fee numerator.
+ * @param numberOfPeriod - The number of periods.
+ * @param periodFrequency - The period frequency.
+ * @param reductionFactor - The reduction factor.
+ * @param feeSchedulerMode - The fee scheduler mode.
+ * @returns The min base fee numerator.
+ */
+declare function getMinBaseFeeNumerator(cliffFeeNumerator: BN$1, numberOfPeriod: number, periodFrequency: BN$1, reductionFactor: BN$1, feeSchedulerMode: BaseFeeMode): BN$1;
+/**
+ * Gets the base fee numerator by period.
+ * @param cliffFeeNumerator - The cliff fee numerator.
+ * @param numberOfPeriod - The number of periods.
+ * @param period - The period.
+ * @param reductionFactor - The reduction factor.
+ * @param feeSchedulerMode - The fee scheduler mode.
+ * @returns The base fee numerator by period.
+ */
+declare function getBaseFeeNumeratorByPeriod(cliffFeeNumerator: BN$1, numberOfPeriod: number, period: BN$1, reductionFactor: BN$1, feeSchedulerMode: BaseFeeMode): BN$1;
+/**
+ * Gets the fee numerator on linear fee scheduler.
+ * @param cliffFeeNumerator - The cliff fee numerator.
+ * @param reductionFactor - The reduction factor.
+ * @param period - The period.
+ * @returns The fee numerator on linear fee scheduler.
+ */
+declare function getFeeNumeratorOnLinearFeeScheduler(cliffFeeNumerator: BN$1, reductionFactor: BN$1, period: number): BN$1;
+/**
+ * Gets the fee numerator on exponential fee scheduler.
+ * @param cliffFeeNumerator - The cliff fee numerator.
+ * @param reductionFactor - The reduction factor.
+ * @param period - The period.
+ * @returns The fee numerator on exponential fee scheduler.
+ */
+declare function getFeeNumeratorOnExponentialFeeScheduler(cliffFeeNumerator: BN$1, reductionFactor: BN$1, period: number): BN$1;
+/**
+ * Gets the base fee numerator.
+ * @param cliffFeeNumerator - The cliff fee numerator.
+ * @param numberOfPeriod - The number of periods.
+ * @param periodFrequency - The period frequency.
+ * @param reductionFactor - The reduction factor.
+ * @param feeSchedulerMode - The fee scheduler mode.
+ * @param currentPoint - The current point.
+ * @param activationPoint - The activation point.
+ * @returns The base fee numerator.
+ */
+declare function getBaseFeeNumerator(cliffFeeNumerator: BN$1, numberOfPeriod: number, periodFrequency: BN$1, reductionFactor: BN$1, feeSchedulerMode: BaseFeeMode, currentPoint: BN$1, activationPoint: BN$1): BN$1;
+
+/**
+ * Checks if the rate limiter is zero.
+ * @param referenceAmount - The reference amount.
+ * @param maxLimiterDuration - The maximum rate limiter duration.
+ * @param maxFeeBps - The maximum fee in basis points.
+ * @param feeIncrementBps - The fee increment in basis points.
+ * @returns True if the rate limiter is zero, false otherwise.
+ */
+declare function isZeroRateLimiter(referenceAmount: BN$1, maxLimiterDuration: number, maxFeeBps: number, feeIncrementBps: number): boolean;
+/**
+ * Checks if the rate limiter is non-zero.
+ * @param referenceAmount - The reference amount.
+ * @param maxLimiterDuration - The maximum rate limiter duration.
+ * @param maxFeeBps - The maximum fee in basis points.
+ * @param feeIncrementBps - The fee increment in basis points.
+ * @returns True if the rate limiter is non-zero, false otherwise.
+ */
+declare function isNonZeroRateLimiter(referenceAmount: BN$1, maxLimiterDuration: number, maxFeeBps: number, feeIncrementBps: number): boolean;
+/**
+ * Checks if the rate limiter is applied.
+ * @param referenceAmount - The reference amount.
+ * @param maxLimiterDuration - The maximum rate limiter duration.
+ * @param maxFeeBps - The maximum fee in basis points.
+ * @param feeIncrementBps - The fee increment in basis points.
+ * @param currentPoint - The current point.
+ * @param activationPoint - The activation point.
+ * @param tradeDirection - The trade direction.
+ * @returns True if the rate limiter is applied, false otherwise.
+ */
+declare function isRateLimiterApplied(referenceAmount: BN$1, maxLimiterDuration: number, maxFeeBps: number, feeIncrementBps: number, currentPoint: BN$1, activationPoint: BN$1, tradeDirection: TradeDirection): boolean;
+/**
+ * Gets the maximum index.
+ * @param maxFeeBps - The maximum fee in basis points.
+ * @param cliffFeeNumerator - The cliff fee numerator.
+ * @param feeIncrementBps - The fee increment in basis points.
+ * @returns The maximum index.
+ */
+declare function getMaxIndex(maxFeeBps: number, cliffFeeNumerator: BN$1, feeIncrementBps: number): BN$1;
+/**
+ * Gets the fee numerator from included fee amount.
+ * @param inputAmount - The input amount.
+ * @param referenceAmount - The reference amount.
+ * @param cliffFeeNumerator - The cliff fee numerator.
+ * @param maxFeeBps - The maximum fee in basis points.
+ * @param feeIncrementBps - The fee increment in basis points.
+ * @returns The fee numerator from included fee amount.
+ */
+declare function getFeeNumeratorFromIncludedFeeAmount(inputAmount: BN$1, referenceAmount: BN$1, cliffFeeNumerator: BN$1, maxFeeBps: number, feeIncrementBps: number): BN$1;
+/**
+ * Gets the excluded fee amount from included fee amount.
+ * @param includedFeeAmount - The included fee amount.
+ * @param referenceAmount - The reference amount.
+ * @param cliffFeeNumerator - The cliff fee numerator.
+ * @param maxFeeBps - The maximum fee in basis points.
+ * @param feeIncrementBps - The fee increment in basis points.
+ * @returns The excluded fee amount.
+ */
+declare function getExcludedFeeAmountFromIncludedFeeAmount(includedFeeAmount: BN$1, referenceAmount: BN$1, cliffFeeNumerator: BN$1, maxFeeBps: number, feeIncrementBps: number): BN$1;
+/**
+ * Returns checked output and input amounts, and a flag indicating if the input was capped at u64::MAX.
+ * @param referenceAmount - The reference amount
+ * @param cliffFeeNumerator - The cliff fee numerator
+ * @param maxFeeBps - The maximum fee in basis points
+ * @param feeIncrementBps - The fee increment in basis points
+ * @returns [checkedOutputAmount: BN, checkedIncludedFeeAmount: BN, capped: boolean]
+ */
+declare function getCheckedAmounts(referenceAmount: BN$1, cliffFeeNumerator: BN$1, maxFeeBps: number, feeIncrementBps: number): [BN$1, BN$1, boolean];
+/**
+ * Calculates the fee numerator from an excluded fee amount.
+ * @param excludedFeeAmount - The excluded fee amount
+ * @param referenceAmount - The reference amount
+ * @param cliffFeeNumerator - The cliff fee numerator
+ * @param maxFeeBps - The maximum fee in basis points
+ * @param feeIncrementBps - The fee increment in basis points
+ * @returns The fee numerator
+ */
+declare function getFeeNumeratorFromExcludedFeeAmount(excludedFeeAmount: BN$1, referenceAmount: BN$1, cliffFeeNumerator: BN$1, maxFeeBps: number, feeIncrementBps: number): BN$1;
+
+/**
+ * Gets the swap result from exact input
+ * @param poolState - The pool state
+ * @param amountIn - The amount in
+ * @param feeMode - The fee mode
+ * @param tradeDirection - The trade direction
+ * @param currentPoint - The current point
+ * @returns The swap result from exact input
+ */
+declare function getSwapResultFromExactInput(poolState: PoolState, amountIn: BN$1, feeMode: FeeMode, tradeDirection: TradeDirection, currentPoint: BN$1): SwapResult2;
+/**
+ * Calculates the swap result from exact input
+ * @param poolState - The pool state
+ * @param amountIn - The amount in
+ * @returns The swap result from exact input
+ */
+declare function calculateAtoBFromAmountIn(poolState: PoolState, amountIn: BN$1): {
+    outputAmount: BN$1;
+    nextSqrtPrice: BN$1;
+    amountLeft: BN$1;
+};
+/**
+ * Calculates the swap result from exact input
+ * @param poolState - The pool state
+ * @param amountIn - The amount in
+ * @returns The swap result from exact input
+ */
+declare function calculateBtoAFromAmountIn(poolState: PoolState, amountIn: BN$1): {
+    outputAmount: BN$1;
+    nextSqrtPrice: BN$1;
+    amountLeft: BN$1;
+};
+/**
+ * Gets the swap result from partial input
+ * @param poolState - The pool state
+ * @param amountIn - The amount in
+ * @param feeMode - The fee mode
+ * @param tradeDirection - The trade direction
+ * @param currentPoint - The current point
+ * @returns The swap result from partial input
+ */
+declare function getSwapResultFromPartialInput(poolState: PoolState, amountIn: BN$1, feeMode: FeeMode, tradeDirection: TradeDirection, currentPoint: BN$1): SwapResult2;
+/**
+ * Calculates the swap result from partial input
+ * @param poolState - The pool state
+ * @param amountIn - The amount in
+ * @returns The swap result from partial input
+ */
+declare function calculateAtoBFromPartialAmountIn(poolState: PoolState, amountIn: BN$1): {
+    outputAmount: BN$1;
+    nextSqrtPrice: BN$1;
+    amountLeft: BN$1;
+};
+/**
+ * Calculates the swap result from partial input
+ * @param poolState - The pool state
+ * @param amountIn - The amount in
+ * @returns The swap result from partial input
+ */
+declare function calculateBtoAFromPartialAmountIn(poolState: PoolState, amountIn: BN$1): {
+    outputAmount: BN$1;
+    nextSqrtPrice: BN$1;
+    amountLeft: BN$1;
+};
+/**
+ * Gets the swap result from exact output
+ * @param poolState - The pool state
+ * @param amountOut - The amount out
+ * @param feeMode - The fee mode
+ * @param tradeDirection - The trade direction
+ * @param currentPoint - The current point
+ * @returns The swap result from exact output
+ */
+declare function getSwapResultFromExactOutput(poolState: PoolState, amountOut: BN$1, feeMode: FeeMode, tradeDirection: TradeDirection, currentPoint: BN$1): SwapResult2;
+/**
+ * Calculates the swap result from exact output
+ * @param poolState - The pool state
+ * @param amountOut - The amount out
+ * @returns The swap result from exact output
+ */
+declare function calculateAtoBFromAmountOut(poolState: PoolState, amountOut: BN$1): {
+    inputAmount: BN$1;
+    nextSqrtPrice: BN$1;
+};
+/**
+ * Calculates the swap result from exact output
+ * @param poolState - The pool state
+ * @param amountOut - The amount out
+ * @returns The swap result from exact output
+ */
+declare function calculateBtoAFromAmountOut(poolState: PoolState, amountOut: BN$1): {
+    inputAmount: BN$1;
+    nextSqrtPrice: BN$1;
+};
+/**
+ * Swaps quote exact input
+ * @param pool - The pool
+ * @param currentPoint - The current point
+ * @param amountIn - The amount in
+ * @param slippage - The slippage
+ * @param aToB - The trade direction
+ * @param hasReferral - The has referral
+ * @param tokenADecimal - The token A decimal
+ * @param tokenBDecimal - The token B decimal
+ * @param inputTokenInfo - The input token info
+ * @param outputTokenInfo - The output token info
+ * @returns The swap quote exact input
+ */
+declare function swapQuoteExactInput(pool: PoolState, currentPoint: BN$1, amountIn: BN$1, slippage: number, aToB: boolean, hasReferral: boolean, tokenADecimal: number, tokenBDecimal: number, inputTokenInfo?: {
+    mint: Mint;
+    currentEpoch: number;
+}, outputTokenInfo?: {
+    mint: Mint;
+    currentEpoch: number;
+}): Quote2Result;
+/**
+ * Swaps quote exact output
+ * @param pool - The pool
+ * @param currentPoint - The current point
+ * @param amountOut - The amount out
+ * @param slippage - The slippage
+ * @param aToB - The trade direction
+ * @param hasReferral - The has referral
+ * @param tokenADecimal - The token A decimal
+ * @param tokenBDecimal - The token B decimal
+ * @param inputTokenInfo - The input token info
+ * @param outputTokenInfo - The output token info
+ * @returns The swap quote exact output
+ */
+declare function swapQuoteExactOutput(pool: PoolState, currentPoint: BN$1, amountOut: BN$1, slippage: number, aToB: boolean, hasReferral: boolean, tokenADecimal: number, tokenBDecimal: number, inputTokenInfo?: {
+    mint: Mint;
+    currentEpoch: number;
+}, outputTokenInfo?: {
+    mint: Mint;
+    currentEpoch: number;
+}): Quote2Result;
+/**
+ * Swaps quote partial input
+ * @param pool - The pool
+ * @param currentPoint - The current point
+ * @param amountIn - The amount in
+ * @param slippage - The slippage
+ * @param aToB - The trade direction
+ * @param hasReferral - The has referral
+ * @param tokenADecimal - The token A decimal
+ * @param tokenBDecimal - The token B decimal
+ * @param inputTokenInfo - The input token info
+ * @param outputTokenInfo - The output token info
+ * @returns The swap quote partial input
+ */
+declare function swapQuotePartialInput(pool: PoolState, currentPoint: BN$1, amountIn: BN$1, slippage: number, aToB: boolean, hasReferral: boolean, tokenADecimal: number, tokenBDecimal: number, inputTokenInfo?: {
+    mint: Mint;
+    currentEpoch: number;
+}, outputTokenInfo?: {
+    mint: Mint;
+    currentEpoch: number;
+}): Quote2Result;
+
+/**
+ * Gets the next sqrt price given a delta of token_b (input), rounding down.
+ * √P' = √P + Δb / L
+ * @param sqrtPrice - current sqrt price (BN)
+ * @param liquidity - current liquidity (BN)
+ * @param amount - delta of token_b (BN)
+ * @returns next sqrt price (BN)
+ */
+declare function getNextSqrtPriceFromAmountInBRoundingDown(sqrtPrice: BN$1, liquidity: BN$1, amount: BN$1): BN$1;
+/**
+ * Gets the next sqrt price given a delta of token_b (output), rounding down.
+ * √P' = √P - Δb / L
+ * @param sqrtPrice - current sqrt price (BN)
+ * @param liquidity - current liquidity (BN)
+ * @param amount - delta of token_b (BN)
+ * @returns next sqrt price (BN)
+ */
+declare function getNextSqrtPriceFromAmountOutBRoundingDown(sqrtPrice: BN$1, liquidity: BN$1, amount: BN$1): BN$1;
+/**
+ * Gets the next sqrt price √P' given a delta of token_a, rounding up.
+ * √P' = √P * L / (L + Δa * √P)
+ * @param sqrtPrice - current sqrt price (BN)
+ * @param liquidity - current liquidity (BN)
+ * @param amount - delta of token_a (BN)
+ * @returns next sqrt price (BN)
+ */
+declare function getNextSqrtPriceFromAmountInARoundingUp(sqrtPrice: BN$1, liquidity: BN$1, amount: BN$1): BN$1;
+/**
+ * Gets the next sqrt price √P' given a delta of token_a (output), rounding up.
+ * √P' = √P * L / (L - Δa * √P)
+ * @param sqrtPrice - current sqrt price (BN)
+ * @param liquidity - current liquidity (BN)
+ * @param amount - delta of token_a (BN)
+ * @returns next sqrt price (BN)
+ */
+declare function getNextSqrtPriceFromAmountOutARoundingUp(sqrtPrice: BN$1, liquidity: BN$1, amount: BN$1): BN$1;
+/**
+ * Gets the next sqrt price given an output amount of token_a or token_b.
+ * @param sqrtPrice - current sqrt price (BN)
+ * @param liquidity - current liquidity (BN)
+ * @param amountOut - output amount (BN)
+ * @param aForB - true if swapping A for B, false if B for A
+ * @returns next sqrt price (BN)
+ */
+declare function getNextSqrtPriceFromOutput(sqrtPrice: BN$1, liquidity: BN$1, amountOut: BN$1, aForB: boolean): BN$1;
+/**
+ * Gets the next sqrt price given an input amount of token_a or token_b
+ * @param sqrtPrice - current sqrt price (BN)
+ * @param liquidity - current liquidity (BN)
+ * @param amountIn - input amount (BN)
+ * @param aForB - true if swapping A for B, false if B for A
+ * @returns next sqrt price (BN)
+ */
+declare function getNextSqrtPriceFromInput(sqrtPrice: BN$1, liquidity: BN$1, amountIn: BN$1, aForB: boolean): BN$1;
+/**
+ * Gets the delta amount of token_b for given liquidity and price range. (getDeltaAmountBUnsigned)
+ * @param lowerSqrtPrice - lower sqrt price (BN)
+ * @param upperSqrtPrice - upper sqrt price (BN)
+ * @param liquidity - current liquidity (BN)
+ * @param rounding - rounding (Rounding)
+ * @returns delta amount of token_b (BN)
+ */
+declare function getAmountBFromLiquidityDelta(lowerSqrtPrice: BN$1, upperSqrtPrice: BN$1, liquidity: BN$1, rounding: Rounding): BN$1;
+/**
+ * Gets the delta amount_a for given liquidity and price range. (getDeltaAmountAUnsigned)
+ * `Δa = L * (1 / √P_lower - 1 / √P_upper)`
+ * i.e. `L * (√P_upper - √P_lower) / (√P_upper * √P_lower)`
+ * @param lowerSqrtPrice - lower sqrt price (BN)
+ * @param upperSqrtPrice - upper sqrt price (BN)
+ * @param liquidity - current liquidity (BN)
+ * @param rounding - rounding (Rounding)
+ * @returns delta amount of token_a (BN)
+ */
+declare function getAmountAFromLiquidityDelta(lowerSqrtPrice: BN$1, upperSqrtPrice: BN$1, liquidity: BN$1, rounding: Rounding): BN$1;
+/**
+ * Gets the liquidity delta from amount A
+ * Δa = L * (1 / √P_lower - 1 / √P_upper)
+ * Δa = L * (√P_upper - √P_lower) / (√P_upper * √P_lower)
+ * L = Δa * √P_upper * √P_lower / (√P_upper - √P_lower)
+ * @param amountA - The amount of token A
+ * @param lowerSqrtPrice - The lower sqrt price
+ * @param upperSqrtPrice - The upper sqrt price
+ * @returns The liquidity delta from amount A
+ */
+declare function getLiquidityDeltaFromAmountA(amountA: BN$1, lowerSqrtPrice: BN$1, // current sqrt price
+upperSqrtPrice: BN$1): BN$1;
+/**
+ * Gets the liquidity delta from amount B
+ * Δb = L (√P_upper - √P_lower)
+ * L = Δb / (√P_upper - √P_lower)
+ * @param amountB - The amount of token B
+ * @param lowerSqrtPrice - The lower sqrt price
+ * @param upperSqrtPrice - The upper sqrt price
+ * @returns The liquidity delta from amount B
+ */
+declare function getLiquidityDeltaFromAmountB(amountB: BN$1, lowerSqrtPrice: BN$1, // min sqrt price
+upperSqrtPrice: BN$1): BN$1;
+
+/**
+ * Calculates the initial sqrt price
+ * a = L * (1/s - 1/pb)
+ * b = L * (s - pa)
+ * b/a = (s - pa) / (1/s - 1/pb)
+ * With: x = 1 / pb and y = b/a
+ * => s ^ 2 + s * (-pa + x * y) - y = 0
+ * s = [(pa - xy) + √((xy - pa)² + 4y)]/2
+ * @param tokenAAmount - The token A amount
+ * @param tokenBAmount - The token B amount
+ * @param minSqrtPrice - The min sqrt price
+ * @param maxSqrtPrice - The max sqrt price
+ * @returns The initial sqrt price
+ */
+declare function calculateInitSqrtPrice(tokenAAmount: BN, tokenBAmount: BN, minSqrtPrice: BN, maxSqrtPrice: BN): BN;
 
 var address = "cpamdpZCGKUy5JxQXB4dcpGPiikHawvSWAd6mEn1sGG";
 var metadata = {
 	name: "cp_amm",
-	version: "0.1.3",
+	version: "0.1.5",
 	spec: "0.1.0",
 	description: "Created with Anchor"
 };
@@ -9941,67 +11228,233 @@ var instructions = [
 				writable: true
 			},
 			{
-				name: "token_a_vault",
-				docs: [
-					"The vault token account for input token"
-				],
+				name: "token_a_vault",
+				docs: [
+					"The vault token account for input token"
+				],
+				writable: true,
+				relations: [
+					"pool"
+				]
+			},
+			{
+				name: "token_b_vault",
+				docs: [
+					"The vault token account for output token"
+				],
+				writable: true,
+				relations: [
+					"pool"
+				]
+			},
+			{
+				name: "token_a_mint",
+				docs: [
+					"The mint of token a"
+				],
+				relations: [
+					"pool"
+				]
+			},
+			{
+				name: "token_b_mint",
+				docs: [
+					"The mint of token b"
+				],
+				relations: [
+					"pool"
+				]
+			},
+			{
+				name: "position_nft_account",
+				docs: [
+					"The token account for nft"
+				]
+			},
+			{
+				name: "owner",
+				docs: [
+					"owner of position"
+				],
+				signer: true
+			},
+			{
+				name: "token_a_program",
+				docs: [
+					"Token a program"
+				]
+			},
+			{
+				name: "token_b_program",
+				docs: [
+					"Token b program"
+				]
+			},
+			{
+				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: "RemoveLiquidityParameters"
+					}
+				}
+			}
+		]
+	},
+	{
+		name: "set_pool_status",
+		discriminator: [
+			112,
+			87,
+			135,
+			223,
+			83,
+			204,
+			132,
+			53
+		],
+		accounts: [
+			{
+				name: "pool",
+				writable: true
+			},
+			{
+				name: "admin",
+				signer: true
+			},
+			{
+				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: "status",
+				type: "u8"
+			}
+		]
+	},
+	{
+		name: "split_position",
+		discriminator: [
+			172,
+			241,
+			221,
+			138,
+			161,
+			29,
+			253,
+			42
+		],
+		accounts: [
+			{
+				name: "pool",
 				writable: true,
 				relations: [
-					"pool"
+					"first_position",
+					"second_position"
 				]
 			},
 			{
-				name: "token_b_vault",
+				name: "first_position",
 				docs: [
-					"The vault token account for output token"
+					"The first position"
 				],
-				writable: true,
-				relations: [
-					"pool"
-				]
+				writable: true
 			},
 			{
-				name: "token_a_mint",
+				name: "first_position_nft_account",
 				docs: [
-					"The mint of token a"
-				],
-				relations: [
-					"pool"
+					"The token account for position nft"
 				]
 			},
 			{
-				name: "token_b_mint",
+				name: "second_position",
 				docs: [
-					"The mint of token b"
+					"The second position"
 				],
-				relations: [
-					"pool"
-				]
+				writable: true
 			},
 			{
-				name: "position_nft_account",
+				name: "second_position_nft_account",
 				docs: [
-					"The token account for nft"
+					"The token account for position nft"
 				]
 			},
 			{
-				name: "owner",
+				name: "first_owner",
 				docs: [
-					"owner of position"
+					"Owner of first position"
 				],
 				signer: true
 			},
 			{
-				name: "token_a_program",
-				docs: [
-					"Token a program"
-				]
-			},
-			{
-				name: "token_b_program",
+				name: "second_owner",
 				docs: [
-					"Token b program"
-				]
+					"Owner of second position"
+				],
+				signer: true
 			},
 			{
 				name: "event_authority",
@@ -10041,31 +11494,71 @@ var instructions = [
 				name: "params",
 				type: {
 					defined: {
-						name: "RemoveLiquidityParameters"
+						name: "SplitPositionParameters"
 					}
 				}
 			}
 		]
 	},
 	{
-		name: "set_pool_status",
+		name: "split_position2",
 		discriminator: [
-			112,
-			87,
-			135,
-			223,
-			83,
-			204,
-			132,
-			53
+			221,
+			147,
+			228,
+			207,
+			140,
+			212,
+			17,
+			119
 		],
 		accounts: [
 			{
 				name: "pool",
+				writable: true,
+				relations: [
+					"first_position",
+					"second_position"
+				]
+			},
+			{
+				name: "first_position",
+				docs: [
+					"The first position"
+				],
 				writable: true
 			},
 			{
-				name: "admin",
+				name: "first_position_nft_account",
+				docs: [
+					"The token account for position nft"
+				]
+			},
+			{
+				name: "second_position",
+				docs: [
+					"The second position"
+				],
+				writable: true
+			},
+			{
+				name: "second_position_nft_account",
+				docs: [
+					"The token account for position nft"
+				]
+			},
+			{
+				name: "first_owner",
+				docs: [
+					"Owner of first position"
+				],
+				signer: true
+			},
+			{
+				name: "second_owner",
+				docs: [
+					"Owner of second position"
+				],
 				signer: true
 			},
 			{
@@ -10103,71 +11596,107 @@ var instructions = [
 		],
 		args: [
 			{
-				name: "status",
-				type: "u8"
+				name: "numerator",
+				type: "u32"
 			}
 		]
 	},
 	{
-		name: "split_position",
+		name: "swap",
 		discriminator: [
-			172,
-			241,
-			221,
-			138,
-			161,
-			29,
-			253,
-			42
+			248,
+			198,
+			158,
+			145,
+			225,
+			117,
+			135,
+			200
 		],
 		accounts: [
+			{
+				name: "pool_authority",
+				address: "HLnpSz9h2S4hiLQ43rnSD9XkcUThA7B8hQMKmDaiTLcC"
+			},
 			{
 				name: "pool",
-				writable: true,
-				relations: [
-					"first_position",
-					"second_position"
-				]
+				docs: [
+					"Pool account"
+				],
+				writable: true
 			},
 			{
-				name: "first_position",
+				name: "input_token_account",
 				docs: [
-					"The first position"
+					"The user token account for input token"
 				],
 				writable: true
 			},
 			{
-				name: "first_position_nft_account",
+				name: "output_token_account",
 				docs: [
-					"The token account for position nft"
+					"The user token account for output token"
+				],
+				writable: true
+			},
+			{
+				name: "token_a_vault",
+				docs: [
+					"The vault token account for input token"
+				],
+				writable: true,
+				relations: [
+					"pool"
 				]
 			},
 			{
-				name: "second_position",
+				name: "token_b_vault",
 				docs: [
-					"The second position"
+					"The vault token account for output token"
 				],
-				writable: true
+				writable: true,
+				relations: [
+					"pool"
+				]
 			},
 			{
-				name: "second_position_nft_account",
+				name: "token_a_mint",
 				docs: [
-					"The token account for position nft"
+					"The mint of token a"
 				]
 			},
 			{
-				name: "first_owner",
+				name: "token_b_mint",
 				docs: [
-					"Owner of first position"
+					"The mint of token b"
+				]
+			},
+			{
+				name: "payer",
+				docs: [
+					"The user performing the swap"
 				],
 				signer: true
 			},
 			{
-				name: "second_owner",
+				name: "token_a_program",
 				docs: [
-					"Owner of second position"
+					"Token a program"
+				]
+			},
+			{
+				name: "token_b_program",
+				docs: [
+					"Token b program"
+				]
+			},
+			{
+				name: "referral_token_account",
+				docs: [
+					"referral token account"
 				],
-				signer: true
+				writable: true,
+				optional: true
 			},
 			{
 				name: "event_authority",
@@ -10207,23 +11736,23 @@ var instructions = [
 				name: "params",
 				type: {
 					defined: {
-						name: "SplitPositionParameters"
+						name: "SwapParameters"
 					}
 				}
 			}
 		]
 	},
 	{
-		name: "swap",
+		name: "swap2",
 		discriminator: [
-			248,
-			198,
-			158,
-			145,
-			225,
-			117,
-			135,
-			200
+			65,
+			75,
+			63,
+			76,
+			235,
+			91,
+			91,
+			136
 		],
 		accounts: [
 			{
@@ -10348,7 +11877,7 @@ var instructions = [
 				name: "params",
 				type: {
 					defined: {
-						name: "SwapParameters"
+						name: "SwapParameters2"
 					}
 				}
 			}
@@ -10853,6 +12382,19 @@ var events = [
 			249
 		]
 	},
+	{
+		name: "EvtLiquidityChange",
+		discriminator: [
+			197,
+			171,
+			78,
+			127,
+			224,
+			211,
+			87,
+			13
+		]
+	},
 	{
 		name: "EvtLockPosition",
 		discriminator: [
@@ -10906,16 +12448,16 @@ var events = [
 		]
 	},
 	{
-		name: "EvtSplitPosition",
+		name: "EvtSplitPosition2",
 		discriminator: [
-			182,
-			138,
-			42,
-			254,
-			27,
-			94,
-			82,
-			221
+			165,
+			32,
+			203,
+			174,
+			72,
+			100,
+			233,
+			103
 		]
 	},
 	{
@@ -10931,6 +12473,19 @@ var events = [
 			147
 		]
 	},
+	{
+		name: "EvtSwap2",
+		discriminator: [
+			189,
+			66,
+			51,
+			168,
+			38,
+			80,
+			117,
+			153
+		]
+	},
 	{
 		name: "EvtUpdateRewardDuration",
 		discriminator: [
@@ -11206,6 +12761,36 @@ var errors = [
 		code: 6046,
 		name: "SamePosition",
 		msg: "Same position"
+	},
+	{
+		code: 6047,
+		name: "InvalidBaseFeeMode",
+		msg: "Invalid base fee mode"
+	},
+	{
+		code: 6048,
+		name: "InvalidFeeRateLimiter",
+		msg: "Invalid fee rate limiter"
+	},
+	{
+		code: 6049,
+		name: "FailToValidateSingleSwapInstruction",
+		msg: "Fail to validate single swap instruction in rate limiter"
+	},
+	{
+		code: 6050,
+		name: "InvalidFeeScheduler",
+		msg: "Invalid fee scheduler"
+	},
+	{
+		code: 6051,
+		name: "UndeterminedError",
+		msg: "Undetermined error"
+	},
+	{
+		code: 6052,
+		name: "InvalidPoolVersion",
+		msg: "Invalid pool version"
 	}
 ];
 var types = [
@@ -11252,7 +12837,7 @@ var types = [
 					type: "u64"
 				},
 				{
-					name: "fee_scheduler_mode",
+					name: "base_fee_mode",
 					type: "u8"
 				},
 				{
@@ -11265,15 +12850,20 @@ var types = [
 					}
 				},
 				{
-					name: "number_of_period",
+					name: "first_factor",
 					type: "u16"
 				},
 				{
-					name: "period_frequency",
-					type: "u64"
+					name: "second_factor",
+					type: {
+						array: [
+							"u8",
+							8
+						]
+					}
 				},
 				{
-					name: "reduction_factor",
+					name: "third_factor",
 					type: "u64"
 				}
 			]
@@ -11289,19 +12879,24 @@ var types = [
 					type: "u64"
 				},
 				{
-					name: "number_of_period",
+					name: "first_factor",
 					type: "u16"
 				},
 				{
-					name: "period_frequency",
-					type: "u64"
+					name: "second_factor",
+					type: {
+						array: [
+							"u8",
+							8
+						]
+					}
 				},
 				{
-					name: "reduction_factor",
+					name: "third_factor",
 					type: "u64"
 				},
 				{
-					name: "fee_scheduler_mode",
+					name: "base_fee_mode",
 					type: "u8"
 				}
 			]
@@ -11321,7 +12916,7 @@ var types = [
 					type: "u64"
 				},
 				{
-					name: "fee_scheduler_mode",
+					name: "base_fee_mode",
 					type: "u8"
 				},
 				{
@@ -11334,15 +12929,20 @@ var types = [
 					}
 				},
 				{
-					name: "number_of_period",
+					name: "first_factor",
 					type: "u16"
 				},
 				{
-					name: "period_frequency",
-					type: "u64"
+					name: "second_factor",
+					type: {
+						array: [
+							"u8",
+							8
+						]
+					}
 				},
 				{
-					name: "reduction_factor",
+					name: "third_factor",
 					type: "u64"
 				},
 				{
@@ -12181,6 +13781,66 @@ var types = [
 			]
 		}
 	},
+	{
+		name: "EvtLiquidityChange",
+		type: {
+			kind: "struct",
+			fields: [
+				{
+					name: "pool",
+					type: "pubkey"
+				},
+				{
+					name: "position",
+					type: "pubkey"
+				},
+				{
+					name: "owner",
+					type: "pubkey"
+				},
+				{
+					name: "token_a_amount",
+					type: "u64"
+				},
+				{
+					name: "token_b_amount",
+					type: "u64"
+				},
+				{
+					name: "transfer_fee_included_token_a_amount",
+					type: "u64"
+				},
+				{
+					name: "transfer_fee_included_token_b_amount",
+					type: "u64"
+				},
+				{
+					name: "reserve_a_amount",
+					type: "u64"
+				},
+				{
+					name: "reserve_b_amount",
+					type: "u64"
+				},
+				{
+					name: "liquidity_delta",
+					type: "u128"
+				},
+				{
+					name: "token_a_amount_threshold",
+					type: "u64"
+				},
+				{
+					name: "token_b_amount_threshold",
+					type: "u64"
+				},
+				{
+					name: "change_type",
+					type: "u8"
+				}
+			]
+		}
+	},
 	{
 		name: "EvtLockPosition",
 		type: {
@@ -12302,7 +13962,7 @@ var types = [
 		}
 	},
 	{
-		name: "EvtSplitPosition",
+		name: "EvtSplitPosition2",
 		type: {
 			kind: "struct",
 			fields: [
@@ -12358,7 +14018,7 @@ var types = [
 					name: "split_position_parameters",
 					type: {
 						defined: {
-							name: "SplitPositionParameters"
+							name: "SplitPositionParameters2"
 						}
 					}
 				}
@@ -12409,6 +14069,70 @@ var types = [
 			]
 		}
 	},
+	{
+		name: "EvtSwap2",
+		type: {
+			kind: "struct",
+			fields: [
+				{
+					name: "pool",
+					type: "pubkey"
+				},
+				{
+					name: "trade_direction",
+					type: "u8"
+				},
+				{
+					name: "collect_fee_mode",
+					type: "u8"
+				},
+				{
+					name: "has_referral",
+					type: "bool"
+				},
+				{
+					name: "params",
+					type: {
+						defined: {
+							name: "SwapParameters2"
+						}
+					}
+				},
+				{
+					name: "swap_result",
+					type: {
+						defined: {
+							name: "SwapResult2"
+						}
+					}
+				},
+				{
+					name: "included_transfer_fee_amount_in",
+					type: "u64"
+				},
+				{
+					name: "included_transfer_fee_amount_out",
+					type: "u64"
+				},
+				{
+					name: "excluded_transfer_fee_amount_out",
+					type: "u64"
+				},
+				{
+					name: "current_timestamp",
+					type: "u64"
+				},
+				{
+					name: "reserve_a_amount",
+					type: "u64"
+				},
+				{
+					name: "reserve_b_amount",
+					type: "u64"
+				}
+			]
+		}
+	},
 	{
 		name: "EvtUpdateRewardDuration",
 		type: {
@@ -12759,17 +14483,19 @@ var types = [
 					],
 					type: "u8"
 				},
+				{
+					name: "version",
+					docs: [
+						"pool version, 0: max_fee is still capped at 50%, 1: max_fee is capped at 99%"
+					],
+					type: "u8"
+				},
 				{
 					name: "_padding_0",
 					docs: [
 						"padding"
 					],
-					type: {
-						array: [
-							"u8",
-							2
-						]
-					}
+					type: "u8"
 				},
 				{
 					name: "fee_a_per_liquidity",
@@ -13502,6 +15228,38 @@ var types = [
 			]
 		}
 	},
+	{
+		name: "SplitPositionParameters2",
+		type: {
+			kind: "struct",
+			fields: [
+				{
+					name: "unlocked_liquidity_numerator",
+					type: "u32"
+				},
+				{
+					name: "permanent_locked_liquidity_numerator",
+					type: "u32"
+				},
+				{
+					name: "fee_a_numerator",
+					type: "u32"
+				},
+				{
+					name: "fee_b_numerator",
+					type: "u32"
+				},
+				{
+					name: "reward_0_numerator",
+					type: "u32"
+				},
+				{
+					name: "reward_1_numerator",
+					type: "u32"
+				}
+			]
+		}
+	},
 	{
 		name: "StaticConfigParameters",
 		type: {
@@ -13558,6 +15316,35 @@ var types = [
 			]
 		}
 	},
+	{
+		name: "SwapParameters2",
+		type: {
+			kind: "struct",
+			fields: [
+				{
+					name: "amount_0",
+					docs: [
+						"When it's exact in, partial fill, this will be amount_in. When it's exact out, this will be amount_out"
+					],
+					type: "u64"
+				},
+				{
+					name: "amount_1",
+					docs: [
+						"When it's exact in, partial fill, this will be minimum_amount_out. When it's exact out, this will be maximum_amount_in"
+					],
+					type: "u64"
+				},
+				{
+					name: "swap_mode",
+					docs: [
+						"Swap mode, refer [SwapMode]"
+					],
+					type: "u8"
+				}
+			]
+		}
+	},
 	{
 		name: "SwapResult",
 		docs: [
@@ -13593,6 +15380,50 @@ var types = [
 			]
 		}
 	},
+	{
+		name: "SwapResult2",
+		type: {
+			kind: "struct",
+			fields: [
+				{
+					name: "included_fee_input_amount",
+					type: "u64"
+				},
+				{
+					name: "excluded_fee_input_amount",
+					type: "u64"
+				},
+				{
+					name: "amount_left",
+					type: "u64"
+				},
+				{
+					name: "output_amount",
+					type: "u64"
+				},
+				{
+					name: "next_sqrt_price",
+					type: "u128"
+				},
+				{
+					name: "trading_fee",
+					type: "u64"
+				},
+				{
+					name: "protocol_fee",
+					type: "u64"
+				},
+				{
+					name: "partner_fee",
+					type: "u64"
+				},
+				{
+					name: "referral_fee",
+					type: "u64"
+				}
+			]
+		}
+	},
 	{
 		name: "TokenBadge",
 		docs: [
@@ -13764,4 +15595,4 @@ var CpAmmIDL = {
 	types: types
 };
 
-export { ActivationPoint, ActivationType, type AddLiquidityParams, type AmmProgram, BASIS_POINT_MAX, BIN_STEP_BPS_DEFAULT, BIN_STEP_BPS_U128_DEFAULT, type BaseFee, type BuildAddLiquidityParams, type BuildLiquidatePositionInstructionParams, type BuildRemoveAllLiquidityInstructionParams, CP_AMM_PROGRAM_ID, type ClaimPartnerFeeParams, type ClaimPositionFeeInstructionParams, type ClaimPositionFeeParams, type ClaimPositionFeeParams2, type ClaimRewardParams, type ClosePositionInstructionParams, type ClosePositionParams, CollectFeeMode, type ConfigState, CpAmm, type CpAmm$1 as CpAmmTypes, type CreatePoolParams, type CreatePositionAndAddLiquidity, type CreatePositionParams, DYNAMIC_FEE_DECAY_PERIOD_DEFAULT, DYNAMIC_FEE_FILTER_PERIOD_DEFAULT, DYNAMIC_FEE_REDUCTION_FACTOR_DEFAULT, type DepositQuote, type DynamicFee, type DynamicFeeParams, FEE_DENOMINATOR, type FeeMode, FeeSchedulerMode, type FundRewardParams, type GetDepositQuoteParams, type GetQuoteExactOutParams, type GetQuoteParams, type GetWithdrawQuoteParams, type InitializeCustomizeablePoolParams, type InitializeCustomizeablePoolWithDynamicConfigParams, type InitializeRewardParams, LIQUIDITY_SCALE, type LiquidityDeltaParams, type LockPositionParams, MAX_CU_BUFFER, MAX_FEE_NUMERATOR, MAX_PRICE_CHANGE_BPS_DEFAULT, MAX_SQRT_PRICE, MIN_CU_BUFFER, MIN_SQRT_PRICE, type MergePositionParams, ONE, type PermanentLockParams, type PoolFeesParams, type PoolState, type PositionState, type PrepareCustomizablePoolParams, type PreparePoolCreationParams, type PreparePoolCreationSingleSide, type PrepareTokenAccountParams, type PreparedPoolCreation, type QuoteExactOutResult, type RefreshVestingParams, type RemoveAllLiquidityAndClosePositionParams, type RemoveAllLiquidityParams, type RemoveLiquidityParams, type RewardInfo, Rounding, SCALE_OFFSET, type SetupFeeClaimAccountsParams, type SplitPositionParams, type SwapAmount, type SwapParams, type SwapQuotes, type SwapResult, type TokenBadgeState, TradeDirection, type TxBuilder, type UpdateRewardDurationParams, type UpdateRewardFunderParams, type VestingState, type WithdrawIneligibleRewardParams, type WithdrawQuote, bpsToFeeNumerator, calculateInitSqrtPrice, calculateTransferFeeExcludedAmount, calculateTransferFeeIncludedAmount, decimalToQ64, CpAmmIDL as default, deriveClaimFeeOperatorAddress, deriveConfigAddress, deriveCustomizablePoolAddress, derivePoolAddress, derivePoolAuthority, derivePositionAddress, derivePositionNftAccount, deriveRewardVaultAddress, deriveTokenBadgeAddress, deriveTokenVaultAddress, feeNumeratorToBps, getAllPositionNftAccountByOwner, getAllUserPositionNftAccount, getAmountAFromLiquidityDelta, getAmountBFromLiquidityDelta, getAvailableVestingLiquidity, getBaseFeeNumerator, getBaseFeeParams, getDynamicFeeNumerator, getDynamicFeeParams, getEstimatedComputeUnitIxWithBuffer, getEstimatedComputeUnitUsageWithBuffer, getExcludedFeeAmount, getFeeMode, getFeeNumerator, getFirstKey, getIncludedFeeAmount, getLiquidityDeltaFromAmountA, getLiquidityDeltaFromAmountB, getMaxAmountWithSlippage, getMinAmountWithSlippage, getNextSqrtPrice, getNextSqrtPriceFromAmountARoundingDown, getNextSqrtPriceFromAmountBRoundingUp, getNextSqrtPriceFromOutput, getOrCreateATAInstruction, getPriceChange, getPriceFromSqrtPrice, getPriceImpact, getSecondKey, getSimulationComputeUnits, getSqrtPriceFromPrice, getSwapAmount, getSwapResultFromOutAmount, getTokenDecimals, getTokenProgram, getTotalLockedLiquidity, getUnClaimReward, isVestingComplete, mulDiv, positionByPoolFilter, pow, q64ToDecimal, unwrapSOLInstruction, vestingByPositionFilter, wrapSOLInstruction };
+export { ActivationPoint, ActivationType, type AddLiquidityParams, type AmmProgram, BASIS_POINT_MAX, BIN_STEP_BPS_DEFAULT, BIN_STEP_BPS_U128_DEFAULT, type BaseFee, type BaseFeeHandler, BaseFeeMode, type BuildAddLiquidityParams, type BuildLiquidatePositionInstructionParams, type BuildRemoveAllLiquidityInstructionParams, CP_AMM_PROGRAM_ID, CURRENT_POOL_VERSION, type ClaimPartnerFeeParams, type ClaimPositionFeeInstructionParams, type ClaimPositionFeeParams, type ClaimPositionFeeParams2, type ClaimRewardParams, type ClosePositionInstructionParams, type ClosePositionParams, CollectFeeMode, type ConfigState, CpAmm, type CpAmm$1 as CpAmmTypes, type CreatePoolParams, type CreatePositionAndAddLiquidity, type CreatePositionParams, DYNAMIC_FEE_DECAY_PERIOD_DEFAULT, DYNAMIC_FEE_FILTER_PERIOD_DEFAULT, DYNAMIC_FEE_REDUCTION_FACTOR_DEFAULT, DYNAMIC_FEE_ROUNDING_OFFSET, DYNAMIC_FEE_SCALING_FACTOR, type DepositQuote, type DynamicFee, type DynamicFeeParams, type DynamicFeeStruct, FEE_DENOMINATOR, type FeeMode, type FeeOnAmountResult, FeeRateLimiter, FeeScheduler, type FundRewardParams, type GetDepositQuoteParams, type GetQuote2Params, type GetQuoteParams, type GetWithdrawQuoteParams, type InitializeCustomizeablePoolParams, type InitializeCustomizeablePoolWithDynamicConfigParams, type InitializeRewardParams, LIQUIDITY_SCALE, type LiquidityDeltaParams, type LockPositionParams, MAX, MAX_CU_BUFFER, MAX_EXPONENTIAL, MAX_FEE_BPS_V0, MAX_FEE_BPS_V1, MAX_FEE_NUMERATOR_V0, MAX_FEE_NUMERATOR_V1, MAX_PRICE_CHANGE_BPS_DEFAULT, MAX_RATE_LIMITER_DURATION_IN_SECONDS, MAX_RATE_LIMITER_DURATION_IN_SLOTS, MAX_SQRT_PRICE, MIN_CU_BUFFER, MIN_FEE_BPS, MIN_FEE_NUMERATOR, MIN_SQRT_PRICE, type MergePositionParams, ONE_Q64, type PermanentLockParams, type PoolFeesParams, type PoolFeesStruct, type PoolState, PoolStatus, PoolVersion, type PositionState, type PrepareCustomizablePoolParams, type PreparePoolCreationParams, type PreparePoolCreationSingleSide, type PrepareTokenAccountParams, type PreparedPoolCreation, type Quote2Result, type RefreshVestingParams, type RemoveAllLiquidityAndClosePositionParams, type RemoveAllLiquidityParams, type RemoveLiquidityParams, type RewardInfo, Rounding, SCALE_OFFSET, SPLIT_POSITION_DENOMINATOR, type SetupFeeClaimAccountsParams, type SplitFees, type SplitPosition2Params, type SplitPositionParams, type Swap2Params, type SwapAmount, SwapMode, type SwapParams, type SwapResult, type SwapResult2, type TokenBadgeState, TradeDirection, type TxBuilder, U128_MAX, U16_MAX, U64_MAX, type UpdateRewardDurationParams, type UpdateRewardFunderParams, type VestingState, type WithdrawIneligibleRewardParams, type WithdrawQuote, bpsToFeeNumerator, calculateAtoBFromAmountIn, calculateAtoBFromAmountOut, calculateAtoBFromPartialAmountIn, calculateBtoAFromAmountIn, calculateBtoAFromAmountOut, calculateBtoAFromPartialAmountIn, calculateInitSqrtPrice, calculateTransferFeeExcludedAmount, calculateTransferFeeIncludedAmount, convertToFeeSchedulerSecondFactor, convertToLamports, convertToRateLimiterSecondFactor, decimalToQ64, CpAmmIDL as default, deriveClaimFeeOperatorAddress, deriveConfigAddress, deriveCustomizablePoolAddress, derivePoolAddress, derivePoolAuthority, derivePositionAddress, derivePositionNftAccount, deriveRewardVaultAddress, deriveTokenBadgeAddress, deriveTokenVaultAddress, feeNumeratorToBps, fromDecimalToBN, getAllPositionNftAccountByOwner, getAllUserPositionNftAccount, getAmountAFromLiquidityDelta, getAmountBFromLiquidityDelta, getAmountWithSlippage, getAvailableVestingLiquidity, getBaseFeeHandler, getBaseFeeNumerator, getBaseFeeNumeratorByPeriod, getBaseFeeParams, getCheckedAmounts, getCurrentPoint, getDynamicFeeNumerator, getDynamicFeeParams, getEstimatedComputeUnitIxWithBuffer, getEstimatedComputeUnitUsageWithBuffer, getExcludedFeeAmount, getExcludedFeeAmountFromIncludedFeeAmount, getFeeInPeriod, getFeeMode, getFeeNumeratorFromExcludedFeeAmount, getFeeNumeratorFromIncludedFeeAmount, getFeeNumeratorOnExponentialFeeScheduler, getFeeNumeratorOnLinearFeeScheduler, getFeeOnAmount, getFeeSchedulerParams, getFirstKey, getIncludedFeeAmount, getLiquidityDeltaFromAmountA, getLiquidityDeltaFromAmountB, getMaxAmountWithSlippage, getMaxBaseFeeNumerator, getMaxFeeBps, getMaxFeeNumerator, getMaxIndex, getMinBaseFeeNumerator, getNextSqrtPriceFromAmountInARoundingUp, getNextSqrtPriceFromAmountInBRoundingDown, getNextSqrtPriceFromAmountOutARoundingUp, getNextSqrtPriceFromAmountOutBRoundingDown, getNextSqrtPriceFromInput, getNextSqrtPriceFromOutput, getOrCreateATAInstruction, getPriceChange, getPriceFromSqrtPrice, getPriceImpact, getRateLimiterParams, getSecondKey, getSimulationComputeUnits, getSqrtPriceFromPrice, getSwapResultFromExactInput, getSwapResultFromExactOutput, getSwapResultFromPartialInput, getTokenDecimals, getTokenProgram, getTotalFeeNumerator, getTotalLockedLiquidity, getTotalTradingFeeFromExcludedFeeAmount, getTotalTradingFeeFromIncludedFeeAmount, getUnClaimReward, hasPartner, isDynamicFeeEnabled, isNonZeroRateLimiter, isRateLimiterApplied, isSwapEnabled, isVestingComplete, isZeroRateLimiter, mulDiv, parseFeeSchedulerSecondFactor, parseRateLimiterSecondFactor, positionByPoolFilter, pow, q64ToDecimal, splitFees, sqrt, swapQuoteExactInput, swapQuoteExactOutput, swapQuotePartialInput, toNumerator, unwrapSOLInstruction, validateFeeFraction, validateFeeRateLimiter, validateFeeScheduler, vestingByPositionFilter, wrapSOLInstruction };