@meteora-ag/cp-amm-sdk 1.1.5 → 1.1.7

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.4";
+        version: "0.1.5";
         spec: "0.1.0";
         description: "Created with Anchor";
     };
@@ -2851,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];
@@ -3125,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];
@@ -3149,6 +3260,10 @@ type CpAmm$1 = {
             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];
@@ -3397,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: [
@@ -3437,7 +3582,7 @@ type CpAmm$1 = {
                         type: "u64";
                     },
                     {
-                        name: "feeSchedulerMode";
+                        name: "baseFeeMode";
                         type: "u8";
                     },
                     {
@@ -3447,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";
                     }
                 ];
@@ -3471,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";
                     }
                 ];
@@ -3503,7 +3652,7 @@ type CpAmm$1 = {
                         type: "u64";
                     },
                     {
-                        name: "feeSchedulerMode";
+                        name: "baseFeeMode";
                         type: "u8";
                     },
                     {
@@ -3513,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";
                     },
                     {
@@ -4299,6 +4450,66 @@ type CpAmm$1 = {
                 ];
             };
         },
+        {
+            name: "evtLiquidityChange";
+            type: {
+                kind: "struct";
+                fields: [
+                    {
+                        name: "pool";
+                        type: "pubkey";
+                    },
+                    {
+                        name: "position";
+                        type: "pubkey";
+                    },
+                    {
+                        name: "owner";
+                        type: "pubkey";
+                    },
+                    {
+                        name: "tokenAAmount";
+                        type: "u64";
+                    },
+                    {
+                        name: "tokenBAmount";
+                        type: "u64";
+                    },
+                    {
+                        name: "transferFeeIncludedTokenAAmount";
+                        type: "u64";
+                    },
+                    {
+                        name: "transferFeeIncludedTokenBAmount";
+                        type: "u64";
+                    },
+                    {
+                        name: "reserveAAmount";
+                        type: "u64";
+                    },
+                    {
+                        name: "reserveBAmount";
+                        type: "u64";
+                    },
+                    {
+                        name: "liquidityDelta";
+                        type: "u128";
+                    },
+                    {
+                        name: "tokenAAmountThreshold";
+                        type: "u64";
+                    },
+                    {
+                        name: "tokenBAmountThreshold";
+                        type: "u64";
+                    },
+                    {
+                        name: "changeType";
+                        type: "u8";
+                    }
+                ];
+            };
+        },
         {
             name: "evtLockPosition";
             type: {
@@ -4527,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: {
@@ -4818,11 +5093,16 @@ type CpAmm$1 = {
                         type: "u8";
                     },
                     {
-                        name: "padding0";
-                        docs: ["padding"];
-                        type: {
-                            array: ["u8", 2];
-                        };
+                        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: "u8";
                     },
                     {
                         name: "feeAPerLiquidity";
@@ -5512,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"];
@@ -5545,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"];
@@ -5694,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,
@@ -5710,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[];
@@ -6004,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;
@@ -6026,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;
@@ -6061,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;
@@ -6270,6 +6680,24 @@ type SplitPosition2Params = {
     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
@@ -6454,7 +6882,7 @@ declare class CpAmm {
     canUnlockPosition(positionState: PositionState, vestings: Array<{
         account: PublicKey;
         vestingState: VestingState;
-    }>, currentPoint: BN): {
+    }>, currentPoint: BN$1): {
         canUnlock: boolean;
         reason?: string;
     };
@@ -6465,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.
      *
@@ -6516,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
@@ -6585,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.
@@ -6698,38 +7122,611 @@ 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;
+/**
+ * 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 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.
+ * @param connection A Solana connection object.
+ * @param instructions The instructions of the transaction to simulate.
+ * @param feePayer The public key of the fee payer.
+ * @param buffer The buffer to add to the estimated compute unit usage. Max value is 1. Default value is 0.1 if not provided, and will be capped between 50k - 200k.
+ * @returns The estimated compute unit usage with the buffer.
+ */
+declare const getEstimatedComputeUnitUsageWithBuffer: (connection: Connection, instructions: TransactionInstruction[], feePayer: PublicKey, buffer?: number) => Promise<number>;
+/**
+ * Gets the estimated compute unit usage with a buffer and converts it to a SetComputeUnitLimit instruction.
+ * If the estimated compute unit usage cannot be retrieved, returns a SetComputeUnitLimit instruction with the fallback unit.
+ * @param connection A Solana connection object.
+ * @param instructions The instructions of the transaction to simulate.
+ * @param feePayer The public key of the fee payer.
+ * @param buffer The buffer to add to the estimated compute unit usage. Max value is 1. Default value is 0.1 if not provided, and will be capped between 50k - 200k.
+ * @returns A SetComputeUnitLimit instruction with the estimated compute unit usage.
+ */
+declare const getEstimatedComputeUnitIxWithBuffer: (connection: Connection, instructions: TransactionInstruction[], feePayer: PublicKey, buffer?: number) => Promise<TransactionInstruction>;
+
+/**
+ * It takes an amount and a slippage rate, and returns the maximum amount that can be received with
+ * that slippage rate
+ * @param {BN} amount - The amount of tokens you want to buy.
+ * @param {number} rate - The maximum percentage of slippage you're willing to accept. (Max to 2 decimal place)
+ * @returns The maximum amount of tokens that can be bought with the given amount of ETH, given the
+ * slippage rate.
+ */
+declare const getMaxAmountWithSlippage: (amount: BN, rate: number) => BN;
+/**
+ * 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 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
+ * @param amountIn - Input amount (in base units)
+ * @param amountOut - Output amount (in base units)
+ * @param currentSqrtPrice - Current pool sqrt price (spot price)
+ * @param aToB - Direction of swap: true for token A to token B, false for token B to token A
+ * @param tokenADecimal - Decimal places for token A
+ * @param tokenBDecimal - Decimal places for token B
+ * @returns Price impact as a percentage (e.g., 1.5 means 1.5% worse than spot price)
+ */
+declare const getPriceImpact: (amountIn: BN, amountOut: BN, currentSqrtPrice: BN, aToB: boolean, tokenADecimal: number, tokenBDecimal: number) => Decimal;
+/**
+ * Calculate price change as a percentage (old implementation)
+ * This measures the percentage change in pool price after a swap
+ * @param nextSqrtPrice sqrt price after swap
+ * @param currentSqrtPrice current pool sqrt price
+ * @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;
+
+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;
+
+/**
+ * Checks if a vesting schedule is ready for full release
+ * @param vestingData The vesting account data
+ * @param currentPoint Current timestamp or slot
+ * @returns True if the vesting is complete and all liquidity can be released
+ */
+declare function isVestingComplete(vestingData: VestingState, currentPoint: BN): boolean;
+/**
+ * Gets the total amount of liquidity in the vesting schedule
+ * @param vestingData The vesting account data
+ * @returns The total locked liquidity amount
+ */
+declare function getTotalLockedLiquidity(vestingData: VestingState): BN;
+/**
+ * Calculates the available liquidity to withdraw based on vesting schedule
+ * @param vestingData The vesting account data
+ * @param positionData The position account data
+ * @param currentPoint Current timestamp or slot
+ * @returns The amount of liquidity available to withdraw
+ */
+declare function getAvailableVestingLiquidity(vestingData: VestingState, currentPoint: 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(poolState: PoolState): 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;
+
+/**
+ * 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
  *
@@ -6738,248 +7735,421 @@ declare function getBaseFeeNumerator(feeSchedulerMode: FeeSchedulerMode, cliffFe
  * @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;
+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): {
+    checkedExcludedFeeAmount: BN$1;
+    checkedIncludedFeeAmount: BN$1;
+    isOverflow: 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;
+
 /**
- * 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
+ * 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 getFeeNumerator(currentPoint: number, activationPoint: BN, numberOfPeriod: number, periodFrequency: BN, feeSchedulerMode: number, cliffFeeNumerator: BN, reductionFactor: BN, dynamicFeeParams?: {
-    volatilityAccumulator: BN;
-    binStep: number;
-    variableFeeControl: number;
-}): BN;
+declare function getSwapResultFromExactInput(poolState: PoolState, amountIn: BN$1, feeMode: FeeMode, tradeDirection: TradeDirection, currentPoint: BN$1): SwapResult2;
 /**
- * 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 }
+ * 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 getFeeMode(collectFeeMode: CollectFeeMode, btoA: boolean): FeeMode;
+declare function calculateAtoBFromAmountIn(poolState: PoolState, amountIn: BN$1): {
+    outputAmount: BN$1;
+    nextSqrtPrice: BN$1;
+    amountLeft: BN$1;
+};
 /**
- *
- * 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
+ * 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 getSwapAmount(inAmount: BN, sqrtPrice: BN, liquidity: BN, tradeFeeNumerator: BN, aToB: boolean, collectFeeMode: number): {
-    amountOut: BN;
-    totalFee: BN;
-    nextSqrtPrice: BN;
+declare function calculateBtoAFromAmountIn(poolState: PoolState, amountIn: BN$1): {
+    outputAmount: BN$1;
+    nextSqrtPrice: BN$1;
+    amountLeft: BN$1;
 };
 /**
- * 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
+ * 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 bpsToFeeNumerator(bps: number): BN;
+declare function getSwapResultFromPartialInput(poolState: PoolState, amountIn: BN$1, feeMode: FeeMode, tradeDirection: TradeDirection, currentPoint: BN$1): SwapResult2;
 /**
- * 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]
+ * 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 feeNumeratorToBps(feeNumerator: BN): number;
+declare function calculateAtoBFromPartialAmountIn(poolState: PoolState, amountIn: BN$1): {
+    outputAmount: BN$1;
+    nextSqrtPrice: BN$1;
+    amountLeft: BN$1;
+};
 /**
- * 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}
+ * 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 getBaseFeeParams(maxBaseFeeBps: number, minBaseFeeBps: number, feeSchedulerMode: FeeSchedulerMode, numberOfPeriod: number, totalDuration: number): BaseFee;
+declare function calculateBtoAFromPartialAmountIn(poolState: PoolState, amountIn: BN$1): {
+    outputAmount: BN$1;
+    nextSqrtPrice: BN$1;
+    amountLeft: BN$1;
+};
 /**
- * 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}
+ * 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 getDynamicFeeParams(baseFeeBps: number, maxPriceChangeBps?: number): DynamicFee;
+declare function getSwapResultFromExactOutput(poolState: PoolState, amountOut: BN$1, feeMode: FeeMode, tradeDirection: TradeDirection, currentPoint: BN$1): SwapResult2;
 /**
- * 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]
+ * 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 getExcludedFeeAmount(tradeFeeNumerator: BN, includedFeeAmount: BN): {
-    excludedFeeAmount: BN;
-    tradingFee: BN;
+declare function calculateAtoBFromAmountOut(poolState: PoolState, amountOut: BN$1): {
+    inputAmount: BN$1;
+    nextSqrtPrice: BN$1;
 };
 /**
- * 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
+ * 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 getIncludedFeeAmount(tradeFeeNumerator: BN, excludedFeeAmount: BN): BN;
+declare function calculateBtoAFromAmountOut(poolState: PoolState, amountOut: BN$1): {
+    inputAmount: BN$1;
+    nextSqrtPrice: BN$1;
+};
 /**
- * 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]
+ * 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 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>;
+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;
 /**
- * Gets the estimated compute unit usage with a buffer.
- * @param connection A Solana connection object.
- * @param instructions The instructions of the transaction to simulate.
- * @param feePayer The public key of the fee payer.
- * @param buffer The buffer to add to the estimated compute unit usage. Max value is 1. Default value is 0.1 if not provided, and will be capped between 50k - 200k.
- * @returns The estimated compute unit usage with the buffer.
+ * 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 const getEstimatedComputeUnitUsageWithBuffer: (connection: Connection, instructions: TransactionInstruction[], feePayer: PublicKey, buffer?: number) => Promise<number>;
+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;
 /**
- * Gets the estimated compute unit usage with a buffer and converts it to a SetComputeUnitLimit instruction.
- * If the estimated compute unit usage cannot be retrieved, returns a SetComputeUnitLimit instruction with the fallback unit.
- * @param connection A Solana connection object.
- * @param instructions The instructions of the transaction to simulate.
- * @param feePayer The public key of the fee payer.
- * @param buffer The buffer to add to the estimated compute unit usage. Max value is 1. Default value is 0.1 if not provided, and will be capped between 50k - 200k.
- * @returns A SetComputeUnitLimit instruction with the estimated compute unit usage.
+ * 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 const getEstimatedComputeUnitIxWithBuffer: (connection: Connection, instructions: TransactionInstruction[], feePayer: PublicKey, buffer?: number) => Promise<TransactionInstruction>;
+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;
 
 /**
- * It takes an amount and a slippage rate, and returns the maximum amount that can be received with
- * that slippage rate
- * @param {BN} amount - The amount of tokens you want to buy.
- * @param {number} rate - The maximum percentage of slippage you're willing to accept. (Max to 2 decimal place)
- * @returns The maximum amount of tokens that can be bought with the given amount of ETH, given the
- * slippage rate.
+ * 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 const getMaxAmountWithSlippage: (amount: BN, rate: number) => BN;
+declare function getNextSqrtPriceFromAmountInBRoundingDown(sqrtPrice: BN$1, liquidity: BN$1, amount: BN$1): BN$1;
 /**
- * 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.
+ * 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 const getMinAmountWithSlippage: (amount: BN, rate: number) => BN;
+declare function getNextSqrtPriceFromAmountOutBRoundingDown(sqrtPrice: BN$1, liquidity: BN$1, amount: BN$1): BN$1;
 /**
- * Calculate price impact as a percentage
- * Price impact measures how much worse the user's execution was compared to the current market price
- * @param amountIn - Input amount (in base units)
- * @param amountOut - Output amount (in base units)
- * @param currentSqrtPrice - Current pool sqrt price (spot price)
- * @param aToB - Direction of swap: true for token A to token B, false for token B to token A
- * @param tokenADecimal - Decimal places for token A
- * @param tokenBDecimal - Decimal places for token B
- * @returns Price impact as a percentage (e.g., 1.5 means 1.5% worse than spot price)
+ * 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 const getPriceImpact: (amountIn: BN, amountOut: BN, currentSqrtPrice: BN, aToB: boolean, tokenADecimal: number, tokenBDecimal: number) => Decimal;
+declare function getNextSqrtPriceFromAmountInARoundingUp(sqrtPrice: BN$1, liquidity: BN$1, amount: BN$1): BN$1;
 /**
- * Calculate price change as a percentage (old implementation)
- * This measures the percentage change in pool price after a swap
- * @param nextSqrtPrice sqrt price after swap
- * @param currentSqrtPrice current pool sqrt price
- * @returns Price change as a percentage (e.g., 1.5 means 1.5% change)
+ * 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 const getPriceChange: (nextSqrtPrice: BN, currentSqrtPrice: BN) => number;
-declare const getPriceFromSqrtPrice: (sqrtPrice: BN, tokenADecimal: number, tokenBDecimal: number) => Decimal;
-declare const getSqrtPriceFromPrice: (price: string, tokenADecimal: number, tokenBDecimal: number) => BN;
-declare const getUnClaimReward: (poolState: PoolState, positionState: PositionState) => {
-    feeTokenA: BN;
-    feeTokenB: BN;
-    rewards: BN[];
-};
-
-declare const positionByPoolFilter: (pool: PublicKey) => GetProgramAccountsFilter;
-declare const vestingByPositionFilter: (position: PublicKey) => GetProgramAccountsFilter;
-
-declare function calculateInitSqrtPrice(tokenAAmount: BN, tokenBAmount: BN, minSqrtPrice: BN, maxSqrtPrice: BN): BN;
-
-interface TransferFeeIncludedAmount {
-    amount: BN;
-    transferFee: BN;
-}
-declare function calculateTransferFeeIncludedAmount(transferFeeExcludedAmount: BN, mint: Mint, currentEpoch: number): TransferFeeIncludedAmount;
-interface TransferFeeExcludedAmount {
-    amount: BN;
-    transferFee: BN;
-}
-declare function calculateTransferFeeExcludedAmount(transferFeeIncludedAmount: BN, mint: Mint, currentEpoch: number): TransferFeeExcludedAmount;
-
+declare function getNextSqrtPriceFromAmountOutARoundingUp(sqrtPrice: BN$1, liquidity: BN$1, amount: BN$1): BN$1;
 /**
- * Checks if a vesting schedule is ready for full release
- * @param vestingData The vesting account data
- * @param currentPoint Current timestamp or slot
- * @returns True if the vesting is complete and all liquidity can be released
+ * 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 isVestingComplete(vestingData: VestingState, currentPoint: BN): boolean;
+declare function getNextSqrtPriceFromOutput(sqrtPrice: BN$1, liquidity: BN$1, amountOut: BN$1, aForB: boolean): BN$1;
 /**
- * Gets the total amount of liquidity in the vesting schedule
- * @param vestingData The vesting account data
- * @returns The total locked liquidity amount
+ * 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 getTotalLockedLiquidity(vestingData: VestingState): BN;
+declare function getNextSqrtPriceFromInput(sqrtPrice: BN$1, liquidity: BN$1, amountIn: BN$1, aForB: boolean): BN$1;
 /**
- * Calculates the available liquidity to withdraw based on vesting schedule
- * @param vestingData The vesting account data
- * @param positionData The position account data
- * @param currentPoint Current timestamp or slot
- * @returns The amount of liquidity available to withdraw
+ * 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 getAvailableVestingLiquidity(vestingData: VestingState, currentPoint: BN): BN;
-
-declare const ONE: BN;
-declare function pow(base: BN, exp: BN): 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;
 
-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;
+/**
+ * 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.4",
+	version: "0.1.5",
 	spec: "0.1.0",
 	description: "Created with Anchor"
 };
@@ -10570,7 +11740,148 @@ var instructions = [
 				name: "params",
 				type: {
 					defined: {
-						name: "SwapParameters"
+						name: "SwapParameters"
+					}
+				}
+			}
+		]
+	},
+	{
+		name: "swap2",
+		discriminator: [
+			65,
+			75,
+			63,
+			76,
+			235,
+			91,
+			91,
+			136
+		],
+		accounts: [
+			{
+				name: "pool_authority",
+				address: "HLnpSz9h2S4hiLQ43rnSD9XkcUThA7B8hQMKmDaiTLcC"
+			},
+			{
+				name: "pool",
+				docs: [
+					"Pool account"
+				],
+				writable: true
+			},
+			{
+				name: "input_token_account",
+				docs: [
+					"The user token account for input token"
+				],
+				writable: true
+			},
+			{
+				name: "output_token_account",
+				docs: [
+					"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: "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"
+				]
+			},
+			{
+				name: "token_b_mint",
+				docs: [
+					"The mint of token b"
+				]
+			},
+			{
+				name: "payer",
+				docs: [
+					"The user performing the swap"
+				],
+				signer: true
+			},
+			{
+				name: "token_a_program",
+				docs: [
+					"Token a program"
+				]
+			},
+			{
+				name: "token_b_program",
+				docs: [
+					"Token b program"
+				]
+			},
+			{
+				name: "referral_token_account",
+				docs: [
+					"referral token account"
+				],
+				writable: true,
+				optional: 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: "params",
+				type: {
+					defined: {
+						name: "SwapParameters2"
 					}
 				}
 			}
@@ -11075,6 +12386,19 @@ var events = [
 			249
 		]
 	},
+	{
+		name: "EvtLiquidityChange",
+		discriminator: [
+			197,
+			171,
+			78,
+			127,
+			224,
+			211,
+			87,
+			13
+		]
+	},
 	{
 		name: "EvtLockPosition",
 		discriminator: [
@@ -11153,6 +12477,19 @@ var events = [
 			147
 		]
 	},
+	{
+		name: "EvtSwap2",
+		discriminator: [
+			189,
+			66,
+			51,
+			168,
+			38,
+			80,
+			117,
+			153
+		]
+	},
 	{
 		name: "EvtUpdateRewardDuration",
 		discriminator: [
@@ -11428,6 +12765,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 = [
@@ -11474,7 +12841,7 @@ var types = [
 					type: "u64"
 				},
 				{
-					name: "fee_scheduler_mode",
+					name: "base_fee_mode",
 					type: "u8"
 				},
 				{
@@ -11487,15 +12854,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"
 				}
 			]
@@ -11511,19 +12883,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"
 				}
 			]
@@ -11543,7 +12920,7 @@ var types = [
 					type: "u64"
 				},
 				{
-					name: "fee_scheduler_mode",
+					name: "base_fee_mode",
 					type: "u8"
 				},
 				{
@@ -11556,15 +12933,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"
 				},
 				{
@@ -12403,6 +13785,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: {
@@ -12631,6 +14073,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: {
@@ -12981,17 +14487,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",
@@ -13812,6 +15320,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: [
@@ -13847,6 +15384,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: [
@@ -14018,4 +15599,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, SPLIT_POSITION_DENOMINATOR, type SetupFeeClaimAccountsParams, type SplitPosition2Params, 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 };