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

package/dist/index.mjs

@@ -1,4 +1,23 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
 var __pow = Math.pow;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
 var __async = (__this, __arguments, generator) => {
   return new Promise((resolve, reject) => {
     var fulfilled = (value) => {
@@ -21,7 +40,7 @@ var __async = (__this, __arguments, generator) => {
 };
 
 // src/CpAmm.ts
-import { Program, BN as BN10 } from "@coral-xyz/anchor";
+import { Program } from "@coral-xyz/anchor";
 import { NATIVE_MINT as NATIVE_MINT2, TOKEN_2022_PROGRAM_ID as TOKEN_2022_PROGRAM_ID2 } from "@solana/spl-token";
 import invariant from "invariant";
 
@@ -30,7 +49,7 @@ var cp_amm_default = {
   address: "cpamdpZCGKUy5JxQXB4dcpGPiikHawvSWAd6mEn1sGG",
   metadata: {
     name: "cp_amm",
-    version: "0.1.3",
+    version: "0.1.5",
     spec: "0.1.0",
     description: "Created with Anchor"
   },
@@ -3376,6 +3395,107 @@ var cp_amm_default = {
         }
       ]
     },
+    {
+      name: "split_position2",
+      discriminator: [
+        221,
+        147,
+        228,
+        207,
+        140,
+        212,
+        17,
+        119
+      ],
+      accounts: [
+        {
+          name: "pool",
+          writable: true,
+          relations: [
+            "first_position",
+            "second_position"
+          ]
+        },
+        {
+          name: "first_position",
+          docs: [
+            "The first position"
+          ],
+          writable: true
+        },
+        {
+          name: "first_position_nft_account",
+          docs: [
+            "The token account for position nft"
+          ]
+        },
+        {
+          name: "second_position",
+          docs: [
+            "The second position"
+          ],
+          writable: true
+        },
+        {
+          name: "second_position_nft_account",
+          docs: [
+            "The token account for position nft"
+          ]
+        },
+        {
+          name: "first_owner",
+          docs: [
+            "Owner of first position"
+          ],
+          signer: true
+        },
+        {
+          name: "second_owner",
+          docs: [
+            "Owner of second position"
+          ],
+          signer: true
+        },
+        {
+          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: "numerator",
+          type: "u32"
+        }
+      ]
+    },
     {
       name: "swap",
       discriminator: [
@@ -3517,6 +3637,147 @@ var cp_amm_default = {
         }
       ]
     },
+    {
+      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"
+            }
+          }
+        }
+      ]
+    },
     {
       name: "update_reward_duration",
       discriminator: [
@@ -4016,6 +4277,19 @@ var cp_amm_default = {
         249
       ]
     },
+    {
+      name: "EvtLiquidityChange",
+      discriminator: [
+        197,
+        171,
+        78,
+        127,
+        224,
+        211,
+        87,
+        13
+      ]
+    },
     {
       name: "EvtLockPosition",
       discriminator: [
@@ -4069,20 +4343,20 @@ var cp_amm_default = {
       ]
     },
     {
-      name: "EvtSplitPosition",
+      name: "EvtSplitPosition2",
       discriminator: [
-        182,
-        138,
-        42,
-        254,
-        27,
-        94,
-        82,
-        221
-      ]
-    },
-    {
-      name: "EvtSwap",
+        165,
+        32,
+        203,
+        174,
+        72,
+        100,
+        233,
+        103
+      ]
+    },
+    {
+      name: "EvtSwap",
       discriminator: [
         27,
         60,
@@ -4094,6 +4368,19 @@ var cp_amm_default = {
         147
       ]
     },
+    {
+      name: "EvtSwap2",
+      discriminator: [
+        189,
+        66,
+        51,
+        168,
+        38,
+        80,
+        117,
+        153
+      ]
+    },
     {
       name: "EvtUpdateRewardDuration",
       discriminator: [
@@ -4369,6 +4656,36 @@ var cp_amm_default = {
       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: [
@@ -4415,7 +4732,7 @@ var cp_amm_default = {
             type: "u64"
           },
           {
-            name: "fee_scheduler_mode",
+            name: "base_fee_mode",
             type: "u8"
           },
           {
@@ -4428,15 +4745,20 @@ var cp_amm_default = {
             }
           },
           {
-            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"
           }
         ]
@@ -4452,19 +4774,24 @@ var cp_amm_default = {
             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"
           }
         ]
@@ -4484,7 +4811,7 @@ var cp_amm_default = {
             type: "u64"
           },
           {
-            name: "fee_scheduler_mode",
+            name: "base_fee_mode",
             type: "u8"
           },
           {
@@ -4497,15 +4824,20 @@ var cp_amm_default = {
             }
           },
           {
-            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"
           },
           {
@@ -5344,6 +5676,66 @@ var cp_amm_default = {
         ]
       }
     },
+    {
+      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: {
@@ -5465,7 +5857,7 @@ var cp_amm_default = {
       }
     },
     {
-      name: "EvtSplitPosition",
+      name: "EvtSplitPosition2",
       type: {
         kind: "struct",
         fields: [
@@ -5521,7 +5913,7 @@ var cp_amm_default = {
             name: "split_position_parameters",
             type: {
               defined: {
-                name: "SplitPositionParameters"
+                name: "SplitPositionParameters2"
               }
             }
           }
@@ -5572,6 +5964,70 @@ var cp_amm_default = {
         ]
       }
     },
+    {
+      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: {
@@ -5922,17 +6378,19 @@ var cp_amm_default = {
             ],
             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",
@@ -6665,6 +7123,38 @@ var cp_amm_default = {
         ]
       }
     },
+    {
+      name: "SplitPositionParameters2",
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "unlocked_liquidity_numerator",
+            type: "u32"
+          },
+          {
+            name: "permanent_locked_liquidity_numerator",
+            type: "u32"
+          },
+          {
+            name: "fee_a_numerator",
+            type: "u32"
+          },
+          {
+            name: "fee_b_numerator",
+            type: "u32"
+          },
+          {
+            name: "reward_0_numerator",
+            type: "u32"
+          },
+          {
+            name: "reward_1_numerator",
+            type: "u32"
+          }
+        ]
+      }
+    },
     {
       name: "StaticConfigParameters",
       type: {
@@ -6721,6 +7211,35 @@ var cp_amm_default = {
         ]
       }
     },
+    {
+      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: [
@@ -6757,34 +7276,78 @@ var cp_amm_default = {
       }
     },
     {
-      name: "TokenBadge",
-      docs: [
-        "Parameter that set by the protocol"
-      ],
-      serialization: "bytemuck",
-      repr: {
-        kind: "c"
-      },
+      name: "SwapResult2",
       type: {
         kind: "struct",
         fields: [
           {
-            name: "token_mint",
-            docs: [
-              "token mint"
-            ],
-            type: "pubkey"
+            name: "included_fee_input_amount",
+            type: "u64"
           },
           {
-            name: "_padding",
-            docs: [
-              "Reserve"
-            ],
-            type: {
-              array: [
-                "u8",
-                128
-              ]
+            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: [
+        "Parameter that set by the protocol"
+      ],
+      serialization: "bytemuck",
+      repr: {
+        kind: "c"
+      },
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "token_mint",
+            docs: [
+              "token mint"
+            ],
+            type: "pubkey"
+          },
+          {
+            name: "_padding",
+            docs: [
+              "Reserve"
+            ],
+            type: {
+              array: [
+                "u8",
+                128
+              ]
             }
           }
         ]
@@ -6922,7 +7485,8 @@ var cp_amm_default = {
 // src/CpAmm.ts
 import {
   Transaction,
-  SystemProgram as SystemProgram2
+  SystemProgram as SystemProgram2,
+  SYSVAR_INSTRUCTIONS_PUBKEY
 } from "@solana/web3.js";
 
 // src/types.ts
@@ -6936,51 +7500,85 @@ var ActivationPoint = /* @__PURE__ */ ((ActivationPoint2) => {
   ActivationPoint2[ActivationPoint2["Slot"] = 1] = "Slot";
   return ActivationPoint2;
 })(ActivationPoint || {});
-var FeeSchedulerMode = /* @__PURE__ */ ((FeeSchedulerMode2) => {
-  FeeSchedulerMode2[FeeSchedulerMode2["Linear"] = 0] = "Linear";
-  FeeSchedulerMode2[FeeSchedulerMode2["Exponential"] = 1] = "Exponential";
-  return FeeSchedulerMode2;
-})(FeeSchedulerMode || {});
-var CollectFeeMode = /* @__PURE__ */ ((CollectFeeMode2) => {
-  CollectFeeMode2[CollectFeeMode2["BothToken"] = 0] = "BothToken";
-  CollectFeeMode2[CollectFeeMode2["OnlyB"] = 1] = "OnlyB";
-  return CollectFeeMode2;
+var BaseFeeMode = /* @__PURE__ */ ((BaseFeeMode3) => {
+  BaseFeeMode3[BaseFeeMode3["FeeSchedulerLinear"] = 0] = "FeeSchedulerLinear";
+  BaseFeeMode3[BaseFeeMode3["FeeSchedulerExponential"] = 1] = "FeeSchedulerExponential";
+  BaseFeeMode3[BaseFeeMode3["RateLimiter"] = 2] = "RateLimiter";
+  return BaseFeeMode3;
+})(BaseFeeMode || {});
+var CollectFeeMode = /* @__PURE__ */ ((CollectFeeMode3) => {
+  CollectFeeMode3[CollectFeeMode3["BothToken"] = 0] = "BothToken";
+  CollectFeeMode3[CollectFeeMode3["OnlyB"] = 1] = "OnlyB";
+  return CollectFeeMode3;
 })(CollectFeeMode || {});
-var TradeDirection = /* @__PURE__ */ ((TradeDirection2) => {
-  TradeDirection2[TradeDirection2["AtoB"] = 0] = "AtoB";
-  TradeDirection2[TradeDirection2["BtoA"] = 1] = "BtoA";
-  return TradeDirection2;
+var TradeDirection = /* @__PURE__ */ ((TradeDirection3) => {
+  TradeDirection3[TradeDirection3["AtoB"] = 0] = "AtoB";
+  TradeDirection3[TradeDirection3["BtoA"] = 1] = "BtoA";
+  return TradeDirection3;
 })(TradeDirection || {});
-var ActivationType = /* @__PURE__ */ ((ActivationType2) => {
-  ActivationType2[ActivationType2["Slot"] = 0] = "Slot";
-  ActivationType2[ActivationType2["Timestamp"] = 1] = "Timestamp";
-  return ActivationType2;
+var ActivationType = /* @__PURE__ */ ((ActivationType3) => {
+  ActivationType3[ActivationType3["Slot"] = 0] = "Slot";
+  ActivationType3[ActivationType3["Timestamp"] = 1] = "Timestamp";
+  return ActivationType3;
 })(ActivationType || {});
+var PoolVersion = /* @__PURE__ */ ((PoolVersion5) => {
+  PoolVersion5[PoolVersion5["V0"] = 0] = "V0";
+  PoolVersion5[PoolVersion5["V1"] = 1] = "V1";
+  return PoolVersion5;
+})(PoolVersion || {});
+var PoolStatus = /* @__PURE__ */ ((PoolStatus2) => {
+  PoolStatus2[PoolStatus2["Enable"] = 0] = "Enable";
+  PoolStatus2[PoolStatus2["Disable"] = 1] = "Disable";
+  return PoolStatus2;
+})(PoolStatus || {});
+var SwapMode = /* @__PURE__ */ ((SwapMode2) => {
+  SwapMode2[SwapMode2["ExactIn"] = 0] = "ExactIn";
+  SwapMode2[SwapMode2["PartialFill"] = 1] = "PartialFill";
+  SwapMode2[SwapMode2["ExactOut"] = 2] = "ExactOut";
+  return SwapMode2;
+})(SwapMode || {});
 
 // src/pda.ts
 import { PublicKey as PublicKey2 } from "@solana/web3.js";
 
 // src/constants.ts
-import { BN } from "@coral-xyz/anchor";
 import { PublicKey } from "@solana/web3.js";
+import BN from "bn.js";
 var CP_AMM_PROGRAM_ID = new PublicKey(
   "cpamdpZCGKUy5JxQXB4dcpGPiikHawvSWAd6mEn1sGG"
 );
 var LIQUIDITY_SCALE = 128;
 var SCALE_OFFSET = 64;
 var BASIS_POINT_MAX = 1e4;
-var MAX_FEE_NUMERATOR = 5e8;
 var FEE_DENOMINATOR = 1e9;
+var ONE_Q64 = new BN(1).shln(SCALE_OFFSET);
+var MAX_EXPONENTIAL = new BN(524288);
+var MAX = new BN(2).pow(new BN(128)).sub(new BN(1));
+var MIN_FEE_BPS = 1;
+var MIN_FEE_NUMERATOR = 1e5;
+var MAX_FEE_BPS_V0 = 5e3;
+var MAX_FEE_NUMERATOR_V0 = 5e8;
+var MAX_FEE_BPS_V1 = 9900;
+var MAX_FEE_NUMERATOR_V1 = 99e7;
 var MIN_SQRT_PRICE = new BN("4295048016");
 var MAX_SQRT_PRICE = new BN("79226673521066979257578248091");
 var MIN_CU_BUFFER = 5e4;
 var MAX_CU_BUFFER = 2e5;
+var DYNAMIC_FEE_SCALING_FACTOR = new BN(1e11);
+var DYNAMIC_FEE_ROUNDING_OFFSET = new BN(99999999999);
 var DYNAMIC_FEE_FILTER_PERIOD_DEFAULT = 10;
 var DYNAMIC_FEE_DECAY_PERIOD_DEFAULT = 120;
 var DYNAMIC_FEE_REDUCTION_FACTOR_DEFAULT = 5e3;
 var BIN_STEP_BPS_DEFAULT = 1;
 var BIN_STEP_BPS_U128_DEFAULT = new BN("1844674407370955");
 var MAX_PRICE_CHANGE_BPS_DEFAULT = 1500;
+var U128_MAX = new BN("340282366920938463463374607431768211455");
+var U64_MAX = new BN("18446744073709551615");
+var U16_MAX = 65535;
+var MAX_RATE_LIMITER_DURATION_IN_SECONDS = 43200;
+var MAX_RATE_LIMITER_DURATION_IN_SLOTS = 108e3;
+var SPLIT_POSITION_DENOMINATOR = 1e9;
+var CURRENT_POOL_VERSION = 0 /* V0 */;
 
 // src/pda.ts
 function getFirstKey(key1, key2) {
@@ -7211,877 +7809,2153 @@ function getAllPositionNftAccountByOwner(connection, user) {
   });
 }
 
-// src/helpers/fee.ts
-import { BN as BN5 } from "@coral-xyz/anchor";
-
-// src/math/feeMath.ts
-import { BN as BN2 } from "@coral-xyz/anchor";
-var MAX_EXPONENTIAL = new BN2(524288);
-var ONE = new BN2(1).shln(SCALE_OFFSET);
-var MAX = new BN2(2).pow(new BN2(128)).sub(new BN2(1));
-function pow(base, exp) {
-  let invert = exp.isNeg();
-  if (exp.isZero()) {
-    return ONE;
-  }
-  exp = invert ? exp.abs() : exp;
-  if (exp.gt(MAX_EXPONENTIAL)) {
-    return new BN2(0);
-  }
-  let squaredBase = base;
-  let result = ONE;
-  if (squaredBase.gte(result)) {
-    squaredBase = MAX.div(squaredBase);
-    invert = !invert;
-  }
-  if (!exp.and(new BN2(1)).isZero()) {
-    result = result.mul(squaredBase).shrn(SCALE_OFFSET);
-  }
-  squaredBase = squaredBase.mul(squaredBase).shrn(SCALE_OFFSET);
-  if (!exp.and(new BN2(2)).isZero()) {
-    result = result.mul(squaredBase).shrn(SCALE_OFFSET);
-  }
-  squaredBase = squaredBase.mul(squaredBase).shrn(SCALE_OFFSET);
-  if (!exp.and(new BN2(4)).isZero()) {
-    result = result.mul(squaredBase).shrn(SCALE_OFFSET);
-  }
-  squaredBase = squaredBase.mul(squaredBase).shrn(SCALE_OFFSET);
-  if (!exp.and(new BN2(8)).isZero()) {
-    result = result.mul(squaredBase).shrn(SCALE_OFFSET);
-  }
-  squaredBase = squaredBase.mul(squaredBase).shrn(SCALE_OFFSET);
-  if (!exp.and(new BN2(16)).isZero()) {
-    result = result.mul(squaredBase).shrn(SCALE_OFFSET);
-  }
-  squaredBase = squaredBase.mul(squaredBase).shrn(SCALE_OFFSET);
-  if (!exp.and(new BN2(32)).isZero()) {
-    result = result.mul(squaredBase).shrn(SCALE_OFFSET);
-  }
-  squaredBase = squaredBase.mul(squaredBase).shrn(SCALE_OFFSET);
-  if (!exp.and(new BN2(64)).isZero()) {
-    result = result.mul(squaredBase).shrn(SCALE_OFFSET);
-  }
-  squaredBase = squaredBase.mul(squaredBase).shrn(SCALE_OFFSET);
-  if (!exp.and(new BN2(128)).isZero()) {
-    result = result.mul(squaredBase).shrn(SCALE_OFFSET);
-  }
-  squaredBase = squaredBase.mul(squaredBase).shrn(SCALE_OFFSET);
-  if (!exp.and(new BN2(256)).isZero()) {
-    result = result.mul(squaredBase).shrn(SCALE_OFFSET);
-  }
-  squaredBase = squaredBase.mul(squaredBase).shrn(SCALE_OFFSET);
-  if (!exp.and(new BN2(512)).isZero()) {
-    result = result.mul(squaredBase).shrn(SCALE_OFFSET);
-  }
-  squaredBase = squaredBase.mul(squaredBase).shrn(SCALE_OFFSET);
-  if (!exp.and(new BN2(1024)).isZero()) {
-    result = result.mul(squaredBase).shrn(SCALE_OFFSET);
-  }
-  squaredBase = squaredBase.mul(squaredBase).shrn(SCALE_OFFSET);
-  if (!exp.and(new BN2(2048)).isZero()) {
-    result = result.mul(squaredBase).shrn(SCALE_OFFSET);
-  }
-  squaredBase = squaredBase.mul(squaredBase).shrn(SCALE_OFFSET);
-  if (!exp.and(new BN2(4096)).isZero()) {
-    result = result.mul(squaredBase).shrn(SCALE_OFFSET);
-  }
-  squaredBase = squaredBase.mul(squaredBase).shrn(SCALE_OFFSET);
-  if (!exp.and(new BN2(8192)).isZero()) {
-    result = result.mul(squaredBase).shrn(SCALE_OFFSET);
-  }
-  squaredBase = squaredBase.mul(squaredBase).shrn(SCALE_OFFSET);
-  if (!exp.and(new BN2(16384)).isZero()) {
-    result = result.mul(squaredBase).shrn(SCALE_OFFSET);
-  }
-  squaredBase = squaredBase.mul(squaredBase).shrn(SCALE_OFFSET);
-  if (!exp.and(new BN2(32768)).isZero()) {
-    result = result.mul(squaredBase).shrn(SCALE_OFFSET);
-  }
-  squaredBase = squaredBase.mul(squaredBase).shrn(SCALE_OFFSET);
-  if (!exp.and(new BN2(65536)).isZero()) {
-    result = result.mul(squaredBase).shrn(SCALE_OFFSET);
-  }
-  squaredBase = squaredBase.mul(squaredBase).shrn(SCALE_OFFSET);
-  if (!exp.and(new BN2(131072)).isZero()) {
-    result = result.mul(squaredBase).shrn(SCALE_OFFSET);
+// src/helpers/computeUnits.ts
+import {
+  ComputeBudgetProgram,
+  PublicKey as PublicKey4,
+  TransactionMessage,
+  VersionedTransaction
+} from "@solana/web3.js";
+var getSimulationComputeUnits = (connection, instructions, payer, lookupTables, commitment = "confirmed") => __async(void 0, null, function* () {
+  var _a, _b, _c;
+  const testInstructions = [
+    // Set an arbitrarily high number in simulation
+    // so we can be sure the transaction will succeed
+    // and get the real compute units used
+    ComputeBudgetProgram.setComputeUnitLimit({ units: 14e5 }),
+    ...instructions
+  ];
+  const testTransaction = new VersionedTransaction(
+    new TransactionMessage({
+      instructions: testInstructions,
+      payerKey: payer,
+      // RecentBlockhash can by any public key during simulation
+      // since 'replaceRecentBlockhash' is set to 'true' below
+      recentBlockhash: PublicKey4.default.toString()
+    }).compileToV0Message(lookupTables)
+  );
+  const rpcResponse = yield connection.simulateTransaction(testTransaction, {
+    replaceRecentBlockhash: true,
+    sigVerify: false,
+    commitment
+  });
+  if ((_a = rpcResponse == null ? void 0 : rpcResponse.value) == null ? void 0 : _a.err) {
+    const logs = ((_b = rpcResponse.value.logs) == null ? void 0 : _b.join("\n  \u2022 ")) || "No logs available";
+    throw new Error(
+      `Transaction simulation failed:
+  \u2022${logs}` + JSON.stringify((_c = rpcResponse == null ? void 0 : rpcResponse.value) == null ? void 0 : _c.err)
+    );
   }
-  squaredBase = squaredBase.mul(squaredBase).shrn(SCALE_OFFSET);
-  if (!exp.and(new BN2(262144)).isZero()) {
-    result = result.mul(squaredBase).shrn(SCALE_OFFSET);
+  return rpcResponse.value.unitsConsumed || null;
+});
+var getEstimatedComputeUnitUsageWithBuffer = (connection, instructions, feePayer, buffer) => __async(void 0, null, function* () {
+  if (!buffer) {
+    buffer = 0.1;
   }
-  if (result.isZero()) {
-    return new BN2(0);
+  buffer = Math.max(0, buffer);
+  buffer = Math.min(1, buffer);
+  const estimatedComputeUnitUsage = yield getSimulationComputeUnits(
+    connection,
+    instructions,
+    feePayer,
+    []
+  );
+  if (!estimatedComputeUnitUsage) {
+    return 0;
   }
-  if (invert) {
-    result = MAX.div(result);
+  let extraComputeUnitBuffer = estimatedComputeUnitUsage * buffer;
+  if (extraComputeUnitBuffer > MAX_CU_BUFFER) {
+    extraComputeUnitBuffer = MAX_CU_BUFFER;
+  } else if (extraComputeUnitBuffer < MIN_CU_BUFFER) {
+    extraComputeUnitBuffer = MIN_CU_BUFFER;
   }
-  return result;
-}
+  return estimatedComputeUnitUsage + extraComputeUnitBuffer;
+});
+var getEstimatedComputeUnitIxWithBuffer = (connection, instructions, feePayer, buffer) => __async(void 0, null, function* () {
+  const units = yield getEstimatedComputeUnitUsageWithBuffer(
+    connection,
+    instructions,
+    feePayer,
+    buffer
+  ).catch((error) => {
+    console.error("Error::getEstimatedComputeUnitUsageWithBuffer", error);
+    return 14e5;
+  });
+  return ComputeBudgetProgram.setComputeUnitLimit({ units });
+});
 
-// src/math/mathUtils.ts
-import { BN as BN3 } from "@coral-xyz/anchor";
+// src/helpers/utils.ts
+import { BN as BN2 } from "@coral-xyz/anchor";
 import Decimal from "decimal.js";
-function mulDiv(x, y, denominator, rounding) {
-  const { div, mod } = x.mul(y).divmod(denominator);
-  if (rounding == 0 /* Up */ && !mod.isZero()) {
-    return div.add(new BN3(1));
-  }
-  return div;
-}
-function q64ToDecimal(num, decimalPlaces) {
-  return new Decimal(num.toString()).div(Decimal.pow(2, 64)).toDecimalPlaces(decimalPlaces);
-}
-function decimalToQ64(num) {
-  return new BN3(num.mul(Decimal.pow(2, 64)).floor().toFixed());
-}
-
-// src/helpers/curve.ts
-import { BN as BN4 } from "@coral-xyz/anchor";
-function getNextSqrtPrice(amount, sqrtPrice, liquidity, aToB) {
+var getMaxAmountWithSlippage = (amount, rate) => {
+  const slippage = (100 + rate) / 100 * BASIS_POINT_MAX;
+  return amount.mul(new BN2(slippage)).div(new BN2(BASIS_POINT_MAX));
+};
+var getAmountWithSlippage = (amount, slippageBps, swapMode) => {
   let result;
-  if (aToB) {
-    const product = amount.mul(sqrtPrice);
-    const denominator = liquidity.add(product);
-    const numerator = liquidity.mul(sqrtPrice);
-    result = numerator.add(denominator.sub(new BN4(1))).div(denominator);
+  if (slippageBps > 0) {
+    if (swapMode === 2 /* ExactOut */) {
+      const slippageFactor = new BN2(BASIS_POINT_MAX + slippageBps);
+      result = amount.mul(slippageFactor).div(new BN2(BASIS_POINT_MAX));
+    } else {
+      const slippageFactor = new BN2(BASIS_POINT_MAX - slippageBps);
+      result = amount.mul(slippageFactor).div(new BN2(BASIS_POINT_MAX));
+    }
   } else {
-    const quotient = amount.shln(SCALE_OFFSET * 2).div(liquidity);
-    result = sqrtPrice.add(quotient);
-  }
-  return result;
-}
-function getLiquidityDeltaFromAmountA(amountA, lowerSqrtPrice, upperSqrtPrice) {
-  const product = amountA.mul(lowerSqrtPrice).mul(upperSqrtPrice);
-  const denominator = upperSqrtPrice.sub(lowerSqrtPrice);
-  return product.div(denominator);
-}
-function getLiquidityDeltaFromAmountB(amountB, lowerSqrtPrice, upperSqrtPrice) {
-  const denominator = upperSqrtPrice.sub(lowerSqrtPrice);
-  const product = amountB.shln(128);
-  return product.div(denominator);
-}
-function getAmountAFromLiquidityDelta(liquidity, currentSqrtPrice, maxSqrtPrice, rounding) {
-  const product = liquidity.mul(maxSqrtPrice.sub(currentSqrtPrice));
-  const denominator = currentSqrtPrice.mul(maxSqrtPrice);
-  if (rounding == 0 /* Up */) {
-    return product.add(denominator.sub(new BN4(1))).div(denominator);
-  }
-  return product.div(denominator);
-}
-function getAmountBFromLiquidityDelta(liquidity, currentSqrtPrice, minSqrtPrice, rounding) {
-  const one = new BN4(1).shln(128);
-  const deltaPrice = currentSqrtPrice.sub(minSqrtPrice);
-  const result = liquidity.mul(deltaPrice);
-  if (rounding == 0 /* Up */) {
-    return result.add(one.sub(new BN4(1))).div(one);
-  }
-  return result.shrn(128);
-}
-function getNextSqrtPriceFromAmountBRoundingUp(sqrtPrice, liquidity, amount) {
-  const quotient = amount.shln(128).add(liquidity).sub(new BN4(1)).div(liquidity);
-  const result = sqrtPrice.sub(quotient);
-  if (result.isNeg()) {
-    throw new Error("sqrt price cannot be negative");
+    result = amount;
   }
   return result;
-}
-function getNextSqrtPriceFromAmountARoundingDown(sqrtPrice, liquidity, amount) {
-  if (amount.isZero()) {
-    return sqrtPrice;
-  }
-  const product = amount.mul(sqrtPrice);
-  const denominator = liquidity.sub(product);
-  if (denominator.isNeg() || denominator.isZero()) {
-    throw new Error("Invalid denominator in sqrt price calculation");
+};
+var getPriceImpact = (amountIn, amountOut, currentSqrtPrice, aToB, tokenADecimal, tokenBDecimal) => {
+  if (amountIn.eq(new BN2(0))) {
+    return new Decimal(0);
   }
-  const numerator = liquidity.mul(sqrtPrice);
-  const result = numerator.div(denominator);
-  return result;
-}
-function getNextSqrtPriceFromOutput(sqrtPrice, liquidity, outAmount, isB) {
-  if (sqrtPrice.isZero()) {
-    throw new Error("sqrt price must be greater than 0");
+  if (amountOut.eq(new BN2(0))) {
+    throw new Error("Amount out must be greater than 0");
   }
-  if (isB) {
-    return getNextSqrtPriceFromAmountBRoundingUp(
+  const spotPrice = getPriceFromSqrtPrice(
+    currentSqrtPrice,
+    tokenADecimal,
+    tokenBDecimal
+  );
+  const executionPrice = new Decimal(amountIn.toString()).div(new Decimal(amountOut.toString())).mul(
+    Decimal.pow(
+      10,
+      aToB ? tokenBDecimal - tokenADecimal : tokenADecimal - tokenBDecimal
+    )
+  );
+  let priceImpact;
+  let actualExecutionPrice;
+  if (aToB) {
+    actualExecutionPrice = new Decimal(1).div(executionPrice);
+  } else {
+    actualExecutionPrice = executionPrice;
+  }
+  priceImpact = actualExecutionPrice.sub(spotPrice).abs().div(spotPrice).mul(100);
+  return priceImpact;
+};
+var getPriceChange = (nextSqrtPrice, currentSqrtPrice) => {
+  const diff = nextSqrtPrice.pow(new BN2(2)).sub(currentSqrtPrice.pow(new BN2(2))).abs();
+  return new Decimal(diff.toString()).div(new Decimal(currentSqrtPrice.pow(new BN2(2)).toString())).mul(100).toNumber();
+};
+var getPriceFromSqrtPrice = (sqrtPrice, tokenADecimal, tokenBDecimal) => {
+  const decimalSqrtPrice = new Decimal(sqrtPrice.toString());
+  const price = decimalSqrtPrice.mul(decimalSqrtPrice).mul(new Decimal(__pow(10, tokenADecimal - tokenBDecimal))).div(Decimal.pow(2, 128));
+  return price;
+};
+var getSqrtPriceFromPrice = (price, tokenADecimal, tokenBDecimal) => {
+  const decimalPrice = new Decimal(price);
+  const adjustedByDecimals = decimalPrice.div(
+    new Decimal(__pow(10, tokenADecimal - tokenBDecimal))
+  );
+  const sqrtValue = Decimal.sqrt(adjustedByDecimals);
+  const sqrtValueQ64 = sqrtValue.mul(Decimal.pow(2, 64));
+  return new BN2(sqrtValueQ64.floor().toFixed());
+};
+var getUnClaimReward = (poolState, positionState) => {
+  const totalPositionLiquidity = positionState.unlockedLiquidity.add(positionState.vestedLiquidity).add(positionState.permanentLockedLiquidity);
+  const feeAPerTokenStored = new BN2(
+    Buffer.from(poolState.feeAPerLiquidity).reverse()
+  ).sub(new BN2(Buffer.from(positionState.feeAPerTokenCheckpoint).reverse()));
+  const feeBPerTokenStored = new BN2(
+    Buffer.from(poolState.feeBPerLiquidity).reverse()
+  ).sub(new BN2(Buffer.from(positionState.feeBPerTokenCheckpoint).reverse()));
+  const feeA = totalPositionLiquidity.mul(feeAPerTokenStored).shrn(LIQUIDITY_SCALE);
+  const feeB = totalPositionLiquidity.mul(feeBPerTokenStored).shrn(LIQUIDITY_SCALE);
+  return {
+    feeTokenA: positionState.feeAPending.add(feeA),
+    feeTokenB: positionState.feeBPending.add(feeB),
+    rewards: positionState.rewardInfos.length > 0 ? positionState.rewardInfos.map((item) => item.rewardPendings) : []
+  };
+};
+
+// src/helpers/accountFilters.ts
+var positionByPoolFilter = (pool) => {
+  return {
+    memcmp: {
+      bytes: pool.toBase58(),
+      offset: 8
+    }
+  };
+};
+var vestingByPositionFilter = (position) => {
+  return {
+    memcmp: {
+      bytes: position.toBase58(),
+      offset: 8
+    }
+  };
+};
+
+// src/helpers/token2022.ts
+import { BN as BN3 } from "@coral-xyz/anchor";
+import {
+  calculateFee,
+  getEpochFee,
+  getTransferFeeConfig,
+  MAX_FEE_BASIS_POINTS
+} from "@solana/spl-token";
+function calculatePreFeeAmount(transferFee, postFeeAmount) {
+  if (postFeeAmount.isZero()) {
+    return new BN3(0);
+  }
+  if (transferFee.transferFeeBasisPoints === 0) {
+    return postFeeAmount;
+  }
+  const maximumFee = new BN3(transferFee.maximumFee.toString());
+  if (transferFee.transferFeeBasisPoints === MAX_FEE_BASIS_POINTS) {
+    return postFeeAmount.add(maximumFee);
+  }
+  const ONE_IN_BASIS_POINTS = new BN3(MAX_FEE_BASIS_POINTS);
+  const numerator = postFeeAmount.mul(ONE_IN_BASIS_POINTS);
+  const denominator = ONE_IN_BASIS_POINTS.sub(
+    new BN3(transferFee.transferFeeBasisPoints)
+  );
+  const rawPreFeeAmount = numerator.add(denominator).sub(new BN3(1)).div(denominator);
+  if (rawPreFeeAmount.sub(postFeeAmount).gte(maximumFee)) {
+    return postFeeAmount.add(maximumFee);
+  }
+  return rawPreFeeAmount;
+}
+function calculateInverseFee(transferFee, postFeeAmount) {
+  const preFeeAmount = calculatePreFeeAmount(transferFee, postFeeAmount);
+  return new BN3(
+    calculateFee(transferFee, BigInt(preFeeAmount.toString())).toString()
+  );
+}
+function calculateTransferFeeIncludedAmount(transferFeeExcludedAmount, mint, currentEpoch) {
+  if (transferFeeExcludedAmount.isZero()) {
+    return {
+      amount: new BN3(0),
+      transferFee: new BN3(0)
+    };
+  }
+  const transferFeeConfig = getTransferFeeConfig(mint);
+  if (transferFeeConfig === null) {
+    return {
+      amount: transferFeeExcludedAmount,
+      transferFee: new BN3(0)
+    };
+  }
+  const epochFee = getEpochFee(transferFeeConfig, BigInt(currentEpoch));
+  const transferFee = epochFee.transferFeeBasisPoints == MAX_FEE_BASIS_POINTS ? new BN3(epochFee.maximumFee.toString()) : calculateInverseFee(epochFee, transferFeeExcludedAmount);
+  const transferFeeIncludedAmount = transferFeeExcludedAmount.add(transferFee);
+  return {
+    amount: transferFeeIncludedAmount,
+    transferFee
+  };
+}
+function calculateTransferFeeExcludedAmount(transferFeeIncludedAmount, mint, currentEpoch) {
+  const transferFeeConfig = getTransferFeeConfig(mint);
+  if (transferFeeConfig === null) {
+    return {
+      amount: transferFeeIncludedAmount,
+      transferFee: new BN3(0)
+    };
+  }
+  const transferFeeIncludedAmountN = BigInt(
+    transferFeeIncludedAmount.toString()
+  );
+  const transferFee = calculateFee(
+    getEpochFee(transferFeeConfig, BigInt(currentEpoch)),
+    transferFeeIncludedAmountN
+  );
+  const transferFeeExcludedAmount = new BN3(
+    (transferFeeIncludedAmountN - transferFee).toString()
+  );
+  return {
+    amount: transferFeeExcludedAmount,
+    transferFee: new BN3(transferFee.toString())
+  };
+}
+
+// src/helpers/vestings.ts
+import { BN as BN4 } from "@coral-xyz/anchor";
+import { min } from "bn.js";
+function isVestingComplete(vestingData, currentPoint) {
+  const cliffPoint = vestingData.cliffPoint;
+  const periodFrequency = vestingData.periodFrequency;
+  const numberOfPeriods = vestingData.numberOfPeriod;
+  const endPoint = cliffPoint.add(periodFrequency.muln(numberOfPeriods));
+  return currentPoint.gte(endPoint);
+}
+function getTotalLockedLiquidity(vestingData) {
+  return vestingData.cliffUnlockLiquidity.add(
+    vestingData.liquidityPerPeriod.mul(new BN4(vestingData.numberOfPeriod))
+  );
+}
+function getAvailableVestingLiquidity(vestingData, currentPoint) {
+  const {
+    cliffPoint,
+    periodFrequency,
+    cliffUnlockLiquidity,
+    liquidityPerPeriod,
+    numberOfPeriod,
+    totalReleasedLiquidity
+  } = vestingData;
+  if (currentPoint.lt(cliffPoint)) {
+    return new BN4(0);
+  }
+  if (periodFrequency.isZero()) {
+    return cliffUnlockLiquidity;
+  }
+  let passedPeriod = new BN4(currentPoint).sub(cliffPoint).div(periodFrequency);
+  passedPeriod = min(passedPeriod, new BN4(numberOfPeriod));
+  const unlockedLiquidity = cliffUnlockLiquidity.add(
+    passedPeriod.mul(liquidityPerPeriod)
+  );
+  const availableReleasingLiquidity = unlockedLiquidity.sub(
+    totalReleasedLiquidity
+  );
+  return availableReleasingLiquidity;
+}
+
+// src/helpers/validation.ts
+import BN14 from "bn.js";
+
+// src/math/poolFees/baseFee.ts
+import BN9 from "bn.js";
+
+// src/math/poolFees/rateLimiter.ts
+import BN7 from "bn.js";
+
+// src/math/feeMath.ts
+import { BN as BN6 } from "@coral-xyz/anchor";
+
+// src/math/utilsMath.ts
+import Decimal2 from "decimal.js";
+import BN5 from "bn.js";
+function mulDiv(x, y, denominator, rounding) {
+  const { div, mod } = x.mul(y).divmod(denominator);
+  if (rounding == 0 /* Up */ && !mod.isZero()) {
+    return div.add(new BN5(1));
+  }
+  return div;
+}
+function q64ToDecimal(num, decimalPlaces) {
+  return new Decimal2(num.toString()).div(Decimal2.pow(2, 64)).toDecimalPlaces(decimalPlaces);
+}
+function decimalToQ64(num) {
+  return new BN5(num.mul(Decimal2.pow(2, 64)).floor().toFixed());
+}
+function sqrt(value) {
+  if (value.isZero()) {
+    return new BN5(0);
+  }
+  if (value.eq(new BN5(1))) {
+    return new BN5(1);
+  }
+  let x = value;
+  let y = value.add(new BN5(1)).div(new BN5(2));
+  while (y.lt(x)) {
+    x = y;
+    y = x.add(value.div(x)).div(new BN5(2));
+  }
+  return x;
+}
+function pow(base, exp) {
+  let invert = exp.isNeg();
+  if (exp.isZero()) {
+    return ONE_Q64;
+  }
+  exp = invert ? exp.abs() : exp;
+  if (exp.gt(MAX_EXPONENTIAL)) {
+    return new BN5(0);
+  }
+  let squaredBase = base;
+  let result = ONE_Q64;
+  if (squaredBase.gte(result)) {
+    squaredBase = MAX.div(squaredBase);
+    invert = !invert;
+  }
+  if (!exp.and(new BN5(1)).isZero()) {
+    result = result.mul(squaredBase).shrn(SCALE_OFFSET);
+  }
+  squaredBase = squaredBase.mul(squaredBase).shrn(SCALE_OFFSET);
+  if (!exp.and(new BN5(2)).isZero()) {
+    result = result.mul(squaredBase).shrn(SCALE_OFFSET);
+  }
+  squaredBase = squaredBase.mul(squaredBase).shrn(SCALE_OFFSET);
+  if (!exp.and(new BN5(4)).isZero()) {
+    result = result.mul(squaredBase).shrn(SCALE_OFFSET);
+  }
+  squaredBase = squaredBase.mul(squaredBase).shrn(SCALE_OFFSET);
+  if (!exp.and(new BN5(8)).isZero()) {
+    result = result.mul(squaredBase).shrn(SCALE_OFFSET);
+  }
+  squaredBase = squaredBase.mul(squaredBase).shrn(SCALE_OFFSET);
+  if (!exp.and(new BN5(16)).isZero()) {
+    result = result.mul(squaredBase).shrn(SCALE_OFFSET);
+  }
+  squaredBase = squaredBase.mul(squaredBase).shrn(SCALE_OFFSET);
+  if (!exp.and(new BN5(32)).isZero()) {
+    result = result.mul(squaredBase).shrn(SCALE_OFFSET);
+  }
+  squaredBase = squaredBase.mul(squaredBase).shrn(SCALE_OFFSET);
+  if (!exp.and(new BN5(64)).isZero()) {
+    result = result.mul(squaredBase).shrn(SCALE_OFFSET);
+  }
+  squaredBase = squaredBase.mul(squaredBase).shrn(SCALE_OFFSET);
+  if (!exp.and(new BN5(128)).isZero()) {
+    result = result.mul(squaredBase).shrn(SCALE_OFFSET);
+  }
+  squaredBase = squaredBase.mul(squaredBase).shrn(SCALE_OFFSET);
+  if (!exp.and(new BN5(256)).isZero()) {
+    result = result.mul(squaredBase).shrn(SCALE_OFFSET);
+  }
+  squaredBase = squaredBase.mul(squaredBase).shrn(SCALE_OFFSET);
+  if (!exp.and(new BN5(512)).isZero()) {
+    result = result.mul(squaredBase).shrn(SCALE_OFFSET);
+  }
+  squaredBase = squaredBase.mul(squaredBase).shrn(SCALE_OFFSET);
+  if (!exp.and(new BN5(1024)).isZero()) {
+    result = result.mul(squaredBase).shrn(SCALE_OFFSET);
+  }
+  squaredBase = squaredBase.mul(squaredBase).shrn(SCALE_OFFSET);
+  if (!exp.and(new BN5(2048)).isZero()) {
+    result = result.mul(squaredBase).shrn(SCALE_OFFSET);
+  }
+  squaredBase = squaredBase.mul(squaredBase).shrn(SCALE_OFFSET);
+  if (!exp.and(new BN5(4096)).isZero()) {
+    result = result.mul(squaredBase).shrn(SCALE_OFFSET);
+  }
+  squaredBase = squaredBase.mul(squaredBase).shrn(SCALE_OFFSET);
+  if (!exp.and(new BN5(8192)).isZero()) {
+    result = result.mul(squaredBase).shrn(SCALE_OFFSET);
+  }
+  squaredBase = squaredBase.mul(squaredBase).shrn(SCALE_OFFSET);
+  if (!exp.and(new BN5(16384)).isZero()) {
+    result = result.mul(squaredBase).shrn(SCALE_OFFSET);
+  }
+  squaredBase = squaredBase.mul(squaredBase).shrn(SCALE_OFFSET);
+  if (!exp.and(new BN5(32768)).isZero()) {
+    result = result.mul(squaredBase).shrn(SCALE_OFFSET);
+  }
+  squaredBase = squaredBase.mul(squaredBase).shrn(SCALE_OFFSET);
+  if (!exp.and(new BN5(65536)).isZero()) {
+    result = result.mul(squaredBase).shrn(SCALE_OFFSET);
+  }
+  squaredBase = squaredBase.mul(squaredBase).shrn(SCALE_OFFSET);
+  if (!exp.and(new BN5(131072)).isZero()) {
+    result = result.mul(squaredBase).shrn(SCALE_OFFSET);
+  }
+  squaredBase = squaredBase.mul(squaredBase).shrn(SCALE_OFFSET);
+  if (!exp.and(new BN5(262144)).isZero()) {
+    result = result.mul(squaredBase).shrn(SCALE_OFFSET);
+  }
+  if (result.isZero()) {
+    return new BN5(0);
+  }
+  if (invert) {
+    result = MAX.div(result);
+  }
+  return result;
+}
+
+// src/math/feeMath.ts
+function toNumerator(bps, feeDenominator) {
+  try {
+    const numerator = mulDiv(
+      bps,
+      feeDenominator,
+      new BN6(BASIS_POINT_MAX),
+      1 /* Down */
+    );
+    return numerator;
+  } catch (error) {
+    throw new Error("Type cast failed or calculation overflow in toNumerator");
+  }
+}
+function getFeeInPeriod(cliffFeeNumerator, reductionFactor, passedPeriod) {
+  if (reductionFactor.isZero()) {
+    return cliffFeeNumerator;
+  }
+  const bps = reductionFactor.shln(SCALE_OFFSET).div(new BN6(BASIS_POINT_MAX));
+  const base = ONE_Q64.sub(bps);
+  const result = pow(base, new BN6(passedPeriod));
+  if (result.gt(U128_MAX)) {
+    throw new Error("Math overflow");
+  }
+  const fee = result.mul(cliffFeeNumerator).shrn(SCALE_OFFSET);
+  if (fee.gt(U64_MAX)) {
+    throw new Error("Type cast failed: fee does not fit in u64");
+  }
+  return fee;
+}
+function getFeeMode(collectFeeMode, tradeDirection, hasReferral) {
+  let feesOnInput;
+  let feesOnTokenA;
+  if (collectFeeMode === 0 /* BothToken */) {
+    if (tradeDirection === 0 /* AtoB */) {
+      feesOnInput = false;
+      feesOnTokenA = false;
+    } else {
+      feesOnInput = false;
+      feesOnTokenA = true;
+    }
+  } else {
+    if (tradeDirection === 0 /* AtoB */) {
+      feesOnInput = false;
+      feesOnTokenA = false;
+    } else {
+      feesOnInput = true;
+      feesOnTokenA = false;
+    }
+  }
+  return {
+    feesOnInput,
+    feesOnTokenA,
+    hasReferral
+  };
+}
+function getTotalFeeNumerator(poolFees, baseFeeNumerator, maxFeeNumerator) {
+  const dynamicFeeNumerator = getDynamicFeeNumerator(
+    poolFees.dynamicFee.volatilityAccumulator,
+    new BN6(poolFees.dynamicFee.binStep),
+    new BN6(poolFees.dynamicFee.variableFeeControl)
+  );
+  const totalFeeNumerator = dynamicFeeNumerator.add(baseFeeNumerator);
+  if (totalFeeNumerator.gt(U64_MAX)) {
+    throw new Error("Type cast failed: fee does not fit in u64");
+  }
+  if (totalFeeNumerator.gt(maxFeeNumerator)) {
+    return maxFeeNumerator;
+  } else {
+    return totalFeeNumerator;
+  }
+}
+function getTotalTradingFeeFromIncludedFeeAmount(poolFees, currentPoint, activationPoint, includedFeeAmount, tradeDirection, maxFeeNumerator) {
+  const baseFeeHandler = getBaseFeeHandler(
+    poolFees.baseFee.cliffFeeNumerator,
+    poolFees.baseFee.firstFactor,
+    poolFees.baseFee.secondFactor,
+    poolFees.baseFee.thirdFactor,
+    poolFees.baseFee.baseFeeMode
+  );
+  const baseFeeNumerator = baseFeeHandler.getBaseFeeNumeratorFromIncludedFeeAmount(
+    currentPoint,
+    activationPoint,
+    tradeDirection,
+    includedFeeAmount
+  );
+  return getTotalFeeNumerator(poolFees, baseFeeNumerator, maxFeeNumerator);
+}
+function getTotalTradingFeeFromExcludedFeeAmount(poolFees, currentPoint, activationPoint, excludedFeeAmount, tradeDirection, maxFeeNumerator) {
+  const baseFeeHandler = getBaseFeeHandler(
+    poolFees.baseFee.cliffFeeNumerator,
+    poolFees.baseFee.firstFactor,
+    poolFees.baseFee.secondFactor,
+    poolFees.baseFee.thirdFactor,
+    poolFees.baseFee.baseFeeMode
+  );
+  const baseFeeNumerator = baseFeeHandler.getBaseFeeNumeratorFromExcludedFeeAmount(
+    currentPoint,
+    activationPoint,
+    tradeDirection,
+    excludedFeeAmount
+  );
+  return getTotalFeeNumerator(poolFees, baseFeeNumerator, maxFeeNumerator);
+}
+function splitFees(poolFees, feeAmount, hasReferral, hasPartner2) {
+  const protocolFee = feeAmount.muln(poolFees.protocolFeePercent).divn(100);
+  const tradingFee = feeAmount.sub(protocolFee);
+  let referralFee = new BN6(0);
+  if (hasReferral) {
+    referralFee = protocolFee.muln(poolFees.referralFeePercent).divn(100);
+  }
+  const protocolFeeAfterReferral = protocolFee.sub(referralFee);
+  let partnerFee = new BN6(0);
+  if (hasPartner2 && poolFees.partnerFeePercent > 0) {
+    partnerFee = protocolFeeAfterReferral.muln(poolFees.partnerFeePercent).divn(100);
+  }
+  const finalProtocolFee = protocolFeeAfterReferral.sub(partnerFee);
+  return {
+    tradingFee,
+    protocolFee: finalProtocolFee,
+    referralFee,
+    partnerFee
+  };
+}
+function getFeeOnAmount(poolFees, amount, tradeFeeNumerator, hasReferral, hasPartner2) {
+  const { excludedFeeAmount, tradingFee } = getExcludedFeeAmount(
+    tradeFeeNumerator,
+    amount
+  );
+  const splitFeesResult = splitFees(
+    poolFees,
+    tradingFee,
+    hasReferral,
+    hasPartner2
+  );
+  return {
+    amount: excludedFeeAmount,
+    tradingFee: splitFeesResult.tradingFee,
+    protocolFee: splitFeesResult.protocolFee,
+    partnerFee: splitFeesResult.partnerFee,
+    referralFee: splitFeesResult.referralFee
+  };
+}
+function getExcludedFeeAmount(tradeFeeNumerator, includedFeeAmount) {
+  const tradingFee = mulDiv(
+    includedFeeAmount,
+    tradeFeeNumerator,
+    new BN6(FEE_DENOMINATOR),
+    0 /* Up */
+  );
+  const excludedFeeAmount = includedFeeAmount.sub(tradingFee);
+  return { excludedFeeAmount, tradingFee };
+}
+function getIncludedFeeAmount(tradeFeeNumerator, excludedFeeAmount) {
+  const denominator = new BN6(FEE_DENOMINATOR).sub(tradeFeeNumerator);
+  if (denominator.isZero() || denominator.isNeg()) {
+    throw new Error("Invalid fee numerator");
+  }
+  const includedFeeAmount = mulDiv(
+    excludedFeeAmount,
+    new BN6(FEE_DENOMINATOR),
+    denominator,
+    0 /* Up */
+  );
+  const feeAmount = includedFeeAmount.sub(excludedFeeAmount);
+  return { includedFeeAmount, feeAmount };
+}
+function getMaxFeeNumerator(poolVersion) {
+  switch (poolVersion) {
+    case 0 /* V0 */:
+      return new BN6(MAX_FEE_NUMERATOR_V0);
+    case 1 /* V1 */:
+      return new BN6(MAX_FEE_NUMERATOR_V1);
+    default:
+      throw new Error("Invalid pool version");
+  }
+}
+function getMaxFeeBps(poolVersion) {
+  switch (poolVersion) {
+    case 0 /* V0 */:
+      return MAX_FEE_BPS_V0;
+    case 1 /* V1 */:
+      return MAX_FEE_BPS_V1;
+    default:
+      throw new Error("Invalid pool version");
+  }
+}
+
+// src/math/poolFees/rateLimiter.ts
+function isZeroRateLimiter(referenceAmount, maxLimiterDuration, maxFeeBps, feeIncrementBps) {
+  return referenceAmount.isZero() && maxLimiterDuration === 0 && maxFeeBps === 0 && feeIncrementBps === 0;
+}
+function isNonZeroRateLimiter(referenceAmount, maxLimiterDuration, maxFeeBps, feeIncrementBps) {
+  return referenceAmount.isZero() && maxLimiterDuration !== 0 && maxFeeBps !== 0 && feeIncrementBps !== 0;
+}
+function isRateLimiterApplied(referenceAmount, maxLimiterDuration, maxFeeBps, feeIncrementBps, currentPoint, activationPoint, tradeDirection) {
+  if (isZeroRateLimiter(
+    referenceAmount,
+    maxLimiterDuration,
+    maxFeeBps,
+    feeIncrementBps
+  )) {
+    return false;
+  }
+  if (tradeDirection === 0 /* AtoB */) {
+    return false;
+  }
+  if (currentPoint.lt(activationPoint)) {
+    return false;
+  }
+  const lastEffectiveRateLimiterPoint = activationPoint.add(
+    new BN7(maxLimiterDuration)
+  );
+  if (currentPoint.gt(lastEffectiveRateLimiterPoint)) {
+    return false;
+  }
+  return true;
+}
+function getMaxIndex(maxFeeBps, cliffFeeNumerator, feeIncrementBps) {
+  const maxFeeNumerator = toNumerator(
+    new BN7(maxFeeBps),
+    new BN7(FEE_DENOMINATOR)
+  );
+  if (cliffFeeNumerator.gt(maxFeeNumerator)) {
+    throw new Error("cliffFeeNumerator cannot be greater than maxFeeNumerator");
+  }
+  const deltaNumerator = maxFeeNumerator.sub(cliffFeeNumerator);
+  const feeIncrementNumerator = toNumerator(
+    new BN7(feeIncrementBps),
+    new BN7(FEE_DENOMINATOR)
+  );
+  if (feeIncrementNumerator.isZero()) {
+    throw new Error("feeIncrementNumerator cannot be zero");
+  }
+  const maxIndex = deltaNumerator.div(feeIncrementNumerator);
+  return maxIndex;
+}
+function getFeeNumeratorFromIncludedFeeAmount(inputAmount, referenceAmount, cliffFeeNumerator, maxFeeBps, feeIncrementBps) {
+  if (inputAmount.lte(referenceAmount)) {
+    return cliffFeeNumerator;
+  } else {
+    const maxFeeNumerator = toNumerator(
+      new BN7(maxFeeBps),
+      new BN7(FEE_DENOMINATOR)
+    );
+    const c = cliffFeeNumerator;
+    const inputMinusRef = inputAmount.sub(referenceAmount);
+    const a = inputMinusRef.div(referenceAmount);
+    const b = inputMinusRef.mod(referenceAmount);
+    const maxIndex = getMaxIndex(maxFeeBps, cliffFeeNumerator, feeIncrementBps);
+    const i = toNumerator(new BN7(feeIncrementBps), new BN7(FEE_DENOMINATOR));
+    const x0 = referenceAmount;
+    const one = new BN7(1);
+    const two = new BN7(2);
+    let tradingFeeNumerator;
+    if (a.lt(maxIndex)) {
+      const numerator1 = c.add(c.mul(a)).add(i.mul(a).mul(a.add(one)).div(two));
+      const numerator2 = c.add(i.mul(a.add(one)));
+      const firstFee = x0.mul(numerator1);
+      const secondFee = b.mul(numerator2);
+      tradingFeeNumerator = firstFee.add(secondFee);
+    } else {
+      const numerator1 = c.add(c.mul(maxIndex)).add(i.mul(maxIndex).mul(maxIndex.add(one)).div(two));
+      const numerator2 = maxFeeNumerator;
+      const firstFee = x0.mul(numerator1);
+      const d = a.sub(maxIndex);
+      const leftAmount = d.mul(x0).add(b);
+      const secondFee = leftAmount.mul(numerator2);
+      tradingFeeNumerator = firstFee.add(secondFee);
+    }
+    const denominator = new BN7(FEE_DENOMINATOR);
+    const tradingFee = tradingFeeNumerator.add(denominator).sub(one).div(denominator);
+    const numerator = mulDiv(tradingFee, denominator, inputAmount, 0 /* Up */);
+    if (numerator.gt(new BN7(U64_MAX))) {
+      throw new Error("Numerator does not fit in u64");
+    }
+    return numerator;
+  }
+}
+function getExcludedFeeAmountFromIncludedFeeAmount(includedFeeAmount, referenceAmount, cliffFeeNumerator, maxFeeBps, feeIncrementBps) {
+  const feeNumerator = getFeeNumeratorFromIncludedFeeAmount(
+    includedFeeAmount,
+    referenceAmount,
+    cliffFeeNumerator,
+    maxFeeBps,
+    feeIncrementBps
+  );
+  const { excludedFeeAmount } = getExcludedFeeAmount(
+    feeNumerator,
+    includedFeeAmount
+  );
+  return excludedFeeAmount;
+}
+function getCheckedAmounts(referenceAmount, cliffFeeNumerator, maxFeeBps, feeIncrementBps) {
+  const maxIndex = getMaxIndex(maxFeeBps, cliffFeeNumerator, feeIncrementBps);
+  const x0 = referenceAmount;
+  const one = new BN7(1);
+  const maxIndexInputAmount = maxIndex.add(one).mul(x0);
+  if (maxIndexInputAmount.lte(U64_MAX)) {
+    const checkedIncludedFeeAmount = maxIndexInputAmount;
+    const checkedOutputAmount = getExcludedFeeAmountFromIncludedFeeAmount(
+      checkedIncludedFeeAmount,
+      referenceAmount,
+      cliffFeeNumerator,
+      maxFeeBps,
+      feeIncrementBps
+    );
+    return [checkedOutputAmount, checkedIncludedFeeAmount, false];
+  } else {
+    const checkedIncludedFeeAmount = U64_MAX;
+    const checkedOutputAmount = getExcludedFeeAmountFromIncludedFeeAmount(
+      checkedIncludedFeeAmount,
+      referenceAmount,
+      cliffFeeNumerator,
+      maxFeeBps,
+      feeIncrementBps
+    );
+    return [checkedOutputAmount, checkedIncludedFeeAmount, true];
+  }
+}
+function getFeeNumeratorFromExcludedFeeAmount(excludedFeeAmount, referenceAmount, cliffFeeNumerator, maxFeeBps, feeIncrementBps) {
+  const excludedFeeReferenceAmount = getExcludedFeeAmountFromIncludedFeeAmount(
+    referenceAmount,
+    referenceAmount,
+    cliffFeeNumerator,
+    maxFeeBps,
+    feeIncrementBps
+  );
+  if (excludedFeeAmount.lte(excludedFeeReferenceAmount)) {
+    return cliffFeeNumerator;
+  }
+  const [checkedExcludedFeeAmount, checkedIncludedFeeAmount, isOverflow] = getCheckedAmounts(
+    referenceAmount,
+    cliffFeeNumerator,
+    maxFeeBps,
+    feeIncrementBps
+  );
+  if (excludedFeeAmount.eq(checkedExcludedFeeAmount)) {
+    return getFeeNumeratorFromIncludedFeeAmount(
+      checkedIncludedFeeAmount,
+      referenceAmount,
+      cliffFeeNumerator,
+      maxFeeBps,
+      feeIncrementBps
+    );
+  }
+  let includedFeeAmount;
+  if (excludedFeeAmount.lt(checkedExcludedFeeAmount)) {
+    const TWO = new BN7(2);
+    const FOUR = new BN7(4);
+    const i = toNumerator(new BN7(feeIncrementBps), new BN7(FEE_DENOMINATOR));
+    const x0 = referenceAmount;
+    const d = new BN7(FEE_DENOMINATOR);
+    const c = cliffFeeNumerator;
+    const ex = excludedFeeAmount;
+    const x = i;
+    const y = TWO.mul(d).mul(x0).add(i.mul(x0)).sub(TWO.mul(c).mul(x0));
+    const z = TWO.mul(ex).mul(d).mul(x0);
+    const discriminant = y.mul(y).sub(FOUR.mul(x).mul(z));
+    const sqrtDiscriminant = sqrt(discriminant);
+    includedFeeAmount = y.sub(sqrtDiscriminant).div(TWO.mul(x));
+    const numerator = y.sub(sqrtDiscriminant);
+    const denominator = TWO.mul(x);
+    includedFeeAmount = numerator.div(denominator);
+    const aPlusOne = includedFeeAmount.div(x0);
+    const firstExcludedFeeAmount = getExcludedFeeAmountFromIncludedFeeAmount(
+      includedFeeAmount,
+      referenceAmount,
+      cliffFeeNumerator,
+      maxFeeBps,
+      feeIncrementBps
+    );
+    const excludedFeeRemainingAmount = excludedFeeAmount.sub(
+      firstExcludedFeeAmount
+    );
+    const remainingAmountFeeNumerator = c.add(i.mul(aPlusOne));
+    const { includedFeeAmount: includedFeeRemainingAmount } = getIncludedFeeAmount(
+      remainingAmountFeeNumerator,
+      excludedFeeRemainingAmount
+    );
+    includedFeeAmount = includedFeeAmount.add(includedFeeRemainingAmount);
+  } else {
+    if (isOverflow) {
+      throw new Error("Math overflow in getFeeNumeratorFromExcludedFeeAmount");
+    }
+    const excludedFeeRemainingAmount = excludedFeeAmount.sub(
+      checkedExcludedFeeAmount
+    );
+    const maxFeeNumerator = toNumerator(
+      new BN7(maxFeeBps),
+      new BN7(FEE_DENOMINATOR)
+    );
+    const { includedFeeAmount: includedFeeRemainingAmount } = getIncludedFeeAmount(maxFeeNumerator, excludedFeeRemainingAmount);
+    includedFeeAmount = includedFeeRemainingAmount.add(
+      checkedIncludedFeeAmount
+    );
+  }
+  const tradingFee = includedFeeAmount.sub(excludedFeeAmount);
+  const feeNumerator = mulDiv(
+    tradingFee,
+    new BN7(FEE_DENOMINATOR),
+    includedFeeAmount,
+    0 /* Up */
+  );
+  if (feeNumerator.lt(cliffFeeNumerator)) {
+    throw new Error("feeNumerator is less than cliffFeeNumerator");
+  }
+  return feeNumerator;
+}
+
+// src/math/poolFees/feeScheduler.ts
+import BN8 from "bn.js";
+function getMaxBaseFeeNumerator(cliffFeeNumerator) {
+  return cliffFeeNumerator;
+}
+function getMinBaseFeeNumerator(cliffFeeNumerator, numberOfPeriod, periodFrequency, reductionFactor, feeSchedulerMode) {
+  return getBaseFeeNumeratorByPeriod(
+    cliffFeeNumerator,
+    numberOfPeriod,
+    periodFrequency,
+    reductionFactor,
+    feeSchedulerMode
+  );
+}
+function getBaseFeeNumeratorByPeriod(cliffFeeNumerator, numberOfPeriod, period, reductionFactor, feeSchedulerMode) {
+  const periodValue = BN8.min(period, new BN8(numberOfPeriod));
+  const periodNumber = periodValue.toNumber();
+  if (periodNumber > U16_MAX) {
+    throw new Error("Math overflow");
+  }
+  switch (feeSchedulerMode) {
+    case 0 /* FeeSchedulerLinear */: {
+      const feeNumerator = getFeeNumeratorOnLinearFeeScheduler(
+        cliffFeeNumerator,
+        reductionFactor,
+        periodNumber
+      );
+      return feeNumerator;
+    }
+    case 1 /* FeeSchedulerExponential */: {
+      const feeNumerator = getFeeNumeratorOnExponentialFeeScheduler(
+        cliffFeeNumerator,
+        reductionFactor,
+        periodNumber
+      );
+      return feeNumerator;
+    }
+    default:
+      throw new Error("Invalid fee scheduler mode");
+  }
+}
+function getFeeNumeratorOnLinearFeeScheduler(cliffFeeNumerator, reductionFactor, period) {
+  const reduction = new BN8(period).mul(reductionFactor);
+  return cliffFeeNumerator.sub(reduction);
+}
+function getFeeNumeratorOnExponentialFeeScheduler(cliffFeeNumerator, reductionFactor, period) {
+  if (period === 0) {
+    return cliffFeeNumerator;
+  }
+  const basisPointMax = new BN8(BASIS_POINT_MAX);
+  const bps = new BN8(reductionFactor).shln(64).div(basisPointMax);
+  const base = ONE_Q64.sub(bps);
+  const result = pow(base, new BN8(period));
+  return cliffFeeNumerator.mul(result).div(ONE_Q64);
+}
+function getBaseFeeNumerator(cliffFeeNumerator, numberOfPeriod, periodFrequency, reductionFactor, feeSchedulerMode, currentPoint, activationPoint) {
+  if (periodFrequency.isZero()) {
+    return cliffFeeNumerator;
+  }
+  const period = currentPoint.sub(activationPoint).div(periodFrequency);
+  return getBaseFeeNumeratorByPeriod(
+    cliffFeeNumerator,
+    numberOfPeriod,
+    period,
+    reductionFactor,
+    feeSchedulerMode
+  );
+}
+
+// src/math/poolFees/baseFee.ts
+var FeeRateLimiter = class {
+  constructor(cliffFeeNumerator, feeIncrementBps, maxFeeBps, maxLimiterDuration, referenceAmount) {
+    this.cliffFeeNumerator = cliffFeeNumerator;
+    this.feeIncrementBps = feeIncrementBps;
+    this.maxFeeBps = maxFeeBps;
+    this.maxLimiterDuration = maxLimiterDuration;
+    this.referenceAmount = referenceAmount;
+  }
+  validate(collectFeeMode, activationType, poolVersion) {
+    return validateFeeRateLimiter(
+      this.cliffFeeNumerator,
+      this.feeIncrementBps,
+      this.maxFeeBps,
+      this.maxLimiterDuration,
+      this.referenceAmount,
+      collectFeeMode,
+      activationType,
+      poolVersion
+    );
+  }
+  getBaseFeeNumeratorFromIncludedFeeAmount(currentPoint, activationPoint, tradeDirection, includedFeeAmount) {
+    if (isRateLimiterApplied(
+      this.referenceAmount,
+      this.maxLimiterDuration,
+      this.maxFeeBps,
+      this.feeIncrementBps,
+      currentPoint,
+      activationPoint,
+      tradeDirection
+    )) {
+      return getFeeNumeratorFromIncludedFeeAmount(
+        includedFeeAmount,
+        this.referenceAmount,
+        this.cliffFeeNumerator,
+        this.maxFeeBps,
+        this.feeIncrementBps
+      );
+    } else {
+      return this.cliffFeeNumerator;
+    }
+  }
+  getBaseFeeNumeratorFromExcludedFeeAmount(currentPoint, activationPoint, tradeDirection, excludedFeeAmount) {
+    if (isRateLimiterApplied(
+      this.referenceAmount,
+      this.maxLimiterDuration,
+      this.maxFeeBps,
+      this.feeIncrementBps,
+      currentPoint,
+      activationPoint,
+      tradeDirection
+    )) {
+      return getFeeNumeratorFromExcludedFeeAmount(
+        excludedFeeAmount,
+        this.referenceAmount,
+        this.cliffFeeNumerator,
+        this.maxFeeBps,
+        this.feeIncrementBps
+      );
+    } else {
+      return this.cliffFeeNumerator;
+    }
+  }
+};
+var FeeScheduler = class {
+  constructor(cliffFeeNumerator, numberOfPeriod, periodFrequency, reductionFactor, feeSchedulerMode) {
+    this.cliffFeeNumerator = cliffFeeNumerator;
+    this.numberOfPeriod = numberOfPeriod;
+    this.periodFrequency = periodFrequency;
+    this.reductionFactor = reductionFactor;
+    this.feeSchedulerMode = feeSchedulerMode;
+  }
+  validate(collectFeeMode, activationType, poolVersion) {
+    return validateFeeScheduler(
+      this.numberOfPeriod,
+      this.periodFrequency,
+      this.reductionFactor,
+      this.cliffFeeNumerator,
+      this.feeSchedulerMode,
+      poolVersion
+    );
+  }
+  getBaseFeeNumeratorFromIncludedFeeAmount(currentPoint, activationPoint) {
+    return getBaseFeeNumerator(
+      this.cliffFeeNumerator,
+      this.numberOfPeriod,
+      this.periodFrequency,
+      this.reductionFactor,
+      this.feeSchedulerMode,
+      currentPoint,
+      activationPoint
+    );
+  }
+  getBaseFeeNumeratorFromExcludedFeeAmount(currentPoint, activationPoint) {
+    return getBaseFeeNumerator(
+      this.cliffFeeNumerator,
+      this.numberOfPeriod,
+      this.periodFrequency,
+      this.reductionFactor,
+      this.feeSchedulerMode,
+      currentPoint,
+      activationPoint
+    );
+  }
+};
+function getBaseFeeHandler(cliffFeeNumerator, firstFactor, secondFactor, thirdFactor, baseFeeMode) {
+  switch (baseFeeMode) {
+    case 0 /* FeeSchedulerLinear */:
+    case 1 /* FeeSchedulerExponential */: {
+      if (secondFactor.length < 8) {
+        throw new Error(
+          "TypeCastFailed: secondFactor must be at least 8 bytes"
+        );
+      }
+      const periodFrequency = new BN9(
+        Buffer.from(secondFactor.slice(0, 8)),
+        "le"
+      );
+      const feeScheduler = new FeeScheduler(
+        cliffFeeNumerator,
+        firstFactor,
+        periodFrequency,
+        thirdFactor,
+        baseFeeMode
+      );
+      return feeScheduler;
+    }
+    case 2 /* RateLimiter */: {
+      if (secondFactor.length < 8) {
+        throw new Error(
+          "TypeCastFailed: secondFactor must be at least 8 bytes"
+        );
+      }
+      const maxLimiterDuration = Buffer.from(
+        secondFactor.slice(0, 4)
+      ).readUInt32LE(0);
+      const maxFeeBps = Buffer.from(secondFactor.slice(4, 8)).readUInt32LE(0);
+      const feeRateLimiter = new FeeRateLimiter(
+        cliffFeeNumerator,
+        firstFactor,
+        maxLimiterDuration,
+        maxFeeBps,
+        thirdFactor
+      );
+      return feeRateLimiter;
+    }
+    default:
+      throw new Error("Invalid base fee mode");
+  }
+}
+
+// src/math/poolFees/dynamicFee.ts
+import BN10 from "bn.js";
+function isDynamicFeeEnabled(dynamicFee) {
+  return dynamicFee.initialized !== 0;
+}
+function getDynamicFeeNumerator(volatilityAccumulator, binStep, variableFeeControl) {
+  if (variableFeeControl.isZero()) {
+    return new BN10(0);
+  }
+  const squareVfaBin = volatilityAccumulator.mul(new BN10(binStep)).pow(new BN10(2));
+  const vFee = variableFeeControl.mul(squareVfaBin);
+  return vFee.add(new BN10(DYNAMIC_FEE_ROUNDING_OFFSET)).div(new BN10(DYNAMIC_FEE_SCALING_FACTOR));
+}
+
+// src/math/quote.ts
+import BN12 from "bn.js";
+
+// src/math/curve.ts
+import BN11 from "bn.js";
+function getNextSqrtPriceFromAmountInBRoundingDown(sqrtPrice, liquidity, amount) {
+  const quotient = amount.shln(SCALE_OFFSET * 2).div(liquidity);
+  const result = sqrtPrice.add(quotient);
+  return result;
+}
+function getNextSqrtPriceFromAmountOutBRoundingDown(sqrtPrice, liquidity, amount) {
+  const numerator = amount.shln(SCALE_OFFSET * 2);
+  const quotient = numerator.add(liquidity).subn(1).div(liquidity);
+  const result = sqrtPrice.sub(quotient);
+  if (result.isNeg()) {
+    throw new Error("sqrt price cannot be negative");
+  }
+  return result;
+}
+function getNextSqrtPriceFromAmountInARoundingUp(sqrtPrice, liquidity, amount) {
+  if (amount.isZero()) {
+    return sqrtPrice;
+  }
+  const product = amount.mul(sqrtPrice);
+  const denominator = liquidity.add(product);
+  const result = mulDiv(liquidity, sqrtPrice, denominator, 0 /* Up */);
+  return result;
+}
+function getNextSqrtPriceFromAmountOutARoundingUp(sqrtPrice, liquidity, amount) {
+  if (amount.isZero()) {
+    return sqrtPrice;
+  }
+  const product = amount.mul(sqrtPrice);
+  const denominator = liquidity.sub(product);
+  if (denominator.lte(new BN11(0))) {
+    throw new Error("MathOverflow: denominator is zero or negative");
+  }
+  return mulDiv(liquidity, sqrtPrice, denominator, 0 /* Up */);
+}
+function getNextSqrtPriceFromOutput(sqrtPrice, liquidity, amountOut, aForB) {
+  if (sqrtPrice.lte(new BN11(0))) {
+    throw new Error("sqrtPrice must be greater than 0");
+  }
+  if (liquidity.lte(new BN11(0))) {
+    throw new Error("liquidity must be greater than 0");
+  }
+  if (aForB) {
+    return getNextSqrtPriceFromAmountOutBRoundingDown(
       sqrtPrice,
       liquidity,
-      outAmount
+      amountOut
     );
   } else {
-    return getNextSqrtPriceFromAmountARoundingDown(
+    return getNextSqrtPriceFromAmountOutARoundingUp(
       sqrtPrice,
       liquidity,
-      outAmount
+      amountOut
     );
   }
 }
-
-// src/helpers/fee.ts
-import Decimal2 from "decimal.js";
-function getBaseFeeNumerator(feeSchedulerMode, cliffFeeNumerator, period, reductionFactor) {
-  let feeNumerator;
-  if (feeSchedulerMode == 0 /* Linear */) {
-    feeNumerator = cliffFeeNumerator.sub(period.mul(reductionFactor));
+function getNextSqrtPriceFromInput(sqrtPrice, liquidity, amountIn, aForB) {
+  if (sqrtPrice.lte(new BN11(0))) {
+    throw new Error("sqrtPrice must be greater than 0");
+  }
+  if (liquidity.lte(new BN11(0))) {
+    throw new Error("liquidity must be greater than 0");
+  }
+  if (aForB) {
+    return getNextSqrtPriceFromAmountInARoundingUp(
+      sqrtPrice,
+      liquidity,
+      amountIn
+    );
   } else {
-    const bps = reductionFactor.shln(SCALE_OFFSET).div(new BN5(BASIS_POINT_MAX));
-    const base = ONE.sub(bps);
-    const result = pow(base, period);
-    feeNumerator = cliffFeeNumerator.mul(result).shrn(SCALE_OFFSET);
+    return getNextSqrtPriceFromAmountInBRoundingDown(
+      sqrtPrice,
+      liquidity,
+      amountIn
+    );
   }
-  return feeNumerator;
 }
-function getDynamicFeeNumerator(volatilityAccumulator, binStep, variableFeeControl) {
-  if (variableFeeControl.isZero()) {
-    return new BN5(0);
+function getAmountBFromLiquidityDelta(lowerSqrtPrice, upperSqrtPrice, liquidity, rounding) {
+  const result = getDeltaAmountBUnsignedUnchecked(
+    lowerSqrtPrice,
+    upperSqrtPrice,
+    liquidity,
+    rounding
+  );
+  if (result.gt(U64_MAX)) {
+    throw new Error("MathOverflow: result exceeds u64 max");
   }
-  const squareVfaBin = volatilityAccumulator.mul(new BN5(binStep)).pow(new BN5(2));
-  const vFee = variableFeeControl.mul(squareVfaBin);
-  return vFee.add(new BN5(99999999999)).div(new BN5(1e11));
+  return result;
 }
-function getFeeNumerator(currentPoint, activationPoint, numberOfPeriod, periodFrequency, feeSchedulerMode, cliffFeeNumerator, reductionFactor, dynamicFeeParams) {
-  if (Number(periodFrequency) == 0 || new BN5(currentPoint).lt(activationPoint)) {
-    return cliffFeeNumerator;
+function getDeltaAmountBUnsignedUnchecked(lowerSqrtPrice, upperSqrtPrice, liquidity, rounding) {
+  const deltaSqrtPrice = upperSqrtPrice.sub(lowerSqrtPrice);
+  const prod = liquidity.mul(deltaSqrtPrice);
+  const shift = SCALE_OFFSET * 2;
+  if (rounding === 0 /* Up */) {
+    const denominator = new BN11(1).ushln(shift);
+    const result = prod.add(denominator.subn(1)).div(denominator);
+    return result;
+  } else {
+    const result = prod.ushrn(shift);
+    return result;
   }
-  const period = BN5.min(
-    new BN5(numberOfPeriod),
-    new BN5(currentPoint).sub(activationPoint).div(periodFrequency)
+}
+function getAmountAFromLiquidityDelta(lowerSqrtPrice, upperSqrtPrice, liquidity, rounding) {
+  const result = getDeltaAmountAUnsignedUnchecked(
+    lowerSqrtPrice,
+    upperSqrtPrice,
+    liquidity,
+    rounding
   );
-  let feeNumerator = getBaseFeeNumerator(
-    feeSchedulerMode,
-    cliffFeeNumerator,
-    period,
-    reductionFactor
+  if (result.gt(U64_MAX)) {
+    throw new Error("MathOverflow: result exceeds u64 max");
+  }
+  return result;
+}
+function getDeltaAmountAUnsignedUnchecked(lowerSqrtPrice, upperSqrtPrice, liquidity, rounding) {
+  const numerator1 = liquidity;
+  const numerator2 = upperSqrtPrice.sub(lowerSqrtPrice);
+  const denominator = lowerSqrtPrice.mul(upperSqrtPrice);
+  if (denominator.lte(new BN11(0))) {
+    throw new Error("Denominator must be greater than zero");
+  }
+  const result = mulDiv(numerator1, numerator2, denominator, rounding);
+  return result;
+}
+function getLiquidityDeltaFromAmountA(amountA, lowerSqrtPrice, upperSqrtPrice) {
+  const product = amountA.mul(lowerSqrtPrice).mul(upperSqrtPrice);
+  const denominator = upperSqrtPrice.sub(lowerSqrtPrice);
+  return product.div(denominator);
+}
+function getLiquidityDeltaFromAmountB(amountB, lowerSqrtPrice, upperSqrtPrice) {
+  const denominator = upperSqrtPrice.sub(lowerSqrtPrice);
+  const product = amountB.shln(128);
+  return product.div(denominator);
+}
+
+// src/math/quote.ts
+function getSwapResultFromExactInput(poolState, amountIn, feeMode, tradeDirection, currentPoint) {
+  let actualProtocolFee = new BN12(0);
+  let actualTradingFee = new BN12(0);
+  let actualReferralFee = new BN12(0);
+  let actualPartnerFee = new BN12(0);
+  const maxFeeNumerator = getMaxFeeNumerator(poolState.version);
+  const tradeFeeNumerator = getTotalTradingFeeFromIncludedFeeAmount(
+    poolState.poolFees,
+    currentPoint,
+    poolState.activationPoint,
+    amountIn,
+    tradeDirection,
+    maxFeeNumerator
   );
-  if (dynamicFeeParams) {
-    const { volatilityAccumulator, binStep, variableFeeControl } = dynamicFeeParams;
-    const dynamicFeeNumberator = getDynamicFeeNumerator(
-      volatilityAccumulator,
-      new BN5(binStep),
-      new BN5(variableFeeControl)
+  let actualAmountIn;
+  if (feeMode.feesOnInput) {
+    const { amount, tradingFee, protocolFee, partnerFee, referralFee } = getFeeOnAmount(
+      poolState.poolFees,
+      amountIn,
+      tradeFeeNumerator,
+      feeMode.hasReferral,
+      hasPartner(poolState.partner)
     );
-    feeNumerator = feeNumerator.add(dynamicFeeNumberator);
+    actualProtocolFee = protocolFee;
+    actualTradingFee = tradingFee;
+    actualReferralFee = referralFee;
+    actualPartnerFee = partnerFee;
+    actualAmountIn = amount;
+  } else {
+    actualAmountIn = amountIn;
+  }
+  let swapAmountFromInput;
+  if (tradeDirection === 0 /* AtoB */) {
+    swapAmountFromInput = calculateAtoBFromAmountIn(poolState, actualAmountIn);
+  } else {
+    swapAmountFromInput = calculateBtoAFromAmountIn(poolState, actualAmountIn);
+  }
+  const { outputAmount, nextSqrtPrice, amountLeft } = swapAmountFromInput;
+  let actualAmountOut;
+  if (feeMode.feesOnInput) {
+    actualAmountOut = outputAmount;
+  } else {
+    const { amount, tradingFee, protocolFee, partnerFee, referralFee } = getFeeOnAmount(
+      poolState.poolFees,
+      outputAmount,
+      tradeFeeNumerator,
+      feeMode.hasReferral,
+      hasPartner(poolState.partner)
+    );
+    actualProtocolFee = protocolFee;
+    actualTradingFee = tradingFee;
+    actualReferralFee = referralFee;
+    actualPartnerFee = partnerFee;
+    actualAmountOut = amount;
   }
-  return feeNumerator.gt(new BN5(MAX_FEE_NUMERATOR)) ? new BN5(MAX_FEE_NUMERATOR) : feeNumerator;
-}
-function getFeeMode(collectFeeMode, btoA) {
-  const feeOnInput = btoA && collectFeeMode === 1 /* OnlyB */;
-  const feesOnTokenA = btoA && collectFeeMode === 0 /* BothToken */;
   return {
-    feeOnInput,
-    feesOnTokenA
+    amountLeft,
+    includedFeeInputAmount: amountIn,
+    excludedFeeInputAmount: actualAmountIn,
+    outputAmount: actualAmountOut,
+    nextSqrtPrice,
+    tradingFee: actualTradingFee,
+    protocolFee: actualProtocolFee,
+    partnerFee: actualPartnerFee,
+    referralFee: actualReferralFee
   };
 }
-function getTotalFeeOnAmount(amount, tradeFeeNumerator) {
-  return mulDiv(
-    amount,
-    tradeFeeNumerator,
-    new BN5(FEE_DENOMINATOR),
-    0 /* Up */
-  );
-}
-function getSwapAmount(inAmount, sqrtPrice, liquidity, tradeFeeNumerator, aToB, collectFeeMode) {
-  let feeMode = getFeeMode(collectFeeMode, !aToB);
-  let actualInAmount = inAmount;
-  let totalFee = new BN5(0);
-  if (feeMode.feeOnInput) {
-    totalFee = getTotalFeeOnAmount(inAmount, tradeFeeNumerator);
-    actualInAmount = inAmount.sub(totalFee);
-  }
-  const nextSqrtPrice = getNextSqrtPrice(
-    actualInAmount,
-    sqrtPrice,
-    liquidity,
-    aToB
+function calculateAtoBFromAmountIn(poolState, amountIn) {
+  const nextSqrtPrice = getNextSqrtPriceFromInput(
+    poolState.sqrtPrice,
+    poolState.liquidity,
+    amountIn,
+    true
   );
-  const outAmount = aToB ? getAmountBFromLiquidityDelta(
-    liquidity,
-    sqrtPrice,
+  if (nextSqrtPrice.lt(poolState.sqrtMinPrice)) {
+    throw new Error("Price range is violated");
+  }
+  const outputAmount = getAmountBFromLiquidityDelta(
+    poolState.sqrtPrice,
     nextSqrtPrice,
+    poolState.liquidity,
     1 /* Down */
-  ) : getAmountAFromLiquidityDelta(
-    liquidity,
-    sqrtPrice,
+  );
+  return {
+    outputAmount,
+    nextSqrtPrice,
+    amountLeft: new BN12(0)
+  };
+}
+function calculateBtoAFromAmountIn(poolState, amountIn) {
+  const nextSqrtPrice = getNextSqrtPriceFromInput(
+    poolState.sqrtPrice,
+    poolState.liquidity,
+    amountIn,
+    false
+  );
+  if (nextSqrtPrice.gt(poolState.sqrtMaxPrice)) {
+    throw new Error("Price range is violated");
+  }
+  const outputAmount = getAmountAFromLiquidityDelta(
+    poolState.sqrtPrice,
     nextSqrtPrice,
+    poolState.liquidity,
     1 /* Down */
   );
-  const amountOut = feeMode.feeOnInput ? outAmount : (totalFee = getTotalFeeOnAmount(outAmount, tradeFeeNumerator), outAmount.sub(totalFee));
-  return { amountOut, totalFee, nextSqrtPrice };
-}
-function bpsToFeeNumerator(bps) {
-  return new BN5(bps * FEE_DENOMINATOR).divn(BASIS_POINT_MAX);
-}
-function feeNumeratorToBps(feeNumerator) {
-  return feeNumerator.muln(BASIS_POINT_MAX).div(new BN5(FEE_DENOMINATOR)).toNumber();
+  return {
+    outputAmount,
+    nextSqrtPrice,
+    amountLeft: new BN12(0)
+  };
 }
-function getBaseFeeParams(maxBaseFeeBps, minBaseFeeBps, feeSchedulerMode, numberOfPeriod, totalDuration) {
-  if (maxBaseFeeBps == minBaseFeeBps) {
-    if (numberOfPeriod != 0 || totalDuration != 0) {
-      throw new Error("numberOfPeriod and totalDuration must both be zero");
-    }
-    return {
-      cliffFeeNumerator: bpsToFeeNumerator(maxBaseFeeBps),
-      numberOfPeriod: 0,
-      periodFrequency: new BN5(0),
-      reductionFactor: new BN5(0),
-      feeSchedulerMode: 0
-    };
-  }
-  if (numberOfPeriod <= 0) {
-    throw new Error("Total periods must be greater than zero");
-  }
-  if (maxBaseFeeBps > feeNumeratorToBps(new BN5(MAX_FEE_NUMERATOR))) {
-    throw new Error(
-      `maxBaseFeeBps (${maxBaseFeeBps} bps) exceeds maximum allowed value of ${feeNumeratorToBps(
-        new BN5(MAX_FEE_NUMERATOR)
-      )} bps`
+function getSwapResultFromPartialInput(poolState, amountIn, feeMode, tradeDirection, currentPoint) {
+  let actualProtocolFee = new BN12(0);
+  let actualTradingFee = new BN12(0);
+  let actualReferralFee = new BN12(0);
+  let actualPartnerFee = new BN12(0);
+  const maxFeeNumerator = getMaxFeeNumerator(poolState.version);
+  const tradeFeeNumerator = getTotalTradingFeeFromIncludedFeeAmount(
+    poolState.poolFees,
+    currentPoint,
+    poolState.activationPoint,
+    amountIn,
+    tradeDirection,
+    maxFeeNumerator
+  );
+  let actualAmountIn;
+  if (feeMode.feesOnInput) {
+    const { amount, tradingFee, protocolFee, partnerFee, referralFee } = getFeeOnAmount(
+      poolState.poolFees,
+      amountIn,
+      tradeFeeNumerator,
+      feeMode.hasReferral,
+      hasPartner(poolState.partner)
     );
+    actualProtocolFee = protocolFee;
+    actualTradingFee = tradingFee;
+    actualReferralFee = referralFee;
+    actualPartnerFee = partnerFee;
+    actualAmountIn = amount;
+  } else {
+    actualAmountIn = amountIn;
   }
-  if (minBaseFeeBps > maxBaseFeeBps) {
-    throw new Error(
-      "minBaseFee bps must be less than or equal to maxBaseFee bps"
+  let swapAmountFromInput;
+  if (tradeDirection === 0 /* AtoB */) {
+    swapAmountFromInput = calculateAtoBFromPartialAmountIn(
+      poolState,
+      actualAmountIn
     );
-  }
-  if (numberOfPeriod == 0 || totalDuration == 0) {
-    throw new Error(
-      "numberOfPeriod and totalDuration must both greater than zero"
+  } else {
+    swapAmountFromInput = calculateBtoAFromPartialAmountIn(
+      poolState,
+      actualAmountIn
     );
   }
-  const maxBaseFeeNumerator = bpsToFeeNumerator(maxBaseFeeBps);
-  const minBaseFeeNumerator = bpsToFeeNumerator(minBaseFeeBps);
-  const periodFrequency = new BN5(totalDuration / numberOfPeriod);
-  let reductionFactor;
-  if (feeSchedulerMode == 0 /* Linear */) {
-    const totalReduction = maxBaseFeeNumerator.sub(minBaseFeeNumerator);
-    reductionFactor = totalReduction.divn(numberOfPeriod);
+  let { amountLeft, outputAmount, nextSqrtPrice } = swapAmountFromInput;
+  let includedFeeInputAmount;
+  if (amountLeft.gt(new BN12(0))) {
+    actualAmountIn = actualAmountIn.sub(amountLeft);
+    if (feeMode.feesOnInput) {
+      const tradeFeeNumerator2 = getTotalTradingFeeFromExcludedFeeAmount(
+        poolState.poolFees,
+        currentPoint,
+        poolState.activationPoint,
+        actualAmountIn,
+        tradeDirection,
+        maxFeeNumerator
+      );
+      const { includedFeeAmount, feeAmount } = getIncludedFeeAmount(
+        tradeFeeNumerator2,
+        actualAmountIn
+      );
+      const { tradingFee, protocolFee, referralFee, partnerFee } = splitFees(
+        poolState.poolFees,
+        feeAmount,
+        feeMode.hasReferral,
+        hasPartner(poolState.partner)
+      );
+      actualProtocolFee = protocolFee;
+      actualTradingFee = tradingFee;
+      actualReferralFee = referralFee;
+      actualPartnerFee = partnerFee;
+      includedFeeInputAmount = includedFeeAmount;
+    } else {
+      includedFeeInputAmount = actualAmountIn;
+    }
   } else {
-    const ratio = minBaseFeeNumerator.toNumber() / maxBaseFeeNumerator.toNumber();
-    const decayBase = Math.pow(ratio, 1 / numberOfPeriod);
-    reductionFactor = new BN5(BASIS_POINT_MAX * (1 - decayBase));
+    includedFeeInputAmount = amountIn;
   }
-  return {
-    cliffFeeNumerator: maxBaseFeeNumerator,
-    numberOfPeriod,
-    periodFrequency,
-    reductionFactor,
-    feeSchedulerMode
-  };
-}
-function getDynamicFeeParams(baseFeeBps, maxPriceChangeBps = MAX_PRICE_CHANGE_BPS_DEFAULT) {
-  if (maxPriceChangeBps > MAX_PRICE_CHANGE_BPS_DEFAULT) {
-    throw new Error(
-      `maxPriceChangeBps (${maxPriceChangeBps} bps) must be less than or equal to ${MAX_PRICE_CHANGE_BPS_DEFAULT}`
+  let actualAmountOut;
+  if (feeMode.feesOnInput) {
+    actualAmountOut = outputAmount;
+  } else {
+    const { amount, tradingFee, protocolFee, partnerFee, referralFee } = getFeeOnAmount(
+      poolState.poolFees,
+      outputAmount,
+      tradeFeeNumerator,
+      feeMode.hasReferral,
+      hasPartner(poolState.partner)
     );
+    actualProtocolFee = protocolFee;
+    actualTradingFee = tradingFee;
+    actualReferralFee = referralFee;
+    actualPartnerFee = partnerFee;
+    actualAmountOut = amount;
   }
-  const priceRatio = maxPriceChangeBps / BASIS_POINT_MAX + 1;
-  const sqrtPriceRatioQ64 = new BN5(
-    Decimal2.sqrt(priceRatio.toString()).mul(Decimal2.pow(2, 64)).floor().toFixed()
-  );
-  const deltaBinId = sqrtPriceRatioQ64.sub(ONE).div(BIN_STEP_BPS_U128_DEFAULT).muln(2);
-  const maxVolatilityAccumulator = new BN5(deltaBinId.muln(BASIS_POINT_MAX));
-  const squareVfaBin = maxVolatilityAccumulator.mul(new BN5(BIN_STEP_BPS_DEFAULT)).pow(new BN5(2));
-  const baseFeeNumerator = new BN5(bpsToFeeNumerator(baseFeeBps));
-  const maxDynamicFeeNumerator = baseFeeNumerator.muln(20).divn(100);
-  const vFee = maxDynamicFeeNumerator.mul(new BN5(1e11)).sub(new BN5(99999999999));
-  const variableFeeControl = vFee.div(squareVfaBin);
   return {
-    binStep: BIN_STEP_BPS_DEFAULT,
-    binStepU128: BIN_STEP_BPS_U128_DEFAULT,
-    filterPeriod: DYNAMIC_FEE_FILTER_PERIOD_DEFAULT,
-    decayPeriod: DYNAMIC_FEE_DECAY_PERIOD_DEFAULT,
-    reductionFactor: DYNAMIC_FEE_REDUCTION_FACTOR_DEFAULT,
-    maxVolatilityAccumulator: maxVolatilityAccumulator.toNumber(),
-    variableFeeControl: variableFeeControl.toNumber()
+    includedFeeInputAmount,
+    excludedFeeInputAmount: actualAmountIn,
+    amountLeft,
+    outputAmount: actualAmountOut,
+    nextSqrtPrice,
+    tradingFee: actualTradingFee,
+    protocolFee: actualProtocolFee,
+    partnerFee: actualPartnerFee,
+    referralFee: actualReferralFee
   };
 }
-function getExcludedFeeAmount(tradeFeeNumerator, includedFeeAmount) {
-  const tradingFee = mulDiv(
-    includedFeeAmount,
-    tradeFeeNumerator,
-    new BN5(FEE_DENOMINATOR),
-    0 /* Up */
-  );
-  const excludedFeeAmount = includedFeeAmount.sub(tradingFee);
-  return { excludedFeeAmount, tradingFee };
-}
-function getIncludedFeeAmount(tradeFeeNumerator, excludedFeeAmount) {
-  const denominator = new BN5(FEE_DENOMINATOR).sub(tradeFeeNumerator);
-  if (denominator.isZero() || denominator.isNeg()) {
-    throw new Error("Invalid fee numerator");
-  }
-  const includedFeeAmount = mulDiv(
-    excludedFeeAmount,
-    new BN5(FEE_DENOMINATOR),
-    denominator,
+function calculateAtoBFromPartialAmountIn(poolState, amountIn) {
+  const maxAmountIn = getAmountAFromLiquidityDelta(
+    poolState.sqrtMinPrice,
+    poolState.sqrtPrice,
+    poolState.liquidity,
     0 /* Up */
   );
-  const { excludedFeeAmount: inverseAmount } = getExcludedFeeAmount(
-    tradeFeeNumerator,
-    includedFeeAmount
-  );
-  if (inverseAmount.lt(excludedFeeAmount)) {
-    throw new Error("Inverse amount is less than excluded_fee_amount");
-  }
-  return includedFeeAmount;
-}
-function getInAmountFromAToB(pool, outAmount) {
-  const nextSqrtPrice = getNextSqrtPriceFromOutput(
-    pool.sqrtPrice,
-    pool.liquidity,
-    outAmount,
-    true
-  );
-  if (nextSqrtPrice.lt(pool.sqrtMinPrice)) {
-    throw new Error("Price range is violated");
+  let consumedInAmount;
+  let nextSqrtPrice;
+  if (amountIn.gte(maxAmountIn)) {
+    consumedInAmount = maxAmountIn;
+    nextSqrtPrice = poolState.sqrtMinPrice;
+  } else {
+    nextSqrtPrice = getNextSqrtPriceFromInput(
+      poolState.sqrtPrice,
+      poolState.liquidity,
+      amountIn,
+      true
+    );
+    consumedInAmount = amountIn;
   }
-  const outputAmount = getAmountAFromLiquidityDelta(
-    pool.liquidity,
+  const outputAmount = getAmountBFromLiquidityDelta(
     nextSqrtPrice,
-    pool.sqrtPrice,
-    0 /* Up */
+    poolState.sqrtPrice,
+    poolState.liquidity,
+    1 /* Down */
   );
+  const amountLeft = amountIn.sub(consumedInAmount);
   return {
     outputAmount,
-    nextSqrtPrice
+    nextSqrtPrice,
+    amountLeft
   };
 }
-function getInAmountFromBToA(pool, outAmount) {
-  const nextSqrtPrice = getNextSqrtPriceFromOutput(
-    pool.sqrtPrice,
-    pool.liquidity,
-    outAmount,
-    false
+function calculateBtoAFromPartialAmountIn(poolState, amountIn) {
+  const maxAmountIn = getAmountBFromLiquidityDelta(
+    poolState.sqrtPrice,
+    poolState.sqrtMaxPrice,
+    poolState.liquidity,
+    0 /* Up */
   );
-  if (nextSqrtPrice.gt(pool.sqrtMaxPrice)) {
-    throw new Error("Price range is violated");
+  let consumedInAmount;
+  let nextSqrtPrice;
+  if (amountIn.gte(maxAmountIn)) {
+    consumedInAmount = maxAmountIn;
+    nextSqrtPrice = poolState.sqrtMaxPrice;
+  } else {
+    nextSqrtPrice = getNextSqrtPriceFromInput(
+      poolState.sqrtPrice,
+      poolState.liquidity,
+      amountIn,
+      false
+    );
+    consumedInAmount = amountIn;
   }
-  const outputAmount = getAmountBFromLiquidityDelta(
-    pool.liquidity,
-    pool.sqrtPrice,
+  const outputAmount = getAmountAFromLiquidityDelta(
+    poolState.sqrtPrice,
     nextSqrtPrice,
-    0 /* Up */
+    poolState.liquidity,
+    1 /* Down */
   );
+  const amountLeft = amountIn.sub(consumedInAmount);
   return {
     outputAmount,
-    nextSqrtPrice
+    nextSqrtPrice,
+    amountLeft
   };
 }
-function getSwapResultFromOutAmount(pool, outAmount, feeMode, tradeDirection, currentPoint) {
-  let actualProtocolFee = new BN5(0);
-  let actualLpFee = new BN5(0);
-  let actualPartnerFee = new BN5(0);
-  let actualReferralFee = new BN5(0);
-  const tradeFeeNumerator = getFeeNumerator(
-    currentPoint,
-    pool.activationPoint,
-    pool.poolFees.baseFee.numberOfPeriod,
-    pool.poolFees.baseFee.periodFrequency,
-    pool.poolFees.baseFee.feeSchedulerMode,
-    pool.poolFees.baseFee.cliffFeeNumerator,
-    pool.poolFees.baseFee.reductionFactor,
-    pool.poolFees.dynamicFee.initialized === 1 ? {
-      volatilityAccumulator: pool.poolFees.dynamicFee.volatilityAccumulator,
-      binStep: pool.poolFees.dynamicFee.binStep,
-      variableFeeControl: pool.poolFees.dynamicFee.variableFeeControl
-    } : void 0
-  );
-  let includedFeeOutAmount;
-  if (feeMode.feeOnInput) {
-    includedFeeOutAmount = outAmount;
+function getSwapResultFromExactOutput(poolState, amountOut, feeMode, tradeDirection, currentPoint) {
+  let actualProtocolFee = new BN12(0);
+  let actualTradingFee = new BN12(0);
+  let actualReferralFee = new BN12(0);
+  let actualPartnerFee = new BN12(0);
+  const maxFeeNumerator = getMaxFeeNumerator(poolState.version);
+  let includedFeeAmountOut;
+  if (feeMode.feesOnInput) {
+    includedFeeAmountOut = amountOut;
   } else {
-    includedFeeOutAmount = getIncludedFeeAmount(tradeFeeNumerator, outAmount);
-    const totalFee = getTotalFeeOnAmount(outAmount, tradeFeeNumerator);
-    actualProtocolFee = mulDiv(
-      totalFee,
-      new BN5(pool.poolFees.protocolFeePercent),
-      new BN5(100),
-      1 /* Down */
-    );
-    if (feeMode.hasReferral) {
-      actualReferralFee = mulDiv(
-        actualProtocolFee,
-        new BN5(pool.poolFees.referralFeePercent),
-        new BN5(100),
-        1 /* Down */
-      );
-    }
-    const protocolFeeAfterReferral = actualProtocolFee.sub(actualReferralFee);
-    actualPartnerFee = mulDiv(
-      protocolFeeAfterReferral,
-      new BN5(pool.poolFees.partnerFeePercent),
-      new BN5(100),
-      1 /* Down */
+    const tradeFeeNumerator = getTotalTradingFeeFromExcludedFeeAmount(
+      poolState.poolFees,
+      currentPoint,
+      poolState.activationPoint,
+      amountOut,
+      tradeDirection,
+      maxFeeNumerator
     );
-    actualLpFee = totalFee.sub(actualProtocolFee).sub(actualPartnerFee);
-  }
-  const { outputAmount: excludedFeeInAmount, nextSqrtPrice } = tradeDirection === 0 /* AtoB */ ? getInAmountFromAToB(pool, includedFeeOutAmount) : getInAmountFromBToA(pool, includedFeeOutAmount);
-  let includedFeeInAmount;
-  if (feeMode.feeOnInput) {
-    includedFeeInAmount = getIncludedFeeAmount(
+    const { includedFeeAmount, feeAmount } = getIncludedFeeAmount(
       tradeFeeNumerator,
-      excludedFeeInAmount
+      amountOut
     );
-    const totalFee = getTotalFeeOnAmount(
-      includedFeeInAmount,
-      tradeFeeNumerator
+    const split = splitFees(
+      poolState.poolFees,
+      feeAmount,
+      feeMode.hasReferral,
+      hasPartner(poolState.partner)
     );
-    actualProtocolFee = mulDiv(
-      totalFee,
-      new BN5(pool.poolFees.protocolFeePercent),
-      new BN5(100),
-      1 /* Down */
+    actualTradingFee = split.tradingFee;
+    actualProtocolFee = split.protocolFee;
+    actualReferralFee = split.referralFee;
+    actualPartnerFee = split.partnerFee;
+    includedFeeAmountOut = includedFeeAmount;
+  }
+  let swapAmountFromOutput;
+  if (tradeDirection === 0 /* AtoB */) {
+    swapAmountFromOutput = calculateAtoBFromAmountOut(
+      poolState,
+      includedFeeAmountOut
     );
-    if (feeMode.hasReferral) {
-      actualReferralFee = mulDiv(
-        actualProtocolFee,
-        new BN5(pool.poolFees.referralFeePercent),
-        new BN5(100),
-        1 /* Down */
-      );
-    }
-    const protocolFeeAfterReferral = actualProtocolFee.sub(actualReferralFee);
-    actualPartnerFee = mulDiv(
-      protocolFeeAfterReferral,
-      new BN5(pool.poolFees.partnerFeePercent),
-      new BN5(100),
-      1 /* Down */
+  } else {
+    swapAmountFromOutput = calculateBtoAFromAmountOut(
+      poolState,
+      includedFeeAmountOut
+    );
+  }
+  const { inputAmount, nextSqrtPrice } = swapAmountFromOutput;
+  let includedFeeInputAmount;
+  if (feeMode.feesOnInput) {
+    const tradeFeeNumerator = getTotalTradingFeeFromExcludedFeeAmount(
+      poolState.poolFees,
+      currentPoint,
+      poolState.activationPoint,
+      inputAmount,
+      tradeDirection,
+      maxFeeNumerator
     );
-    actualLpFee = totalFee.sub(actualProtocolFee).sub(actualPartnerFee);
+    const { includedFeeAmount, feeAmount } = getIncludedFeeAmount(
+      tradeFeeNumerator,
+      inputAmount
+    );
+    const split = splitFees(
+      poolState.poolFees,
+      feeAmount,
+      feeMode.hasReferral,
+      hasPartner(poolState.partner)
+    );
+    actualTradingFee = split.tradingFee;
+    actualProtocolFee = split.protocolFee;
+    actualReferralFee = split.referralFee;
+    actualPartnerFee = split.partnerFee;
+    includedFeeInputAmount = includedFeeAmount;
   } else {
-    includedFeeInAmount = excludedFeeInAmount;
+    includedFeeInputAmount = inputAmount;
+  }
+  return {
+    amountLeft: new BN12(0),
+    includedFeeInputAmount,
+    excludedFeeInputAmount: inputAmount,
+    outputAmount: amountOut,
+    nextSqrtPrice,
+    tradingFee: actualTradingFee,
+    protocolFee: actualProtocolFee,
+    partnerFee: actualPartnerFee,
+    referralFee: actualReferralFee
+  };
+}
+function calculateAtoBFromAmountOut(poolState, amountOut) {
+  const nextSqrtPrice = getNextSqrtPriceFromOutput(
+    poolState.sqrtPrice,
+    poolState.liquidity,
+    amountOut,
+    true
+  );
+  if (nextSqrtPrice.lt(poolState.sqrtMinPrice)) {
+    throw new Error("Price Range Violation");
   }
+  const inputAmount = getAmountAFromLiquidityDelta(
+    nextSqrtPrice,
+    poolState.sqrtPrice,
+    poolState.liquidity,
+    0 /* Up */
+  );
   return {
-    swapResult: {
-      outputAmount: outAmount,
-      nextSqrtPrice,
-      lpFee: actualLpFee,
-      protocolFee: actualProtocolFee,
-      referralFee: actualReferralFee,
-      partnerFee: actualPartnerFee
-    },
-    inputAmount: includedFeeInAmount
+    inputAmount,
+    nextSqrtPrice
   };
 }
-
-// src/helpers/computeUnits.ts
-import {
-  ComputeBudgetProgram,
-  PublicKey as PublicKey4,
-  TransactionMessage,
-  VersionedTransaction
-} from "@solana/web3.js";
-var getSimulationComputeUnits = (connection, instructions, payer, lookupTables, commitment = "confirmed") => __async(void 0, null, function* () {
-  var _a, _b, _c;
-  const testInstructions = [
-    // Set an arbitrarily high number in simulation
-    // so we can be sure the transaction will succeed
-    // and get the real compute units used
-    ComputeBudgetProgram.setComputeUnitLimit({ units: 14e5 }),
-    ...instructions
-  ];
-  const testTransaction = new VersionedTransaction(
-    new TransactionMessage({
-      instructions: testInstructions,
-      payerKey: payer,
-      // RecentBlockhash can by any public key during simulation
-      // since 'replaceRecentBlockhash' is set to 'true' below
-      recentBlockhash: PublicKey4.default.toString()
-    }).compileToV0Message(lookupTables)
+function calculateBtoAFromAmountOut(poolState, amountOut) {
+  const nextSqrtPrice = getNextSqrtPriceFromOutput(
+    poolState.sqrtPrice,
+    poolState.liquidity,
+    amountOut,
+    false
   );
-  const rpcResponse = yield connection.simulateTransaction(testTransaction, {
-    replaceRecentBlockhash: true,
-    sigVerify: false,
-    commitment
-  });
-  if ((_a = rpcResponse == null ? void 0 : rpcResponse.value) == null ? void 0 : _a.err) {
-    const logs = ((_b = rpcResponse.value.logs) == null ? void 0 : _b.join("\n  \u2022 ")) || "No logs available";
-    throw new Error(
-      `Transaction simulation failed:
-  \u2022${logs}` + JSON.stringify((_c = rpcResponse == null ? void 0 : rpcResponse.value) == null ? void 0 : _c.err)
-    );
-  }
-  return rpcResponse.value.unitsConsumed || null;
-});
-var getEstimatedComputeUnitUsageWithBuffer = (connection, instructions, feePayer, buffer) => __async(void 0, null, function* () {
-  if (!buffer) {
-    buffer = 0.1;
+  if (nextSqrtPrice.gt(poolState.sqrtMaxPrice)) {
+    throw new Error("Price Range Violation");
   }
-  buffer = Math.max(0, buffer);
-  buffer = Math.min(1, buffer);
-  const estimatedComputeUnitUsage = yield getSimulationComputeUnits(
-    connection,
-    instructions,
-    feePayer,
-    []
+  const inputAmount = getAmountBFromLiquidityDelta(
+    poolState.sqrtPrice,
+    nextSqrtPrice,
+    poolState.liquidity,
+    0 /* Up */
   );
-  if (!estimatedComputeUnitUsage) {
-    return 0;
-  }
-  let extraComputeUnitBuffer = estimatedComputeUnitUsage * buffer;
-  if (extraComputeUnitBuffer > MAX_CU_BUFFER) {
-    extraComputeUnitBuffer = MAX_CU_BUFFER;
-  } else if (extraComputeUnitBuffer < MIN_CU_BUFFER) {
-    extraComputeUnitBuffer = MIN_CU_BUFFER;
+  return {
+    inputAmount,
+    nextSqrtPrice
+  };
+}
+function swapQuoteExactInput(pool, currentPoint, amountIn, slippage, aToB, hasReferral, tokenADecimal, tokenBDecimal, inputTokenInfo, outputTokenInfo) {
+  if (amountIn.lte(new BN12(0))) {
+    throw new Error("Amount in must be greater than 0");
+  }
+  if (!isSwapEnabled(pool, currentPoint)) {
+    throw new Error("Swap is disabled");
+  }
+  const tradeDirection = aToB ? 0 /* AtoB */ : 1 /* BtoA */;
+  const feeMode = getFeeMode(pool.collectFeeMode, tradeDirection, hasReferral);
+  let actualAmountIn = amountIn;
+  if (inputTokenInfo) {
+    actualAmountIn = calculateTransferFeeExcludedAmount(
+      amountIn,
+      inputTokenInfo.mint,
+      inputTokenInfo.currentEpoch
+    ).amount;
+  }
+  const swapResult = getSwapResultFromExactInput(
+    pool,
+    actualAmountIn,
+    feeMode,
+    tradeDirection,
+    currentPoint
+  );
+  let actualAmountOut = swapResult.outputAmount;
+  if (outputTokenInfo) {
+    actualAmountOut = calculateTransferFeeExcludedAmount(
+      swapResult.outputAmount,
+      outputTokenInfo.mint,
+      outputTokenInfo.currentEpoch
+    ).amount;
   }
-  return estimatedComputeUnitUsage + extraComputeUnitBuffer;
-});
-var getEstimatedComputeUnitIxWithBuffer = (connection, instructions, feePayer, buffer) => __async(void 0, null, function* () {
-  const units = yield getEstimatedComputeUnitUsageWithBuffer(
-    connection,
-    instructions,
-    feePayer,
-    buffer
-  ).catch((error) => {
-    console.error("Error::getEstimatedComputeUnitUsageWithBuffer", error);
-    return 14e5;
+  const minimumAmountOut = getAmountWithSlippage(
+    actualAmountOut,
+    slippage,
+    0 /* ExactIn */
+  );
+  const priceImpact = getPriceImpact(
+    actualAmountIn,
+    actualAmountOut,
+    pool.sqrtPrice,
+    aToB,
+    tokenADecimal,
+    tokenBDecimal
+  );
+  return __spreadProps(__spreadValues({}, swapResult), {
+    minimumAmountOut,
+    priceImpact
   });
-  return ComputeBudgetProgram.setComputeUnitLimit({ units });
-});
-
-// src/helpers/utils.ts
-import { BN as BN6 } from "@coral-xyz/anchor";
-import Decimal3 from "decimal.js";
-var getMaxAmountWithSlippage = (amount, rate) => {
-  const slippage = (100 + rate) / 100 * BASIS_POINT_MAX;
-  return amount.mul(new BN6(slippage)).div(new BN6(BASIS_POINT_MAX));
-};
-var getMinAmountWithSlippage = (amount, rate) => {
-  const slippage = (100 - rate) / 100 * BASIS_POINT_MAX;
-  return amount.mul(new BN6(slippage)).div(new BN6(BASIS_POINT_MAX));
-};
-var getPriceImpact = (amountIn, amountOut, currentSqrtPrice, aToB, tokenADecimal, tokenBDecimal) => {
-  if (amountIn.eq(new BN6(0))) {
-    return new Decimal3(0);
-  }
-  if (amountOut.eq(new BN6(0))) {
+}
+function swapQuoteExactOutput(pool, currentPoint, amountOut, slippage, aToB, hasReferral, tokenADecimal, tokenBDecimal, inputTokenInfo, outputTokenInfo) {
+  if (amountOut.lte(new BN12(0))) {
     throw new Error("Amount out must be greater than 0");
   }
-  const spotPrice = getPriceFromSqrtPrice(
-    currentSqrtPrice,
+  if (!isSwapEnabled(pool, currentPoint)) {
+    throw new Error("Swap is disabled");
+  }
+  const tradeDirection = aToB ? 0 /* AtoB */ : 1 /* BtoA */;
+  const feeMode = getFeeMode(pool.collectFeeMode, tradeDirection, hasReferral);
+  let actualAmountOut = amountOut;
+  if (outputTokenInfo) {
+    actualAmountOut = calculateTransferFeeIncludedAmount(
+      amountOut,
+      outputTokenInfo.mint,
+      outputTokenInfo.currentEpoch
+    ).amount;
+  }
+  const swapResult = getSwapResultFromExactOutput(
+    pool,
+    actualAmountOut,
+    feeMode,
+    tradeDirection,
+    currentPoint
+  );
+  let actualAmountIn = swapResult.includedFeeInputAmount;
+  if (inputTokenInfo) {
+    actualAmountIn = calculateTransferFeeIncludedAmount(
+      swapResult.includedFeeInputAmount,
+      inputTokenInfo.mint,
+      inputTokenInfo.currentEpoch
+    ).amount;
+  }
+  const maximumAmountIn = getAmountWithSlippage(
+    actualAmountIn,
+    slippage,
+    2 /* ExactOut */
+  );
+  const priceImpact = getPriceImpact(
+    actualAmountIn,
+    actualAmountOut,
+    pool.sqrtPrice,
+    aToB,
     tokenADecimal,
     tokenBDecimal
   );
-  const executionPrice = new Decimal3(amountIn.toString()).div(new Decimal3(amountOut.toString())).mul(
-    Decimal3.pow(
-      10,
-      aToB ? tokenBDecimal - tokenADecimal : tokenADecimal - tokenBDecimal
-    )
+  return __spreadProps(__spreadValues({}, swapResult), {
+    maximumAmountIn,
+    priceImpact
+  });
+}
+function swapQuotePartialInput(pool, currentPoint, amountIn, slippage, aToB, hasReferral, tokenADecimal, tokenBDecimal, inputTokenInfo, outputTokenInfo) {
+  if (amountIn.lte(new BN12(0))) {
+    throw new Error("Amount in must be greater than 0");
+  }
+  if (!isSwapEnabled(pool, currentPoint)) {
+    throw new Error("Swap is disabled");
+  }
+  const tradeDirection = aToB ? 0 /* AtoB */ : 1 /* BtoA */;
+  const feeMode = getFeeMode(pool.collectFeeMode, tradeDirection, hasReferral);
+  let actualAmountIn = amountIn;
+  if (inputTokenInfo) {
+    actualAmountIn = calculateTransferFeeExcludedAmount(
+      amountIn,
+      inputTokenInfo.mint,
+      inputTokenInfo.currentEpoch
+    ).amount;
+  }
+  const swapResult = getSwapResultFromPartialInput(
+    pool,
+    actualAmountIn,
+    feeMode,
+    tradeDirection,
+    currentPoint
   );
-  let priceImpact;
-  let actualExecutionPrice;
-  if (aToB) {
-    actualExecutionPrice = new Decimal3(1).div(executionPrice);
-  } else {
-    actualExecutionPrice = executionPrice;
+  let actualAmountOut = swapResult.outputAmount;
+  if (outputTokenInfo) {
+    actualAmountOut = calculateTransferFeeExcludedAmount(
+      swapResult.outputAmount,
+      outputTokenInfo.mint,
+      outputTokenInfo.currentEpoch
+    ).amount;
   }
-  priceImpact = actualExecutionPrice.sub(spotPrice).abs().div(spotPrice).mul(100);
-  return priceImpact;
-};
-var getPriceChange = (nextSqrtPrice, currentSqrtPrice) => {
-  const diff = nextSqrtPrice.pow(new BN6(2)).sub(currentSqrtPrice.pow(new BN6(2))).abs();
-  return new Decimal3(diff.toString()).div(new Decimal3(currentSqrtPrice.pow(new BN6(2)).toString())).mul(100).toNumber();
-};
-var getPriceFromSqrtPrice = (sqrtPrice, tokenADecimal, tokenBDecimal) => {
-  const decimalSqrtPrice = new Decimal3(sqrtPrice.toString());
-  const price = decimalSqrtPrice.mul(decimalSqrtPrice).mul(new Decimal3(__pow(10, tokenADecimal - tokenBDecimal))).div(Decimal3.pow(2, 128));
-  return price;
-};
-var getSqrtPriceFromPrice = (price, tokenADecimal, tokenBDecimal) => {
-  const decimalPrice = new Decimal3(price);
-  const adjustedByDecimals = decimalPrice.div(
-    new Decimal3(__pow(10, tokenADecimal - tokenBDecimal))
+  const minimumAmountOut = getAmountWithSlippage(
+    actualAmountOut,
+    slippage,
+    1 /* PartialFill */
   );
-  const sqrtValue = Decimal3.sqrt(adjustedByDecimals);
-  const sqrtValueQ64 = sqrtValue.mul(Decimal3.pow(2, 64));
-  return new BN6(sqrtValueQ64.floor().toFixed());
-};
-var getUnClaimReward = (poolState, positionState) => {
-  const totalPositionLiquidity = positionState.unlockedLiquidity.add(positionState.vestedLiquidity).add(positionState.permanentLockedLiquidity);
-  const feeAPerTokenStored = new BN6(
-    Buffer.from(poolState.feeAPerLiquidity).reverse()
-  ).sub(new BN6(Buffer.from(positionState.feeAPerTokenCheckpoint).reverse()));
-  const feeBPerTokenStored = new BN6(
-    Buffer.from(poolState.feeBPerLiquidity).reverse()
-  ).sub(new BN6(Buffer.from(positionState.feeBPerTokenCheckpoint).reverse()));
-  const feeA = totalPositionLiquidity.mul(feeAPerTokenStored).shrn(LIQUIDITY_SCALE);
-  const feeB = totalPositionLiquidity.mul(feeBPerTokenStored).shrn(LIQUIDITY_SCALE);
-  return {
-    feeTokenA: positionState.feeAPending.add(feeA),
-    feeTokenB: positionState.feeBPending.add(feeB),
-    rewards: positionState.rewardInfos.length > 0 ? positionState.rewardInfos.map((item) => item.rewardPendings) : []
-  };
-};
-
-// src/helpers/accountFilters.ts
-var positionByPoolFilter = (pool) => {
-  return {
-    memcmp: {
-      bytes: pool.toBase58(),
-      offset: 8
-    }
-  };
-};
-var vestingByPositionFilter = (position) => {
-  return {
-    memcmp: {
-      bytes: position.toBase58(),
-      offset: 8
-    }
-  };
-};
+  const priceImpact = getPriceImpact(
+    actualAmountIn,
+    actualAmountOut,
+    pool.sqrtPrice,
+    aToB,
+    tokenADecimal,
+    tokenBDecimal
+  );
+  return __spreadProps(__spreadValues({}, swapResult), {
+    minimumAmountOut,
+    priceImpact
+  });
+}
 
-// src/helpers/priceMath.ts
-import { BN as BN7 } from "@coral-xyz/anchor";
-import Decimal4 from "decimal.js";
+// src/math/priceMath.ts
+import { BN as BN13 } from "@coral-xyz/anchor";
+import Decimal3 from "decimal.js";
 function calculateInitSqrtPrice(tokenAAmount, tokenBAmount, minSqrtPrice, maxSqrtPrice) {
   if (tokenAAmount.isZero() || tokenBAmount.isZero()) {
     throw new Error("Amount cannot be zero");
   }
-  const amountADecimal = new Decimal4(tokenAAmount.toString());
-  const amountBDecimal = new Decimal4(tokenBAmount.toString());
-  const minSqrtPriceDecimal = new Decimal4(minSqrtPrice.toString()).div(
-    Decimal4.pow(2, 64)
+  const amountADecimal = new Decimal3(tokenAAmount.toString());
+  const amountBDecimal = new Decimal3(tokenBAmount.toString());
+  const minSqrtPriceDecimal = new Decimal3(minSqrtPrice.toString()).div(
+    Decimal3.pow(2, 64)
   );
-  const maxSqrtPriceDecimal = new Decimal4(maxSqrtPrice.toString()).div(
-    Decimal4.pow(2, 64)
+  const maxSqrtPriceDecimal = new Decimal3(maxSqrtPrice.toString()).div(
+    Decimal3.pow(2, 64)
   );
-  const x = new Decimal4(1).div(maxSqrtPriceDecimal);
+  const x = new Decimal3(1).div(maxSqrtPriceDecimal);
   const y = amountBDecimal.div(amountADecimal);
   const xy = x.mul(y);
   const paMinusXY = minSqrtPriceDecimal.sub(xy);
   const xyMinusPa = xy.sub(minSqrtPriceDecimal);
-  const fourY = new Decimal4(4).mul(y);
+  const fourY = new Decimal3(4).mul(y);
   const discriminant = xyMinusPa.mul(xyMinusPa).add(fourY);
   const sqrtDiscriminant = discriminant.sqrt();
-  const result = paMinusXY.add(sqrtDiscriminant).div(new Decimal4(2)).mul(Decimal4.pow(2, 64));
-  return new BN7(result.floor().toFixed());
+  const result = paMinusXY.add(sqrtDiscriminant).div(new Decimal3(2)).mul(Decimal3.pow(2, 64));
+  return new BN13(result.floor().toFixed());
 }
 
-// src/helpers/token2022.ts
-import { BN as BN8 } from "@coral-xyz/anchor";
-import {
-  calculateFee,
-  getEpochFee,
-  getTransferFeeConfig,
-  MAX_FEE_BASIS_POINTS
-} from "@solana/spl-token";
-function calculatePreFeeAmount(transferFee, postFeeAmount) {
-  if (postFeeAmount.isZero()) {
-    return new BN8(0);
+// src/helpers/validation.ts
+function validateFeeScheduler(numberOfPeriod, periodFrequency, reductionFactor, cliffFeeNumerator, baseFeeMode, poolVersion) {
+  if (!periodFrequency.eq(new BN14(0)) || numberOfPeriod !== 0 || !reductionFactor.eq(new BN14(0))) {
+    if (numberOfPeriod === 0 || periodFrequency.eq(new BN14(0)) || reductionFactor.eq(new BN14(0))) {
+      return false;
+    }
   }
-  if (transferFee.transferFeeBasisPoints === 0) {
-    return postFeeAmount;
+  const minFeeNumerator = getMinBaseFeeNumerator(
+    cliffFeeNumerator,
+    numberOfPeriod,
+    periodFrequency,
+    reductionFactor,
+    baseFeeMode
+  );
+  const maxFeeNumerator = getMaxBaseFeeNumerator(cliffFeeNumerator);
+  validateFeeFraction(minFeeNumerator, new BN14(FEE_DENOMINATOR));
+  validateFeeFraction(maxFeeNumerator, new BN14(FEE_DENOMINATOR));
+  if (minFeeNumerator.lt(new BN14(MIN_FEE_NUMERATOR)) || maxFeeNumerator.gt(getMaxFeeNumerator(poolVersion))) {
+    throw new Error("PoolError::ExceedMaxFeeBps");
   }
-  const maximumFee = new BN8(transferFee.maximumFee.toString());
-  if (transferFee.transferFeeBasisPoints === MAX_FEE_BASIS_POINTS) {
-    return postFeeAmount.add(maximumFee);
+  return true;
+}
+function validateFeeRateLimiter(cliffFeeNumerator, feeIncrementBps, maxFeeBps, maxLimiterDuration, referenceAmount, collectFeeMode, activationType, poolVersion) {
+  if (collectFeeMode !== 1 /* OnlyB */) {
+    return false;
   }
-  const ONE_IN_BASIS_POINTS = new BN8(MAX_FEE_BASIS_POINTS);
-  const numerator = postFeeAmount.mul(ONE_IN_BASIS_POINTS);
-  const denominator = ONE_IN_BASIS_POINTS.sub(
-    new BN8(transferFee.transferFeeBasisPoints)
+  const maxFeeNumeratorFromBps = toNumerator(
+    new BN14(maxFeeBps),
+    new BN14(FEE_DENOMINATOR)
   );
-  const rawPreFeeAmount = numerator.add(denominator).sub(new BN8(1)).div(denominator);
-  if (rawPreFeeAmount.sub(postFeeAmount).gte(maximumFee)) {
-    return postFeeAmount.add(maximumFee);
+  if (cliffFeeNumerator.lt(new BN14(MIN_FEE_NUMERATOR)) || cliffFeeNumerator.gt(maxFeeNumeratorFromBps)) {
+    return false;
+  }
+  if (isZeroRateLimiter(
+    referenceAmount,
+    maxLimiterDuration,
+    maxFeeBps,
+    feeIncrementBps
+  )) {
+    return true;
+  }
+  if (isNonZeroRateLimiter(
+    referenceAmount,
+    maxLimiterDuration,
+    maxFeeBps,
+    feeIncrementBps
+  )) {
+    return false;
+  }
+  const maxLimiterDurationLimit = activationType === 0 /* Slot */ ? new BN14(MAX_RATE_LIMITER_DURATION_IN_SLOTS) : new BN14(MAX_RATE_LIMITER_DURATION_IN_SECONDS);
+  if (new BN14(maxLimiterDuration).gt(maxLimiterDurationLimit)) {
+    return false;
+  }
+  const feeIncrementNumerator = toNumerator(
+    new BN14(feeIncrementBps),
+    new BN14(FEE_DENOMINATOR)
+  );
+  if (feeIncrementNumerator.gte(new BN14(FEE_DENOMINATOR))) {
+    return false;
   }
-  return rawPreFeeAmount;
+  if (maxFeeBps > getMaxFeeBps(poolVersion)) {
+    return false;
+  }
+  const minFeeNumerator = getFeeNumeratorFromIncludedFeeAmount(
+    new BN14(0),
+    cliffFeeNumerator,
+    referenceAmount,
+    maxFeeBps,
+    feeIncrementBps
+  );
+  const maxFeeNumeratorFromAmount = getFeeNumeratorFromIncludedFeeAmount(
+    new BN14(Number.MAX_SAFE_INTEGER),
+    cliffFeeNumerator,
+    referenceAmount,
+    maxFeeBps,
+    feeIncrementBps
+  );
+  if (minFeeNumerator.lt(new BN14(MIN_FEE_NUMERATOR)) || maxFeeNumeratorFromAmount.gt(getMaxFeeNumerator(poolVersion))) {
+    return false;
+  }
+  return true;
 }
-function calculateInverseFee(transferFee, postFeeAmount) {
-  const preFeeAmount = calculatePreFeeAmount(transferFee, postFeeAmount);
-  return new BN8(
-    calculateFee(transferFee, BigInt(preFeeAmount.toString())).toString()
+function validateFeeFraction(numerator, denominator) {
+  if (denominator.isZero() || numerator.gte(denominator)) {
+    throw new Error(
+      "InvalidFee: Fee numerator must be less than denominator and denominator must be non-zero"
+    );
+  }
+}
+
+// src/helpers/common.ts
+import { PublicKey as PublicKey5 } from "@solana/web3.js";
+import BN15 from "bn.js";
+import Decimal4 from "decimal.js";
+function hasPartner(partner) {
+  return !partner.equals(PublicKey5.default);
+}
+function getCurrentPoint(connection, activationType) {
+  return __async(this, null, function* () {
+    const currentSlot = yield connection.getSlot();
+    if (activationType === 0 /* Slot */) {
+      return new BN15(currentSlot);
+    } else {
+      const currentTime = yield connection.getBlockTime(currentSlot);
+      return new BN15(currentTime);
+    }
+  });
+}
+function isSwapEnabled(pool, currentPoint) {
+  if (typeof pool.poolStatus !== "number") {
+    throw new Error("invalid pool status");
+  }
+  return pool.poolStatus === 0 /* Enable */ && currentPoint.gte(pool.activationPoint);
+}
+function convertToFeeSchedulerSecondFactor(value) {
+  return Array.from(value.toArrayLike(Buffer, "le", 8));
+}
+function parseFeeSchedulerSecondFactor(secondFactor) {
+  return new BN15(Buffer.from(secondFactor), "le");
+}
+function convertToRateLimiterSecondFactor(maxLimiterDuration, maxFeeBps) {
+  const buffer1 = maxLimiterDuration.toArrayLike(Buffer, "le", 4);
+  const buffer2 = maxFeeBps.toArrayLike(Buffer, "le", 4);
+  const buffer = Buffer.concat([buffer1, buffer2]);
+  return Array.from(buffer);
+}
+function parseRateLimiterSecondFactor(secondFactor) {
+  const buffer = Buffer.from(secondFactor);
+  return {
+    maxLimiterDuration: buffer.readUInt32LE(0),
+    maxFeeBps: buffer.readUInt32LE(4)
+  };
+}
+function bpsToFeeNumerator(bps) {
+  return new BN15(bps * FEE_DENOMINATOR).divn(BASIS_POINT_MAX);
+}
+function feeNumeratorToBps(feeNumerator) {
+  return feeNumerator.muln(BASIS_POINT_MAX).div(new BN15(FEE_DENOMINATOR)).toNumber();
+}
+function convertToLamports(amount, tokenDecimal) {
+  const valueInLamports = new Decimal4(amount).mul(
+    Decimal4.pow(10, tokenDecimal)
   );
+  return fromDecimalToBN(valueInLamports);
 }
-function calculateTransferFeeIncludedAmount(transferFeeExcludedAmount, mint, currentEpoch) {
-  if (transferFeeExcludedAmount.isZero()) {
+function fromDecimalToBN(value) {
+  return new BN15(value.floor().toFixed());
+}
+function getFeeSchedulerParams(startingBaseFeeBps, endingBaseFeeBps, baseFeeMode, numberOfPeriod, totalDuration) {
+  if (startingBaseFeeBps == endingBaseFeeBps) {
+    if (numberOfPeriod != 0 || totalDuration != 0) {
+      throw new Error("numberOfPeriod and totalDuration must both be zero");
+    }
     return {
-      amount: new BN8(0),
-      transferFee: new BN8(0)
+      cliffFeeNumerator: bpsToFeeNumerator(startingBaseFeeBps),
+      firstFactor: 0,
+      secondFactor: Array.from(new BN15(0).toArrayLike(Buffer, "le", 8)),
+      thirdFactor: new BN15(0),
+      baseFeeMode: 0 /* FeeSchedulerLinear */
     };
   }
-  const transferFeeConfig = getTransferFeeConfig(mint);
-  if (transferFeeConfig === null) {
-    return {
-      amount: transferFeeExcludedAmount,
-      transferFee: new BN8(0)
-    };
+  if (numberOfPeriod <= 0) {
+    throw new Error("Total periods must be greater than zero");
+  }
+  const poolMaxFeeBps = getMaxFeeBps(CURRENT_POOL_VERSION);
+  if (startingBaseFeeBps > poolMaxFeeBps) {
+    throw new Error(
+      `startingBaseFeeBps (${startingBaseFeeBps} bps) exceeds maximum allowed value of ${poolMaxFeeBps} bps`
+    );
+  }
+  if (endingBaseFeeBps > startingBaseFeeBps) {
+    throw new Error(
+      "endingBaseFeeBps bps must be less than or equal to startingBaseFeeBps bps"
+    );
+  }
+  if (numberOfPeriod == 0 || totalDuration == 0) {
+    throw new Error(
+      "numberOfPeriod and totalDuration must both greater than zero"
+    );
+  }
+  const maxBaseFeeNumerator = bpsToFeeNumerator(startingBaseFeeBps);
+  const minBaseFeeNumerator = bpsToFeeNumerator(endingBaseFeeBps);
+  const periodFrequency = new BN15(totalDuration / numberOfPeriod);
+  const secondFactor = convertToFeeSchedulerSecondFactor(periodFrequency);
+  let reductionFactor;
+  if (baseFeeMode == 0 /* FeeSchedulerLinear */) {
+    const totalReduction = maxBaseFeeNumerator.sub(minBaseFeeNumerator);
+    reductionFactor = totalReduction.divn(numberOfPeriod);
+  } else {
+    const ratio = minBaseFeeNumerator.toNumber() / maxBaseFeeNumerator.toNumber();
+    const decayBase = Math.pow(ratio, 1 / numberOfPeriod);
+    reductionFactor = new BN15(BASIS_POINT_MAX * (1 - decayBase));
   }
-  const epochFee = getEpochFee(transferFeeConfig, BigInt(currentEpoch));
-  const transferFee = epochFee.transferFeeBasisPoints == MAX_FEE_BASIS_POINTS ? new BN8(epochFee.maximumFee.toString()) : calculateInverseFee(epochFee, transferFeeExcludedAmount);
-  const transferFeeIncludedAmount = transferFeeExcludedAmount.add(transferFee);
   return {
-    amount: transferFeeIncludedAmount,
-    transferFee
+    cliffFeeNumerator: maxBaseFeeNumerator,
+    firstFactor: numberOfPeriod,
+    secondFactor,
+    thirdFactor: reductionFactor,
+    baseFeeMode
   };
 }
-function calculateTransferFeeExcludedAmount(transferFeeIncludedAmount, mint, currentEpoch) {
-  const transferFeeConfig = getTransferFeeConfig(mint);
-  if (transferFeeConfig === null) {
-    return {
-      amount: transferFeeIncludedAmount,
-      transferFee: new BN8(0)
-    };
+function getRateLimiterParams(baseFeeBps, feeIncrementBps, referenceAmount, maxLimiterDuration, maxFeeBps, tokenBDecimal, activationType) {
+  const cliffFeeNumerator = bpsToFeeNumerator(baseFeeBps);
+  const feeIncrementNumerator = bpsToFeeNumerator(feeIncrementBps);
+  if (baseFeeBps <= 0 || feeIncrementBps <= 0 || referenceAmount <= 0 || maxLimiterDuration <= 0) {
+    throw new Error("All rate limiter parameters must be greater than zero");
+  }
+  const poolMaxFeeBps = getMaxFeeBps(CURRENT_POOL_VERSION);
+  const poolMaxFeeNumerator = getMaxFeeNumerator(CURRENT_POOL_VERSION);
+  if (baseFeeBps > poolMaxFeeBps) {
+    throw new Error(
+      `Base fee (${baseFeeBps} bps) exceeds maximum allowed value of ${poolMaxFeeBps} bps`
+    );
   }
-  const transferFeeIncludedAmountN = BigInt(
-    transferFeeIncludedAmount.toString()
-  );
-  const transferFee = calculateFee(
-    getEpochFee(transferFeeConfig, BigInt(currentEpoch)),
-    transferFeeIncludedAmountN
+  if (feeIncrementBps > poolMaxFeeBps) {
+    throw new Error(
+      `Fee increment (${feeIncrementBps} bps) exceeds maximum allowed value of ${poolMaxFeeBps} bps`
+    );
+  }
+  if (feeIncrementNumerator.gte(new BN15(FEE_DENOMINATOR))) {
+    throw new Error(
+      "Fee increment numerator must be less than FEE_DENOMINATOR"
+    );
+  }
+  if (maxFeeBps > poolMaxFeeBps) {
+    throw new Error(
+      `Max fee (${maxFeeBps} bps) exceeds maximum allowed value of ${poolMaxFeeBps} bps for PoolVersion V${CURRENT_POOL_VERSION}`
+    );
+  }
+  const deltaNumerator = new BN15(poolMaxFeeNumerator).sub(cliffFeeNumerator);
+  const maxIndex = deltaNumerator.div(feeIncrementNumerator);
+  if (maxIndex.lt(new BN15(1))) {
+    throw new Error("Fee increment is too large for the given base fee");
+  }
+  if (cliffFeeNumerator.lt(new BN15(MIN_FEE_NUMERATOR)) || cliffFeeNumerator.gt(new BN15(poolMaxFeeNumerator))) {
+    throw new Error("Base fee must be between 0.01% and 99%");
+  }
+  const maxDuration = activationType === 0 /* Slot */ ? MAX_RATE_LIMITER_DURATION_IN_SLOTS : MAX_RATE_LIMITER_DURATION_IN_SECONDS;
+  if (maxLimiterDuration > maxDuration) {
+    throw new Error(
+      `Max duration exceeds maximum allowed value of ${maxDuration}`
+    );
+  }
+  const referenceAmountInLamports = convertToLamports(
+    referenceAmount,
+    tokenBDecimal
   );
-  const transferFeeExcludedAmount = new BN8(
-    (transferFeeIncludedAmountN - transferFee).toString()
+  const secondFactor = convertToRateLimiterSecondFactor(
+    new BN15(maxLimiterDuration),
+    new BN15(maxFeeBps)
   );
   return {
-    amount: transferFeeExcludedAmount,
-    transferFee: new BN8(transferFee.toString())
+    cliffFeeNumerator,
+    firstFactor: feeIncrementBps,
+    secondFactor,
+    thirdFactor: new BN15(referenceAmountInLamports),
+    baseFeeMode: 2 /* RateLimiter */
   };
 }
-
-// src/helpers/vestings.ts
-import { BN as BN9 } from "@coral-xyz/anchor";
-import { min } from "bn.js";
-function isVestingComplete(vestingData, currentPoint) {
-  const cliffPoint = vestingData.cliffPoint;
-  const periodFrequency = vestingData.periodFrequency;
-  const numberOfPeriods = vestingData.numberOfPeriod;
-  const endPoint = cliffPoint.add(periodFrequency.muln(numberOfPeriods));
-  return currentPoint.gte(endPoint);
-}
-function getTotalLockedLiquidity(vestingData) {
-  return vestingData.cliffUnlockLiquidity.add(
-    vestingData.liquidityPerPeriod.mul(new BN9(vestingData.numberOfPeriod))
-  );
-}
-function getAvailableVestingLiquidity(vestingData, currentPoint) {
-  const {
-    cliffPoint,
-    periodFrequency,
-    cliffUnlockLiquidity,
-    liquidityPerPeriod,
-    numberOfPeriod,
-    totalReleasedLiquidity
-  } = vestingData;
-  if (currentPoint.lt(cliffPoint)) {
-    return new BN9(0);
+function getBaseFeeParams(baseFeeParams, tokenBDecimal, activationType) {
+  if (baseFeeParams.baseFeeMode === 2 /* RateLimiter */) {
+    if (!baseFeeParams.rateLimiterParam) {
+      throw new Error(
+        "Rate limiter parameters are required for RateLimiter mode"
+      );
+    }
+    const {
+      baseFeeBps,
+      feeIncrementBps,
+      referenceAmount,
+      maxLimiterDuration,
+      maxFeeBps
+    } = baseFeeParams.rateLimiterParam;
+    return getRateLimiterParams(
+      baseFeeBps,
+      feeIncrementBps,
+      referenceAmount,
+      maxLimiterDuration,
+      maxFeeBps,
+      tokenBDecimal,
+      activationType
+    );
+  } else {
+    if (!baseFeeParams.feeSchedulerParam) {
+      throw new Error(
+        "Fee scheduler parameters are required for FeeScheduler mode"
+      );
+    }
+    const { startingFeeBps, endingFeeBps, numberOfPeriod, totalDuration } = baseFeeParams.feeSchedulerParam;
+    return getFeeSchedulerParams(
+      startingFeeBps,
+      endingFeeBps,
+      baseFeeParams.baseFeeMode,
+      numberOfPeriod,
+      totalDuration
+    );
   }
-  if (periodFrequency.isZero()) {
-    return cliffUnlockLiquidity;
+}
+function getDynamicFeeParams(baseFeeBps, maxPriceChangeBps = MAX_PRICE_CHANGE_BPS_DEFAULT) {
+  if (maxPriceChangeBps > MAX_PRICE_CHANGE_BPS_DEFAULT) {
+    throw new Error(
+      `maxPriceChangeBps (${maxPriceChangeBps} bps) must be less than or equal to ${MAX_PRICE_CHANGE_BPS_DEFAULT}`
+    );
   }
-  let passedPeriod = new BN9(currentPoint).sub(cliffPoint).div(periodFrequency);
-  passedPeriod = min(passedPeriod, new BN9(numberOfPeriod));
-  const unlockedLiquidity = cliffUnlockLiquidity.add(
-    passedPeriod.mul(liquidityPerPeriod)
-  );
-  const availableReleasingLiquidity = unlockedLiquidity.sub(
-    totalReleasedLiquidity
+  const priceRatio = maxPriceChangeBps / BASIS_POINT_MAX + 1;
+  const sqrtPriceRatioQ64 = new BN15(
+    Decimal4.sqrt(priceRatio.toString()).mul(Decimal4.pow(2, 64)).floor().toFixed()
   );
-  return availableReleasingLiquidity;
+  const deltaBinId = sqrtPriceRatioQ64.sub(ONE_Q64).div(BIN_STEP_BPS_U128_DEFAULT).muln(2);
+  const maxVolatilityAccumulator = new BN15(deltaBinId.muln(BASIS_POINT_MAX));
+  const squareVfaBin = maxVolatilityAccumulator.mul(new BN15(BIN_STEP_BPS_DEFAULT)).pow(new BN15(2));
+  const baseFeeNumerator = new BN15(bpsToFeeNumerator(baseFeeBps));
+  const maxDynamicFeeNumerator = baseFeeNumerator.muln(20).divn(100);
+  const vFee = maxDynamicFeeNumerator.mul(new BN15(1e11)).sub(new BN15(99999999999));
+  const variableFeeControl = vFee.div(squareVfaBin);
+  return {
+    binStep: BIN_STEP_BPS_DEFAULT,
+    binStepU128: BIN_STEP_BPS_U128_DEFAULT,
+    filterPeriod: DYNAMIC_FEE_FILTER_PERIOD_DEFAULT,
+    decayPeriod: DYNAMIC_FEE_DECAY_PERIOD_DEFAULT,
+    reductionFactor: DYNAMIC_FEE_REDUCTION_FACTOR_DEFAULT,
+    maxVolatilityAccumulator: maxVolatilityAccumulator.toNumber(),
+    variableFeeControl: variableFeeControl.toNumber()
+  };
 }
 
 // src/CpAmm.ts
-import { min as min2, max } from "bn.js";
+import BN16, { min as min2, max } from "bn.js";
 var CpAmm = class {
   constructor(connection) {
     this._program = new Program(cp_amm_default, {
@@ -8796,158 +10670,101 @@ var CpAmm = class {
       currentTime,
       currentSlot,
       inputTokenInfo,
-      outputTokenInfo
+      outputTokenInfo,
+      tokenADecimal,
+      tokenBDecimal,
+      hasReferral
     } = params;
-    const {
-      sqrtPrice: sqrtPriceQ64,
-      liquidity: liquidityQ64,
-      activationType,
-      activationPoint,
-      collectFeeMode,
-      poolFees
-    } = poolState;
-    const {
-      feeSchedulerMode,
-      cliffFeeNumerator,
-      numberOfPeriod,
-      reductionFactor,
-      periodFrequency
-    } = poolFees.baseFee;
-    const dynamicFee = poolFees.dynamicFee;
-    let actualAmountIn = inAmount;
-    if (inputTokenInfo) {
-      actualAmountIn = calculateTransferFeeExcludedAmount(
-        inAmount,
-        inputTokenInfo.mint,
-        inputTokenInfo.currentEpoch
-      ).amount;
-    }
+    const { sqrtPrice: sqrtPriceQ64, activationType } = poolState;
     const aToB = poolState.tokenAMint.equals(inputTokenMint);
-    const currentPoint = activationType ? currentTime : currentSlot;
-    let dynamicFeeParams;
-    if (dynamicFee.initialized) {
-      const { volatilityAccumulator, binStep, variableFeeControl } = dynamicFee;
-      dynamicFeeParams = { volatilityAccumulator, binStep, variableFeeControl };
-    }
-    const tradeFeeNumerator = getFeeNumerator(
+    const currentPoint = activationType ? new BN16(currentTime) : new BN16(currentSlot);
+    const swapResult = swapQuoteExactInput(
+      poolState,
       currentPoint,
-      activationPoint,
-      numberOfPeriod,
-      periodFrequency,
-      feeSchedulerMode,
-      cliffFeeNumerator,
-      reductionFactor,
-      dynamicFeeParams
-    );
-    const { amountOut, totalFee, nextSqrtPrice } = getSwapAmount(
-      actualAmountIn,
-      sqrtPriceQ64,
-      liquidityQ64,
-      tradeFeeNumerator,
+      inAmount,
+      slippage,
       aToB,
-      collectFeeMode
-    );
-    let actualAmountOut = amountOut;
-    if (outputTokenInfo) {
-      actualAmountOut = calculateTransferFeeExcludedAmount(
-        amountOut,
-        outputTokenInfo.mint,
-        outputTokenInfo.currentEpoch
-      ).amount;
-    }
-    const minSwapOutAmount = getMinAmountWithSlippage(
-      actualAmountOut,
-      slippage
+      hasReferral,
+      tokenADecimal,
+      tokenBDecimal,
+      inputTokenInfo,
+      outputTokenInfo
     );
     return {
       swapInAmount: inAmount,
-      consumedInAmount: actualAmountIn,
-      swapOutAmount: actualAmountOut,
-      minSwapOutAmount,
-      totalFee,
-      priceImpact: getPriceImpact(
-        actualAmountIn,
-        actualAmountOut,
-        sqrtPriceQ64,
-        aToB,
-        params.tokenADecimal,
-        params.tokenBDecimal
-      )
+      consumedInAmount: swapResult.includedFeeInputAmount,
+      swapOutAmount: swapResult.outputAmount,
+      minSwapOutAmount: swapResult.minimumAmountOut,
+      totalFee: swapResult.tradingFee.add(swapResult.protocolFee).add(swapResult.partnerFee).add(swapResult.referralFee),
+      priceImpact: swapResult.priceImpact
     };
   }
-  /**
-   * 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) {
+  getQuote2(params) {
     const {
-      outAmount,
-      outputTokenMint,
+      inputTokenMint,
       slippage,
       poolState,
-      currentTime,
-      currentSlot,
+      currentPoint,
       inputTokenInfo,
-      outputTokenInfo
+      outputTokenInfo,
+      hasReferral,
+      tokenADecimal,
+      tokenBDecimal,
+      swapMode
     } = params;
-    const {
-      sqrtPrice: sqrtPriceQ64,
-      activationType,
-      collectFeeMode,
-      poolFees
-    } = poolState;
-    const dynamicFee = poolFees.dynamicFee;
-    const bToA = poolState.tokenAMint.equals(outputTokenMint);
-    const tradeDirection = bToA ? 1 /* BtoA */ : 0 /* AtoB */;
-    const currentPoint = activationType ? currentTime : currentSlot;
-    let dynamicFeeParams;
-    if (dynamicFee.initialized) {
-      const { volatilityAccumulator, binStep, variableFeeControl } = dynamicFee;
-      dynamicFeeParams = { volatilityAccumulator, binStep, variableFeeControl };
-    }
-    let actualAmountOut = outAmount;
-    if (outputTokenInfo) {
-      actualAmountOut = calculateTransferFeeIncludedAmount(
-        outAmount,
-        outputTokenInfo.mint,
-        outputTokenInfo.currentEpoch
-      ).amount;
-    }
-    const feeMode = getFeeMode(collectFeeMode, bToA);
-    const { swapResult, inputAmount } = getSwapResultFromOutAmount(
-      poolState,
-      actualAmountOut,
-      feeMode,
-      tradeDirection,
-      currentPoint
-    );
-    let actualInputAmount = inputAmount;
-    if (inputTokenInfo) {
-      actualInputAmount = calculateTransferFeeIncludedAmount(
-        inputAmount,
-        inputTokenInfo.mint,
-        inputTokenInfo.currentEpoch
-      ).amount;
+    const aToB = poolState.tokenAMint.equals(inputTokenMint);
+    switch (swapMode) {
+      case 0 /* ExactIn */:
+        if ("amountIn" in params) {
+          return swapQuoteExactInput(
+            poolState,
+            currentPoint,
+            params.amountIn,
+            slippage,
+            aToB,
+            hasReferral,
+            tokenADecimal,
+            tokenBDecimal,
+            inputTokenInfo,
+            outputTokenInfo
+          );
+        }
+        throw new Error("amountIn is required for ExactIn swap mode");
+      case 2 /* ExactOut */:
+        if ("amountOut" in params) {
+          return swapQuoteExactOutput(
+            poolState,
+            currentPoint,
+            params.amountOut,
+            slippage,
+            aToB,
+            hasReferral,
+            tokenADecimal,
+            tokenBDecimal,
+            inputTokenInfo,
+            outputTokenInfo
+          );
+        }
+        throw new Error("outAmount is required for ExactOut swap mode");
+      case 1 /* PartialFill */:
+        if ("amountIn" in params) {
+          return swapQuotePartialInput(
+            poolState,
+            currentPoint,
+            params.amountIn,
+            slippage,
+            aToB,
+            hasReferral,
+            tokenADecimal,
+            tokenBDecimal,
+            inputTokenInfo,
+            outputTokenInfo
+          );
+        }
+        throw new Error("amountIn is required for PartialFill swap mode");
+      default:
+        throw new Error(`Unsupported swap mode: ${swapMode}`);
     }
-    const maxInputAmount = new BN10(
-      Math.ceil(actualInputAmount.toNumber() * (1 + slippage / 100))
-    );
-    const priceImpact = getPriceImpact(
-      actualInputAmount,
-      actualAmountOut,
-      sqrtPriceQ64,
-      !bToA,
-      // aToB is the opposite of bToA
-      params.tokenADecimal,
-      params.tokenBDecimal
-    ).toNumber();
-    return {
-      swapResult,
-      inputAmount: actualInputAmount,
-      maxInputAmount,
-      priceImpact
-    };
   }
   /**
    * Calculates the deposit quote for liquidity pool.
@@ -8999,7 +10816,7 @@ var CpAmm = class {
         0 /* Up */
       )
     };
-    const rawOutputAmount = new BN10(rawAmount(liquidityDelta));
+    const rawOutputAmount = new BN16(rawAmount(liquidityDelta));
     const outputAmount = outputTokenInfo ? calculateTransferFeeIncludedAmount(
       rawOutputAmount,
       outputTokenInfo.mint,
@@ -9106,7 +10923,7 @@ var CpAmm = class {
       tokenAInfo,
       tokenBInfo
     } = params;
-    if (tokenAAmount.eq(new BN10(0)) && tokenBAmount.eq(new BN10(0))) {
+    if (tokenAAmount.eq(new BN16(0)) && tokenBAmount.eq(new BN16(0))) {
       throw new Error("Invalid input amount");
     }
     const actualAmountAIn = tokenAInfo ? tokenAAmount.sub(
@@ -9273,7 +11090,7 @@ var CpAmm = class {
         tokenAMint,
         tokenBMint,
         tokenAAmount,
-        tokenBAmount: tokenBMint.equals(NATIVE_MINT2) ? max(tokenBAmount, new BN10(1)) : tokenBAmount,
+        tokenBAmount: tokenBMint.equals(NATIVE_MINT2) ? max(tokenBAmount, new BN16(1)) : tokenBAmount,
         payer,
         positionNft,
         tokenAProgram,
@@ -9785,6 +11602,7 @@ var CpAmm = class {
       const [inputTokenProgram, outputTokenProgram] = inputTokenMint.equals(
         tokenAMint
       ) ? [tokenAProgram, tokenBProgram] : [tokenBProgram, tokenAProgram];
+      const tradeDirection = inputTokenMint.equals(tokenAMint) ? 0 /* AtoB */ : 1 /* BtoA */;
       const {
         tokenAAta: inputTokenAccount,
         tokenBAta: outputTokenAccount,
@@ -9813,6 +11631,30 @@ var CpAmm = class {
         const closeWrappedSOLIx = yield unwrapSOLInstruction(payer);
         closeWrappedSOLIx && postInstructions.push(closeWrappedSOLIx);
       }
+      const poolState = yield this.fetchPoolState(pool);
+      const currentPoint = yield getCurrentPoint(
+        this._program.provider.connection,
+        poolState.activationType
+      );
+      const { maxLimiterDuration, maxFeeBps } = parseRateLimiterSecondFactor(
+        poolState.poolFees.baseFee.secondFactor
+      );
+      const rateLimiterApplied = isRateLimiterApplied(
+        poolState.poolFees.baseFee.thirdFactor,
+        maxLimiterDuration,
+        maxFeeBps,
+        poolState.poolFees.baseFee.firstFactor,
+        currentPoint,
+        poolState.activationPoint,
+        tradeDirection
+      );
+      const remainingAccounts = rateLimiterApplied ? [
+        {
+          isSigner: false,
+          isWritable: false,
+          pubkey: SYSVAR_INSTRUCTIONS_PUBKEY
+        }
+      ] : [];
       return yield this._program.methods.swap({
         amountIn,
         minimumAmountOut
@@ -9829,7 +11671,109 @@ var CpAmm = class {
         tokenAProgram,
         tokenBProgram,
         referralTokenAccount
-      }).preInstructions(preInstructions).postInstructions(postInstructions).transaction();
+      }).remainingAccounts(remainingAccounts).preInstructions(preInstructions).postInstructions(postInstructions).transaction();
+    });
+  }
+  swap2(params) {
+    return __async(this, null, function* () {
+      const {
+        payer,
+        pool,
+        inputTokenMint,
+        outputTokenMint,
+        tokenAVault,
+        tokenBVault,
+        tokenAMint,
+        tokenBMint,
+        tokenAProgram,
+        tokenBProgram,
+        referralTokenAccount,
+        swapMode
+      } = params;
+      const [inputTokenProgram, outputTokenProgram] = inputTokenMint.equals(
+        tokenAMint
+      ) ? [tokenAProgram, tokenBProgram] : [tokenBProgram, tokenAProgram];
+      const tradeDirection = inputTokenMint.equals(tokenAMint) ? 0 /* AtoB */ : 1 /* BtoA */;
+      const {
+        tokenAAta: inputTokenAccount,
+        tokenBAta: outputTokenAccount,
+        instructions: preInstructions
+      } = yield this.prepareTokenAccounts({
+        payer,
+        tokenAOwner: payer,
+        tokenBOwner: payer,
+        tokenAMint: inputTokenMint,
+        tokenBMint: outputTokenMint,
+        tokenAProgram: inputTokenProgram,
+        tokenBProgram: outputTokenProgram
+      });
+      let amount0;
+      let amount1;
+      if (swapMode === 2 /* ExactOut */) {
+        amount0 = params.amountOut;
+        amount1 = params.maximumAmountIn;
+      } else {
+        amount0 = params.amountIn;
+        amount1 = params.minimumAmountOut;
+      }
+      if (inputTokenMint.equals(NATIVE_MINT2)) {
+        const amount = swapMode === 0 /* ExactIn */ || swapMode === 1 /* PartialFill */ ? amount0 : amount1;
+        const wrapSOLIx = wrapSOLInstruction(
+          payer,
+          inputTokenAccount,
+          BigInt(amount.toString())
+        );
+        preInstructions.push(...wrapSOLIx);
+      }
+      const postInstructions = [];
+      if ([tokenAMint.toBase58(), tokenBMint.toBase58()].includes(
+        NATIVE_MINT2.toBase58()
+      )) {
+        const closeWrappedSOLIx = yield unwrapSOLInstruction(payer);
+        closeWrappedSOLIx && postInstructions.push(closeWrappedSOLIx);
+      }
+      const poolState = yield this.fetchPoolState(pool);
+      const currentPoint = yield getCurrentPoint(
+        this._program.provider.connection,
+        poolState.activationType
+      );
+      const { maxLimiterDuration, maxFeeBps } = parseRateLimiterSecondFactor(
+        poolState.poolFees.baseFee.secondFactor
+      );
+      const rateLimiterApplied = isRateLimiterApplied(
+        poolState.poolFees.baseFee.thirdFactor,
+        maxLimiterDuration,
+        maxFeeBps,
+        poolState.poolFees.baseFee.firstFactor,
+        currentPoint,
+        poolState.activationPoint,
+        tradeDirection
+      );
+      const remainingAccounts = rateLimiterApplied ? [
+        {
+          isSigner: false,
+          isWritable: false,
+          pubkey: SYSVAR_INSTRUCTIONS_PUBKEY
+        }
+      ] : [];
+      return yield this._program.methods.swap2({
+        amount0,
+        amount1,
+        swapMode
+      }).accountsPartial({
+        poolAuthority: this.poolAuthority,
+        pool,
+        payer,
+        inputTokenAccount,
+        outputTokenAccount,
+        tokenAVault,
+        tokenBVault,
+        tokenAMint,
+        tokenBMint,
+        tokenAProgram,
+        tokenBProgram,
+        referralTokenAccount
+      }).remainingAccounts(remainingAccounts).preInstructions(preInstructions).postInstructions(postInstructions).transaction();
     });
   }
   /**
@@ -10063,7 +12007,7 @@ var CpAmm = class {
             );
             return total.add(available);
           },
-          new BN10(0)
+          new BN16(0)
         );
         positionBLiquidityDelta = positionBLiquidityDelta.add(
           totalAvailableVestingLiquidity
@@ -10510,6 +12454,29 @@ var CpAmm = class {
       }).transaction();
     });
   }
+  splitPosition2(params) {
+    return __async(this, null, function* () {
+      const {
+        firstPositionOwner,
+        secondPositionOwner,
+        pool,
+        firstPosition,
+        firstPositionNftAccount,
+        secondPosition,
+        secondPositionNftAccount,
+        numerator
+      } = params;
+      return yield this._program.methods.splitPosition2(numerator).accountsPartial({
+        pool,
+        firstPosition,
+        firstPositionNftAccount,
+        secondPosition,
+        secondPositionNftAccount,
+        firstOwner: firstPositionOwner,
+        secondOwner: secondPositionOwner
+      }).transaction();
+    });
+  }
 };
 
 // src/index.ts
@@ -10520,29 +12487,59 @@ export {
   BASIS_POINT_MAX,
   BIN_STEP_BPS_DEFAULT,
   BIN_STEP_BPS_U128_DEFAULT,
+  BaseFeeMode,
   CP_AMM_PROGRAM_ID,
+  CURRENT_POOL_VERSION,
   CollectFeeMode,
   CpAmm,
   DYNAMIC_FEE_DECAY_PERIOD_DEFAULT,
   DYNAMIC_FEE_FILTER_PERIOD_DEFAULT,
   DYNAMIC_FEE_REDUCTION_FACTOR_DEFAULT,
+  DYNAMIC_FEE_ROUNDING_OFFSET,
+  DYNAMIC_FEE_SCALING_FACTOR,
   FEE_DENOMINATOR,
-  FeeSchedulerMode,
+  FeeRateLimiter,
+  FeeScheduler,
   LIQUIDITY_SCALE,
+  MAX,
   MAX_CU_BUFFER,
-  MAX_FEE_NUMERATOR,
+  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,
-  ONE,
+  ONE_Q64,
+  PoolStatus,
+  PoolVersion,
   Rounding,
   SCALE_OFFSET,
+  SPLIT_POSITION_DENOMINATOR,
+  SwapMode,
   TradeDirection,
+  U128_MAX,
+  U16_MAX,
+  U64_MAX,
   bpsToFeeNumerator,
+  calculateAtoBFromAmountIn,
+  calculateAtoBFromAmountOut,
+  calculateAtoBFromPartialAmountIn,
+  calculateBtoAFromAmountIn,
+  calculateBtoAFromAmountOut,
+  calculateBtoAFromPartialAmountIn,
   calculateInitSqrtPrice,
   calculateTransferFeeExcludedAmount,
   calculateTransferFeeIncludedAmount,
+  convertToFeeSchedulerSecondFactor,
+  convertToLamports,
+  convertToRateLimiterSecondFactor,
   decimalToQ64,
   index_default as default,
   deriveClaimFeeOperatorAddress,
@@ -10556,49 +12553,90 @@ export {
   deriveTokenBadgeAddress,
   deriveTokenVaultAddress,
   feeNumeratorToBps,
+  fromDecimalToBN,
   getAllPositionNftAccountByOwner,
   getAllUserPositionNftAccount,
   getAmountAFromLiquidityDelta,
   getAmountBFromLiquidityDelta,
+  getAmountWithSlippage,
   getAvailableVestingLiquidity,
+  getBaseFeeHandler,
   getBaseFeeNumerator,
+  getBaseFeeNumeratorByPeriod,
   getBaseFeeParams,
+  getCheckedAmounts,
+  getCurrentPoint,
   getDynamicFeeNumerator,
   getDynamicFeeParams,
   getEstimatedComputeUnitIxWithBuffer,
   getEstimatedComputeUnitUsageWithBuffer,
   getExcludedFeeAmount,
+  getExcludedFeeAmountFromIncludedFeeAmount,
+  getFeeInPeriod,
   getFeeMode,
-  getFeeNumerator,
+  getFeeNumeratorFromExcludedFeeAmount,
+  getFeeNumeratorFromIncludedFeeAmount,
+  getFeeNumeratorOnExponentialFeeScheduler,
+  getFeeNumeratorOnLinearFeeScheduler,
+  getFeeOnAmount,
+  getFeeSchedulerParams,
   getFirstKey,
   getIncludedFeeAmount,
   getLiquidityDeltaFromAmountA,
   getLiquidityDeltaFromAmountB,
   getMaxAmountWithSlippage,
-  getMinAmountWithSlippage,
-  getNextSqrtPrice,
-  getNextSqrtPriceFromAmountARoundingDown,
-  getNextSqrtPriceFromAmountBRoundingUp,
+  getMaxBaseFeeNumerator,
+  getMaxFeeBps,
+  getMaxFeeNumerator,
+  getMaxIndex,
+  getMinBaseFeeNumerator,
+  getNextSqrtPriceFromAmountInARoundingUp,
+  getNextSqrtPriceFromAmountInBRoundingDown,
+  getNextSqrtPriceFromAmountOutARoundingUp,
+  getNextSqrtPriceFromAmountOutBRoundingDown,
+  getNextSqrtPriceFromInput,
   getNextSqrtPriceFromOutput,
   getOrCreateATAInstruction,
   getPriceChange,
   getPriceFromSqrtPrice,
   getPriceImpact,
+  getRateLimiterParams,
   getSecondKey,
   getSimulationComputeUnits,
   getSqrtPriceFromPrice,
-  getSwapAmount,
-  getSwapResultFromOutAmount,
+  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
 };